topical media & game development
game-xna-intro-XnaShooter-GameScreens-Mission.cs / cs
// Project: XnaShooter, File: Mission.cs
// Namespace: XnaShooter.GameScreens, Class: Mission
// Path: C:\code\XnaShooter\GameScreens, Author: Abi
// Code lines: 46, Size of file: 857 Bytes
// Creation date: 01.11.2005 23:55
// Last modified: 08.12.2005 16:14
// Generated with Commenter by abi.exDream.com
#region Using directives
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using XnaShooter.Graphics;
using XnaShooter.Helpers;
using XnaShooter.Game;
using XnaShooter.Sounds;
using Texture = XnaShooter.Graphics.Texture;
using Model = XnaShooter.Graphics.Model;
using XnaShooter.Shaders;
#endregion
namespace XnaShooter.GameScreens
{
<summary>
Mission, just manages the on screen display for the game.
Controlling is done in SpaceCamera class.
Most graphical stuff is done in AsteroidManager.
</summary>
public class Mission : IGameScreen
{
#region Variables
<summary>
Link to game.hudTexture and inGameTexture, the texture itself is not
loaded here, but in the main game. This are just references.
</summary>
private Texture hudTopTexture, hudBottomTexture;
<summary>
Background model for the landscape ground and all objects
we render on it.
</summary>
internal Model[] landscapeModels = null,
shipModels = null,
itemModels = null;
<summary>
Landscape model size for rendering.
</summary>
float[] LandscapeModelSize = new float[]
{
// LandscapeGround,
100,
// Building1,
12,//25,
// Building2,
11,//35,
// Building3,
11,//20,
// Building4,
11,//25,
// Building5,
12,//30,
// Kaktus1,
3.5f,//4,
// Kaktus2,
3.5f,//3,
// Kaktus3,
4.0f,//4,
// Kaktus4,
4.5f,//5,
};
<summary>
Number of landscape models
</summary>
const int NumOfLandscapeModels = 10;
<summary>
Model size for all items.
</summary>
internal const float ItemModelSize = 2.5f;
<summary>
Landscape model size for rendering.
</summary>
internal static readonly float[] ShipModelSize = new float[]
{
// OwnShip
5,
// Corvette
5,
// SmallTransporter
4,
// Firebird
7,
// RocketFrigate
13,
// Rocket
1.25f,
// Asteroid
3.4f,
};
<summary>
All ships z height
</summary>
public const float AllShipsZHeight = 5;
<summary>
Ship model types
</summary>
internal enum ShipModelTypes
{
OwnShip,
Corvette,
SmallTransporter,
Firebird,
RocketFrigate,
Rocket,
Asteroid,
} // enum ShipModelTypes
<summary>
Matrix and number for landscape objects
</summary>
class MatrixAndNumber
{
public Matrix renderMatrix;
public int number;
public MatrixAndNumber(Matrix setMatrix, int setNumber)
{
renderMatrix = setMatrix;
number = setNumber;
} // MatrixAndNumber(setMatrix, setNumber)
} // class MatrixAndNumber
<summary>
Only keep lists of this and the next segment landscape objects.
</summary>
List<MatrixAndNumber>
thisLandscapeSegmentObjects = new List<MatrixAndNumber>(),
nextLandscapeSegmentObjects = new List<MatrixAndNumber>();
<summary>
Generated landscape segment number for objects.
</summary>
int generatedLandscapeSegmentNumber = 0;
<summary>
Max. number of objects we generate each segment
</summary>
const int MaxNumberOfObjectsGeneratedEachSegment = 24;
<summary>
Segment length
</summary>
public const float SegmentLength = 122,// 122.12f,
ViewDistance = 70,
GroundZValue = -16,
LookAheadYValue = 40;
<summary>
Look at position.
</summary>
static Vector3 lookAtPosition = new Vector3(0, 0, -16);
<summary>
Look at position.
</summary>
public static Vector3 LookAtPosition
{
get
{
return lookAtPosition;
} // get
} // LookAtPosition
#endregion
#region Units
<summary>
Current enemy units.
</summary>
internal static List<Unit> units = new List<Unit>();
<summary>
Add unit
</summary>
<param name="unitType">Unit
</param>
<param name="position">Pos
</param>
public static void AddEnemyUnit(
Unit.UnitTypes unitType, Vector2 position,
Unit.MovementPattern movementAI)
{
units.Add(new Unit(unitType, position, movementAI));
} // AddWeaponProjectile(weaponType, position, direction)
<summary>
Render enemy units
</summary>
private void RenderEnemyUnits()
{
for (int num = 0; num < units.Count; num++)
{
// Remove this enemy unit if it died
if (units[num].Render(this))
{
// If this is a transporter or rocket frigate,
// create an item here in 25% of the time we kill such a unit.
if ((units[num].unitType == Unit.UnitTypes.SmallTransporter ||
units[num].unitType == Unit.UnitTypes.RocketFrigate) &&
RandomHelper.GetRandomInt(
// Create more items if we only have the MG
Player.currentWeapon == Player.WeaponTypes.MG ? 2 : 4) == 0)
AddItem((Item.ItemTypes)RandomHelper.GetRandomInt(6),
units[num].position);
units.RemoveAt(num);
num--;
} // if
} // for
} // RenderEnemyUnits()
#endregion
#region Items
<summary>
Items.
</summary>
internal static List<Item> items = new List<Item>();
<summary>
Add item
</summary>
<param name="itemType">Item
</param>
<param name="position">Pos
</param>
public static void AddItem(
Item.ItemTypes itemType, Vector2 position)
{
// Don't create a item we currently have as our weapon
if (itemType == Item.ItemTypes.Mg &&
Player.currentWeapon == Player.WeaponTypes.MG ||
itemType == Item.ItemTypes.Gattling &&
Player.currentWeapon == Player.WeaponTypes.Gattling ||
itemType == Item.ItemTypes.Plasma &&
Player.currentWeapon == Player.WeaponTypes.Plasma ||
itemType == Item.ItemTypes.Rockets &&
Player.currentWeapon == Player.WeaponTypes.Rockets)
{
if (Player.health < 0.75f)
itemType = Item.ItemTypes.Health;
else if (Player.empBombs < 3)
itemType = Item.ItemTypes.Emp;
else
itemType = (Item.ItemTypes)(((int)itemType + 1) % 6);
} // if
// Always give health item if health is low.
if (Player.health < 0.25f)
itemType = Item.ItemTypes.Health;
items.Add(new Item(itemType, position));
} // AddItem(itemType, position)
<summary>
Render items
</summary>
private void RenderItems()
{
for (int num = 0; num < items.Count; num++)
{
// Remove items if we are done
if (items[num].Render(this))
{
items.RemoveAt(num);
num--;
} // if
} // for
} // RenderItems()
#endregion
#region Weapon projectiles
<summary>
Current weapon projectiles.
</summary>
static List<Projectile> weaponProjectiles = new List<Projectile>();
<summary>
Add weapon projectile
</summary>
<param name="weaponType">Weapon
</param>
<param name="position">Pos
</param>
<param name="ownProjectile">True for player, false for enemy
</param>
public static void AddWeaponProjectile(
Projectile.WeaponTypes weaponType, Vector3 position,
bool ownProjectile)
{
weaponProjectiles.Add(
new Projectile(weaponType, position, ownProjectile));
} // AddWeaponProjectile(weaponType, position, direction)
<summary>
Render weapon projectiles
</summary>
private void RenderWeaponProjectiles()
{
for (int num = 0; num < weaponProjectiles.Count; num++)
{
// Remove weapon projectile if we are done
if (weaponProjectiles[num].Render(this))
{
weaponProjectiles.RemoveAt(num);
num--;
} // if
} // for
} // RenderWeaponProjectiles()
#endregion
#region Properties
<summary>
Name of this game screen
</summary>
<returns>String
</returns>
public string Name
{
get
{
return "Mission";
} // get
} // Name
private bool quit = false;
<summary>
Returns true if we want to quit this screen and return to the
previous screen. If no more screens are left the game is exited.
</summary>
<returns>Bool
</returns>
public bool Quit
{
get
{
return quit;
} // get
} // Quit
#endregion
#region Constructor
<summary>
Create mission
</summary>
public Mission()
{
Player.Reset();
thisLandscapeSegmentObjects = GenerateLandscapeSegment(0);
nextLandscapeSegmentObjects = GenerateLandscapeSegment(1);
} // Mission()
#endregion
#region Generate landscape segment
<summary>
Generate landscape segment
</summary>
<param name="segmentNumber">Segment number
</param>
private List<MatrixAndNumber> GenerateLandscapeSegment(int segmentNumber)
{
#region Generate enemy units
int numOfNewEnemies = 8 + RandomHelper.GetRandomInt(segmentNumber / 2);//3);
if (segmentNumber == 0)
numOfNewEnemies = 0;
// Finished level?
if (segmentNumber > 60)
{
Player.victory = true;
Sound.PlayVictorySound();
Player.SetGameOverAndUploadHighscore();
} // if
else
{
for (int num = 0; num < numOfNewEnemies; num++)
{
AddEnemyUnit((Unit.UnitTypes)
(segmentNumber < 3 ? RandomHelper.GetRandomInt(2) :
segmentNumber < 7 ? RandomHelper.GetRandomInt(3) :
segmentNumber < 11 ? RandomHelper.GetRandomInt(4) :
segmentNumber < 21 ? RandomHelper.GetRandomInt(5) :
segmentNumber < 35 ? 1 + RandomHelper.GetRandomInt(4) :
2 + RandomHelper.GetRandomInt(3)),
new Vector2(RandomHelper.GetRandomFloat(-20, +20),
segmentNumber * SegmentLength +
RandomHelper.GetRandomFloat(-SegmentLength / 2, 3*SegmentLength / 2)),
(Unit.MovementPattern)
RandomHelper.GetRandomInt(Unit.NumOfMovementPatterns));
} // for
} // else
#endregion
#region Generate random landscape objects on the ground
generatedLandscapeSegmentNumber = segmentNumber;
List<MatrixAndNumber> ret = new List<MatrixAndNumber>();
int numOfNewObjects = RandomHelper.GetRandomInt(
MaxNumberOfObjectsGeneratedEachSegment);
if (numOfNewObjects < 8)
numOfNewObjects = 8;
for (int num = 0; num < numOfNewObjects; num++)
{
int type = 1+RandomHelper.GetRandomInt(NumOfLandscapeModels-1);
// Create buildings only left and right
if (type <= 5)
{
int rotSimple = RandomHelper.GetRandomInt(4);
float rot = rotSimple == 0 ? 0 :
rotSimple == 1 ? MathHelper.PiOver2 :
rotSimple == 1 ? MathHelper.Pi : MathHelper.PiOver2 * 3;
bool side = RandomHelper.GetRandomInt(2) == 0;
float yPos = segmentNumber * SegmentLength + 0.94f *
RandomHelper.GetRandomFloat(-SegmentLength / 2, SegmentLength / 2);
Vector3 pos = new Vector3(side ? -18 : +18, yPos, -16);
// Do we have this position already?
bool tooClose = false;
int tries = 10;
do
{
tooClose = false;
foreach (MatrixAndNumber obj in ret)
if (Vector3.Distance(obj.renderMatrix.Translation, pos) < 16)
tooClose = true;
if (tooClose)
{
yPos = segmentNumber * SegmentLength + 0.92f *
RandomHelper.GetRandomFloat(-SegmentLength / 2, SegmentLength / 2);
side = RandomHelper.GetRandomInt(2) == 0;
pos = new Vector3(side ? -18 : +18, yPos, -15);
} // if
} while (tooClose && tries-- > 0);
// Add very little height to each object to avoid same height
// if buildings collide into each other.
pos += new Vector3(0, 0, 0.001f * num);
ret.Add(new MatrixAndNumber(
Matrix.CreateScale(LandscapeModelSize[type]) *
Matrix.CreateRotationZ(rot) *
Matrix.CreateTranslation(pos),
type));
} // if
else
{
ret.Add(new MatrixAndNumber(
Matrix.CreateScale(LandscapeModelSize[type]) *
Matrix.CreateRotationZ(
RandomHelper.GetRandomFloat(0, MathHelper.Pi * 2)) *
Matrix.CreateTranslation(new Vector3(
RandomHelper.GetRandomFloat(-20, +20),
segmentNumber * SegmentLength +
RandomHelper.GetRandomFloat(-SegmentLength / 2, SegmentLength / 2),
-15)),
type));
} // else
} // for
#endregion
return ret;
} // GenerateLandscapeSegment(segmentNumber)
#endregion
#region Render level background
<summary>
Helper structure to keep models and matrices for rendering in a list.
</summary>
internal struct ModelAndMatrix
{
public Model model;
public Matrix matrix;
} // struct ModelAndMatrix
<summary>
Max. number of models we can render each frame. We got between 20 and
50 landscape objects (ground+objects), and usually between 5 and 20
ships on the screen. This list should be sufficiant for most scenes,
if we got more than 100 models a few landscape objects might be
skipped (they are rendered at last).
</summary>
const int MaxNumberOfModelsToRender = 100;
<summary>
List of all models we have to render this frame. The main reason
for this list is maintainability because we have to render everything
3 times: Once for shadow map generation, once for receiving shadows
and finally on the screen.
The list is created only once and is reused, dynamic lists and foreach
would be too slow on the Xbox 360.
</summary>
internal ModelAndMatrix[] modelsToRender =
new ModelAndMatrix
[MaxNumberOfModelsToRender];
<summary>
Keep track on how many models we currently have in our list. If this
reaches MaxNumberOfModelsToRender no more new objects are added.
</summary>
internal int numOfModelsToRender = 0;
<summary>
Helper method to simply add a new model for rendering.
</summary>
<param name="setModel">Model
</param>
<param name="renderMatrix">Render Matrix
</param>
internal void AddModelToRender(Model setModel, Matrix renderMatrix)
{
if (numOfModelsToRender >= MaxNumberOfModelsToRender)
return;
modelsToRender[numOfModelsToRender].model = setModel;
modelsToRender[numOfModelsToRender].matrix = renderMatrix;
numOfModelsToRender++;
} // AddModelToRender(setModel, renderMatrix)
<summary>
Render level background
</summary>
public void RenderLevelBackground(float levelPosition)
{
if DEBUG
// Landscape or unit ship models not initialized yet?
// Can happen in certain unit tests, initialize them for us!
if (landscapeModels == null)
landscapeModels = new Model[]
{
new Model("BackgroundGround"),
new Model("Building"),
new Model("Building2"),
new Model("Building3"),
new Model("Building4"),
new Model("Building5"),
new Model("Kaktus"),
new Model("Kaktus2"),
new Model("KaktusBenny"),
new Model("KaktusSeg"),
};
if (shipModels == null)
shipModels = new Model[]
{
new Model("OwnShip"),
new Model("Corvette"),
new Model("SmallTransporter"),
new Model("Firebird"),
new Model("RocketFrigate"),
new Model("Rocket"),
new Model("Asteroid"),
};
if (itemModels == null)
itemModels = new Model[]
{
new Model("ItemMg"),
new Model("ItemGattling"),
new Model("ItemPlasma"),
new Model("ItemRockets"),
new Model("ItemEmp"),
};
endif
#region Update camera
// Construct camera position, it will just move up.
Vector3 cameraPosition = new Vector3(0, levelPosition, ViewDistance);
// For widescreen look closer to the ground, else it does not fit on the screen
if ((float)BaseGame.Width / (float)BaseGame.Height >= 1.5f)
{
cameraPosition.Z -= 10;
cameraPosition.Y -= 2;
} // if
lookAtPosition = new Vector3(0, levelPosition + LookAheadYValue, GroundZValue);
BaseGame.ViewMatrix = Matrix.CreateLookAt(
cameraPosition,
lookAtPosition,
new Vector3(0, 1, 0));
if (Player.GameOver)
{
cameraPosition += new Vector3(0, 0, -20) +
Vector3.TransformNormal(new Vector3(30, 0, 0),
Matrix.CreateRotationZ(BaseGame.TotalTimeMs / 2593.0f));
BaseGame.ViewMatrix = Matrix.CreateLookAt(
cameraPosition,
lookAtPosition,
new Vector3(0, 1, 0));
} // if
#endregion
#region Update landscape position
// Show current landscape block and the next one with a wall
// segment between them. We usually just see one block.
int blockPosition = (int)((levelPosition + LookAheadYValue) / SegmentLength);
if (blockPosition + 1 != generatedLandscapeSegmentNumber)
{
// Copy over last objects
thisLandscapeSegmentObjects = nextLandscapeSegmentObjects;
nextLandscapeSegmentObjects =
GenerateLandscapeSegment(blockPosition + 1);
} // if
#endregion
#region Prepare rendering
Vector3 levelVector = new Vector3(0, levelPosition + LookAheadYValue - 5, 0);
// Start new list
numOfModelsToRender = 0;
#endregion
#region Render landscape
Model landscapeModel = landscapeModels[(int)0];
Matrix landscapeScaleMatrix = Matrix.CreateScale(
LandscapeModelSize[(int)0]);
AddModelToRender(landscapeModel, landscapeScaleMatrix *
Matrix.CreateTranslation(
new Vector3(0, blockPosition * SegmentLength, 0)));
AddModelToRender(landscapeModel, landscapeScaleMatrix *
Matrix.CreateTranslation(
new Vector3(0, blockPosition * SegmentLength + SegmentLength, 0)));
#endregion
#region Render ships
Player.shipPos =
new Vector3(Player.position, AllShipsZHeight) + levelVector;
AddModelToRender(
shipModels[(int)ShipModelTypes.OwnShip],
Matrix.CreateScale(ShipModelSize[(int)ShipModelTypes.OwnShip]) *
Matrix.CreateRotationZ(MathHelper.Pi) *
Matrix.CreateRotationX(Player.shipRotation.Y) *
Matrix.CreateRotationY(Player.shipRotation.X) *
Matrix.CreateTranslation(Player.shipPos));
// Add smoke effects for our ship
EffectManager.AddRocketOrShipFlareAndSmoke(
Player.shipPos + new Vector3(-0.3f, -2.65f, +0.35f), 1.35f,
5 * Player.MovementSpeedPerSecond);
EffectManager.AddRocketOrShipFlareAndSmoke(
Player.shipPos + new Vector3(0.3f, -2.65f, +0.35f), 1.35f,
5 * Player.MovementSpeedPerSecond);
// Render enemy units and all weapon projectiles
RenderEnemyUnits();
RenderWeaponProjectiles();
RenderItems();
#endregion
#region Render landscape objects
// Show all landscape models
// Note: Avoid foreach to optimize performance on Xbox 360!
for (int num = 0; num < thisLandscapeSegmentObjects.Count; num++)
{
MatrixAndNumber obj = thisLandscapeSegmentObjects[num];
AddModelToRender(landscapeModels[obj.number], obj.renderMatrix);
} // for
for (int num = 0; num < nextLandscapeSegmentObjects.Count; num++)
{
MatrixAndNumber obj = nextLandscapeSegmentObjects[num];
AddModelToRender(landscapeModels[obj.number], obj.renderMatrix);
} // for
#endregion
#region Render all and add shadows
#region Generate shadows
// Generate shadows
ShaderEffect.shadowMapping.GenerateShadows(
delegate
{
// Generate shadows for all models except the first two (landscape)
for (int num = 2; num < numOfModelsToRender; num++)
modelsToRender[num].model.GenerateShadow(
modelsToRender[num].matrix);
});
// Render shadows
ShaderEffect.shadowMapping.RenderShadows(
delegate
{
// Show and render shadows for all models including the landscape
for (int num = 0; num < numOfModelsToRender; num++)
modelsToRender[num].model.UseShadow(
modelsToRender[num].matrix);
});
#endregion
#region Render normally
// Time to render all models the normal way (with normal mapping)
for (int num = 0; num < numOfModelsToRender; num++)
modelsToRender[num].model.Render(
modelsToRender[num].matrix);
// And finally bring everything on the screen
BaseGame.MeshRenderManager.Render();
#endregion
#region Show shadows
ShaderEffect.shadowMapping.ShowShadows();
#endregion
#endregion
} // RenderLevelBackground()
#endregion
#region Render hud
private void RenderHud()
{
Rectangle rect =
BaseGame.CalcRectangleKeep4To3(hudTopTexture.GfxRectangle);
if XBOX360
// Make it 7% smaller!
rect.X = (int)(rect.X + BaseGame.Width * 0.035f);
rect.Y = (int)(rect.Y + BaseGame.Height * 0.035f);
rect.Width = (int)(rect.Width * 0.93f);
//rect.Height = (int)(rect.Height * 0.93f);
endif
// Render top hud part
hudTopTexture.RenderOnScreen(
rect, hudTopTexture.GfxRectangle);
// Time
BaseGame.NumbersFont.WriteTime(
rect.X + (int)(73 * rect.Width / 1024.0f),
rect.Y + BaseGame.YToRes(8),
(int)Player.gameTimeMs);
// Score
BaseGame.NumbersFont.WriteNumberCentered(
rect.X + (int)(485 * rect.Width / 1024.0f),
rect.Y + BaseGame.YToRes(8),
Player.score);
// Highscore
BaseGame.NumbersFont.WriteNumberCentered(
rect.X + (int)(920 * rect.Width / 1024.0f),
rect.Y + BaseGame.YToRes(8),
Highscores.TopHighscore);
// Render bottom hud part
Rectangle bottomHudGfxRect = new Rectangle(0, 25, 1024, 39);
rect = BaseGame.CalcRectangleKeep4To3(bottomHudGfxRect);
rect.Y = BaseGame.YToRes(768-40);
if XBOX360
// Make it 10% smaller!
rect.X = (int)(rect.X + BaseGame.Width * 0.035f);
rect.Y = (int)(rect.Y - BaseGame.Height * 0.035f);
rect.Width = (int)(rect.Width * 0.93f);
//rect.Height = (int)(rect.Height * 0.93f);
endif
hudBottomTexture.RenderOnScreen(
rect, bottomHudGfxRect);
// Health
//tst: Player.health = 0.35f;
Rectangle healthGfxRect = new Rectangle(50, 0, 361, 24);
healthGfxRect = new Rectangle(healthGfxRect.X, healthGfxRect.Y,
(int)(healthGfxRect.Width * Player.health), healthGfxRect.Height);
hudBottomTexture.RenderOnScreen(
//Relative4To3(50, 768 - 31,
new Rectangle(
rect.X + (int)(50 * rect.Width / 1024.0f),
rect.Bottom - BaseGame.YToRes(31),
(int)(healthGfxRect.Width * rect.Width / 1024.0f),
BaseGame.YToRes(24)),
healthGfxRect);
// Weapon and Emps!
Rectangle weaponMgGfxRect = new Rectangle(876, 0, 31, 24);
Rectangle weaponGattlingGfxRect = new Rectangle(909, 0, 27, 24);
Rectangle weaponPlasmaGfxRect = new Rectangle(939, 0, 33, 24);
Rectangle weaponRocketsGfxRect = new Rectangle(975, 0, 24, 24);
Rectangle weaponEmpGfxRect = new Rectangle(1001, 0, 23, 24);
int xPos = rect.X + (int)(608 * rect.Width / 1024.0f);
int yPos = rect.Bottom - BaseGame.YToRes(20) -
TextureFont.Height / 3;
TextureFont.WriteText(xPos, yPos, "Weapon: ");
// Show weapon icon!
Rectangle weaponRect =
Player.currentWeapon == Player.WeaponTypes.MG ? weaponMgGfxRect :
Player.currentWeapon == Player.WeaponTypes.Gattling ? weaponGattlingGfxRect :
Player.currentWeapon == Player.WeaponTypes.Plasma ? weaponPlasmaGfxRect :
weaponRocketsGfxRect;
hudBottomTexture.RenderOnScreen(
new Rectangle(
rect.X + (int)(704 * rect.Width / 1024.0f),
rect.Bottom - BaseGame.YToRes(30),
(int)((weaponRect.Width-2) * rect.Width / 1024.0f),
BaseGame.YToRes(weaponRect.Height-2)),
weaponRect);
// And weapon name
xPos += BaseGame.XToRes(735 - 606);
TextureFont.WriteText(xPos, yPos, Player.currentWeapon.ToString());
xPos += BaseGame.XToRes(858 - 747);
TextureFont.WriteText(xPos, yPos, "EMPs: ");
// Show emp icons if we have any
//tst:Player.empBombs = 3;
xPos = rect.Right - BaseGame.XToRes(1024 - 916);
yPos = rect.Y + BaseGame.YToRes(8);// (int)((768 - 31) * rect.Height / 768.0f);
for (int num = 0; num < Player.empBombs; num++)
hudBottomTexture.RenderOnScreen(
new Rectangle(xPos+BaseGame.XToRes(24*num), yPos,
BaseGame.XToRes(weaponEmpGfxRect.Width),
BaseGame.XToRes(weaponEmpGfxRect.Height)),
weaponEmpGfxRect);
} // RenderHud()
#endregion
#region Run
<summary>
Run game screen. Called each frame.
</summary>
<param name="game">Form for access to asteroid manager and co
</param>
public void Run(XnaShooterGame game)
{
// Make sure the textures and models are linked correctly
hudTopTexture = game.hudTopTexture;
hudBottomTexture = game.hudBottomTexture;
landscapeModels = game.landscapeModels;
shipModels = game.shipModels;
itemModels = game.itemModels;
// Render landscape, ships and neutral objects
RenderLevelBackground(
//tst: 30+
Player.gameTimeMs / 64.0f);//66.0f);//33.0f);
// Handle game logic, move player around, weapons, collisions, etc.
Player.HandleGameLogic(this);
// Handle effect stuff
BaseGame.effectManager.HandleAllEffects();
// Render hud on top of 3d stuff
RenderHud();
// End game if escape was pressed or game is over and space or mouse
// button was pressed.
if (Input.KeyboardEscapeJustPressed ||
Input.GamePadBackJustPressed ||
(Player.GameOver &&
(Input.KeyboardSpaceJustPressed ||
Input.GamePadAJustPressed ||
Input.GamePadBJustPressed ||
Input.GamePadXJustPressed ||
Input.GamePadXJustPressed ||
Input.MouseLeftButtonJustPressed)))
{
// Upload new highscore (as we currently are in game,
// no bonus or anything will be added, this score is low!)
Player.SetGameOverAndUploadHighscore();
// Reset camera to origin and notify we are not longer in game mode
XnaShooterGame.camera.SetPosition(Vector3.Zero);
// Quit to the main menu
quit = true;
} // if
} // Run(game)
#endregion
#region Unit Testing
if DEBUG
<summary>
Test render level background with landscape objects.
</summary>
public static void TestRenderLevelBackground()
{
Mission dummyMission = null;
TestGame.Start("TestRenderLevelBackground",
delegate
{
dummyMission = new Mission();
},
delegate
{
dummyMission.RenderLevelBackground(
BaseGame.TotalTimeMs / 33.0f);
});
} // TestRenderLevelBackground()
<summary>
Test hud
</summary>
public static void TestHud()
{
Mission dummyMission = null;
TestGame.Start("TestHud",
delegate
{
dummyMission = new Mission();
dummyMission.hudTopTexture = new Texture("HudTop");
dummyMission.hudBottomTexture = new Texture("HudBottom");
},
delegate
{
dummyMission.RenderLevelBackground(
BaseGame.TotalTimeMs / 33.0f);
dummyMission.RenderHud();
});
} // TestHud()
endif
#endregion
} // class Mission
} // namespace XnaShooter.GameScreens
(C) Æliens
20/2/2008
You may not copy or print any of this material without explicit permission of the author or the publisher.
In case of other copyright issues, contact the author.
