MTA Game Development

1. Developing the Game Functionality
Lesson 6

2. Exam Objective Matrix
Skills/Concepts MTA Exam Objectives
Programming the
Components
Understand Components (1.5)
Capture User Data (1.6)
Work with XNA (1.7)
Handling Game Data Work with XNA (1.7)

3. Programming the Components
• A significant part of game development
goes into creating and programming the
game functionality.
• The game development process
comprises of the following elements:
– Creating tools
– Programming the game
– Incorporating AI

4. Understanding Tool Creation
• Almost every game involves the use of
game tools for tasks such as importing or
converting art, building levels, and so on.
– Tool creation is the process when a game
programmer creates game tools.
• Tools created might include:
– Asset conversion tools, level editors or
map editors.

5. Tools
• Asset conversion tools are programs that
convert the artwork such as 3D models
into formats required by the game.
• Level editor tools allow the game player to
customize or modify levels within a game.
• Map editor tools allow the game player to
create custom maps with no knowledge of
programming skills.

6. Programming the Game
• After you load or add game components,
such as sprites, textures, game models,
and images in your game, you need to
make the components functional.
• To make the components functional, as
per the player’s input or as per the game’s
progress, you need to further program the
components.

7. Programming the Game: Showing Changes
Full health Low health

8. Programming the Game: Health Change
• The code sample in the textbook provides an
easy way to show changes in the player
character’s health by pressing keyboard keys.
• In the actual game, you would need to map
these changes in variable value to events such
as taking damage or picking up a health kit.
• Notice the color change as an extra indicator to
the player of the character's health state.

9. Programming the Game: Showing Changes
Full magazine Partially full magazine

10. Programming the Game: Using Bullets
• The code sample in the textbook provides
an easy way to show changes in the
number of bullets in the character’s
magazine by pressing keyboard keys.
• In the actual game, you would need to
map these changes in variable value to
events such as shooting the gun (pressing
a button) or picking up ammunition.

11. Programming the Game: Working the Deltas
• Notice that in both of the previous
examples, the majority of the game assets
were unchanged.
• As the player’s health changed, or the
number of remaining bullets changed, only
those items required an update.
• You’ll want to change as little as possible
by using drawable components.

12. Incorporating Artificial Intelligence (AI)
• Incorporating AI involves programming the
behavior of the nonplayer character (NPC) as
close to a human as possible.
• You can add AI for various game scenarios, as
each technique indicates.
• Popular AI techniques:
– Evading AI
– Chasing AI
– Flocking or Grouping AI
– Path finding AI

13. Evading AI
• One of the scenarios that present an opportunity
to incorporate AI is to make the movement of an
object or NPC intelligent.
• Simple sample of evading AI:
1. Get the player character's position on the screen.
2. If the player character's position is in the defined range, then assign
a random wait time to the sprite.
3. Do not move the sprite until the waiting time is over; allows the
player to catch the sprite if he reaches the sprite before the wait
time is over.
4. As soon as the wait time is over, make the sprite appear in some
other place on the scene.
5. Continue steps 2 to 4 until the player catches the sprite.

14. Chasing AI
• The player must evade the AI instead of chasing
(or catching the AI).
• The chasing AI is used when the player must
battle the computer controlled NPC.
• Simplified process:
1. Calculate the difference between the player position
and the AI position and decide on the AI direction of
travel.
2. Normalize the direction, then add randomness to the
direction.
3. Move towards the calculated player position.

15. Flocking or Group AI
• Certain NPCs, such as a group of soldiers,
should to move together without walking over
each other.
• Based on the Craig Reynolds algorithm.
• This algorithm follows three simple rules:
– Steer and avoid colliding into other members of the
group.
– Align towards the average heading of the members of
the group.
– Steer or move toward the average position of the
members of the group.

16. Path Finding AI
• This AI involves moving a game object in an
effort to find a path around an obstacle.
• Most common techniques:
– Breadcrumb path following: The player character
progresses through the game marking some invisible
markers or "breadcrumbs" on her path unknowingly.
– Waypoint navigation: Allows you to place reference
points in the game world which allows the use of
these precalculated paths in the appropriate path
finding algorithms.

17. Other Pathfinding AI Techniques
• Terrain analysis helps to increase the capabilities of an
AI opponent by providing information about the game
world. For example, information about hills, ambush
points, water bodies, and so on can be used by the AI
opponent to its advantage.
• An influence map is a technique that warns the
computer-controlled opponent when its enemy is
spotted.
• Visibility graphs break down larger areas into smaller
areas that are interconnected. This technique is also
used to give the game AI an advantage over the player.

18. Handling Game Data
• Game data means information about every
element in a game. It includes the player or user
data that encompasses the AI data and the level
data. The AI data includes information about the
position of the NPC and the position of the
player character on the game screen.
• Handling game data involves
capturing/retrieving the game data back and
forth from a disk file and managing the state of
the game.

19. Primary Reasons to Save Game Data
• Allows storing the player’s progress in the
current game session and reloading the game
from the last saved point in the next session.
• To allure customers, game manufacturers today
provide the player with the flexibility of saving
the game at any point of time during the
gameplay, at the end of each game level, or at
the specific designated areas within the game.

20. Capturing User Data
• You can capture the game data by using
the XmlSerializer and the
StorageContainer classes in XNA 4.0.
• The XmlSerializer class serializes
objects into XML documents and
deserializes the objects from XML
documents.

21. Serializing Data
• Serializing an object means translating its
public properties and fields into a serial
format, such as an XML document for
storage or transport.
– It is the way of saving an object's state into
a stream or buffer.
• Deserialization is the process of getting
back the object in its original state from the
serialized form.

22. Storage of Game Data
• The StorageContainer class is a
logical set of storage files.
• You can create files to store the state of
the various objects and components in the
game and store the files in a
StorageContainer object.

23. Storing the Game Data
• To store the game data, you need to write code
to perform the following tasks:
– Define all of the data that is to be stored (level, score,
character name chosen, etc.).
– Serialize the game data into the required game file.
• Use the FileExists method of the
StorageContainer class to check if a save
file exists, or use the DeleteFile method to
delete an existing save file.

24. Defining Game Data to Save
public struct PlayerData
{
public string PlayerName;
public Vector2PlayerPosition;
public int Level;
public int Score;
public List<string> completedAchievements;
/* If game is having 24 hr day night system we need to
save that.*/
public System.TimeSpan currentGameTime;
/* If your game has some weather condition , need to
save it too . My game has a fog effect.*/
public bool fogEnable;
}

25. Creating a StorageContainer Object
// Open a storage container.
IAsyncResult asyncResult=
device.BeginOpenContainer("SavingPlayerProfile",
null, null);
// Wait for the WaitHandle to become signaled.
asyncResult.AsyncWaitHandle.WaitOne();
StorageContainer container =
device.EndOpenContainer(asyncResult);
// Close the wait handle.
asyncResult.AsyncWaitHandle.Close();

26. Checking if Save File Exists
string filename = "savedGameState.sav";
// Check to see whether the save exists.
if (container.FileExists(filename))
// Delete it so that we can create one fresh.
container.DeleteFile(filename);

27. Create the Save File and XMLSerializer Object
// Create the file.
Stream fileStream = container.CreateFile(filename);
// Convert the object to XML data and put it in the
stream.
XmlSerializer serializer = new
XmlSerializer(typeof(PlayerData));

28. Stream Data into the Save File, Close the File
PlayerData playerData = new PlayerData();
/* Then set playerData with appropriate info from
game */
playerData.fogEnable = true;
playerData. PlayerName = “your name”;
playerData.Score = 300;
serializer.Serialize(fileStream, playerdata);
// Close the file.
fileStream.Close();
//dispose the containder
Container.Dispose();

29. Loading the Game Data
• Loading or reading the game data from the
game file involves the following tasks:
– Create a StorageContainer object to
access the game file
– Deserialize the game data to load using the
Deserialize method of the
XmlSerializer object.
– Close the stream and dispose of the
StorageContainer object.

30. Managing Game States
• A game state defines the behavior of
every object at any given point in the
game.
• In general, the simplest of games can
have the following game states:
– Initialize
– DisplayMenu
– PlayerPlay
– PlayerLose
– GameOver

31. Managing Game States
• In general, the game tends to behave
according to the value of the game state.
• You manage game states according to the
player’s action(s).
• You must first define all possible game
states, then program the code to support
the various states and the transition
between the states.

32. Basic Switch Logic for Managing Game State
• Not all inclusive below!
switch (currentGameState)
{
case GameState.PlayerPlay:
updatePlayerGamePlayLoop(gameTime);
break;
case GameState.PlayerLose:
if (player.IsReplay)
{
player.Reinitialize();
currentGameState = GameState.PlayerPlay;
}
else
{
currentGameState = GameState.GameOver;
}

33. Recap
• Programming the Components
• Understanding Tool Creation
• Tools
• Programming the Game
• Incorporating Artificial
Intelligence (AI)
• Evading AI
• Chasing AI
• Flocking or Grouping AI
• Path finding AI
• Other Pathfinding AI Techniques
• Handling Game Data
• Capturing User Data
• Serializing Data
• Storage the Game Data
• Loading the Game Data
• Managing Game States