Name: 自己編寫代碼!蠕蟲終結篇#3 (C++) (Code-It-Yourself! Worms Finale Part #3 (C++))
Uploaded: 2021-01-14T10:14:58.000Z
Duration: 32 min 2 s
Description: 【看影片學英語】數萬部 YouTube 影片，搭配英漢字典即點即查，輕鬆掌握單字發音與用法，長久累積看電影不必再看字幕。

反身代名詞

hello and welcome to the final part of my code it yourself worm.

How you usually do the videos because I've got the last part of this video is a full battle.

Fighting each other on this video is really going to be about the aye aye strategy that I've developed to get them to do that.

Now, Fundamentally, I've not changed very much from the previous video in this series.

I've added a prettier looking sky, and I've added a countdown timer on health.

But Andi, there are teams of worms, but I'm not going to go into very much detail like a usually would about how all of that's done.

Instead, we're going to focus on the A I.

The Cody Self Worms game has now become quite a large project.

In fact, there's about 1000 lines of code, but please believe me when I say most of the code you have seen in the previous two videos, I've not made any changes to the create map function.

I've not made any changes to the pearl in noise function.

I've not made any changes to the boom function.

And I've made one slight change to the sea physics object class, which is the inclusion off this damage function, which we'll see later.

I've also made no changes to the camera tracking all the firing weapon routines, and I've made absolutely no changes at all to the physics engine.

So let's have a quick look at the C team class on this class is really just a rapper for a vector off worm objects on the specters called back members on those two functions this class provides, and one is his team alive, which just iterated through all of the members in the vector and checks to see if their health is greater than zero.

If any of the worms have a health that is greater than zero, then the team is still alive.

It's still available to take part in combat.

On the second function is get Next member, which returns a pointer to a sea worm object on DTH.

This function goes through the vector one by one and wraps around, so this way we can work out which worms turn.

It is given a particular team, and of course, we don't want it to choose worms, which aren't healthy.

And you might be thinking, Well, if a worm dies wise, it's still a member of the team.

What I've decided to do is George as a gravestone instead of a worm.

And if we look in the drawer, function off the sea worm object we can see is playable.

This flag is directly set by the health of the words.

If it's greater than zero, the worm is playable.

Then we draw the worm using the drawer partial spite routine, as we did in the previous video.

We also take this opportunity to draw the health bar underneath, which is just scrolling through the health values, setting pixels beneath the worm.

We use the drawer partial spite routine because the single sprite ass it's this game uses contains all four team colors individually, George and it also contains for tombstones with the team colors marked on them.

So if the worm isn't playable, instead of drawing the worms right, we draw the tombstones bright.

The previous video looked at using state machines to govern the order of play, and we're still doing that here.

The only difference is the allocate units has now been filled in.

It was blank, and it's in this state that we can set the number of teams or the number of worms per team that we want, and we can play with these numbers as long as we don't have more than four teams on.

How much space does each team and worm need?

Because we want the Team City be deployed in a team, But the worms, we don't want them all to be on top of each other.

We want to deploy them next to each other in their teams.

So once we calculated the spacing, we create a team object, and then we add worms to it at the appropriate location Organ.

See here where we're taking the vector of teams were taking the vector of members for that team, and we're pushing the worm to the back of that vector.

So it's really just two nested four loops, creating all the teams and worms, and it's quite nice.

So, for example, if I chose to have two teams but 10 worms per team.

We could easily do that and see what it looks like.

And there were two big teams you may notice.

I've added the ability to zoom in and zoom out when the user presses the tab key that this was quite useful.

Let me just put it back to four teams of four.

So I'm going to continue with my strategy of closing up the things that we don't need to see.

That start play State is where the action happens on.

It will remain in this state until one of two things has happened.

The player has fired the weapon, which we saw in the previous video or the turn.

So in the a news update function now I'm decreasing the turn time from 15 seconds just by subtracting every lapse time from it.

The other major change to the state machine is tthe e camera mode state.

This state was responsible for controlling the camera following the object of interest on it did so until the physics engine settled and then returned back to start play.

But we're also now waiting for the physics engine to settle and then choosing the next object of interest.

So if we've got teams of worms, it goes between one team, then to the next, and then it goes to the next worm within that team, etcetera, etcetera.

So once the physics engine is stable, we can assume the action has stopped and it's time to choose the next team on worm to play.

So to do this, I just increment the current team counter and I make sure that that wraps around the number of teams that are playing.

So we're always going between zero on the maximum number of teams minus one.

But I'm also making sure that when I increased the team counter that that current team is alive, do they actually have the ability to play?

If they don't, it just goes around and increments again.

This leaves us with a situation where the next team to play could be the same as the current scene that is playing, and in this case that means there must only be that one team left therefore that team has one, so we look for that specifically.

If current team is equal to old team, then we go into the game over state.

However, we want one of the teams to be controlled by the player on all of the teams to be controlled by the A.

Zero is the player team there, the red ones.

So if the current team is the player team, we enable player control and we disable computer control as opposed to the eye team, where we disable the player control and enable the computer control.

Once they're selected, a new worm object to follow.

We set it is the object under control and we tell the camera to track it.

I've set here the zoom out flag to be false because that will make it sure that the camera zooms in on the worm that is currently under control and we go back to the start Play ST Let's just briefly look at how the zoom out function works.

If we're not zoomed out, then we draw, as we did in video, to the only difference here is I've made the sky a Grady int instead of just a fixed science color.

And as before, thee objects draw themselves and draw across her to indicate in which direction they are aiming.

However, if we have zoomed out, then we re scale the sampling points for the map, and we draw the whole map on the single screen again.

I need code to draw the gray tinted sky, and the objects go on draw themselves.

But we can't just get them to draw themselves natively.

We have to do some clever offsetting to get them to draw them in the right location.

Because remember, now we're looking at the whole map on the screen, and we also need to indicate that we want them to be drawn at a smaller scale.

So I've modified the drawer function to include a flag, which we set to true for when we're in zoomed out mode.

If we just briefly look at the drawer function for the missile object, it uses the drawer wife remodel function, as it did before.

But if the zoomed out flag is set to true, then it fixes the scaling factor to North 0.5 instead off the radius, which was set before so drawing the landscape, we can check that off to at the top of the screen.

I'm drawing health bars that represent the total health off the team on.

I'm calculating this in a very trivial way.

I'm just iterating through all of the team members on accumulating their health, and I used the fill function to draw a colored rectangle in the team colors, the appropriate length across the screen.

The countdown timer in the corner was a seven segment display on this code.

Believe it or not, generates that seven segment display for us.

Well, on the discord server, we've had lots of little challenges where we try to do some code Gulf on.

This was the minimal amount of code required to draw a seven segment display using the council game engine.

I've decided to leave it in its gulf form because, well, it looks cool, and it's little intellectual curiosity for any of those that do look at the source code for this project.

So with all that out, the way we can now focus on the real content of this video, which is the artificial intelligence or AI I I decided early on that the A I shouldn't be allowed to cheat.

So I'm going to restrict the eye to using the same controls that the player can use on the one that many.

So there was a MME left, aim right, jump on fire.

字幕列表影片播放

自己編寫代碼!蠕蟲終結篇#3 (C++) (Code-It-Yourself! Worms Finale Part #3 (C++))

struggle

strategy

positive

aggressive