An overview of the game created through this project, which will be a side-scrolling beat-em-up. Here, we discuss the key concepts behind the game.
This second video of the XNA side scroller takes a look at the implementation plan for game creation, giving you a solid grasp of how the game will be created.
In this video we cover our implementation plan for the coding of the base game of our side-scrolling fighting game.
With the implementation plan fully in place, we now begin coding our base game class, implementing the features covered during the planning process.
This video covers the process of using SpriteBatch with layer depths to control the individual layering of objects on the screen.
Here prepare to create a larger level for our game, including a background, foreground, and a player character that can move around the screen.
Now that we have a solid plan for creating our larger level, we have only to code it out. In this video, we get the textures set up in our code.
In this video we set up the player character's texture to dynamically sort its layer depth, as well as limit the play area of the game.
Here we cover the implementation plan for our game's character, showing how we will handle his motion when sitting still.
With the idle process all planned out, we now move on to the coding portion, in which we bring in the different textures required and set up their behavior.
We now move on to the implementation plan for handling the movement of our character, including walking about and jumping into the air.
We have now planned out how the motion of the character will be dealt with, we now go into Visual Studio and code in the necessary behavior.
In this video, we walk through the implemenation plan for the attacking and combo system, allowing the characer to do a 3-hit combo with a roundhouse kick.
The planning process for our attack and combo system is complete. We now move on to the coding process, getting the fighting behavior in place.
In this video we set up the implementation plan for allowing our character to perform a jump kick attack.
We now begin our Enemies class. In this video, we overiew what this class will entail as we preapare to implement the code.
Now we jump into Visual Studio and prepare our Enemy class to take some hits from the player with some collision.
We now get the collision detection working for the player class, making it possible for the player to hit the enemies on the screen.
Moving on to Phase 6, we now move on our SoundManager class, which will handle all of the sound effects for our game.
It's time for Phase 7. Here, we take a look at adding in throwing weapons, in this case knives. Here, we plan out how we're going to add this element.
In this first section of Phase 7, we discuss the necessary additions for bringing in the throwing knife system so that the player can use it.
With our planning out of the way, we can now move on and actually code in our throwing knives. We begin with sounds and textures.
Moving on with the throwing knives, we plan the trash can portion of the knife system, in which we can damage a trash can and recieve a knife.
Continuing with Phase 7, we bring in the sounds and textures for the trash can, and get it implemented into the game.
The trash can is done, but now we need to be able to pick up the knife that is left behind when the trash can is destroyed.
We now need to set up appropriate collision scenarios between the knife and the enemies, as well as the trash can and the enemies.
Here we overview the concept of adding health bars into our game, allowing the player to keep track of enemy life.
We begin the health bar implementation by setting up the bar for the Enemy class, which will allow us to see how much health each enemy has.
Our player now needs a health bar of its own, and so in this video we set up a heads-up display for the player, showing their health.
Our health bars are now implemented, but we need to set up what happens when an actor's health reaches zero. Here, we set up actor death.
We now begin with Enemy AI. To start, we begin with an overview of the 2 enemy types we will create, close-range and ranged.
We start the behavior of the Enemy AI by setting up the circumstances under which the enemy will retreat from the player.
We now need the enemy to always face the player, control enemy layer depth, and prevent enemies from being able to exit the screen.
The next portion of AI we set up is to give the enemies the ability to decide to advance upon the player's position for attack.
This video focuses on moving the enemy into the pre-attack state, holding there for a random amount of time before attacking.
We now need the Enemy to begin attacking the Player. In this video, we set things up so that the Enemy is ready to punch and kick.
It's now time to deactivate the "god mode" that the Player has been in during testing. Now the Player can actually take damage when hit.
Here we fix a simple bug with the trash can in which when we try to kick a trash can at the Enemy, it also damages the Player.
By now, the CloseRange Enemy is essentially done. We now need to plan out the other type of Enemy, the Ranged fighter who throws knives at the Player.
Here we move on to the Ranged enemy class. This provides us with a type of enemy who stays away from the player and throws knives.
Now we make sure that the ranged enemy does not run off the screen, and also to ascertain that the player can hit them with his fists.
It's time to wrap up the ranged enemy class. Here, we adjust the ranged enemy to drop knives on death, and prevent the ranged enemy from hitting himself with his knife.
At this point we need to set up the game to have a "game over" screen, as well as the ability to continue.
In this video we add some polish to the game over screen and continue screen, adding some fade and other types of cleanup.
One of the conventions of side-scrolling beat-em-ups is to have some sort of pickup in the game that augments the player's current health.
The game now needs some way to tell the story of the game. Here, we discuss how we are going to implement a cutscene system to deal with this.
We've now established a basic understanding of cutscenes, and so in this video we cover how we're going to trigger a cutscene in our game.
In this video we begin the implementation process of the cutscene system, making the game play the cutscene and then continue with gameplay.
To clean up the visual side of the cutscenes, we need to bring in the text that will be placed within the cutscene and get it positioned properly.
We can now add in the story-based aspects of the story and turn this from something technical into something more focused on the game iteslf.
Here we set up the necessary assets for the start screen including the necessary sounds and textures.
In this video we set up the MusicManager for our game. We will be using musc created by Kevin McLeod (www.incompetech.com).
We now get the games very first cut scene completely working. We block out the scene and add in the appropriate sounds and music.
Now we extend the MusicManager class to allow for music volume adjustment, rather than simple play/stop behavior.
The next cutscene in the script now needs to be implemented. We set up the means by which the cutscene will play and plan the scene.
In this first part of the second cutscene implementation, we adjust which enemies are visible on the screen when the game first starts.
We have 2 enemies standing and ready to go, we now need to set up the invisible trigger box that will cause the 2nd cutscene to begin.
We can now actually set up the second cutscene itself, establishing the necessary WAV files for the voice acting and setting up the text.
We now add in the next event that takes place after the second cutscene finishes, causing the Enemy actors to engage the player.
We now set up some triggers that cause level events that will fire during gameplay, such as spawning more enemies and other such things.
Now that we are ready to set up some events, our first will be to establish a spawner in the door that causes the enemies to enter it.
Enemies can now come in through the doors, but to add in some flavor, we set up spawners that bring in enemies to walk onto the screen.
We are almost done with the lower level. We need to set up another cutscene for the end of the level and establish the appropriate trigger.
The lower level is now more or less complete. We now create a new trigger that will allow the player to move from the lower to the upper level.
We are now upstairs. It's time to create some enemies that Tony can taunt before starting to crack is knuckles on their faces.
The end of the road is now in sight. Our goal here is to clean up the upper level by spawning in some more enemies and establishing our final cutscene.
Here in the final video of the 2D side scroller, we perform some genearl cleanup and debugging and conclude this programming lesson.