WEBVTT

00:07.440 --> 00:08.460
Welcome back.

00:09.080 --> 00:15.650
We're now in the attributes set and we're about to debuff stuff, but we don't know how to debuff right

00:15.650 --> 00:17.360
here in C plus plus.

00:17.360 --> 00:23.930
And so far we've only applied gameplay effects when we've had a gameplay effect class and we've created

00:23.930 --> 00:25.600
gameplay effect blueprints.

00:25.610 --> 00:30.170
Well, there is a way to create a gameplay effect in C plus plus right here.

00:30.170 --> 00:31.070
Dynamically.

00:31.070 --> 00:36.290
We can do that and we can apply it, but there are some limitations to doing it this way.

00:36.320 --> 00:43.910
These are not supported for replication, so you just got to do it on the server and anything you change

00:43.910 --> 00:45.020
should be replicated.

00:45.020 --> 00:51.800
So if we're going to change something as in set the incoming damage or something like that, then we're

00:51.800 --> 00:54.470
relying on the server handling that.

00:54.470 --> 01:02.240
And either that attribute is replicated which meta attributes are not, or it changes something else

01:02.240 --> 01:07.070
that is replicated and indirectly the client will catch wind of it.

01:07.160 --> 01:12.710
So how do we create a gameplay effect and apply it right here and set all of its properties?

01:12.710 --> 01:16.130
Well, first we create an effect context.

01:16.160 --> 01:22.910
We say f gameplay effect context, handle effect context.

01:24.350 --> 01:26.930
And how do we create an effect context?

01:26.930 --> 01:29.060
Well, we need an ability system component.

01:29.060 --> 01:34.550
So we're going to take the source ASC and call make effect context.

01:34.580 --> 01:37.760
It's obvious that we need an effect context right.

01:37.790 --> 01:40.190
We're going to be applying a gameplay effect.

01:40.190 --> 01:43.730
So we already knew how to create an effect context in code.

01:43.730 --> 01:45.260
That part was easy.

01:45.290 --> 01:47.510
We can also set its source object.

01:47.510 --> 01:55.130
We can say effect context dot add source object, and we can pass in props dot and we can set it to

01:55.130 --> 01:59.450
source character or source avatar actor doesn't matter.

01:59.840 --> 02:02.420
Okay, so enough of this stuff we already know about.

02:02.450 --> 02:05.870
How are we actually going to create a new effect.

02:05.870 --> 02:07.250
That's the question.

02:07.280 --> 02:09.320
Well we do it this way.

02:09.320 --> 02:12.020
We say you gameplay effect pointer.

02:12.800 --> 02:15.650
We call it effect or something.

02:15.680 --> 02:23.420
To that effect we use new object specifying the type you gameplay effect.

02:24.740 --> 02:29.630
And we initialize it and we have to call git transient package.

02:34.050 --> 02:34.470
Now.

02:34.470 --> 02:40.200
In addition, we can pass in an F name, which will be the name of this gameplay effect.

02:40.470 --> 02:42.900
So we don't have to, but we can.

02:42.930 --> 02:44.880
It's nice when it has a name.

02:44.880 --> 02:49.410
That way we can sort of know what this effect came from.

02:49.410 --> 02:55.350
So I'm going to make an f string called debuff name because this is a debuff.

02:57.120 --> 02:59.790
It's going to be an f string using print f.

03:01.210 --> 03:06.460
And in the text I'm going to say dynamic debuff.

03:07.300 --> 03:09.430
Underscore percent s.

03:09.430 --> 03:12.520
And I'm just going to use the damage type to identify it.

03:12.520 --> 03:17.410
So I'm going to take you or ability system library get damage type.

03:17.410 --> 03:23.680
And we'll use the effect context handle the initial one, the original one that's in props.

03:23.710 --> 03:26.050
That's how we know what the damage type is.

03:26.050 --> 03:27.940
That's how we're getting that information.

03:27.940 --> 03:31.540
But once we get this gameplay tag we need to call to string.

03:31.540 --> 03:34.660
So we're calling to string on the tag we get.

03:34.660 --> 03:45.730
And it's going to make a lot more sense if we make this a const gameplay tag called damage type, and

03:45.730 --> 03:49.030
we just call or a ability system library.

03:51.130 --> 03:57.100
Get damage type here and then just use damage type and here this is a lot less confusing.

03:57.100 --> 03:58.210
So we'll do that.

03:58.240 --> 04:05.020
Now we can pass in debuff name into new object but it requires an F name if we're going to do that.

04:05.020 --> 04:09.220
So we can pass in an f name initialized with debuff name.

04:09.430 --> 04:13.500
So now we've created an effect dynamically okay.

04:13.510 --> 04:17.080
But as we know gameplay effects have settings on them.

04:17.080 --> 04:18.790
They have a duration policy.

04:18.790 --> 04:19.780
Are they instant.

04:19.780 --> 04:20.830
Are they duration?

04:20.830 --> 04:22.060
Are they infinite?

04:22.090 --> 04:24.280
If they're duration, they have a period.

04:24.310 --> 04:26.650
They also have a duration magnitude.

04:26.650 --> 04:28.210
How long do they last.

04:28.210 --> 04:28.900
Right.

04:28.990 --> 04:35.950
And that's all information we can get from our ability system library with the effect context handle.

04:36.100 --> 04:47.590
And I'd like to just collect all that information first so I can make a const float called Debuff Damage

04:47.890 --> 04:50.560
and use your Aura Ability system library.

04:50.560 --> 04:54.520
Get debuff damage passing in props.

04:54.520 --> 04:56.470
Dot effect context handle.

05:01.410 --> 05:07.200
I'm also going to make a const float called debuff duration.

05:09.100 --> 05:11.800
And we'll call get debuff duration.

05:13.930 --> 05:16.840
So changing this now to duration.

05:18.490 --> 05:20.440
We're also going to get the frequency.

05:20.470 --> 05:22.150
Debuff frequency.

05:26.800 --> 05:29.110
So now we have some more information.

05:29.440 --> 05:31.090
Okay, so now for the real stuff.

05:31.090 --> 05:34.810
How do we set the properties on our gameplay effect.

05:34.840 --> 05:36.940
Well first I'm going to take effect.

05:36.940 --> 05:39.700
And we have lots of things on here.

05:39.700 --> 05:45.640
Look at this modifiers period duration policy I'm going to set the duration policy.

05:46.420 --> 05:49.240
These are all drop downs in the Gameplay effect blueprint.

05:49.240 --> 05:52.150
But here they're variables and duration.

05:52.150 --> 05:58.150
Policy is an enum with type EA gameplay effect duration type.

05:59.020 --> 06:02.260
We can have infinite instant and has duration.

06:02.260 --> 06:04.840
Now debuffs are going to have duration.

06:04.870 --> 06:06.580
They'll be duration based.

06:06.610 --> 06:13.840
We even know things like the duration and the period or debuff frequency.

06:13.840 --> 06:17.170
So we can say effect dot period.

06:17.590 --> 06:20.320
And that's going to be our debuff frequency.

06:21.870 --> 06:25.770
And we know effect has duration magnitude.

06:26.130 --> 06:30.690
Now duration magnitude can be set to any of the magnitude types.

06:30.690 --> 06:33.900
Scalable float really whatever we want.

06:33.930 --> 06:37.830
Notice that its gameplay effect modifier magnitude.

06:37.830 --> 06:39.960
That's a parent class.

06:39.960 --> 06:44.340
And we can use child classes such as F scalable float.

06:45.760 --> 06:52.030
If we use a scalable float, we can initialize it with a float, and then it'll just be a float value

06:52.030 --> 06:53.930
for all intents and purposes.

06:53.950 --> 06:57.040
We're going to pass in debuff duration.

07:02.050 --> 07:10.180
So now our effect has a duration with a period of debuff frequency and a duration magnitude of debuff

07:10.180 --> 07:11.080
duration.

07:11.350 --> 07:16.930
Now I'd like this gameplay effect to grant a gameplay tag.

07:16.960 --> 07:20.200
I'd like it to grant the debuff tag.

07:20.230 --> 07:20.890
Why?

07:20.920 --> 07:26.830
Because I'd like my actors to know when they have been debuffed and when they're no longer debuffing.

07:26.830 --> 07:30.850
Some of them may wish to play animations during the debuffs and so on.

07:30.880 --> 07:36.970
Maybe we need some fire particle effects so our little gobbies are running around with their heads on

07:36.970 --> 07:37.390
fire.

07:37.420 --> 07:43.720
That sounds actually quite nice, so I'm going to make sure my effect will grant tags.

07:43.750 --> 07:45.550
Now here's how we do it.

07:45.580 --> 07:54.040
We take the effect and we get inheritable owned tags container and call add tag.

07:55.700 --> 07:57.410
And we pass in the tag.

07:58.250 --> 08:02.800
Now the tag is going to depend on the damage type, right?

08:02.810 --> 08:05.450
So I need gameplay tags.

08:05.450 --> 08:09.500
I'm going to make a const for a gameplay tags at the top here.

08:11.640 --> 08:16.590
That's a ref called Gameplay Tags and it's going to be for a gameplay tags.

08:16.590 --> 08:17.280
Get.

08:18.390 --> 08:23.370
And down here we're going to get gameplay tags and I'm going to get that map.

08:23.400 --> 08:24.330
What's it called?

08:24.330 --> 08:27.360
Damage types to debuffs.

08:27.450 --> 08:30.150
And I'm going to index it with the damage type.

08:32.300 --> 08:39.590
So now our gameplay effect is going to contain this tag and grant that tag.

08:39.800 --> 08:41.290
Okay cool.

08:41.300 --> 08:43.970
Now we have stacking policy right.

08:43.970 --> 08:45.740
So we need to take effect.

08:45.740 --> 08:49.940
And we can take the stacking type variable.

08:49.940 --> 08:50.840
And we can set that.

08:50.840 --> 08:54.710
It's an gameplay effect stacking type.

08:54.710 --> 08:58.610
And we can use aggregate by source and aggregate by target.

08:58.640 --> 09:01.040
I'm just going to aggregate by source.

09:01.130 --> 09:04.400
We also have our effect stack limit count.

09:05.330 --> 09:08.690
And I'd like the stack limit count to be one.

09:09.350 --> 09:12.260
So we've set some properties on our effect.

09:13.000 --> 09:14.920
Now what about modifiers?

09:15.160 --> 09:19.360
Effects have modifiers and we need to set that too.

09:19.630 --> 09:23.380
After all, we need to know what attribute to change.

09:23.380 --> 09:27.910
If this debuff is going to have any hope to cause damage whatsoever.

09:28.150 --> 09:30.820
So first, here's what we can do.

09:30.850 --> 09:39.550
We take effect and we get its modifiers, which is a hover over t array of gameplay modifier info.

09:39.610 --> 09:44.470
Now, however many modifiers it may have zero, right?

09:44.470 --> 09:49.330
But I'm going to show you just in case you find yourself in a situation where it might not be zero,

09:49.330 --> 09:54.690
but you get the index of the modifiers numb.

09:54.730 --> 09:58.900
Now the index of modifiers dot numb is out of range.

09:58.930 --> 10:05.650
Of course, modifiers dot numb is the number of elements, so the index of the last element is this

10:05.650 --> 10:07.120
number minus one.

10:07.120 --> 10:10.930
So this gives us the number of an element.

10:10.930 --> 10:13.090
If we were to add something to it.

10:13.090 --> 10:13.540
Right.

10:13.540 --> 10:16.150
So what we're going to do is add something to modifiers.

10:16.150 --> 10:19.570
We're going to take effect modifiers dot add.

10:19.570 --> 10:23.020
And we're going to add a new gameplay modifier info.

10:23.020 --> 10:29.020
So f gameplay modifier info, we'll just construct a new one and pass it in there.

10:29.020 --> 10:35.820
So now effect modifiers of ID or index is filled with something in it, right?

10:35.830 --> 10:38.830
It has an F gameplay modifier info.

10:39.010 --> 10:42.370
Not sure I like ID, I'm just going to call it index.

10:42.370 --> 10:46.780
And at this point we know that modifiers of index has something.

10:46.780 --> 10:56.110
So what we'll do is we'll get a reference to that f gameplay modifier info reference modifier info equals

10:56.110 --> 11:01.390
effect modifiers indexed at index.

11:02.710 --> 11:03.820
See how that works.

11:03.820 --> 11:07.540
So we got the index before adding something to it.

11:07.540 --> 11:10.930
And this space that we just filled in.

11:10.960 --> 11:15.610
We now have a reference to that gameplay modifier info we just created.

11:15.700 --> 11:18.190
Now we can modify modifier info.

11:18.520 --> 11:21.640
Sorry, that was the worst use of the word modify.

11:21.670 --> 11:23.710
Now we can change modifier info.

11:23.740 --> 11:24.650
Is that better?

11:24.670 --> 11:25.860
I think it's better.

11:25.870 --> 11:30.310
So modifier info contains things like modifier magnitude.

11:30.670 --> 11:34.230
How much is this modifier magnitude going to be?

11:34.240 --> 11:39.850
In other words, how much damage are we going to cause every one second or whatever our debuff frequency

11:39.850 --> 11:40.480
is.

11:40.570 --> 11:46.120
So this can be set and it's going to be set using a scalable float.

11:46.120 --> 11:50.620
As you can see, modifier types can be other flavors.

11:50.620 --> 11:56.800
So you can see how deep this rabbit hole goes right now how much is that magnitude going to be.

11:56.800 --> 12:01.390
Well we know debuff damage so that's how much it's going to be.

12:01.690 --> 12:07.030
We can also take modifier info and we have the modifier op.

12:07.090 --> 12:14.290
Again another thing that's just a dropdown in the gameplay effect here in Cplusplus it's an enum e gameplay

12:14.440 --> 12:16.690
mod op.

12:17.350 --> 12:22.690
And we can make this modifier additive division max multiplicative override.

12:22.690 --> 12:28.930
We're going to set it to additive because we want to add a value to an attribute.

12:29.260 --> 12:33.700
Speaking of attribute, we need to set the attribute modifier.

12:33.700 --> 12:36.610
Info has the attribute and we can specify it.

12:36.610 --> 12:40.720
So what attribute is it that we want to modify.

12:40.750 --> 12:43.150
Well it needs to be incoming damage right.

12:43.150 --> 12:44.530
The meta attribute.

12:44.530 --> 12:47.080
So how do we get that meta attribute.

12:47.200 --> 12:56.470
I mean we could just call the static getter function u or a attribute set get incoming damage attribute.

12:56.710 --> 12:58.360
That would be just fine.

12:58.450 --> 13:05.290
If we wanted to identify it by gameplay tag, we could use the map in our gameplay tag singleton, but

13:05.290 --> 13:08.440
I don't think we added incoming damage attribute to it.

13:08.470 --> 13:12.340
No worries, we know in our debuff that that's what it's going to be.

13:12.370 --> 13:14.440
The incoming damage attribute.

13:14.470 --> 13:15.700
Okay, great.

13:15.700 --> 13:18.190
So now we've got a modifier.

13:18.190 --> 13:22.600
And by the way you can add multiple modifiers just like you can in blueprint.

13:22.630 --> 13:26.410
You just want to plus plus that index right.

13:26.410 --> 13:28.810
And do this whole thing again.

13:28.810 --> 13:34.600
Since I'm only planning on using index once though, I'm going to make that a const index.

13:34.840 --> 13:35.260
Okay.

13:35.260 --> 13:37.480
So we've created a gameplay effect.

13:37.660 --> 13:40.810
How are we going to apply this gameplay effect.

13:40.930 --> 13:47.720
Well what we can do is make a new gameplay effect spec, and we can use it with the new keyword for

13:47.770 --> 13:52.630
gameplay effect spec pointer we can call it.

13:52.630 --> 14:01.540
I'm going to call it mutable spec because it's not const, and I'm going to use new F gameplay effect

14:01.540 --> 14:02.500
spec.

14:03.130 --> 14:11.260
Now for this we have to pass in an effect an effect context, which we have that as well, and a level

14:11.260 --> 14:12.370
we're going to.

14:12.730 --> 14:15.100
Ply all debuffs at level one.

14:15.140 --> 14:15.610
Whoops.

14:15.610 --> 14:17.530
I put an extra asterisk there.

14:17.560 --> 14:19.880
We're going to apply all debuffs at level one.

14:19.900 --> 14:22.330
Now here's another level of complexity.

14:22.360 --> 14:26.410
You can dive into your debuffs can have levels right.

14:26.410 --> 14:31.000
And then you could perhaps use curve tables and what have you.

14:31.030 --> 14:34.150
You could also just use a curve table for the magnitude here.

14:34.150 --> 14:39.310
But that's just an extra level of complexity that we don't need to get into.

14:39.460 --> 14:43.030
Once we have the mutable spec, we check if mutable spec.

14:46.070 --> 14:49.850
If it's valid, then we can make our effect context.

14:49.850 --> 14:54.320
And the main reason I want to make the effect context is just to set the damage type.

14:54.320 --> 14:58.310
So that way we can identify the damage type by the time it gets through.

14:58.340 --> 15:03.920
So I'm going to make a new F or a gameplay effect context.

15:03.950 --> 15:11.620
We'll use the aura version and I'll call it aura context because that's the one that has a damage type.

15:11.630 --> 15:18.140
So to get this in the form of an aura effect context, to set aura specific variables on it, we take

15:18.140 --> 15:19.430
our effect context.

15:19.430 --> 15:23.990
And just to remind you, we created this way up here with make effect context.

15:24.020 --> 15:30.590
This is a new context, not the context that caused this debuff in the first place, but a completely

15:30.590 --> 15:32.580
new one for the debuff.

15:32.600 --> 15:35.630
So we're going to cast it and we're going to use Static Cast.

15:36.800 --> 15:41.840
And we're going to cast to an for a gameplay effect context pointer.

15:41.840 --> 15:44.900
And we're going to cast mutable spec.

15:47.280 --> 15:48.630
Get context.

15:50.280 --> 15:51.210
Dot get.

15:52.950 --> 16:00.000
Alternatively, it would be the same if you just passed in effect context dot get.

16:00.750 --> 16:02.910
So either one of those works.

16:03.090 --> 16:06.720
Now that we have a context, we can set its damage type.

16:07.260 --> 16:09.840
This needs to be a shared pointer though.

16:09.840 --> 16:12.360
So again we got to make a shared pointer.

16:16.630 --> 16:21.850
So gameplay tag here, we'll call it debuff damage type.

16:22.450 --> 16:26.470
Can't call it damage type because we're already using damage type up here.

16:27.230 --> 16:33.830
And we have to make a shared pointer we can use make shareable.

16:37.190 --> 16:43.790
With a new gameplay tag and this can be initialized with damage type.

16:44.180 --> 16:49.310
So notice I use make shareable here and not make shared because I'm constructing a new one.

16:49.310 --> 16:56.330
So another way to do the same thing now set damage type is going to take in this shared pointer.

16:56.810 --> 17:02.870
So after that now we've set the damage type on the effect context for this gameplay effect.

17:03.080 --> 17:06.440
By the way this can be moved inside the if statement.

17:08.280 --> 17:09.960
If you want to be fancy.

17:10.650 --> 17:14.400
Now all of this is just setting up the gameplay effect.

17:14.430 --> 17:16.650
Now we need to actually apply it.

17:17.010 --> 17:24.990
So what we're going to do is take props, dot, target, ASC and call, apply gameplay effect spec to

17:24.990 --> 17:25.710
self.

17:26.250 --> 17:32.820
And we can pass in that spec that we just created mutable spec, which will have to be inside that if

17:32.820 --> 17:35.090
statement if we want to use mutable spec.

17:35.100 --> 17:36.630
So we'll use it here.

17:37.660 --> 17:38.980
And it's a pointer.

17:38.980 --> 17:42.070
So we have to dereference mutable spec.

17:42.870 --> 17:47.760
So as you can see, doing things from C plus plus is a great deal more work, isn't it?

17:47.790 --> 17:54.150
I mean, in the sense of more typing, most of this stuff is dropdowns that you can just select values

17:54.150 --> 17:54.570
for.

17:54.570 --> 17:58.470
But now we have the ability to do this in C plus plus.

17:58.470 --> 18:04.920
And this is useful because if our effect context says we got a debuff, we got a debuff.

18:04.920 --> 18:06.330
So we're going to debuff.

18:06.330 --> 18:09.660
So that's how we're going to get our debuffs.

18:09.930 --> 18:13.590
And we don't have any danger of an infinite loop here.

18:13.590 --> 18:21.030
What I mean is that when the debuff causes damage then of course post gameplay effect execute will be

18:21.030 --> 18:24.270
executed, handle incoming damage will be executed.

18:24.270 --> 18:30.420
And we're not going to get a successful debuff because we're not setting that in our effect context

18:30.420 --> 18:30.720
here.

18:30.720 --> 18:37.050
Very important that we don't set that to true or even give it a debuff chance because, well, that

18:37.050 --> 18:41.910
would result in an infinite loop potentially if your debuffs could cause debuffs.

18:41.910 --> 18:46.860
Although if you could find a way to make that work without being infinite, maybe cap it off or something

18:46.860 --> 18:49.260
that could be actually kind of cool.

18:49.560 --> 18:52.950
So the last thing to do is compile and launch the editor.

18:52.950 --> 19:01.200
After all that work, now that we have the ability to debuff and we can check to see if we're debuffing.

19:01.780 --> 19:04.480
So I'm going to press play and launch a fireball.

19:07.440 --> 19:11.490
Okay, so I'm not seeing any extra damage happening.

19:11.490 --> 19:12.980
And you know what?

19:12.990 --> 19:17.460
I only have a 20% chance to debuff, so give it a shot.

19:17.520 --> 19:19.650
Need to give it a more of a shot here.

19:21.190 --> 19:21.940
There we go.

19:21.940 --> 19:22.660
We got a debuff.

19:22.660 --> 19:23.290
Look at that.

19:23.290 --> 19:25.780
Oh, and it killed the sucka.

19:31.220 --> 19:33.860
I'm becoming a little too op here.

19:33.890 --> 19:34.940
All right, all right.

19:34.940 --> 19:35.450
Look at that.

19:35.450 --> 19:35.990
Look at that.

19:35.990 --> 19:36.440
Okay.

19:36.440 --> 19:38.340
So interesting.

19:38.360 --> 19:44.180
Our enemies are still taking debuff damage, even past death.

19:44.180 --> 19:51.050
And that's because they're lingering around, and we're not making any checks to prevent debuffs when

19:51.080 --> 19:51.530
dead.

19:51.560 --> 19:56.630
So obviously, we can't be debuffing when dead.

19:56.630 --> 20:05.150
And as soon as an enemy becomes dead, if they are still debuffing, well, they can't hit react, right?

20:05.150 --> 20:07.010
We should not hit react when dead.

20:07.010 --> 20:10.160
So a couple things we shouldn't cause damage.

20:10.160 --> 20:12.230
If dead, we shouldn't hit react.

20:12.230 --> 20:12.950
When dead.

20:12.980 --> 20:14.990
We shouldn't debuff when dead.

20:15.020 --> 20:18.830
A lot of dead checks that we need to put in place now.

20:18.830 --> 20:26.540
One big overall blanket fix for this whole dead thing is to go up to gameplay effect.

20:26.540 --> 20:33.350
Execute here and check to see if the source character is dead.

20:33.680 --> 20:35.540
I mean, we have an interface, right?

20:35.540 --> 20:37.280
Let's check that interface.

20:37.370 --> 20:39.170
It's in interaction.

20:39.170 --> 20:41.900
We're going to go to public interaction.

20:41.900 --> 20:48.260
We have combat interface and it looks like combat interface.

20:49.460 --> 20:55.580
Has a function called is dead blueprint, native event and everything.

20:55.790 --> 21:03.290
So in the attribute set, something we can do first and foremost before anything else happens is we

21:03.290 --> 21:05.390
can take the props.

21:07.830 --> 21:15.960
We can take source character or source avatar actor, either one, and we can use this in our interface

21:15.960 --> 21:16.800
function call.

21:16.800 --> 21:18.780
We can say source character.

21:18.780 --> 21:24.570
We can call implements with you combat interface.

21:24.930 --> 21:26.520
We can check that.

21:29.800 --> 21:34.000
If it does, we can check if and we can call I.

21:34.030 --> 21:35.590
Combat interface.

21:35.980 --> 21:38.110
Execute is dead.

21:40.240 --> 21:41.410
And what do we want to do?

21:41.410 --> 21:43.200
In that case we want to return.

21:43.210 --> 21:47.160
Now of course execute is dead require source character.

21:47.170 --> 21:49.000
So we'll pass that on in.

21:49.000 --> 21:50.200
And that's it.

21:50.500 --> 21:57.400
And if you wanted this to be a one liner, you can say and and you could check this second condition

21:57.400 --> 21:58.270
second.

21:59.410 --> 22:01.960
And you can put the return on the same line.

22:06.200 --> 22:08.780
And you can put on your cool dude sunglasses.

22:08.810 --> 22:09.770
Look at that.

22:09.860 --> 22:16.220
So really, we can prevent everything that happens if the source character is dead.

22:18.990 --> 22:21.000
All right, let's test that out.

22:31.850 --> 22:33.230
Oh, it still happening, right?

22:33.230 --> 22:35.920
Because source character is not right, is it?

22:35.930 --> 22:37.700
It's got to be the target character.

22:37.730 --> 22:40.670
Target character is the owner of this.

22:45.440 --> 22:47.480
So we'll change that to target character.

22:47.480 --> 22:48.860
Let's try this.

22:51.800 --> 22:52.370
Okay.

22:52.400 --> 22:54.290
Launching fireballs.

22:57.260 --> 22:58.430
And look at that.

22:58.430 --> 23:00.050
That one did.

23:01.470 --> 23:02.340
Get a debuff.

23:02.370 --> 23:04.370
It got a fire debuff and it killed it.

23:04.380 --> 23:06.000
Let's try it on here.

23:10.590 --> 23:13.480
You know what's going to make this a lot easier to test?

23:13.520 --> 23:14.100
I don't know why.

23:14.100 --> 23:16.190
I'm just leaving it up to chance.

23:16.200 --> 23:20.790
I'm going to go to ability, system or abilities.

23:20.820 --> 23:21.420
Fire.

23:21.420 --> 23:22.410
Firebolt.

23:23.010 --> 23:24.030
Firebolt.

23:24.060 --> 23:29.400
Go to its class defaults and set its debuff chance to a big fat 100.

23:33.770 --> 23:34.690
There we go.

23:34.700 --> 23:36.440
Guaranteed debuff.

23:38.130 --> 23:40.770
Okay, so that worked.

23:40.770 --> 23:46.730
And I just want to really, really make sure that if it's got still time left on the debuff.

23:46.740 --> 23:54.450
In other words, if the debuff duration was like 10s that it stops when the character dies and I believe

23:54.450 --> 23:55.200
it does.

24:00.470 --> 24:00.980
Boom.

24:00.980 --> 24:02.910
And it worked perfect.

24:02.930 --> 24:05.880
So now we're debuffing, which is really exciting.

24:05.900 --> 24:12.080
I'm going to set that debuff duration back down and I can set the debuff damage down too.

24:12.110 --> 24:13.340
We'll leave it at five.

24:13.340 --> 24:16.880
And with that we now have a burn debuff.

24:16.880 --> 24:19.280
But it's a little boring, right?

24:21.290 --> 24:24.830
All it does is damage, but it'd be nice if we had some fire.

24:24.830 --> 24:29.810
If this little gobby had its head set ablaze, that'd be pretty cool.

24:29.810 --> 24:33.290
So that's what I'd like to do in the videos to come.

24:33.290 --> 24:36.440
But excellent job so far and I'll see you soon.
