Computer Game Design and Development Frameworks
Using Microsoft XNA Game Studio
History of video and computer game development
Section 1

define terminology

define the game objective

describe the history of video and computer games
Section 2

define terminology

list the game genres

given a list of game titles determine the genre
Game Case Studies
Section 1

analyze popular games from the most common genres

break down programming components

report findings from case study
Game development component exploration and Game development Project
Section 1.1 “Computers, C#, XNA, and You”

understand the function of a computer program as a mechanism for describing a solution to a problem.

recognize that the process of building software is a genuinely creative act.

explain the purpose of a programming language and identify C# as such a language.

understand that XNA is a framework for game creation, not a programming language.

describe the role of Microsoft Visual Studio in the game creation process.

explain how XNA game programs are written on a Windows PC using Visual Studio and then executed on a
target device such as Windows PC, Xbox 360 or Zune.

describe the need for a XNA Creators Club membership when deploying games to the Xbox 360, and the
requirement for Premier membership to place games in the Xbox Live store.

explain how software projects and solutions are used to encapsulate programs and resources within the
Visual Studio environment.

use XNA Game Studio Device Center to manage Xbox 360 and Zune devices.

create an empty project in Visual Studio and deploy and run this program on Xbox 360, Windows PC, or
Zune.

create game programs that can be deployed on multiple target devices.
Renee Nichols
Susan Hinton
Game Design and Development
Page 1
Section 2.1 The Anatomy of a Game Program

understand how C# source program files are deployed in an XNA game.

explain how games are executed in terms of Draw and Update method calls.

recognize how methods are called and provided with parameters to modify their behavior.

understand how comments are used to make programs easier to understand.

identify particular data types in a program, and how each data type holds information for a particular
purpose.

review how variables are declared and given identifiers.

declare variables and set initial values into them.

supply variables as parameters to method calls.
Section 2.2 Storing Data in a Game Program

understand how classes can be used to encapsulate data and behaviors, and how this mechanism is used
when an XNA game is created.

appreciate how member data in a class is shared between methods in that class.

contrast variables declared at member level with those declared local to a block of code.

understand how offices can be used as an analogy when discussing classes, behaviors, and member data.

see how byte variables can be declared to hold integer values in a program.

appreciate the role of the Update method in a running game.

use monadic operators to perform actions on byte data.

see how variable values are passed into method calls as parameters.

understand the effects of overflow in a program and how this is caused by the finite capacity of particular
data types.
Section 2.3 Making Decisions in a Program

understand how an algorithm is created before being expressed as a sequence of statements in a computer
program.

see how the C# Boolean type can be used to represent true or false in a program.

use the C# conditional statement to make a decision on a program.

appreciate how the C# compiler can detect simple logical errors in a program.

use the else part of a conditional statement in C#.

have an insight into the process of program debugging.
Section 3.1 Getting Player Input Using a Gamepad

understand how a program can make use of an object-based representation of a physical device.

understand how to obtain an instance of the GamePadState structure that represents the state of the
gamepad.
Renee Nichols
Susan Hinton
Game Design and Development
Page 2

see how the XNA GamePadState object exposes properties that allow a gamepad to be read by a
program.

understand how to use the GamePad class in an XNA game to obtain the state of the gamepad.

create programs that react to user input via the gamepad.

understand the use of the logical OR and logical AND operators, in a suitable context.
Section 3.2.1 Using the Keyboard

understand how the keyboard is represented in an XNA game and the similarities and differences between
this and the gamepad.

see how a program can test for specific keys.

understand how to create a program that uses both gamepad and keypad to control game play by suitable
use of logical expressions.
Section 3.2.2 Adding Vibration Effects

understand how the gamepad produces vibration effects.

control the production of vibration effects from an XNA program.

understand how to use vibration effects in game play.
Section 4.1 Games and Content

understand the relationship between programs and other content.

show how a large software development must be managed as a collection of related items, not all of which
are executable code.

appreciate the role of the XNA Content Manager and how it works alongside Microsoft Visual Studio so that
different types of content can be supported.

see how content is added into XNA Game Studio projects and how Visual Studio provides property
management of that content.
Section 4.2 Making a Sprite

understand how images are manipulated as two dimensional textures within an XNA game, and how a sprite
is an element in a game with a particular texture and position.

create game world variables to represent textures being used in a game.

see how the XNA Game Lifecycle includes the provision of the LoadContent method to allow a game to
obtain assets when it starts running and an Initialize method to perform other game initialization.

understand the role of the XNA Content Manager component in obtaining requested content items.

have an initial appreciation of the generic mechanism provided by C# which allows different resource types
to be managed by a single behavior.

know how screen positions are expressed when drawing sprites in an XNA game.

appreciate the role of the XNA Rectangle type in expressing the position and size of a rectangle on the
screen.
Renee Nichols
Susan Hinton
Game Design and Development
Page 3

understand how 2D textures can be drawn within XNA games and the role of the SpriteBatch class in
this process.

see how property information can be used to manipulate the drawing process.
Section 5.1 Writing Text

see how the design of characters is expressed on a computer in terms of font information.

appreciate the difference between bitmap and vector fonts.

understand that from an XNA perspective a font is simply another content type.

know how to render text in an XNA game and how the vector type can be used to express the position of
text on the display.

know the properties of fonts that control how they are displayed on the screen and how this information
can be changed by means of an XML encoded spritefont file.

have a simple understanding of how data is held in an XML file.
Section 5.2 Using DateTime

understand how the DateTime type can be used to represent a date and time, and how the Now property
of this type can be used to provide the current data and time.

use the appropriate string methods to extract text versions of the date and time from a DateTime
instance.

create a program that displays a ticking clock.

understand how 3D effects can be created by manipulation of a 2D drawing process.

use assignment statements to set the values of variables to expressions.

use a C# for loop construction to repeatedly execute a set of statements a specific number of times.
Section 6.1 Creating a Multi-player Game

introduce the use of debugging to detect and remedy problems in algorithm design.

appreciate the difference between level-triggered inputs and event-triggered inputs.

understand how the Draw and Update behavior of XNA make it necessary for games to maintain state if
they are to detect events.

appreciate the importance of algorithms in program design, and the way that errors can be introduced into
programs if the algorithms are faulty.
Section 6.2 Constructing the Complete Game

extend a single-player game to allow multiple players.

use the IsConnected property of a gamepad to create games that automatically manage multiple
players.

understand the importance of designing programs for test.

make use of conditional compilation to embed test code into a program.
Section 7.1 Adding Sounds
Renee Nichols
Susan Hinton
Game Design and Development
Page 4

understand how sound information is stored and manipulated on a computer.

capture sound and prepare it for inclusion in an XNA game as an item of content.

load a sound effect and play it within an XNA game program.

understand how multiple channels are used to produce sounds on a computer.
Section 7.2 Playing Music

understand how a SoundEffect value serves as a factory that can produce SoundEffectInstance
objects which describe a currently playing sound.

make use of the concept of null as a way of expressing that a variable does not hold a meaningful value.

discover how a running program makes use of exceptions to indicate that a fault has occurred during
runtime.

see how to manage complexity in programs and allow for users entering invalid inputs.

appreciate the need for appropriate testing when creating a solution.
Section 8.1 Reaction Timer Game

measure time passing in an XNA game, and use points in time to control the behavior of the game.

understand how complex program behaviors can be expressed by the use of simple flow diagrams.

examine an algorithm to determine its proper behavior.

refine a game design to remove game play flaws.
Section 8.2 Finding Winners Using Arrays

understand how an array can be used to hold multiple data items, and how each element is identified by
means of a subscript value.

see how the use of a variable as a subscript can make it easy to set values into an array and also search the
array for particular values.

understand how an array can be used as a look-up table.

appreciate how arrays are managed as objects in a C# program.

understand how subscript values must be within the range values which fits the size of the array, and be
aware of what happens when a program attempts to access an element which is not in an array.
Section 9.1 Using the Keyboard in XNA

appreciate that a keyboard is actually an edge-triggered device, and that a program that must respond to
key presses must detect changes in state.

understand how the context of an action determines precisely what form the action will take in a program.
This is explored in terms of the GetState method for keyboard and gamepad, and the + operator in
respect of numeric value and string variable.

appreciate how keyboards function, and how the keyboard hardware needs to register multiple key presses.
Renee Nichols
Susan Hinton
Game Design and Development
Page 5

use a for loop to traverse the elements of an array, and use the Length property provided by the array to
control the setup of the for loop.

understand how an enumerated type can be used to represent a given set of values, and how this is used in
the design of systems.
Section 9.2 Working with Arrays and Objects

appreciate that in a C# program all variables are actually implemented as objects.

understand the difference in behavior between an object managed by value and one managed by reference.

manipulate arrays in terms of objects managed by reference.

understand the principle of garbage collection, and the circumstances that trigger the removal of an object
from memory.

see how to manipulate objects by means of references to them.

make use of the switch construction to select one behavior from a range of possible options.
Section 10.1 Working with Images

understand the relationship between the XNA screen and the draw rectangle so that images can be moved
and scaled when they are drawn.

create methods that accept parameters and return results to the caller.

use the return keyword and understand how void methods do not return results.

create a test harness for a method that will allow the proper behavior of the method to be proved.
Section 10.2 Debugging Programs

understand the importance of test in program development.

appreciate that program design using test makes programming easier.

use the debugging tools in Microsoft Visual Studio to insert breakpoints, step through programs, and view
the contents of variables.

understand the difference between integer and floating point arithmetic in C# programs.

appreciate issues of type safety and data loss when variables are narrowed and widened.

know how to use casting where appropriate to override compiler type checking.

understand the importance of precision in repeated calculations.
Section 11.1 A First Game Program

create game objects from raw image resources.

use folders to organize game assets.

access game assets from folders, and use folder paths in C# programs.

understand how C# programs are made to run, and the role of the Main method.

understand the effect of making class members static.

understand the use of namespaces to organize game components and how the keyword “using” is used to
identify namespaces.
Renee Nichols
Game Design and Development
Page 6
Susan Hinton

understand how the using construction can be used to improve memory management.

perform simple refactoring of a Microsoft Visual Studio Solution. .
Section 11.2 Creating Game Objects

understand how a sprite is comprised of a texture and a draw position, and how to implement this in XNA
and C#.

appreciate the difference between floating point and integer variables when calculating sprite positions.

use double precision and floating point values where appropriate, and understand issues of range and
precision when choosing variable types.

create display and updated code that is mindful of aspect ratio and the particular size of the screen.

ensure that game portability is maintained by use of automatic dimension calculation.

animate the movement of a game sprite and provide bounce behavior.
Section 12.1 Adding Objects

understand how structures are used in C# to store a set of related values.

use the gamepad ThumbSticks to control the movement of objects on the screen.

use refactoring in Microsoft Visual Studio to make the names of items better reflect their purpose.

factor repeated code into methods.

use reference parameters where appropriate.

use rectangle intersection to detect collisions between objects in an XNA game.
Section 12.2 Adding Targets

understand how using structures to manage information makes it much easier to store large numbers of
instances.

create and use an array of structures.

understand how a single object managed by reference can be referenced by a number of variables.

appreciate how proper design with objects and methods can make scaling a program much easier.

appreciate the tradeoffs in program construction between making programs that are the most efficient and
the effort and compilation that needs to be added to achieve this.

understand how to make objects stateful and how to use this information in a program.
Section 13.1 Finishing Off Game Play

understand the fundamentals of what makes a game playable.

appreciate the role of reward, progression, and survival to in making games attractive to players.

see how game play is implemented by creating member variables, methods, and appropriate C# code
constructions.

create more methods that will manage these aspects of a game to enhance its playability.
Section 13.2 Improving Code Design
Renee Nichols
Susan Hinton
Game Design and Development
Page 7

understand the importance of good code structure.

know when to factor code into a method.

understand the importance of appropriate identifiers.

be able to use code regions to improve program readability.

see how to use the Microsoft Visual Studio refactoring tools on code.
Section 13.4 Making a Complete Game

understand how a program can operate as a state machine.

know how to create enumerated types which can hold values to represent state machine states.

appreciate how a State Diagram can be used to express the states that a program can occupy.

use events to trigger state changes in a state machine.

apply the principles of State Machine design to the implementation of a computer game.
Section 14.1 Design with Objects

understand how to use an object-based approach when attempting to design a program.

understand the concepts of cohesion, coupling, and encapsulation as applied to an object-oriented design.

appreciate that high cohesion is a good design aim, as is low coupling.

see how to design systems containing objects and manage the interactions between the objects.

understand the user of the this keyword as a reference to the currently executing instance of an object.

make use of container objects to hold multiple items.
Section 14.2 Creating Game Objects

understand the difference between structures and classes, in terms of their management by reference and
the way that classes can be arranged into class hierarchies.

know the C# syntax by which a class can be defined as being a child of a parent class.

understand what it means when a method in a class is overridden in a child of the class and the C# syntax
that is required to implement this.

know of the requirement to make a method virtual in a parent class if it is to be overridden in a child.

use the protected access modifier to make members of a parent class visible in those classes that extend the
parent.
Section 15.1 Objects and Abstraction

understand the principle of abstraction in software design.

create and use abstract classes.

understand the principles underpinning the use of references in class hierarchies and the usefulness of a
reference to an abstract class.
Renee Nichols
Susan Hinton
Game Design and Development
Page 8

appreciate how Microsoft Visual Studio provides C#-aware features that make it easier to create software
objects.
Section 15.2 From Objects to Components

create constructors for objects.

appreciate the difference in behavior of constructors when constructing instances of value and reference
types.

create overloaded constructors to provide multiple methods of creating object instances.

understand the principle of constructor chaining up a class hierarchy and the use of this and base to call
constructors in the same and parent classes.

understand how the C# interface mechanism can be used to create interchangeable software components.
Section 16.1 Networks and Computers

understand the principles of data transmission on a network.

appreciate how network messages are addressed and the principle of routing.

understand logical and physical network addresses, and the use of the broadcast address.

tell the difference between datagram and call-based connection.

understand the underlying mechanism of a network protocol.

appreciate how these network principles are applied in real-world solutions such as Xbox Live.
Section 16.2 Network Games and State

understand the fundamentals of Xbox Live and how to use Gamer profiles and tags from an XNA program.

know the different connectivity models available to an XNA networked game.

appreciate the need for a game lobby in a network game and how XNA implements this.

see how a state machine can be used to represent the state of games during network game play.

understand how a delegate can be created to serve as a reference to a method in an object.
Section 16.3 Creating a Multi-player Game

understand the different topologies for communication for network games.

appreciate the role of the client and server in a networked game.

make use of the XNA network application programmer interface to form messages and send game
information between games on a network.

create simple networked game play between two systems on a network.
Unit - Introduction to the Game Industry
Section 1
 understand the forces driving game content development
 know the differences between developer and publisher and developer/publisher hybrids
 review the recent history of game development
Renee Nichols
Game Design and Development
Susan Hinton
Page 9
Section 2


examine game platform differences and most current platforms
consider different budget, schedules, and risk factors for each
Section 3



evaluate technical risks
explore game engines, licensed game engines and development tools
understand how team learning curves influence schedule
Section 4



understand how tasking and tracking a game project is done
learn about publisher reviews
understand the design production pipeline
Section 5



consider multi-cycle or multi-loop development
analyze different game genres
identify risk areas in the different game genres
Section 6



Understand how to take a game to “gold”
Understand game promotion principles
Understand Industry events
Section 7



Examine new and emerging platforms and gaming devices
Explore the evolution of the modern game designer
Examine the tools of game design
Section 8




The role of writing in games
Game difficulty balancing and tuning
Game audio
Scripting game behaviors
Section 9




Learn how to manage the collision of time, budget, and functionality
Building content for kids
Developing online children’s communities
Game examples
Section 10

Renee Nichols
Susan Hinton
Examine the game producer’s perspective
Game Design and Development
Page 10




Working with marketing and public relations
Technical support and customer service in games
Outsourcing game development
Industry ethics
Section 11



Game design review
Pursuing the industry
Preparation for various career tracks
Section 12




Renee Nichols
Susan Hinton
Operating a game development studio
Future work models for the game industry
Industry specific considerations
diversification
Game Design and Development
Page 11