Is it possible to make a fun and easy game that can be played by anyone and contains no violence?

Transcription

1

2 IT Technology programme (15 ECTS) Examination: June 2016 Report no.: Name: Daniel Makai Project title: Blobbed Out Problem definition and technical specification: Is it possible to make a fun and easy game that can be played by anyone and contains no violence? In this project I am going to try my best at creating a video game that satisfies the upper mentioned requirements in a 2D environment. The game is going to be made using an extension for Visual C# 2010, called the XNA game studio. The textures for the game (characters, items, maps) are going to be made using Paint.net. The creation of the game will consist of the following steps: Creating textures for the objects of the game Creating animations for certain objects (characters, background) Loading textures into the game environment (also placing them inside the game) Setting up physics for the objects Configuring controls Creating a menu Creating options in the menu Adding controller support (as c# is a Microsoft based product it is possible to use an Xbox 360 or Xbox One controller, 3rd party controllers and Playstation controllers require emulation) The gameplay will revolve around jumping through obstacles and defeating enemies (not in a brutal way) while trying to get as many currencies as possible. There is going to be a high score menu point where the highest scores on levels can be seen. The name of the main character is going to be Ruben and he's going to be a green slimeball. The theme of the maps, the enemies and the currency are still under construction. The project is copyright protected. 1

3 Report Blobbed out Daniel Makai,

4 Table of Contents Preface... 5 Introduction... 6 Problem formulation and project scope... 7 The Project - Design and programs... 8 Design... 8 Programs used... 9 The Project - Game Game - Variables Game - Initialization Game - Content Game - LoadContent Game - Update Game - Draw Main Menu Buttons Options menu Player Camera Gravity Tiles Tilemap Collision (Rectangle Helper) Healthbar Enemy Pause Menu Background Conclusion Appendices Blobbed Out - Game1.cs

5 Blobbed Out - Background.cs Blobbed Out - Button.cs Blobbed Out - Camera.cs Blobbed Out - Enemy.cs Blobbed Out - Healthbar.cs Blobbed Out - Map.cs Blobbed Out - Player.cs Blobbed Out - Program.cs Blobbed Out - Rectangle Helper.cs Blobbed Out - SpriteFont1.spritefont Blobbed Out - Tile.cs

6 Preface This document is about the documentation of my final project about a fictional video game, that I personally made. The project includes includes a detailed explanation of how parts of the game work, and how the programs used to make them work. I put time and effort into this project, but I deeply think that without a time limit, the project could have been better. The project documentation is divided into 6 parts: 1. Introduction 2. Project formulation & project scope 3. The Project - Design and Programs used 4. The Project - Game 5. Conclusion 6. Appendices 5

7 Introduction The final project is the subject of the final exam in the 4th semester in the IT Technology program at the Copenhagen School of Technology and Design (KEA). The final project is a self made project in a topic selected by the students (the topic has to be somehow related to the subjects that the students have studied). This can be done alone or in a group. And the students can use their resources from their internships to create these projects. This report will contain all the details about the final project including design, problem formulation, detailed look into every major part of the program and an appendix which will contain the code of my project. Regarding pictures and diagrams, everything that cannot be shown inside the program will be visually represented in this report. 6

8 Problem formulation and project scope Project formulation: Is it possible to make a fun and easy game that can be played by anyone and contains no violence? In this project, I will break down and explain how I created a video game using the C# programming language, a framework for Microsoft Visual Studio called XNA Game Studio, and the image creating/editing program called paint.net. The scope of the project is to create a video game that can be played by anyone and can be easily picked up by anyone (no matter the age or gender). For advanced users, the creation of new maps and reskinning (changing the textures of the game to someone's liking) the game is also an option. The game itself consist of 2 major parts: the game and the contents. The game itself consists of the actual structure and code while the contents are the files that are added to the program and don't include any coding nor do they influence the structure of the game. Essentially the contents are the cosmetic parts and the game is the logical part. 7

9 The Project - Design and programs Design When I came up with the idea of this project, I did not have a clear view of what I really want. Later I carefully planned and designed every part of the game to my liking. First I had to think about the type of the game. I realized that I could not think of a new idea, so I looked into the best games on the market that are only 2 dimensional. Then I saw that in 2 dimensional games the most famous and succesful games are the Mario type sidescrollers. These game are easy to understand, easy to program, and as a developer it helped me a lot that I did not have to think in 3 dimensions. Secondly I wanted to decided how the core game would look like, in terms of gameplay. I decided the old tilestyled, collecting items, avoiding enemies and traps kinda game would be the best. Of course this meant that I had to develop a system that generates the terrain to the users liking. And I also had to think about how other things would work (like what would be the end of the level, gravity, collision, healthbar, tile behaviour, etc.). Finally, there was design. This was pretty much the most fun, but also the hardest part. Imagining how the player should look like or the tiles in the terrain is a lot of fun, but to actually draw them was not an easy part. Mainly because I came up with an idea for the main character, but I realized I wanted something else when I drew it. So this is how I ended up using slimeballs for the player and the enemy as they had a very simple design with which you cannot go wrong. The terrain was a little bit easier as I wanted to use simple sprites. 8

10 Programs used The programs I used for the game are simple and easy to understand. I choose the following programs, because I have experience in using them (except XNA, but it is a modified version of C# so I technically I had some experience in it). The first two programs I used are Visual Studio 2010 C# and the XNA Game Studio. Essentially XNA is an extension for C#, so they did not have a lot of differences. C# is a programming language developed by Microsoft. It is multi-paradigm programming language that used multiple programming disciplined (ex. it is a object oriented language as well as imperative (statement based). In my opinion it is one of the most user-friendly and easy to use programming language currently available. XNA Game Studios is an extension for the C# programming language. This extension was created so that the ease of use of C# could be used to create video games. The basic principles are the same in both C# and XNA, but XNA has a premade structure (to insure that the program runs even without the user ever writing in it), which can also be called a huge assistance. XNA also uses a Content file (which it automatically creates when starting a new project), which is used for storing the graphical contents of a game (such as the picture of the background or the picture for the player or even a special font type for the game). These graphical contents are called sprites in the game (more on this later (see Game - Content)). The easy and drop system of C# is not available in XNA, so I had to personally code the position and the functions of everything (ex. you could just drag and drop a basic button in C# and then just code what you want it to do, while in XNA, you have to personally give it a position, add and assign texture and then code the attributes). The final program that I used is called paint.net. Think of it as a more serious version of paint (which is installed by default on every windows computer). Paint.net is a picture creating/editing program. It shares the same basic features with paint, but there are more customizability in paint.net (ex. layer system, blurring etc.). It also supports plug-ins which add more customizability to the program (such as more effects, or support for different file types). 9

11 The Project - Game Game - Variables As the XNA Game Studio is an extension of C#, they have a lot in common and it is no different when it comes to variables. A variable is an object with a value. These values can be changed any time, by anyone. The variables have the following format: AccessModifier VariableType VariableName; The access modifier can allow or restrict access to the variable, depending on which modifier is used. The most common modifiers are: Public - all classes can use a public variable Private - only the class it was made in can use the variable Protected - only inherited classes can access the variable The next part of the variable is its type. There are a lot of variable types, but the ones that can be found in the game are: int - whole number between and bool - yes or no value float - floating point numbers (not whole numbers) double - greater floating point numbers (The following variables are not used in this game, but they are very common): char- single character (Unicode) string - character sequence Finally, the variable name. This name can be everything, but it is case sensitive, which means the variable's name has to be written down in the exact same way as it was initialized ( or else the programs will not use the variable). 10

12 Game - Initialization Initialization is a method inside XNA. It is used for querying services and loading non-texture based content into the game. It also it initializes game components, before the contents are loaded. By default, XNA adds the base.initialize(); line of code, which ensures that the basic components of the game are initialized. This is why there is no need to initialize other methods in the main game file, as they are included in the basic initialization. The order of the methods in the game is crucial. The Load, Update and Draw methods have to be after the Initialization, or the game will not be able to use these methods. Also the initialization of different classes into the main file is done in the Initialization with the following format: classname.initialize(); The huge difference between the Initialization method and the LoadContent method is that Initialization is used to load in the basic framework of a game, without it, the program would not run. The LoadContent method is used to load graphical content into the game, such as textures, sounds, or effects. The time between the initialization and the final drawing of the game can vary, depending on the scale of the initialization, the amount of loaded content, the amount of logic in the Update method and the amount of drawing needed in the Draw method. This time is what the user experiences as delay between starting the program and visually seeing the program. 11

13 Game - Content The content is a folder, which is auto-generated by XNA to hold external files, that can be used as ingame textures, sounds, effects or fonts. XNA uses a Content Pipeline that makes loading the contents of the game faster. The way it does this is when the game is building (for example at debugging), the contents which have to be loaded into the game, get processed into a managed code object, which then gets serialized to a file which is included in the game's executable. In other words, this means that the program builds the content into its executable, which then can immediately access said content, which means the build time of the content is lowered, thus the program builds up faster. The contents have to be in appropriate file formats for it to work. Thank fully the Content Pipeline supports a lot of file extensions, so for example it is not a problem for XNA to read.jpeg and.png files at the same time, because it supports both of them (although for cosmetic reasons the.png files are better suited for a game environment). XNA also has a ContentManager inside its programs. This ContentManager loads the objects that the Content Pipeline holds. It also manages their lifespan and it can also disposed selected objects which are no longer needed by the game (the logic for lifespan and disposing has to be set up by the developer). Adding content to the game is easy, simply right clicking in the Content folder while being inside the program brings up a menu. Here the developer can add new content (XML files, SpriteFonts, Effects) which then can be edited inside the program, or add existing content (ex. pictures, sounds). These will be contained in the upper mentioned Content folder. These files can be called into the game, which then forwards it to the Pipeline. 12

14 Game - LoadContent The LoadContent method is responsible for the visual building of the program. This method uses the Content folder to detect and use graphical content. The method uses a ContentManager to load in content from the folder. The ContentManager cannot unload content. The LoadContent is also where a spritebatch is created. The spritebatch uses the already initialized graphicsdevice in order to later draw the textures that are inside the LoadContent method. The loading of individual textures, effects, sounds etc. also happen in this method. An example for loading a content into the game : menuplay.load(content.load<texture2d>("menuplay")); XNA will auto-detect the extension of the content, so when the developer asks for a specific file, the file extension does not have to be written down. The previously mentioned delay between the start of the program and the usable state of the program can highly depend on the amount of content loaded into the game. Also, the LoadContent method can be used in different classes as well. This makes the program tidier, as the specific texture's loading code is located inside a class. The only things needed are a Load method inside the class, and a new ContentManager created in a parameter. Thus if this happens, the developer can simply load the content of a class into the game using the following code: example.load(content) 13

15 Game - Update The Update method is one of the most important methods in an XNA game. This method deals with the logic of the game. Update is running while the game is running. Also most classes have an update method inside them which is connected to the gametime of the game, which means as long as the game is running, the objects which have an update method (which is then initialized in the main game's update method), will be updated while the game is running. The update method runs 60 times in a second or 16.6 milliseconds. This means that the logic of the game is updated multiple times under a second. It's possible to put a switch inside the update method, for the sake of dividing the logic into multiple parts. For example in this game there are three states - MainMenu, Options and Playing. When the switch is placed into the method, the only state that will be updated is currently initialized (in this case the MainMenu is the first state to be initialized so only it's logic will be ran). Of course switching state means that the last state's logic won't be updated as long as the program is running a different state (ex. the collision or the enemy's movement will not be updated as long as the player is in the Main Menu. But the update method is also the place where the input is initialized. Thanks to the multiple running cycles of the method, it can detect whether a key was pressed, if it's still pressed, or if it was released. This also works with the mouse. This is why if the mouse's state detection of put into the Update method, the mouse will run smoothly as its position is constantly updated. The update method can also be paused. This will freeze everything that's not under the pause function's logic. This means that if the game is paused, then the textures stop moving, if gravity is implemented, that also freezes, and no matter if the user is still pressing the buttons that are used for in game movement, the character will not move. This creates a perfect opportunity to create a pause menu which can have unpause functions or could be used to transfer the user to a different gamestate. 14

16 Game - Draw The draw method is ususally the last method that's called in at classes. This method deals with drawing of sprites (textures onto the screen). Every draw method starts with the spritebatch.begin line. The spritebatch is the default variable that the draw method uses. Usually this is followed by the spritebatch.draw line which contains the texture's type (Texture2D for 2 dimensional pictures and Texture3D for 3 dimensional pictures) followed by the name of the picture (has to be inside the Content folder) in "-s m, then the rectangle of the picture (normally no one can see the rectangle, it's there, because XNA treats every single sprite as rectangles), and the color of the sprite (if the user do not want to change the color of the picture, then usually the color is set to white). Then the drawing ends with the spritebatch.end(); line which closes off the drawing. If the End line is not written into the program, it will try to draw more textures, but cannot so the program gives an error message. If a class contains a draw method, that' where the classes' unique sprite is set up. Then when the class is called in in the main game ex. the mainmenuquit button, then the button can be put into the main draw method by using its own name and the parameters that were given inside the class' draw method (normally the only parameter is SpriteBatch spritebatch - to draw the texture). This looks like this : menuquit.draw(spritebatch);. The spritebatch.begin(); line is normally typed in without parameters. However if needed there are a lot of parameters that can be set: SortMode, BlendState, SamplerState, DepthStencilState,RastarizerState, Effect and Matrix. Out of all this the most usually used parameters are SortMode (a specific sorting mode), BlendState (basically if the sprite has some edges that are not used, the BlendState can get rid of them), Effect (does something special with the sprite) and Matrix (this is used the integrate the camera into the drawing (ex. to make sure that an object moves with the camera)). Also the draw method has the speciality, that the drawing order is very important. The draw method has a back-to-front drawing sequence. This means that after spritebatch.begin();, the first thing that should be drawn is the background and the last thing should be the player and the enemy. If the order is broken up, the program wil still draw the texture, but it will put the first thing behind everything that comes after is. For example of the player is drawn first and the background is drawn later, the player will be drawn behind the background, thus the user won't be able to see the player. 15

17 Main Menu The main menu is one of the fundamental parts of a video game. Without it there is no interface to access the game itself, nor to the options. So it is essential to create one. The first thing to do is to create an enumerator, which is used to access a batch of data. In the case of the game, this enumerator is named GameState and has 3 different values inside it: MainMenu, Options and Play. To make sure that the MainMenu value is read when the program is started a variable called CurrentGameState has to be called ( this is how it should look like: GameState CurrentGameState = GameState.MainMenu;). Resolution is also an important factor in both the menu and the game, as a bad resolution could make textures look very pixelated. In order to fix this, the appropriate resolution(s) must be found (via taking a look at the Screen Resolutions menupoint in Windows and finding the resolutions that have their names near the slider, as these resolutions are supported by the computers screen (see picture on the right). After the class is initiated inside the program, the next step is to load the texture in at the Draw section (it can also be done at the LoadContent section, but I chose to simplify things and draw it as well at the same time), and to give a value to the button's position using a vector. After that the mouse has to be initialized (so that it can be seen when the program runs) and the resolution has to be set up. Then it's all down to creating a switch in both the update and the draw method. This switch will tell the game which state it should be in (ex Menu, Options or Play). The switch contains cases, and every state has its own case which is separated by breaks. In the update method, the switch has more to do than the one in the draw section, since the update method is the one, that has to deal with the logic of the game, and not just drawing sprites on the screen. 16

18 This is the main menu of Blobbed Out. 17

19 Buttons After the menu is done, it is time to create buttons for the game. In this game there is a button class which contains the variables, methods and attributes for buttons. Creating a class is always useful as they hold data that can be called into the game, thus reducing the size of the main game file and making it less chaotic (if everything is done in the main game file, then the game file looks like a complete mess). In this case the button class contains a variable for position, texture, rectangle, a color, and boolean variables down and IsClicked. The position variable is responsible for the position of the button (which is set in the Game file), the texture holds the textures of the buttons (each button has its own texture variable). The rectangle makes sure that every button has its own rectangle. The color variable is currently set to white, and it's later used in the coloring of the button. The down is also used at the coloring of the button. And the IsClicked boolean is used to see if the button has been clicked or not. After an empty constructor has been created and a texture holder has been created in the Load function, it's time to see how the logic of the buttons work in the Update method. Firstly the mouse is initialized and both the mouse and the button is given a rectangle (these rectangles hold the position of the mouse and the buttons on both the X and the Y axis as well as their sizes). The size of the mouse is set to a 1x1 pixel rectangle, while the size of the buttons depend on the size of their textures (in this game, every button has a size of 100x20). When this is done, the logic part comes to life. The way this works is the following: if the mouse's rectangle intersects (is inside) the buttons' rectangle, then the program runs an if statement which takes a look at the alpha color of the button. This alpha color is always 0, which means that the program thinks that the button's color is default (that's because the button was colored outside XNA). So if the alpha color is 0, then the program sets the down boolean to true,which is later set in another if statement. Basically if down is true then the program increases the alpha color of the button, meaning that the program starts to brighten up the button, until the color becomes 255 (white). At which point the program starts subtracting from the alpha color until it becomes 0 again (default), thus giving the button a glowing effect. If the game detects a left click from the mouse then it sets the IsClicked to true, at which point the button does what it was programmed for (the logic of the buttons are individually set up in the main game's 18

20 update method). Lastly a draw method is called to ease up the drawing of the buttons later in the main game. Currently the game has 8 buttons: 1. 3 in the main menu: Play - switches the gamestate to playing, effectively starting the game Options - switches the gamestate to option, thus showing the options menu Quit - quits the program 2. 3 in the options menu: Controller - Changes the controls from keyboard to gamepad (disabling the keyboard in the process) Keyboard (default) - Changes the controls from gamepad to keyboard Back -sets the gamestate back to MainMenu 3. 2 in the Pause Menu: Continue - unpauses the game Quit to main menu - sets the gamestate back to main menu and also resets the player's position, health and the coin counter (reseting the game) 19

21 Options menu Next is the options menu. It is essentially the same as the Main menu, except the buttons do different things and the background is different. The options menu is drawn in the switch of the draw method of the main game, it also has the same width and height as the game's screen. The specialty of the options menu, that it's background also contains the mapping of the buttons used for the movement of the player. The option menu as I mentioned has 3 buttons. The controller button switches out the player's controls from keyboard to controller, which means that player can't use the buttons assigned for movement on the keyboard, only the buttons assigned on the controller. By default, the player uses the buttons of the keyboard. The buttons are as follows: A key is movement to the left, D key is movement to the right and the space bar is used for jumping. The controller uses similar controls, except on a controller: D-Pad (the D-pad on a controller contains the directional keys) left is movement to the left, D-pad right is movement to the right, and button X. This is how the options menu looks like. 20

22 Player The player is one of the most complex part of a game. The player has its own texture, class and has to have interaction logic with everything surrounding it (meaning that the player' logic has to be altered in order to have an interaction with objects, ex. logic has to be set up between the player and the coins in order for the coin to have any effect on the gameplay). The player has its own class, which is pretty much the most complex class out of all the classes in the game. This class contains an empty constructor, a Load, an Update, an Input, a Collision and a Draw method. The constructor is only there to make sure that the class can be constructed and used in other classes. The Load method loads in the player's textures from the Content file of the game (see Contents later). Normally the load method in a class which is not the main game's class would not contain the exact textures, as most classes are used up multiple times (like the tile class), which would result in everything using the same texture. Next up is the Update method. This is where the player's gravity is set up. As long as the player's position on the Y axis does not reach a certain limit (10 pixels from the top), the player's position on the Y axis always goes down, except when collision stops it from falling. This is also where the player's rectangle is set up and the Input method is updated. The input method contains the players movements. First the game pad is initialized, then the program jumps into an if statement. The player class has 2 special variables: keyboardon and controlleron. These two are inside in the upper mentioned if statement, where the program takes a look if either the keyboard or the controller is selected for movement. While one is on, the other is off so that the game can't be controlled with a keyboard and a gamepad at the same time. The movement is connected to the game's internal clock, so that even when the whole game lags (this happens if the game is ran on a very weak computer) the movement looks smooth. Movement is done by assigning a value to the velocity of the player which then updates the position of the player. Moving left or right is done by changing the player's velocity (thus position) on the X axis and jumping is done by changing the player's position on the Y axis. Probably the most important method is the Collision. This is where the player's interaction with the world is set up. First the program takes a look at whether the player is touching something or not. If yes then a bool called hastouched is set to true, which indicates if the player touched something or not. Then the tilestyle's enum (see tile later) is investigated: if the player touches any block that's not a spike block, then the collision between block and player is set up (see collision later). In case of touching a spike block, the player's 21

23 health is decreased as long as it's in contact with the spike. The draw method is where the drawing of the player is initialized. In the main game, the player class has to be called in and initialized in order for the program to load in the player's attributes. Then the player's texture has to be loaded in. Later in the Update method, the player has multiple appearances: first the player's has Touched variable is set to false which then set's the healthbar's rate of change to 0 (so that no damage is done to the player)((see healthbar later on for more information about the healthbar's variables)).then the player's collision is initialized, and the player's rectangle also called in for 2 if statements (one for the logic behind coins and one for the end block's logic). After that the player's interaction with the end of the map (respawn) is set up as well as what happens if the player's health reaches 0 (respawn). The player's position and health is also reset when the pause menu's quit to main menu button is pressed. And finally the player is drawn in the Draw method. This is how the player looks like in Blobbed Out. 22

24 Camera The camera makes sure that the player always sees what happens to the player in-game. The camera also has its own class. First the camera's viewport (the screen where the game is played) is set up in the camera's constructor, so that the computer's screen is the viewport for the camera. Then in the Update method, the camera's position is set of the complete center of the screen. Then the what the camera sees is translated to the player using a matrix, which uses a 3 dimensional vector(essentially what happens is, that even though the camera is set up, the things it sees can only be seen by the computer but not by the player, thus a translation is needed so that the program translates what the camera sees to the player)((a 3 dimensional vector has 3 parameters: 1 on the X axis, one on the Y axis, and one on the Z axis, thus that's why the camera's depth (zooming) can also be set. In the main game the camera's viewport is set to the computer's screen. The camera can also be used as a parameter in the draw method. For objects that need a fixed position such as the healthbar, coin counter or the pause menu, the camera's translation is used as a position (with little modification so that these objects won't stick to the center of the camera). 23

25 Gravity Gravity is a feature that's included in both the player and the enemy class. It does the following: there is a limit set up by the developer (in my case it's 10 pixels from the top) and if the player or the enemy is under that limit ( when XNA draws something on the screen then the X axis drawing goes left to right while the Y axis drawing goes from top to bottom, this is why if something Y axis position is subtracted then the object goes up the screen and thus this explains why gravity actually increases the position on the Y axis) then the program pulls it down, but this pull is negated if the player or the enemy comes in contact with a tile. 24

26 Tiles Blobbed out's map is made out of different tiles, for different purposes. These tiles represent the terrain of the game (but as the placement system of this game is very convenient I have also put the coin in with the terrain blocks). These blocks are generated and drawn using something called a tilemap, but more on that later. Also the tiles' have their own class so that when it comes to initializing them it's easier. The blocks are the following: The Grass block is the first tile in the game. They are just usual, regular grass blocks. They do not damage the player, but the player's collision is connected with them, thus the collision is active on this block, stopping the player's gravity. All blocks have their own numbers, which is used later on in the map creation. The number assigned to the grass block is 1. This is a grass block. The second block is the Dirt block. These have essentially the same attributes as the grass blocks that I have mentioned earlier. These blocks represent the underground part of the game, thus why the grass blocks cannot be found in underground areas. The dirt block's number is 2. This is a dirt block. The third block is the Spike block. These blocks can be found on both the surface and the underground. Collision is also implied to them, so the player cannot go through them. But there is a twist with these blocks. In the player class at the collision method's switch the previous two blocks belonged to the default option (collision on, damage off), but the spike has its own case. Whenever the player contacts a spike, the healthbar starts dropping. This means that spikes are a hazard, and thus should be avoided at all cost. Spike blocks' number is 3. This is a spike block 25

27 The fourth block is the Coin block. These blocks are entirely different from the other blocks. These blocks do not possess collision. This means the player can go through them with ease. But this is their purpose. Coin blocks exist for the purpose of the player collecting them. That's right they are collectibles. And they even have a counter (under the healthbar), which shows how many coins did the player collect during the level. Also coins disappear after the player collected them. The way these work is that when the player comes in contact with them (the player's rectangle intersects the coin's rectangle), the program deletes the block that the player touched and then increases the coin counter's integer (it's number based variable). Coin blocks have the number 4. This is a coin block. The last block is the End block. These blocks are similar to the coin blocks in that they don't have collision. But they will not disappear when the player comes in contact with them. The specialty of these blocks is that end blocks only appear at the end of the level. End blocks mark the end of a level and they have a special effect. They teleport the player to the next level, though this feature is not implemented yet to the game (currently it drops the player back to the main menu). When the player get in contacts with the end block the player's position, health and coin counter is also reset. End blocks have the number 5. This is an end block Thanks to the Draw method in the tile class, it only takes one line to draw the blocks into the screen. 26

28 Tilemap The previously mentioned tiles have a special method of drawing them on the screen. This special function is called the Tilemap. The tilemap is a an list which holds multiple rows an each row can hold unlimited number of values. But the kicker is that every row has to be the same length or the program will not allow it to run (it is an error). This list is located in the tilemap's own class called the Map class. This map class has variables for the width and height of blocks, as well as the upper mentioned list called CollisionTiles. The class also has a special method called Generate. This is used to generate the blocks into the game according to their numbers. The method takes a look at the blocks set in the tile map, and if the number in not 0 at a given value then it will draw a block corresponding to the number located at the value. The size of the blocks can also be set here with modifying the second parameter of the method (the first being the list itself). The tile map is initiated in the Load method of the main game file. Thanks to its style it is very easy to create new maps by simply replacing the numbers in the list. (see picture on the right for structure) 27

29 Collision (Rectangle Helper) The collision is one of the biggest part of the game. It's thanks to the collision that the player will not fall out of the screen. The collision has its own method, which is located in both the player class and the enemy class. The method has 4 parameters: Rectangle -which in this case is the rectangle of the tile Xoffset - this helps keeping the player or enemy on the screen on the X axis Yoffset - this helps keeping the player or enemy on the screen on the Y axis Tilestylenum - this is the number that was given to specific tiles The way the collision works is the following: The program first have to pass an if statement regarding whether the player's or the enemy' rectangle ha intersected the block's rectangle. If those to really intersected, then hastouched equals true (hastouched is a bool, and it's there to see if the player/enemy is in contact with a block).then the program has to go through a switch, which's state is changed according to the tilestylenumber that the block has. The switch has 4 different case: The Default case which is used if a block do not have a special case. The default state is used by the grass and the dirt tiles. Case 3 : This is the case of the spike blocks. In this case the collision algorithm has a special condition: whenever the player comes in contact with them, the player loses health. Other than that the collision still works on spikes, making them impassable. Case 4 : This is the case of the coin blocks. They have a simple interaction with the player - if the player touches them, they disappear and increase the coin counter of the player. Case 5 : This is the case of the end blocks. Whenever they come in contact with the player, the game jumps back to the main menu, and the playing state resets. 28

30 In the default and the third case the program continues to go through more if statements. These if statements check where the player or the enemy is touching the block. Upon touching the top, the velocity changes to 0, which means the player/enemy will not fall through the block. Also it reset the ability for the player to jump (when the player has jumped the boolean hasjumped changes to true in order to disable unlimited jumping). When the bottom is touched the velocity changes back to 1, in order for gravity to work. When either side of a block is touched the player will just bounce off the block. Finally collision also makes sure that if the player's position on either the X axis or the Y axis is less or more than the edge of the map, the player will not be able to move further, meaning that the player cannot fall out of the map. This is also true with the Enemy. In case of the spike blocks, anytime the player touches them at any side, it will lose health. The following picture will demonstrate how the collision works: The black box is the tile. The red areas are the ones that the collision method is monitoring. If the player or the enemy comes in contact with these areas, the appropriate effects will kick in. The system is not perfect, but most sidescroller games use this type of collision, mainly for their ease of setting up. 29

31 Healthbar Because there is an object that can harm the player, a special meter has to be set up to track how much damage has been dealt, and how much is left. For this purpose a healthbar is created. The healthbar also has its own class. The healthbar is basically 2 textures put together: a bar and a gauge. Visually the gauge is the one that changes, the bar is only there as a frame. The logic behind the healthbar is a little bit more complex. The healthbar has a currenthealth variable which is by default 170 (max health). Whenever the max health is more than 0, a variable called rate of change will negatively change the currenthealth's value (meaning it reduces health). The currenthealth is connected to the lenght of the gauge. Which means that is the currenthealth is reduced, the length is also reduced. There is also a method for the coloring the healthbar called a HealthColor method. Whenever the gauge's length reaches a certain point, the coloring of the gauge changes. Until 80% the gauge is green, if the width drops between 80% and 60% then the gauge is green-yellow. Between 60% and 40% the gauge is yellow and between 40% and 20% the coloring changes to orange. Upon dropping under 20% the gauge becomes red, until its value reaches 0. When the health becomes 0, the player respawns at the beginning of the level with full health, but with the coin counter reset to 0. Every time the game resets due to: player's health depletion, player falling out of map, player quits; the healthbar's value is always reset to maximum amount. The healthbar's position is connected to the camera, so wherever the camera goes, the healthbar will follow. contact with a spike. This is how the healthbar looks like after the player got briefly in 30

32 Enemy The enemy is another hazard to the player. It has collision and well as gravity just like the player. And it also has its own class. The enemy's interaction is not the same at the player's. The enemy will collide with every block, cannot take damage, and will not respawn when it reaches the end of the map on the Y axis. But its specialty is that is patrols a certain area and will damage the player when they get in contact. When the enemy is spawned in, it will patrol an area (the size of that area is given by the player), until the player breaches its threshold. When the player gets into the enemy's area the enemy will pursue the player as long as the distance will not reach said threshold. When the player escapes, the enemy will stop following the player and continues to patrol a given amount of area where the pursuit has ended. Also when the enemy's rectangle intersects the player's rectangle, the healthbar's rate of change value changes to 1, thus damaging the player in the process. The enemy class has its own draw method, making it easier to draw the enemy in the main game. This is how the enemy looks like in Blobbed Out: 31

33 Pause Menu Whenever the player presses the Escape button (or the start button on the gamepad) while being the the Playing state, the game freezes and a special menu comes up. This menu is called the pause menu. This menu's purpose is to either stop the game for a while (because the user has to do something in real life), or just for restarting the game. The pause menu's texture is similar to the Main Menu or the Options menu, but the coloring of the picture is different. When the pause menu is drawn (in a different program), the opacity of the picture has to be low. What this does, is when the game is paused, the user can still see the game behind the pause screen. This is how the pause menu looks like. The pause menu's logic is set in the main game's Update method. While being in the Playing gamestate, when the player presses the Escape button, the logic of the playing case stops and the pause menu comes up. The pause menu's position is connected to the camera, so wherever the user went when the game was unpaused, will pause there. The pause menu also has two buttons: a Continue and a Quit to Main Menu button. The Continue button will stop the pause function and the game will be restored wherever the user left it. And the Quit to Main menu button changes the gamestate back to MainMenu, effectively qutting the game and putting the user back to the main menu. The specialty of the latter button, that it also resets the game. So when the player presses Play in the main menu everything will be at their starting positions. 32

34 Background Lastly there is a background for the game. The background consists of 2 pictures which are infinitely placed after each other as long as the player moves further than the 2nd picture. Backgrounds also have a class, but the only two variables it has is the texture and the rectangle. There's also method for the backgrounds called scrolling with has the parameters of texture and rectangle. And the backgrounds also have a draw method. The logic behind the backgrounds is located in the main game's Load method, as it's not a regular logic, it's more like clever usage of loading textures. Every time the player moves out of one background, the other will spawn. This works both when the player goes out of the length of the background or when the player goes out of the height of the background. Also when it comes to drawing, the background should be the first thing to be drawn, as if the background's drawing is put after anything else, the background will hide the texture behind it. These are the two pictures used as backgrounds in Blobbed Out (an improved version will come later, but due to time restrictions, these two remained). 33

35 Conclusion The project helped me to improve my skills in planning, managing and executing a complex project, but along the way I also learned more about programming, and how to integrate things from different programs and adding them into mine. Furthermore, the project also helped in honing my researching skills. After the project, I feel like jumping into harder and unknown tasks are much more simple. As I previously had no experience with video game making, I think I improved a lot at understanding how these seemingly very hard programs are really just a bunch of mathematics and logic. Whenever I was in doubt of something, or I simply had no idea of how and where to start or search, I remembered the words of my IT teacher from high school : "Don't worry, if you have a problem just Google it. There could be 999 other people who have the same problem as you, and I guarantee you that there is a 1000th person who knows the answer." Personally I did not mind that I had to work alone, but the nature of my project would normally require more people, since there were a lot of things to work on in a game like this. If I create a video game in the future (I'm currently in the planning phase), then I would like to work with more people, to ease up the work tempo and to have people around if I need to ask something. 34

36 Appendices Blobbed Out - Game1.cs namespace BlobbedOut public class Game1 : Microsoft.Xna.Framework.Game //Graphics variable GraphicsDeviceManager graphics; //Drawing variable SpriteBatch spritebatch; //Font variable SpriteFont Font; //Enum for gamestates enum GameState MainMenu, Options, Playing //Selecting starting gamestate GameState CurrentGameState = GameState.MainMenu; //Screen size int screenwidth = 800, screenheight = 600; //Creating camera variable Camera camera; //Creating map variable Map map; //Creating player variable public static Player player; //Creating healthbar variable public static Healthbar healthbar; //Creating enemy variable Enemy enemy; //Coin counter int coincount = 0; //PauseMenu bool paused = false; Texture2D pausedtexture; Rectangle pausedrectangle; //Buttons Button pauplay, pauquit, menuplay, menuquit, optionkeyb, optioncont, optionback, menuopt; 35

37 List<Scrolling> backgrounds = new List<Scrolling>(); public Game1() //Initializing graphics and content folder graphics = new GraphicsDeviceManager(this); Content.RootDirectory = "Content"; //Initialization protected override void Initialize() //Initializing classes map = new Map(); player = new Player(); healthbar = new Healthbar(Content); //Initializing game base.initialize(); //Loading content protected override void LoadContent() //Loading drawing method spritebatch = new SpriteBatch(GraphicsDevice); //Loading font Font = Content.Load<SpriteFont>("SpriteFont1"); //Screen graphics.preferredbackbufferheight = screenheight; graphics.preferredbackbufferwidth = screenwidth; graphics.applychanges(); //Mouse MouseState mouse = Mouse.GetState(); IsMouseVisible = true; 30); //Enemy enemy = new Enemy(Content.Load<Texture2D>("Enemy"), new Vector2(1850, 64), //MainMenu menuplay = new Button(); menuplay.load(content.load<texture2d>("menuplay")); menuquit = new Button(); menuquit.load(content.load<texture2d>("menuquit")); menuopt = new Button(); menuopt.load(content.load<texture2d>("options")); //Options optionkeyb = new Button(); optionkeyb.load(content.load<texture2d>("keyboard")); optioncont = new Button(); optioncont.load(content.load<texture2d>("controller")); optionback = new Button(); 36

38 optionback.load(content.load<texture2d>("back")); //PauseMenu pausedtexture = Content.Load<Texture2D>("Pause"); pauplay = new Button(); pauplay.load(content.load<texture2d>("pauplay")); pauquit = new Button(); pauquit.load(content.load<texture2d>("pauquit")); //Camera camera = new Camera(GraphicsDevice.Viewport); //Terrain Tile.Content = Content; map.generate(new int[,] 1,0,0,0,0,0,4,0,0,0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0,0,0,5, 2,0,0,0,4,0,1,0,0,0,0,0,2,2,2,0,0,4,4,4,4,4,4,4,4,0,0,5, 2,0,3,0,0,2,2,2,3,3,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,5, 2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2, 1,0,0,2,0,0,0,0,0,0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0,0,0,0, 2,4,0,0,0,0,2,0,0,0,0,0,2,2,2,0,0,0,4,4,4,4,4,4,4,4,0,0, 2,0,0,3,3,2,2,2,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,, 100); //Loading and placement of Background for (int i = 0; i < map.height; i += 600) for (int j = 0; j < map.width; j += 800) if (j % 2 == 0) backgrounds.add(new Scrolling(Content.Load<Texture2D>("Background1"), new Rectangle(j, i, 800, 600))); else backgrounds.add(new Scrolling(Content.Load<Texture2D>("Background2"), new Rectangle(j, i, 800, 600))); //Loading player content player.load(content); //Unloading textures (not used) protected override void UnloadContent() //Game logic update 37