WEBVTT

00:07.850 --> 00:08.990
Welcome back.

00:09.230 --> 00:12.740
So you've probably noticed some funny things about our ability.

00:12.770 --> 00:16.250
For one, those beams never actually go away.

00:16.250 --> 00:21.950
If we kill those enemies, our beams are still going, and that's not good.

00:22.520 --> 00:25.700
So we need a way to know when the enemies die.

00:25.700 --> 00:29.020
And we should stop applying those beams.

00:29.030 --> 00:38.330
And I'd like to end the ability as well, as soon as either the primary target dies or perhaps the last

00:38.330 --> 00:39.940
of the targets dies.

00:39.950 --> 00:43.010
So we're going to work on that in this video.

00:43.160 --> 00:47.300
First of all, we need to know when one of these enemies dies.

00:47.390 --> 00:55.370
And I'd like to have a couple of events that I can implement here and control what happens when either

00:55.370 --> 00:59.450
the primary target dies or any of the additional targets has died.

00:59.720 --> 01:05.550
So I'm going to create a delegate that can be broadcast and we can respond to it here.

01:05.570 --> 01:08.390
I'm going to create that delegate in C plus plus.

01:08.390 --> 01:15.290
And I'm going to create it in the interaction folder in combat interface, because I'd like to create

01:15.290 --> 01:21.140
a function that can retrieve this delegate from any actor that implements the combat interface.

01:21.140 --> 01:22.880
So I'm going to declare it.

01:22.880 --> 01:29.300
It's going to be a dynamic multicast delegate.

01:30.290 --> 01:32.780
And it's going to have one param.

01:33.260 --> 01:38.060
I'd like it to broadcast a pointer to the dead actor that just died.

01:38.120 --> 01:41.570
And I'm going to call this F on death signature.

01:44.190 --> 01:48.210
And it'll take an actor and we'll call it dead actor.

01:48.480 --> 01:55.320
Now, I'd like a function to get the on death signature, so I'm going to make that function here in

01:55.320 --> 01:56.970
the combat interface.

01:57.000 --> 02:02.480
I don't need it to be exposed to blueprint because I plan on binding to it here in C plus plus.

02:02.490 --> 02:04.860
So I'll make it a pure virtual function.

02:04.860 --> 02:10.640
And it's going to return an F on death signature.

02:10.650 --> 02:13.860
But I need to return a reference to it.

02:14.160 --> 02:20.160
This is important because if we're getting an F on death signature, it's important that we don't return

02:20.160 --> 02:22.350
a copy of that delegate.

02:22.380 --> 02:29.220
We have to return a reference to the actual delegate on that character that implements this interface.

02:29.310 --> 02:33.810
So very, very important to have that little ampersand there.

02:33.960 --> 02:37.620
And we're going to call this get on death delegate.

02:39.970 --> 02:44.230
And we're going to set it equal to zero to make it a pure virtual function.

02:44.230 --> 02:50.110
And we'll go ahead and implement this function on the base class for our character.

02:50.140 --> 02:51.980
That's our character base.

02:52.000 --> 03:01.270
So just under our on ASC registered delegate we're going to make an F on death delegate called on death

03:01.480 --> 03:02.470
delegate.

03:02.650 --> 03:06.010
And we'll implement this function I'll put it right under die.

03:06.280 --> 03:09.550
So virtual F on death signature reference.

03:09.580 --> 03:10.600
Get on death.

03:10.600 --> 03:12.520
Delegate override.

03:13.570 --> 03:18.610
I'll go ahead and generate the definition and just have it return on death.

03:18.610 --> 03:19.390
Delegate.

03:20.750 --> 03:24.440
Okay, so I'm getting an error about F on death delegate.

03:24.530 --> 03:28.190
And of course it's not an F on death delegate.

03:28.220 --> 03:30.920
It's an F on death signature.

03:32.510 --> 03:34.520
So that fixes that problem.

03:34.610 --> 03:35.030
Okay.

03:35.030 --> 03:39.380
So now we have an interface function we can call to get this delegate.

03:39.530 --> 03:42.320
And where are we going to bind to it.

03:42.350 --> 03:47.120
Well I'd like a couple functions on my aura beam spell.

03:47.360 --> 03:49.790
So I'm going to go into aura Beam spell.

03:49.790 --> 03:53.630
And I like these functions to be blueprint implementable events.

03:53.630 --> 03:58.970
So I can decide what happens when they get executed in my ability blueprint.

03:59.150 --> 04:01.010
So the first one will be void.

04:01.010 --> 04:05.930
And I'm going to call this function primary target died.

04:05.930 --> 04:14.630
And it has to take an actor pointer called dead actor as this is going to be a callback for my on death

04:14.630 --> 04:20.000
delegate, it's going to be a new function and I'll make it a blueprint implementable event.

04:20.360 --> 04:22.070
Now I'm going to copy this.

04:22.740 --> 04:26.540
And I'll have another one for when an additional target dies.

04:26.550 --> 04:30.630
So I'm going to have this one called additional target died.

04:30.630 --> 04:33.240
And it'll also take a dead actor.

04:33.240 --> 04:38.340
And we're not going to generate definitions because they're blueprint implementable events.

04:38.520 --> 04:41.070
But we do need to bind these delegates.

04:41.070 --> 04:49.650
And we can do that in or ABM spelt CPP, because we have access to the first target as soon as we trace

04:49.650 --> 04:50.460
for it.

04:51.010 --> 04:58.330
So what we'll do here at the end of the function after we've set our mouse hit actor is we'll see if

04:58.330 --> 05:01.830
that mouse hit actor implements the interface first and foremost.

05:01.840 --> 05:07.120
So we're going to say if I combat interface we're going to get a combat interface.

05:07.120 --> 05:12.010
We're going to cast that mouse hit actor to an eye combat interface.

05:12.250 --> 05:14.080
So mouse hit actor there.

05:15.070 --> 05:19.990
If it does implement the interface, then we're going to take the combat interface and we're going to

05:19.990 --> 05:24.760
call get on death, delegate and call Add Dynamic to it.

05:26.220 --> 05:28.530
So the user interface is this.

05:28.560 --> 05:34.080
The delegate is at you or a beam spell.

05:34.080 --> 05:38.940
And this is going to be the primary target died blueprint implementable event.

05:39.150 --> 05:42.720
Now I don't want to bind to this delegate if I already have.

05:42.720 --> 05:44.430
And there's a way to check that.

05:44.520 --> 05:48.720
I'm going to say if not, and I need to get this delegate.

05:48.720 --> 05:56.160
So I'm going to copy the call to get on death delegate from the combat interface and hit Dot and I can

05:56.160 --> 06:03.750
check is already bound, and I can check to see if this delegate is already bound for this particular

06:03.780 --> 06:07.560
gameplay ability and this particular callback.

06:08.150 --> 06:15.290
So I'm going to check that and only bind this callback if it's not already bound.

06:16.200 --> 06:16.680
Now.

06:16.680 --> 06:17.680
That's good.

06:17.700 --> 06:20.070
That takes care of the primary target.

06:20.070 --> 06:24.120
But we're going to do the same thing for additional targets.

06:24.120 --> 06:27.030
And we have them here in store additional targets.

06:27.060 --> 06:30.480
We can loop over the out additional targets array.

06:30.570 --> 06:32.460
So I'd like to do that too.

06:32.490 --> 06:34.710
I'm going to say for a actor.

06:34.950 --> 06:39.120
We'll call this target in out additional targets.

06:39.120 --> 06:44.170
And for each one we're going to check to see if it implements the interface.

06:44.190 --> 06:50.400
So if I combat interface combat interface we'll cast to I combat interface.

06:51.060 --> 06:53.400
And we're going to cast the target this time.

06:55.780 --> 07:01.060
Now, if it does implement the interface, we're going to do the same thing we did here, namely check

07:01.060 --> 07:04.140
to see if that delegate is already bound.

07:04.150 --> 07:09.760
Only we want to check against our additional target died function.

07:12.940 --> 07:18.520
So we're checking if that is already bound and then we're binding additional target died instead of

07:18.520 --> 07:19.450
primary.

07:19.930 --> 07:20.410
All right.

07:20.410 --> 07:26.530
So now we know we'll have blueprint implementable events fired in response to this delegate.

07:26.560 --> 07:28.870
We just need to make sure it's broadcast.

07:28.870 --> 07:36.460
And we can broadcast the delegate in our aura character base and multicast handle.

07:36.460 --> 07:39.700
Death is the perfect place for broadcasting it.

07:39.700 --> 07:42.490
It'll broadcast on server and clients.

07:42.520 --> 07:46.300
So we're going to take on Death Delegate.

07:46.330 --> 07:53.560
We're going to broadcast it and broadcast this as this is the actor that's dying.

07:53.950 --> 07:54.670
Okay.

07:54.700 --> 08:01.930
So with that, we can go ahead and launch the editor and implement those blueprint implementable events.

08:03.380 --> 08:03.920
All right.

08:03.920 --> 08:05.780
So I'm going to open my ability.

08:05.780 --> 08:10.960
And in the event graph I'm going to implement both of these new events.

08:10.970 --> 08:17.390
The first one is primary target died and the other one is additional target died.

08:17.600 --> 08:20.270
Now first we'll do the primary target died.

08:20.630 --> 08:22.610
If our primary target dies.

08:22.610 --> 08:24.650
I know that's my mouse hit actor.

08:24.680 --> 08:30.950
So I can take the dead actor and remove gameplay cue on actor.

08:30.950 --> 08:36.170
And that's going to be that first target cue params that we can pass in.

08:36.170 --> 08:39.770
And the gameplay tag is going to be shock loop.

08:40.350 --> 08:46.680
Now, in addition to removing the gameplay cue, I'd also like to commit the ability cooldown.

08:47.340 --> 08:50.130
So I'm going to call commit ability cooldown here.

08:50.740 --> 08:55.150
And we also need to show the mouse cursor.

08:55.180 --> 09:00.670
Set the owner character to no longer be in shock loop, set its movement mode, all of that stuff.

09:00.670 --> 09:05.740
So that's basically all we're doing in prepare to end ability.

09:05.740 --> 09:13.690
If we go into that, we'll see that we show the mouse cursor, we set in shock loop, we set movement

09:13.690 --> 09:14.470
mode.

09:14.500 --> 09:18.820
We even see if our first target implements the interface.

09:18.820 --> 09:25.300
And if it does, then we take the mouse hit actor, remove the first target, and we remove the shock

09:25.300 --> 09:28.720
loop cue from all the additional targets.

09:28.720 --> 09:34.750
And if the first target doesn't implement the interface, which we know it does because it just died,

09:34.750 --> 09:40.600
right, then we remove that first target cue params from the self.

09:40.840 --> 09:45.250
So basically this is going to end the entire ability.

09:51.130 --> 09:54.670
So we can do that and we can then call end ability.

10:01.500 --> 10:08.580
And in fact, if we wanted to clear and invalidate that timer so it doesn't keep playing our damage

10:08.580 --> 10:16.110
and cost, then really we could just replace these with clear timer and end ability if we wanted to

10:16.110 --> 10:16.890
do that.

10:17.130 --> 10:21.450
Now when an additional target dies, this will be a little different.

10:21.450 --> 10:27.300
All I want to do in this case is just remove the shock loop queue and we have Add.

10:27.450 --> 10:28.500
Didn't want that one.

10:28.500 --> 10:32.100
I wanted remove shock loop queue from additional target.

10:33.790 --> 10:35.350
We can call this.

10:35.990 --> 10:37.070
And we can look at that.

10:37.070 --> 10:42.370
We see that we just remove the queue by looking it up in our map.

10:42.380 --> 10:48.440
And after we do that, we can actually remove that target from our additional targets array.

10:48.740 --> 10:50.420
So we can get that.

10:51.080 --> 10:55.670
And we can call remove from it and we can remove an item.

10:56.090 --> 10:58.130
We're going to remove the dead actor.

10:59.590 --> 11:00.520
So.

11:01.970 --> 11:03.650
Rerouting that up to here.

11:05.720 --> 11:06.590
There we go.

11:07.340 --> 11:12.030
And if primary target has died, we are ending the ability.

11:12.050 --> 11:15.580
So I know I created this boolean out here.

11:15.590 --> 11:19.800
Target dead, but it doesn't really matter.

11:19.820 --> 11:23.480
We're ending the ability as soon as that target dies anyway.

11:24.110 --> 11:29.330
So really, when we commit the ability cost, all we're going to do is apply damage.

11:29.330 --> 11:31.640
So I'm going to simplify this a bit.

11:32.510 --> 11:38.420
And if we can't pay that cost, not only do we clear the timer and end the ability, we can actually

11:38.450 --> 11:42.470
handle the cooldown in clear timer and end ability, I think.

11:42.470 --> 11:46.340
So I'm going to take commit ability cooldown.

11:47.020 --> 11:51.430
I'm going to cut that and we'll stick it in clear timer and end ability.

11:51.430 --> 11:56.140
And before we end the ability, we'll commit the ability cooldown.

11:59.030 --> 12:01.160
So let's take a look at this.

12:14.310 --> 12:14.640
Okay.

12:14.640 --> 12:15.840
So a couple of things.

12:15.840 --> 12:22.760
For one, we're trying to call git ability system component and getting a null pointer basically.

12:22.770 --> 12:32.340
And because this is instanced per actor, as soon as we fill in that array, that array still has actors

12:32.340 --> 12:32.610
in it.

12:32.610 --> 12:34.350
So if I click over here.

12:35.120 --> 12:37.670
We're still causing damage to those actors.

12:37.940 --> 12:44.840
And so what we need to do is clear and clean up some things when we end the ability.

12:45.020 --> 12:51.850
So before calling end ability here, we need to empty our additional targets.

12:51.860 --> 12:55.820
And we also need to empty additional actors to queue params.

12:57.880 --> 13:00.280
So we're going to call clear on the array.

13:00.520 --> 13:05.440
And we're going to call clear on the map as well.

13:11.320 --> 13:13.000
Well, we should also do.

13:13.820 --> 13:16.430
Is we should set our variables.

13:17.460 --> 13:21.510
Such as mouse hit Actor.

13:22.990 --> 13:29.020
I'd actually like to set that set mouse hit actor, and I'm going to set it to nothing.

13:31.510 --> 13:32.320
Like so.

13:32.320 --> 13:36.990
And we also had a boolean first target implements interface.

13:37.000 --> 13:40.090
We're going to set that to false as well.

13:41.900 --> 13:42.590
Okay.

13:54.060 --> 13:55.140
All right.

13:56.090 --> 13:58.880
Now we're accessing none.

13:58.880 --> 14:04.430
And this is where we're trying to call apply damage single target here.

14:04.730 --> 14:11.600
So as soon as some of these enemies are dying and we're continuing to try to apply damage, that's why

14:11.600 --> 14:14.120
we're getting a null pointer basically.

14:14.240 --> 14:20.180
So in apply damage single target, we should check if that ability system component is valid.

14:20.180 --> 14:22.070
We're going to say is valid here.

14:23.780 --> 14:27.050
And if it's not valid, we're not going to continue.

14:30.220 --> 14:30.940
Okay.

14:38.490 --> 14:39.480
Looking better.

14:40.940 --> 14:41.240
Okay.

14:41.240 --> 14:43.340
So we're still getting that error.

14:43.520 --> 14:47.510
And that's because this node is being evaluated multiple times.

14:47.510 --> 14:53.750
So the best way to avoid that issue is promoting this to a variable.

14:54.390 --> 14:59.220
And we'll make it a local variable and we'll call this ASC.

14:59.940 --> 15:04.350
And we'll just check this with as valid here.

15:07.000 --> 15:10.150
And then we don't have to call this multiple times.

15:10.150 --> 15:13.750
So we'll just get the ASC and hook it in here.

15:16.100 --> 15:17.120
Right there.

15:17.330 --> 15:19.790
And we'll also hook it in here.

15:33.510 --> 15:38.640
Okay, so we're still getting it, and it looks like it's on damaged target.

15:38.670 --> 15:40.740
The target that's being passed in.

15:41.010 --> 15:46.170
Now, we don't have to continue if damage target is invalid either.

15:47.370 --> 15:51.900
So we can go ahead and check is valid for that.

15:55.560 --> 15:56.460
Right there.

15:56.970 --> 15:57.450
Okay.

15:57.450 --> 16:05.670
So in our apply damage single target, now that we have our damage target we're checking if that's valid.

16:05.670 --> 16:09.320
We're checking if the ability system component is valid.

16:09.330 --> 16:14.880
We're also taking our damage target here getting its ability system component there.

16:15.660 --> 16:16.290
This one.

16:16.290 --> 16:19.620
Here is the ability system component from actor info.

16:19.650 --> 16:22.860
This one is the AC on the damage target.

16:22.890 --> 16:30.180
We can check if this one is valid too because they'll be pending kill as they drop like flies, so we'll

16:30.180 --> 16:35.580
only apply the gameplay effect on a target that's valid here as well.

16:38.170 --> 16:38.820
Okay.

16:38.830 --> 16:47.770
Now, the last thing is we added some things to our clear timer and end ability, but we're not calling

16:47.770 --> 16:50.560
this in all cases, we really should.

16:50.560 --> 16:52.330
So we can clear all this stuff.

16:52.330 --> 17:00.040
So if we go to our event graph and just look through at each time we're ending our ability, let's just

17:00.040 --> 17:02.800
make sure that we're ending it properly.

17:02.950 --> 17:08.470
So after spawning the electric beam, in fact, let's go into spawn electric beam.

17:09.400 --> 17:09.700
Okay.

17:09.700 --> 17:11.890
We're not ending the ability from that at all.

17:11.890 --> 17:13.270
We can close that.

17:13.390 --> 17:15.640
And after that, we set our timer.

17:15.820 --> 17:19.570
We commit the ability cost each time in the timer.

17:19.570 --> 17:25.870
And if we can't afford to pay the cost, we clear timer and ability.

17:25.870 --> 17:27.760
And that resets all our variables.

17:27.760 --> 17:28.840
So that's great.

17:28.840 --> 17:31.090
And we apply damage otherwise.

17:31.830 --> 17:32.220
Now.

17:32.220 --> 17:36.750
The other times we end, the ability would be on input release.

17:36.780 --> 17:39.750
Now here we prepare to end ability and end the ability.

17:39.750 --> 17:45.080
But clear timer and end ability also zeroes out those variables that we need to zero out.

17:45.090 --> 17:52.830
So we need that here and as well as over here when primary target died.

17:52.860 --> 17:53.400
Yes.

17:53.400 --> 17:55.800
We're clearing the timer and ending the ability there.

17:55.800 --> 18:01.020
And when an additional target died then we don't end the ability.

18:03.020 --> 18:05.450
Okay, let's check this out.

18:11.360 --> 18:17.150
Okay, it seems like we do have a second of cooldown time and we're not getting an error anymore when

18:17.150 --> 18:22.100
we stop, but we're not getting the cooldown timer in our HUD.

18:22.100 --> 18:29.720
And that all comes down to going into ability system data, ability info, and setting the cooldown

18:29.720 --> 18:35.180
tag for our electrocute ability if we set that to cooldown.

18:35.180 --> 18:37.070
Lightning electrocute.

18:37.100 --> 18:44.780
Now, thanks to our data driven approach, our widgets will respond to the cooldown tag, so let's check

18:44.780 --> 18:45.410
that out.

18:46.120 --> 18:47.260
I'm going to release.

18:47.290 --> 18:48.880
There's my cooldown.

18:51.270 --> 18:54.930
So the cooldown doesn't start until we've finished our ability.

18:54.930 --> 18:57.480
And that's the behavior I want.

19:00.080 --> 19:06.260
And of course, when our primary target dies, our ability ends and we kick off the cooldown.

19:20.800 --> 19:21.490
Cool.

19:25.090 --> 19:26.380
So that's looking good.

19:27.520 --> 19:36.070
Now, there's one last issue I want to polish on this ability, and that is if I just right click and

19:36.070 --> 19:36.820
release.

19:37.680 --> 19:40.860
We don't really get any lightning.

19:40.860 --> 19:43.440
We definitely do get our cooldown now.

19:44.150 --> 19:46.940
But we don't even finish our montage.

19:47.700 --> 19:55.800
So I want there to be a minimum amount of time required before we can end the ability in weight input

19:55.800 --> 19:56.550
release.

19:56.910 --> 20:03.060
So to enforce that I'm going to have a minimum spell time.

20:03.060 --> 20:04.230
So I'm going to add a variable.

20:04.230 --> 20:07.380
This will be a float I'm going to call it min spell time.

20:07.680 --> 20:11.310
Change its type to float compile.

20:11.400 --> 20:15.930
And I want at least a minimum spell time of 0.5 seconds.

20:17.820 --> 20:19.500
So how do I enforce that?

20:19.590 --> 20:20.700
Well, notice wait.

20:20.700 --> 20:23.280
Input release has a time held.

20:23.310 --> 20:26.280
So we can check time held.

20:27.030 --> 20:30.720
I'm going to go ahead and just promote it to a variable here.

20:30.780 --> 20:35.640
But if I'm going to promote this to a variable, then I'm going to make sure to clear it out and clear

20:35.640 --> 20:38.550
timer and and ability.

20:38.580 --> 20:41.910
So I'm going to set time held here to zero.

20:45.630 --> 20:48.680
Even though whenever I release it'll be set anyway.

20:48.690 --> 20:52.620
But I'm going to set it and I'm going to set it on release here.

20:53.890 --> 20:55.720
That's when it's valid anyway.

20:56.500 --> 21:01.240
Now, after setting it here, I'm going to check if time held.

21:02.440 --> 21:04.540
Is less than the minimum spell time.

21:04.720 --> 21:06.520
So I'm going to get time held.

21:06.730 --> 21:08.230
Check less than.

21:10.100 --> 21:12.740
Minimum spell time and we'll have a branch.

21:17.280 --> 21:23.010
And if time held is less than the minimum spell time, then I want to get the difference.

21:23.010 --> 21:27.240
I want to get minimum spell time minus.

21:28.390 --> 21:29.350
Time held.

21:30.600 --> 21:37.860
Because this tells me how much time is left that I have to keep my spell active, and I'm just going

21:37.860 --> 21:39.480
to delay for that much.

21:44.410 --> 21:46.570
So that will be for my true case.

21:46.720 --> 21:51.070
And then I can clear timer and end ability after that delay.

21:51.100 --> 21:56.890
However, if time held is not less than minimum spell time, we can clear timer and end the ability

21:56.890 --> 21:57.640
right away.

22:06.920 --> 22:08.150
Like so.

22:10.240 --> 22:13.420
And I'm just going to eliminate these crossing wires here.

22:22.110 --> 22:28.830
It sure is a lot more work when you don't have a nice plugin to help you with those nodes.

22:28.830 --> 22:30.150
Just have to say.

22:36.380 --> 22:37.130
Okay.

22:39.100 --> 22:43.090
And with that, our ability is looking pretty much done.

22:43.910 --> 22:51.590
I'm going to comment this and say primary target died.

22:52.370 --> 22:53.570
We are done.

22:55.640 --> 22:57.380
I can even give this.

22:58.500 --> 23:00.570
A bit of a reddish or orange.

23:02.910 --> 23:04.290
And then this one.

23:05.370 --> 23:06.450
We'll say.

23:07.470 --> 23:09.960
Additional target died.

23:10.530 --> 23:18.030
Remove from additional targets and remove.

23:18.540 --> 23:24.180
Shock loop queue and I'll give that that orange color as well.

23:25.470 --> 23:26.700
That looks a lot better.

23:27.370 --> 23:31.030
And we can't put a delay in a function.

23:31.030 --> 23:39.110
But we can comment this and say enforce minimum spell time.

23:39.130 --> 23:41.380
In fact, let's test that out.

23:41.410 --> 23:43.630
I'm just going to right click and release.

23:44.510 --> 23:46.970
And there we had our minimum spell time.

23:49.340 --> 23:53.120
So at least we'll definitely see our.

23:54.330 --> 23:55.710
Electric beam.

23:57.600 --> 24:01.230
And if we hold it, then we'll keep spending mana.

24:01.230 --> 24:04.660
And if we release, we get our cooldown.

24:04.680 --> 24:05.610
Excellent.

24:06.180 --> 24:09.510
Okay, so that is our electrocute spell.

24:09.540 --> 24:16.230
The only thing left is perhaps to actually set the number of beams based on our ability level, which

24:16.230 --> 24:18.240
we have code in place for that.

24:18.240 --> 24:20.940
And of course to set our descriptions.

24:20.940 --> 24:28.230
So I'm going to close the editor and go back into Aura Beam spell and just find that line we commented

24:28.230 --> 24:33.780
out here and comment out the additional targets equals five.

24:33.780 --> 24:36.240
And now set it equal to our ability level.

24:36.240 --> 24:42.240
And it looks like I called that other one num addition targets and this one num additional targets.

24:42.240 --> 24:44.690
So I'm going to make sure I'm passing in the correct one.

24:44.700 --> 24:49.950
I'll go ahead and compile that and I'll see you in the next video.
