| << Chapter < Page | Chapter >> Page > |
Beyond that, there are several other tools that will make it possible for us to create more sophisticated and interesting games:
I may show you how to create some of those tools later in this series of modules. On the other hand, I may decide to leave that as an exercise for the student.
This section contains a variety of miscellaneous information.
Financial : Although the Connexions site makes it possible for you to download a PDF file for thismodule at no charge, and also makes it possible for you to purchase a pre-printed version of the PDF file, you should beaware that some of the HTML elements in this module may not translate well into PDF.
I also want you to know that, I receive no financial compensation from the Connexions website even if you purchase the PDF version of the module.
In the past, unknown individuals have copied my modules from cnx.org, converted them to Kindle books, and placed them for sale on Amazon.com showing me as the author. Ineither receive compensation for those sales nor do I know who does receive compensation. If you purchase such a book, please beaware that it is a copy of a module that is freely available on cnx.org and that it was made and published withoutmy prior knowledge.
Affiliation :: I am a professor of Computer Information Technology at Austin Community College in Austin, TX.
Complete listings of the XNA program files discussed in this module are provided in Listing 19 and Listing 20 .
Listing 19 . The class named Sprite for the project named XNA0128Proj.
/*Project XNA0128Proj
* This file defines a Sprite class from which a Sprite* object can be instantiated.
*******************************************************/using System;
using Microsoft.Xna.Framework;using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;namespace XNA0128Proj {
class Sprite {private Texture2D image;
private Vector2 position = new Vector2(0,0);private Vector2 direction = new Vector2(0,0);
private Point windowSize;private Random random;
double elapsedTime;//in milliseconds//The following value is the inverse of speed in
// moves/msec expressed in msec/move.double elapsedTimeTarget;
//-------------------------------------------------////Position property accessor
public Vector2 Position {get {
return position;}
set {position = value;
}//end set}//end Position property accessor
//-------------------------------------------------////WindowSize property accessor
public Point WindowSize {set {
windowSize = value;}//end set
}//end WindowSize property accessor//-------------------------------------------------//
//Direction property accessorpublic Vector2 Direction {
get {return direction;
}set {
direction = value;}//end set
}//end Direction property accessor//-------------------------------------------------//
//Speed property accessor. The set side should be// called with speed in moves/msec. The get side
// returns speed moves/msec.public double Speed {
get {//Convert from elapsed time in msec/move to
// speed in moves/msec.return elapsedTimeTarget/1000;
}set {
//Convert from speed in moves/msec to// elapsed time in msec/move.
elapsedTimeTarget = 1000/value;}//end set
}//end Speed property accessor//-------------------------------------------------//
//This constructor loads an image for the sprite// when it is instantiated. Therefore, it requires
// an asset name for the image and a reference to a// ContentManager object.
//Requires a reference to a Random object. Should// use the same Random object for all sprites to
// avoid getting the same sequence for different// sprites.
public Sprite(String assetName,ContentManager contentManager,
Random random) {image = contentManager.Load<Texture2D>(assetName);
this.random = random;}//end constructor
//-------------------------------------------------////This method can be called to load a new image
// for the sprite.public void SetImage(String assetName,
ContentManager contentManager) {image = contentManager.Load<Texture2D>(assetName);
}//end SetImage//-------------------------------------------------//
//This method causes the sprite to move in the// direction of the direction vector if the elapsed
// time since the last move exceeds the elapsed// time target based on the specified speed.
public void Move(GameTime gameTime) {//Accumulate elapsed time since the last move.
elapsedTime +=gameTime.ElapsedGameTime.Milliseconds;
if(elapsedTime>elapsedTimeTarget){
//It's time to make a move. Set the elapsed// time to a value that will attempt to produce// the specified speed on the average.
elapsedTime -= elapsedTimeTarget;//Add the direction vector to the position
// vector to get a new position vector.position = Vector2.Add(position,direction);
//Check for a collision with an edge of the game// window. If the sprite reaches an edge, cause
// the sprite to wrap around and reappear at the// other edge, moving at the same speed in a
// different direction within the same quadrant// as before.
if(position.X<-image.Width){
position.X = windowSize.X;NewDirection();
}//end ifif(position.X>windowSize.X){
position.X = -image.Width/2;NewDirection();
}//end ifif(position.Y<-image.Height) {
position.Y = windowSize.Y;NewDirection();
}//end ifif(position.Y>windowSize.Y){
position.Y = -image.Height / 2;NewDirection();
}//end if on position.Y}//end if on elapsed time
}//end Move//-------------------------------------------------//
//This method determines the length of the current// direction vector along with the signs of the X
// and Y components of the current direction vector.// It computes a new direction vector of the same
// length with the X and Y components having random// lengths and the same signs.
//Note that random.NextDouble returns a// pseudo-random value, uniformly distributed
// between 0.0 and 1.0.private void NewDirection() {
//Get information about the current direction// vector.
double length = Math.Sqrt(direction.X * direction.X +
direction.Y * direction.Y);Boolean xNegative = (direction.X<0)?true:false;
Boolean yNegative = (direction.Y<0)?true:false;
//Compute a new X component as a random portion of// the vector length.
direction.X =(float)(length * random.NextDouble());
//Compute a corresponding Y component that will// keep the same vector length.
direction.Y = (float)Math.Sqrt(length*length -direction.X*direction.X);
//Set the signs on the X and Y components to match// the signs from the original direction vector.
if(xNegative)direction.X = -direction.X;
if(yNegative)direction.Y = -direction.Y;
}//end NewDirection//-------------------------------------------------//
public void Draw(SpriteBatch spriteBatch) {//Call the simplest available version of
// SpriteBatch.DrawspriteBatch.Draw(image,position,Color.White);
}//end Draw method//-------------------------------------------------//
}//end class}//end namespace Listing 20 . The class named Game1 for the project named XNA0128Proj.
/*Project XNA0128Proj
* This project demonstrates how to integrate space* rocks, power pills, and ufos in a program using
* objects of a Sprite class. This could be the* beginnings of a space game.
* *****************************************************/using System;
using System.Collections.Generic;using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;using XNA0128Proj;
namespace XNA0128Proj {public class Game1 : Microsoft.Xna.Framework.Game {
GraphicsDeviceManager graphics;SpriteBatch spriteBatch;
//Use the following values to set the size of the// client area of the game window. The actual window
// with its frame is somewhat larger depending on// the OS display options. On my machine with its
// current display options, these dimensions// produce a 1024x768 game window.
int windowWidth = 1017;int windowHeight = 738;
//This is the length of the greatest distance in// pixels that any sprite will move in a single
// frame of the game loop.double maxVectorLength = 5.0;
//References to the space rocks are stored in this// List object.
List<Sprite>rocks = new List<Sprite>();
int numRocks = 24;//Number of rocks.//The following value should never exceed 60 moves
// per second unless the default frame rate is also// increased to more than 60 frames per second.
double maxRockSpeed = 50;//frames per second//References to the power pills are stored in
// this List.List<Sprite>pills = new List<Sprite>();
int numPills = 12;//Number of pills.double maxPillSpeed = 40;//moves per second
//References to the UFOs are stored in this List.List<Sprite>ufos = new List<Sprite>();
int numUfos = 6;//Max number of ufosdouble maxUfoSpeed = 30;
//Random number generator. It is best to use a single// object of the Random class to avoid the
// possibility of using different streams that// produce the same sequence of values.
//Note that the random.NextDouble() method produces// a pseudo-random value where the sequence of values
// is uniformly distributed between 0.0 and 1.0.Random random = new Random();
//-------------------------------------------------//public Game1() {//constructor
graphics = new GraphicsDeviceManager(this);Content.RootDirectory = "Content";
//Set the size of the game window.graphics.PreferredBackBufferWidth = windowWidth;
graphics.PreferredBackBufferHeight = windowHeight;}//end constructor
//-------------------------------------------------//protected override void Initialize() {
//No initialization required.base.Initialize();
}//end Initialize//-------------------------------------------------//
protected override void LoadContent() {spriteBatch = new SpriteBatch(GraphicsDevice);
//Instantiate all of the rocks and cause them to// move from left to right, top to
// bottom. Pass a reference to the same Random// object to all of the sprites.
for(int cnt = 0;cnt<numRocks;cnt++){
rocks.Add(new Sprite("Rock",Content,random));//Set the position of the current rock at a
// random location within the game window.rocks[cnt].Position = new Vector2((float)(windowWidth * random.NextDouble()),
(float)(windowHeight * random.NextDouble()));//Get a direction vector for the current rock.
// Make both components positive to cause the// vector to point down and to the right.
rocks[cnt].Direction = DirectionVector(
(float)maxVectorLength,(float)(maxVectorLength * random.NextDouble()),
false,//xNegfalse);//yNeg
//Notify the Sprite object of the size of the// game window.
rocks[cnt].WindowSize =
new Point(windowWidth,windowHeight);//Set the speed in moves per second for the
// current sprite to a random value between// maxRockSpeed/2 and maxRockSpeed.
rocks[cnt].Speed = maxRockSpeed/2
+ maxRockSpeed * random.NextDouble()/2;}//end for loop
//Use the same process to instantiate all of the// power pills and cause them to move from right
// to left, top to bottom.for(int cnt = 0;cnt<numPills;cnt++) {
pills.Add(new Sprite("ball",Content,random));pills[cnt].Position = new Vector2((float)(windowWidth * random.NextDouble()),
(float)(windowHeight * random.NextDouble()));pills[cnt].Direction = DirectionVector((float)maxVectorLength,
(float)(maxVectorLength * random.NextDouble()),true,//xNeg
false);//yNegpills[cnt].WindowSize =new Point(windowWidth,windowHeight);pills[cnt].Speed = maxPillSpeed/2+ maxPillSpeed * random.NextDouble()/2;
}//end for loop//Use the same process to instantiate all of the
// ufos and cause them to move from right to left,// bottom to top.
for(int cnt = 0;cnt<numUfos;cnt++) {
ufos.Add(new Sprite("ufo",Content,random));ufos[cnt].Position = new Vector2((float)(windowWidth * random.NextDouble()),
(float)(windowHeight * random.NextDouble()));ufos[cnt].Direction = DirectionVector((float)maxVectorLength,
(float)(maxVectorLength * random.NextDouble()),true,//xNeg
true);//yNegufos[cnt].WindowSize =new Point(windowWidth,windowHeight);
ufos[cnt].Speed = maxUfoSpeed/2
+ maxUfoSpeed * random.NextDouble()/2;}//end for loop
}//end LoadContent//-------------------------------------------------//
//This method returns a direction vector given the// length of the vector, the length of the
// X component, the sign of the X component, and the// sign of the Y component. Set negX and/or negY to
// true to cause them to be negative. By adjusting// the signs on the X and Y components, the vector
// can be caused to point into any of the four// quadrants.
private Vector2 DirectionVector(float vecLen,float xLen,
Boolean negX,Boolean negY){
Vector2 result = new Vector2(xLen,0);result.Y = (float)Math.Sqrt(vecLen*vecLen
- xLen*xLen);if(negX)
result.X = -result.X;if(negY)
result.Y = -result.Y;return result;
}//end DirectionVector//-------------------------------------------------//
protected override void UnloadContent() {//No content unload required.
}//end unloadContent//-------------------------------------------------//
protected override void Update(GameTime gameTime) {//Tell all the rocks in the list to move.
for(int cnt = 0;cnt<rocks.Count;cnt++) {
rocks[cnt].Move(gameTime);
}//end for loop//Tell all the power pills in the list to move.
for(int cnt = 0;cnt<pills.Count;cnt++) {
pills[cnt].Move(gameTime);
}//end for loop//Tell all the ufos in the list to move.
for(int cnt = 0;cnt<ufos.Count;cnt++) {
ufos[cnt].Move(gameTime);
}//end for loopbase.Update(gameTime);
}//end Update method//-------------------------------------------------//
protected override void Draw(GameTime gameTime) {GraphicsDevice.Clear(Color.CornflowerBlue);
spriteBatch.Begin();//Draw all rocks.
for(int cnt = 0;cnt<rocks.Count;cnt++) {
rocks[cnt].Draw(spriteBatch);
}//end for loop//Draw all power pills.
for(int cnt = 0;cnt<pills.Count;cnt++) {
pills[cnt].Draw(spriteBatch);
}//end for loop//Draw all ufos.
for(int cnt = 0;cnt<ufos.Count;cnt++) {
ufos[cnt].Draw(spriteBatch);
}//end for loopspriteBatch.End();
base.Draw(gameTime);}//end Draw method
//-------------------------------------------------//}//end class
}//end namespace -end-
Notification Switch
Would you like to follow the 'Xna game studio' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|