DOOM-3-BFG

GameSSDWindow.cpp (61761B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 #pragma hdrstop
 #include "../idlib/precompiled.h"
 
 #include "DeviceContext.h"
 #include "Window.h"
 #include "UserInterfaceLocal.h"
 #include "GameSSDWindow.h"
 
 
 #define Z_NEAR 100.0f
 #define Z_FAR  4000.0f
 #define ENTITY_START_DIST 3000
 
 #define V_WIDTH 640.0f
 #define V_HEIGHT 480.0f
 
 /*
 *****************************************************************************
 * SSDCrossHair
 ****************************************************************************
 */
 
 #define CROSSHAIR_STANDARD_MATERIAL "game/SSD/crosshair_standard"
 #define CROSSHAIR_SUPER_MATERIAL "game/SSD/crosshair_super"
 
 SSDCrossHair::SSDCrossHair() {
 }
 
 SSDCrossHair::~SSDCrossHair() {
 }
 
 void SSDCrossHair::WriteToSaveGame( idFile *savefile ) {
 	
 	savefile->Write(&currentCrosshair, sizeof(currentCrosshair));
 	savefile->Write(&crosshairWidth, sizeof(crosshairWidth));
 	savefile->Write(&crosshairHeight, sizeof(crosshairHeight));
 
 }
 
 void SSDCrossHair::ReadFromSaveGame( idFile *savefile ) {
 
 	InitCrosshairs();
 
 	savefile->Read(&currentCrosshair, sizeof(currentCrosshair));
 	savefile->Read(&crosshairWidth, sizeof(crosshairWidth));
 	savefile->Read(&crosshairHeight, sizeof(crosshairHeight));
 
 }
 
 void SSDCrossHair::InitCrosshairs() {
 	
 	crosshairMaterial[CROSSHAIR_STANDARD] = declManager->FindMaterial( CROSSHAIR_STANDARD_MATERIAL );
 	crosshairMaterial[CROSSHAIR_SUPER] = declManager->FindMaterial( CROSSHAIR_SUPER_MATERIAL );
 
 	crosshairWidth = 64;
 	crosshairHeight = 64;
 
 	currentCrosshair = CROSSHAIR_STANDARD;
 
 }
 
 void SSDCrossHair::Draw(const idVec2& cursor) {
 
 	float x,y;
 	x = cursor.x-(crosshairWidth/2);
 	y = cursor.y-(crosshairHeight/2);
 	dc->DrawMaterial(x, y, crosshairWidth, crosshairHeight, crosshairMaterial[currentCrosshair], colorWhite, 1.0f, 1.0f);
 	
 }
 
 /*
 *****************************************************************************
 * SSDEntity	
 ****************************************************************************
 */
 
 SSDEntity::SSDEntity() {
 	EntityInit(); 
 }
 
 SSDEntity::~SSDEntity() { 
 }
 
 void SSDEntity::WriteToSaveGame( idFile *savefile ) {
 	
 	savefile->Write(&type, sizeof(type));
 	game->WriteSaveGameString(materialName, savefile);
 	savefile->Write(&position, sizeof(position));
 	savefile->Write(&size, sizeof(size));
 	savefile->Write(&radius, sizeof(radius));
 	savefile->Write(&hitRadius, sizeof(hitRadius));
 	savefile->Write(&rotation, sizeof(rotation));
 
 	savefile->Write(&matColor, sizeof(matColor));
 	
 	game->WriteSaveGameString(text, savefile);
 	savefile->Write(&textScale, sizeof(textScale));
 	savefile->Write(&foreColor, sizeof(foreColor));
 	
 	savefile->Write(&currentTime, sizeof(currentTime));
 	savefile->Write(&lastUpdate, sizeof(lastUpdate));
 	savefile->Write(&elapsed, sizeof(elapsed));
 
 	savefile->Write(&destroyed, sizeof(destroyed));
 	savefile->Write(&noHit, sizeof(noHit));
 	savefile->Write(&noPlayerDamage, sizeof(noPlayerDamage));
 
 	savefile->Write(&inUse, sizeof(inUse));
 
 }
 
 void SSDEntity::ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game ) {
 
 	savefile->Read(&type, sizeof(type));
 	game->ReadSaveGameString(materialName, savefile);
 	SetMaterial(materialName);
 	savefile->Read(&position, sizeof(position));
 	savefile->Read(&size, sizeof(size));
 	savefile->Read(&radius, sizeof(radius));
 	savefile->Read(&hitRadius, sizeof(hitRadius));
 	savefile->Read(&rotation, sizeof(rotation));
 
 	savefile->Read(&matColor, sizeof(matColor));
 
 	game->ReadSaveGameString(text, savefile);
 	savefile->Read(&textScale, sizeof(textScale));
 	savefile->Read(&foreColor, sizeof(foreColor));
 
 	game = _game;
 	savefile->Read(&currentTime, sizeof(currentTime));
 	savefile->Read(&lastUpdate, sizeof(lastUpdate));
 	savefile->Read(&elapsed, sizeof(elapsed));
 
 	savefile->Read(&destroyed, sizeof(destroyed));
 	savefile->Read(&noHit, sizeof(noHit));
 	savefile->Read(&noPlayerDamage, sizeof(noPlayerDamage));
 
 	savefile->Read(&inUse, sizeof(inUse));
 }
 
 void SSDEntity::EntityInit() {
 
 	inUse = false;
 
 
 	type = SSD_ENTITY_BASE;
 	
 	materialName = "";
 	material = NULL;
 	position.Zero();
 	size.Zero();
 	radius = 0.0f;
 	hitRadius = 0.0f;
 	rotation = 0.0f;
 
 
 	currentTime = 0;
 	lastUpdate = 0;
 
 	destroyed = false;
 	noHit = false;
 	noPlayerDamage = false;
 
 	matColor.Set(1, 1, 1, 1);
 
 	text = "";
 	textScale = 1.0f;
 	foreColor.Set(1, 1, 1, 1);
 }
 
 void SSDEntity::SetGame(idGameSSDWindow* _game) {
 	game = _game;
 }
 
 void SSDEntity::SetMaterial(const char* name) {
 	materialName = name;
 	material = declManager->FindMaterial( name );
 	material->SetSort( SS_GUI );
 }
 
 void SSDEntity::SetPosition(const idVec3& _position) {
 	position = _position;
 }
 
 void SSDEntity::SetSize(const idVec2& _size) {
 	size = _size;
 }
 
 void SSDEntity::SetRadius(float _radius, float _hitFactor) {
 	radius = _radius;
 	hitRadius = _radius*_hitFactor;
 }
 
 void SSDEntity::SetRotation(float _rotation) {
 	rotation = _rotation;
 }
 
 void SSDEntity::Update() {
 
 	currentTime = game->ssdTime;
 
 	//Is this the first update
 	if(lastUpdate == 0) {
 		lastUpdate = currentTime;
 		return;
 	}
 
 	elapsed = currentTime - lastUpdate;
 
 	EntityUpdate();
 
 	lastUpdate = currentTime;
 }
 
 bool SSDEntity::HitTest(const idVec2& pt) {
 
 	if(noHit) {
 		return false;
 	}
 
 	idVec3 screenPos = WorldToScreen(position);
 
 
 	//Scale the radius based on the distance from the player
 	float scale = 1.0f -((screenPos.z-Z_NEAR)/(Z_FAR-Z_NEAR));
 	float scaledRad = scale*hitRadius;
 
 	//So we can compare against the square of the length between two points
 	float scaleRadSqr = scaledRad*scaledRad;
 
 	idVec2 diff = screenPos.ToVec2()-pt;
 	float dist = idMath::Fabs(diff.LengthSqr());
 
 	if(dist < scaleRadSqr) {
 		return true;
 	}
 	return false;
 }
 
 void SSDEntity::Draw() {
 
 
 	idVec2 persize;
 	float x,y;
 
 	idBounds bounds;
 	bounds[0] = idVec3(position.x - (size.x/2.0f), position.y - (size.y/2.0f), position.z);
 	bounds[1] = idVec3(position.x + (size.x/2.0f), position.y + (size.y/2.0f), position.z);
 
 	idBounds screenBounds = WorldToScreen(bounds);
 	persize.x = idMath::Fabs(screenBounds[1].x - screenBounds[0].x);
 	persize.y = idMath::Fabs(screenBounds[1].y - screenBounds[0].y);
 
 	idVec3 center = screenBounds.GetCenter();
 
 	x = screenBounds[0].x;
 	y = screenBounds[1].y;
 	dc->DrawMaterialRotated(x, y, persize.x, persize.y, material, matColor, 1.0f, 1.0f, DEG2RAD(rotation));
 
 	if(text.Length() > 0) {
 		idRectangle rect( x, y, VIRTUAL_WIDTH, VIRTUAL_HEIGHT );
 		dc->DrawText( text, textScale, 0, foreColor, rect, false );
 	}
 
 }
 
 void SSDEntity::DestroyEntity() {
 	inUse = false;
 }
 
 idBounds SSDEntity::WorldToScreen(const idBounds worldBounds) {
 
 	idVec3 screenMin = WorldToScreen(worldBounds[0]);
 	idVec3 screenMax = WorldToScreen(worldBounds[1]);
 
 	idBounds screenBounds(screenMin, screenMax);
 	return screenBounds;
 }
 
 idVec3 SSDEntity::WorldToScreen(const idVec3& worldPos) {
 	
 	float d = 0.5f*V_WIDTH*idMath::Tan(DEG2RAD(90.0f)/2.0f);
 
 	//World To Camera Coordinates
 	idVec3 cameraTrans(0,0,d);
 	idVec3 cameraPos;
 	cameraPos = worldPos + cameraTrans;
 
 	//Camera To Screen Coordinates
 	idVec3 screenPos;
 	screenPos.x = d*cameraPos.x/cameraPos.z + (0.5f*V_WIDTH-0.5f);
 	screenPos.y = -d*cameraPos.y/cameraPos.z + (0.5f*V_HEIGHT-0.5f);
 	screenPos.z = cameraPos.z;
 
 	return screenPos;
 }
 
 idVec3 SSDEntity::ScreenToWorld(const idVec3& screenPos) {
 
 	idVec3 worldPos;
 
 	worldPos.x = screenPos.x - 0.5f * V_WIDTH;
 	worldPos.y = -(screenPos.y  - 0.5f * V_HEIGHT);
 	worldPos.z = screenPos.z;
 
 	return worldPos;
 }
 
 /*
 *****************************************************************************
 * SSDMover	
 ****************************************************************************
 */
 
 SSDMover::SSDMover() {
 }
 
 SSDMover::~SSDMover() {
 }
 
 void SSDMover::WriteToSaveGame( idFile *savefile ) {
 	SSDEntity::WriteToSaveGame(savefile);
 	
 	savefile->Write(&speed, sizeof(speed));
 	savefile->Write(&rotationSpeed, sizeof(rotationSpeed));
 }
 
 void SSDMover::ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  ) {
 	SSDEntity::ReadFromSaveGame(savefile, _game);
 
 	savefile->Read(&speed, sizeof(speed));
 	savefile->Read(&rotationSpeed, sizeof(rotationSpeed));
 }
 
 void SSDMover::MoverInit(const idVec3& _speed, float _rotationSpeed) {
 	
 	speed = _speed;
 	rotationSpeed = _rotationSpeed;
 }
 
 void SSDMover::EntityUpdate() {
 	
 	SSDEntity::EntityUpdate();
 
 	//Move forward based on speed (units per second)
 	idVec3 moved = ((float)elapsed/1000.0f)*speed;
 	position += moved;
 
 	float rotated = ((float)elapsed/1000.0f)*rotationSpeed*360.0f;
 	rotation += rotated;
 	if(rotation >= 360) {
 		rotation -= 360.0f;
 	}
 	if(rotation < 0) {
 		rotation += 360.0f;
 	}	
 }
 
 
 /*
 *****************************************************************************
 * SSDAsteroid	
 ****************************************************************************
 */
 
 SSDAsteroid	SSDAsteroid::asteroidPool[MAX_ASTEROIDS];
 
 #define ASTEROID_MATERIAL "game/SSD/asteroid"
 
 SSDAsteroid::SSDAsteroid() {
 }
 
 SSDAsteroid::~SSDAsteroid() {	
 }
 
 void SSDAsteroid::WriteToSaveGame( idFile *savefile ) {
 	SSDMover::WriteToSaveGame(savefile);
 
 	savefile->Write(&health, sizeof(health));
 }
 
 void SSDAsteroid::ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  ) {
 	SSDMover::ReadFromSaveGame(savefile, _game);
 
 	savefile->Read(&health, sizeof(health));
 }
 
 void SSDAsteroid::Init(idGameSSDWindow* _game, const idVec3& startPosition, const idVec2& _size, float _speed, float rotate, int _health) {
 
 	EntityInit();
 	MoverInit(idVec3(0,0, -_speed), rotate);
 	
 	SetGame(_game);
 
 	type = SSD_ENTITY_ASTEROID;
 
 	SetMaterial(ASTEROID_MATERIAL);
 	SetSize(_size);
 	SetRadius(Max(size.x, size.y), 0.3f);
 	SetRotation(game->random.RandomInt(360));
 
 	
 	position = startPosition;
 
 	health = _health;
 }
 
 void SSDAsteroid::EntityUpdate() {
 	
 	SSDMover::EntityUpdate();
 }
 
 SSDAsteroid* SSDAsteroid::GetNewAsteroid(idGameSSDWindow* _game, const idVec3& startPosition, const idVec2& _size, float _speed, float rotate, int _health) {
 	for(int i = 0; i < MAX_ASTEROIDS; i++) {
 		if(!asteroidPool[i].inUse) {
 			asteroidPool[i].Init(_game, startPosition, _size, _speed, rotate, _health);
 			asteroidPool[i].inUse = true;
 			asteroidPool[i].id = i;
 
 			return &asteroidPool[i];
 		}
 	}
 	return NULL;
 }
 
 SSDAsteroid* SSDAsteroid::GetSpecificAsteroid(int id) {
 	return &asteroidPool[id];
 }
 
 void SSDAsteroid::WriteAsteroids(idFile* savefile) {
 	int count = 0;
 	for(int i = 0; i < MAX_ASTEROIDS; i++) {
 		if(asteroidPool[i].inUse) {
 			count++;
 		}
 	}
 	savefile->Write(&count, sizeof(count));
 	for(int i = 0; i < MAX_ASTEROIDS; i++) {
 		if(asteroidPool[i].inUse) {
 			savefile->Write(&(asteroidPool[i].id), sizeof(asteroidPool[i].id));
 			asteroidPool[i].WriteToSaveGame(savefile);
 		}
 	}
 }
 
 void SSDAsteroid::ReadAsteroids( idFile* savefile, idGameSSDWindow* _game) {
 	
 	int count;
 	savefile->Read(&count, sizeof(count));
 	for(int i = 0; i < count; i++) {
 		int id;
 		savefile->Read(&id, sizeof(id));
 		SSDAsteroid* ent = GetSpecificAsteroid(id);
 		ent->ReadFromSaveGame(savefile, _game);
 	}
 }
 
 /*
 *****************************************************************************
 * SSDAstronaut
 ****************************************************************************
 */
 
 SSDAstronaut	SSDAstronaut::astronautPool[MAX_ASTRONAUT];
 
 #define ASTRONAUT_MATERIAL "game/SSD/astronaut"
 
 SSDAstronaut::SSDAstronaut() {
 }
 
 SSDAstronaut::~SSDAstronaut() {	
 }
 
 void SSDAstronaut::WriteToSaveGame( idFile *savefile ) {
 	SSDMover::WriteToSaveGame(savefile);
 
 	savefile->Write(&health, sizeof(health));
 }
 
 void SSDAstronaut::ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  ) {
 	SSDMover::ReadFromSaveGame(savefile, _game);
 
 	savefile->Read(&health, sizeof(health));
 }
 
 void SSDAstronaut::Init(idGameSSDWindow* _game, const idVec3& startPosition, float _speed, float rotate, int _health) {
 
 	EntityInit();
 	MoverInit(idVec3(0,0, -_speed), rotate);
 
 	SetGame(_game);
 
 	type = SSD_ENTITY_ASTRONAUT;
 
 	SetMaterial(ASTRONAUT_MATERIAL);
 	SetSize(idVec2(256,256));
 	SetRadius(Max(size.x, size.y), 0.3f);
 	SetRotation(game->random.RandomInt(360));
 	
 	position = startPosition;
 	health = _health;
 }
 
 SSDAstronaut* SSDAstronaut::GetNewAstronaut(idGameSSDWindow* _game, const idVec3& startPosition, float _speed, float rotate, int _health) {
 	for(int i = 0; i < MAX_ASTRONAUT; i++) {
 		if(!astronautPool[i].inUse) {
 			astronautPool[i].Init(_game, startPosition, _speed, rotate, _health);
 			astronautPool[i].inUse = true;
 			astronautPool[i].id = i;
 			return &astronautPool[i];
 		}
 	}
 	return NULL;
 }
 
 SSDAstronaut* SSDAstronaut::GetSpecificAstronaut(int id) {
 	return &astronautPool[id];
 	
 }
 
 void SSDAstronaut::WriteAstronauts(idFile* savefile) {
 	int count = 0;
 	for(int i = 0; i < MAX_ASTRONAUT; i++) {
 		if(astronautPool[i].inUse) {
 			count++;
 		}
 	}
 	savefile->Write(&count, sizeof(count));
 	for(int i = 0; i < MAX_ASTRONAUT; i++) {
 		if(astronautPool[i].inUse) {
 			savefile->Write(&(astronautPool[i].id), sizeof(astronautPool[i].id));
 			astronautPool[i].WriteToSaveGame(savefile);
 		}
 	}
 }
 
 void SSDAstronaut::ReadAstronauts(idFile* savefile, idGameSSDWindow* _game) {
 
 	int count;
 	savefile->Read(&count, sizeof(count));
 	for(int i = 0; i < count; i++) {
 		int id;
 		savefile->Read(&id, sizeof(id));
 		SSDAstronaut* ent = GetSpecificAstronaut(id);
 		ent->ReadFromSaveGame(savefile, _game);
 	}
 }
 
 /*
 *****************************************************************************
 * SSDExplosion	
 ****************************************************************************
 */
 
 SSDExplosion SSDExplosion::explosionPool[MAX_EXPLOSIONS];
 
 
 //#define EXPLOSION_MATERIAL "game/SSD/fball"
 //#define EXPLOSION_TELEPORT "game/SSD/teleport"
 
 const char* explosionMaterials[] = {
 	"game/SSD/fball",
 	"game/SSD/teleport"
 };
 
 #define EXPLOSION_MATERIAL_COUNT 2
 
 SSDExplosion::SSDExplosion() {
 	type = SSD_ENTITY_EXPLOSION;
 }
 
 SSDExplosion::~SSDExplosion() {
 }
 
 void SSDExplosion::WriteToSaveGame( idFile *savefile ) {
 	SSDEntity::WriteToSaveGame(savefile);
 
 	savefile->Write(&finalSize, sizeof(finalSize));
 	savefile->Write(&length, sizeof(length));
 	savefile->Write(&beginTime, sizeof(beginTime));
 	savefile->Write(&endTime, sizeof(endTime));
 	savefile->Write(&explosionType, sizeof(explosionType));
 
 	
 	savefile->Write(&(buddy->type), sizeof(buddy->type));
 	savefile->Write(&(buddy->id), sizeof(buddy->id));
 
 	savefile->Write(&killBuddy, sizeof(killBuddy));
 	savefile->Write(&followBuddy, sizeof(followBuddy));
 }
 
 void SSDExplosion::ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  ) {
 	SSDEntity::ReadFromSaveGame(savefile, _game);
 
 	savefile->Read(&finalSize, sizeof(finalSize));
 	savefile->Read(&length, sizeof(length));
 	savefile->Read(&beginTime, sizeof(beginTime));
 	savefile->Read(&endTime, sizeof(endTime));
 	savefile->Read(&explosionType, sizeof(explosionType));
 
 	int type, id;
 	savefile->Read(&type, sizeof(type));
 	savefile->Read(&id, sizeof(id));
 
 	//Get a pointer to my buddy
 	buddy = _game->GetSpecificEntity(type, id);
 
 	savefile->Read(&killBuddy, sizeof(killBuddy));
 	savefile->Read(&followBuddy, sizeof(followBuddy));
 }
 
 void SSDExplosion::Init(idGameSSDWindow* _game, const idVec3& _position, const idVec2& _size, int _length, int _type, SSDEntity* _buddy, bool _killBuddy, bool _followBuddy) {
 	
 	EntityInit();
 
 	SetGame(_game);
 
 	type = SSD_ENTITY_EXPLOSION;
 	explosionType = _type;
 
 	SetMaterial(explosionMaterials[explosionType]);
 	SetPosition(_position);
 	position.z -= 50;
 
 	finalSize = _size;	
 	length = _length;
 	beginTime = game->ssdTime;
 	endTime = beginTime + length;
 
 	buddy = _buddy;
 	killBuddy = _killBuddy;
 	followBuddy = _followBuddy;
 
 	//Explosion Starts from nothing and will increase in size until it gets to final size
 	size.Zero();
 
 	noPlayerDamage = true;
 	noHit = true;
 }
 
 void SSDExplosion::EntityUpdate() {
 	
 	SSDEntity::EntityUpdate();
 
 	//Always set my position to my buddies position except change z to be on top
 	if(followBuddy) {
 		position = buddy->position;
 		position.z -= 50;
 	} else {
 		//Only mess with the z if we are not following
 		position.z = buddy->position.z - 50;
 	}
 
 	//Scale the image based on the time
 	size = finalSize*((float)(currentTime-beginTime)/(float)length);
 
 	//Destroy myself after the explosion is done
 	if(currentTime > endTime) {
 		destroyed = true;
 		
 		if(killBuddy) {
 			//Destroy the exploding object
 			buddy->destroyed = true;
 		}
 	}
 }
 
 SSDExplosion* SSDExplosion::GetNewExplosion(idGameSSDWindow* _game, const idVec3& _position, const idVec2& _size, int _length, int _type, SSDEntity* _buddy, bool _killBuddy, bool _followBuddy) {
 	for(int i = 0; i < MAX_EXPLOSIONS; i++) {
 		if(!explosionPool[i].inUse) {
 			explosionPool[i].Init(_game, _position, _size, _length, _type, _buddy, _killBuddy, _followBuddy);
 			explosionPool[i].inUse = true;
 			return &explosionPool[i];
 		}
 	}
 	return NULL;
 }
 
 SSDExplosion* SSDExplosion::GetSpecificExplosion(int id) {
 	return &explosionPool[id];
 }
 
 void SSDExplosion::WriteExplosions(idFile* savefile) {
 	int count = 0;
 	for(int i = 0; i < MAX_EXPLOSIONS; i++) {
 		if(explosionPool[i].inUse) {
 			count++;
 		}
 	}
 	savefile->Write(&count, sizeof(count));
 	for(int i = 0; i < MAX_EXPLOSIONS; i++) {
 		if(explosionPool[i].inUse) {
 			savefile->Write(&(explosionPool[i].id), sizeof(explosionPool[i].id));
 			explosionPool[i].WriteToSaveGame(savefile);
 		}
 	}
 }
 
 void SSDExplosion::ReadExplosions(idFile* savefile, idGameSSDWindow* _game) {
 
 	int count;
 	savefile->Read(&count, sizeof(count));
 	for(int i = 0; i < count; i++) {
 		int id;
 		savefile->Read(&id, sizeof(id));
 		SSDExplosion* ent = GetSpecificExplosion(id);
 		ent->ReadFromSaveGame(savefile, _game);
 	}
 }
 
 /*
 *****************************************************************************
 * SSDPoints
 ****************************************************************************
 */
 
 SSDPoints	SSDPoints::pointsPool[MAX_POINTS];
 
 SSDPoints::SSDPoints() {
 	type = SSD_ENTITY_POINTS;
 }
 
 SSDPoints::~SSDPoints() {
 }
 
 void SSDPoints::WriteToSaveGame( idFile *savefile ) {
 	SSDEntity::WriteToSaveGame(savefile);
 
 	savefile->Write(&length, sizeof(length));
 	savefile->Write(&distance, sizeof(distance));
 	savefile->Write(&beginTime, sizeof(beginTime));
 	savefile->Write(&endTime, sizeof(endTime));
 
 	savefile->Write(&beginPosition, sizeof(beginPosition));
 	savefile->Write(&endPosition, sizeof(endPosition));
 
 	savefile->Write(&beginColor, sizeof(beginColor));
 	savefile->Write(&endColor, sizeof(endColor));
 	
 }
 
 void SSDPoints::ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  ) {
 	SSDEntity::ReadFromSaveGame(savefile, _game);
 
 	savefile->Read(&length, sizeof(length));
 	savefile->Read(&distance, sizeof(distance));
 	savefile->Read(&beginTime, sizeof(beginTime));
 	savefile->Read(&endTime, sizeof(endTime));
 
 	savefile->Read(&beginPosition, sizeof(beginPosition));
 	savefile->Read(&endPosition, sizeof(endPosition));
 
 	savefile->Read(&beginColor, sizeof(beginColor));
 	savefile->Read(&endColor, sizeof(endColor));
 }
 
 void SSDPoints::Init(idGameSSDWindow* _game, SSDEntity* _ent, int _points, int _length, int _distance, const idVec4& color) {
 
 	EntityInit();
 	
 	SetGame(_game);
 
 	length = _length;
 	distance = _distance;
 	beginTime = game->ssdTime;
 	endTime = beginTime + length;
 
 	textScale = 0.4f;
 	text = va("%d", _points);
 
 	float width = 0;
 	for(int i = 0; i < text.Length(); i++) {
 		width += dc->CharWidth(text[i], textScale);
 	}
 
 	size.Set(0,0);
 
 	//Set the start position at the top of the passed in entity
 	position = WorldToScreen(_ent->position);
 	position = ScreenToWorld(position);
 
 	position.z = 0;
 	position.x -= (width/2.0f);
 
 	beginPosition = position;
 
 	endPosition = beginPosition;
 	endPosition.y += _distance;
 
 	//beginColor.Set(0,1,0,1);
 	endColor.Set(1,1,1,0);
 	
 	beginColor = color;
 	beginColor.w = 1;
 
 	noPlayerDamage = true;
 	noHit = true;
 }
 
 void SSDPoints::EntityUpdate() {
 
 	float t = (float)(currentTime - beginTime)/(float)length;
 
 	//Move up from the start position
 	position.Lerp(beginPosition, endPosition, t);
 
 	//Interpolate the color
 	foreColor.Lerp(beginColor, endColor, t);
 
 	if(currentTime > endTime) {
 		destroyed = true;
 	}
 }
 
 SSDPoints* SSDPoints::GetNewPoints(idGameSSDWindow* _game, SSDEntity* _ent, int _points, int _length, int _distance, const idVec4& color) {
 	for(int i = 0; i < MAX_POINTS; i++) {
 		if(!pointsPool[i].inUse) {
 			pointsPool[i].Init(_game, _ent, _points, _length, _distance, color);
 			pointsPool[i].inUse = true;
 			return &pointsPool[i];
 		}
 	}
 	return NULL;
 }
 
 SSDPoints* SSDPoints::GetSpecificPoints(int id) {
 	return &pointsPool[id];
 }
 
 void SSDPoints::WritePoints(idFile* savefile) {
 	int count = 0;
 	for(int i = 0; i < MAX_POINTS; i++) {
 		if(pointsPool[i].inUse) {
 			count++;
 		}
 	}
 	savefile->Write(&count, sizeof(count));
 	for(int i = 0; i < MAX_POINTS; i++) {
 		if(pointsPool[i].inUse) {
 			savefile->Write(&(pointsPool[i].id), sizeof(pointsPool[i].id));
 			pointsPool[i].WriteToSaveGame(savefile);
 		}
 	}
 }
 
 void SSDPoints::ReadPoints(idFile* savefile, idGameSSDWindow* _game) {
 
 	int count;
 	savefile->Read(&count, sizeof(count));
 	for(int i = 0; i < count; i++) {
 		int id;
 		savefile->Read(&id, sizeof(id));
 		SSDPoints* ent = GetSpecificPoints(id);
 		ent->ReadFromSaveGame(savefile, _game);
 	}
 }
 
 /*
 *****************************************************************************
 * SSDProjectile
 ****************************************************************************
 */
 
 SSDProjectile SSDProjectile::projectilePool[MAX_PROJECTILES];
 
 #define PROJECTILE_MATERIAL "game/SSD/fball"
 
 SSDProjectile::SSDProjectile() {
 	type = SSD_ENTITY_PROJECTILE;
 }
 
 SSDProjectile::~SSDProjectile() {
 }
 
 void SSDProjectile::WriteToSaveGame( idFile *savefile ) {
 	SSDEntity::WriteToSaveGame(savefile);
 
 	savefile->Write(&dir, sizeof(dir));
 	savefile->Write(&speed, sizeof(speed));
 	savefile->Write(&beginTime, sizeof(beginTime));
 	savefile->Write(&endTime, sizeof(endTime));
 
 	savefile->Write(&endPosition, sizeof(endPosition));
 }
 
 void SSDProjectile::ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  ) {
 	SSDEntity::ReadFromSaveGame(savefile, _game);
 
 	savefile->Read(&dir, sizeof(dir));
 	savefile->Read(&speed, sizeof(speed));
 	savefile->Read(&beginTime, sizeof(beginTime));
 	savefile->Read(&endTime, sizeof(endTime));
 
 	savefile->Read(&endPosition, sizeof(endPosition));
 }
 
 void SSDProjectile::Init(idGameSSDWindow* _game, const idVec3& _beginPosition, const idVec3& _endPosition, float _speed, float _size) {
 	
 	EntityInit();
 
 	SetGame(_game);
 
 	SetMaterial(PROJECTILE_MATERIAL);
 	size.Set(_size,_size);
 
 	position = _beginPosition;
 	endPosition = _endPosition;
 
 	dir = _endPosition - position;
 	dir.Normalize();
 
 	//speed.Zero();
 	speed.x = speed.y = speed.z = _speed;
 
 	noHit = true;
 }
 
 void SSDProjectile::EntityUpdate() {
 
 	SSDEntity::EntityUpdate();
 
 	//Move forward based on speed (units per second)
 	idVec3 moved = dir*((float)elapsed/1000.0f)*speed.z;
 	position += moved;
 
 	if(position.z > endPosition.z) {
 		//We have reached our position
 		destroyed = true;
 	}
 }
 
 SSDProjectile* SSDProjectile::GetNewProjectile(idGameSSDWindow* _game, const idVec3& _beginPosition, const idVec3& _endPosition, float _speed, float _size) {
 	for(int i = 0; i < MAX_PROJECTILES; i++) {
 		if(!projectilePool[i].inUse) {
 			projectilePool[i].Init(_game, _beginPosition, _endPosition, _speed, _size);
 			projectilePool[i].inUse = true;
 			return &projectilePool[i];
 		}
 	}
 	return NULL;
 }
 
 SSDProjectile* SSDProjectile::GetSpecificProjectile(int id) {
 	return &projectilePool[id];
 }
 
 void SSDProjectile::WriteProjectiles(idFile* savefile) {
 	int count = 0;
 	for(int i = 0; i < MAX_PROJECTILES; i++) {
 		if(projectilePool[i].inUse) {
 			count++;
 		}
 	}
 	savefile->Write(&count, sizeof(count));
 	for(int i = 0; i < MAX_PROJECTILES; i++) {
 		if(projectilePool[i].inUse) {
 			savefile->Write(&(projectilePool[i].id), sizeof(projectilePool[i].id));
 			projectilePool[i].WriteToSaveGame(savefile);
 		}
 	}
 }
 
 void SSDProjectile::ReadProjectiles(idFile* savefile, idGameSSDWindow* _game) {
 
 	int count;
 	savefile->Read(&count, sizeof(count));
 	for(int i = 0; i < count; i++) {
 		int id;
 		savefile->Read(&id, sizeof(id));
 		SSDProjectile* ent = GetSpecificProjectile(id);
 		ent->ReadFromSaveGame(savefile, _game);
 	}
 }
 
 /*
 *****************************************************************************
 * SSDPowerup
 ****************************************************************************
 */
 
 const char* powerupMaterials[][2] = {
 	"game/SSD/powerupHealthClosed",			"game/SSD/powerupHealthOpen",
 	"game/SSD/powerupSuperBlasterClosed",	"game/SSD/powerupSuperBlasterOpen",
 	"game/SSD/powerupNukeClosed",			"game/SSD/powerupNukeOpen",
 	"game/SSD/powerupRescueClosed",			"game/SSD/powerupRescueOpen",
 	"game/SSD/powerupBonusPointsClosed",	"game/SSD/powerupBonusPointsOpen",
 	"game/SSD/powerupDamageClosed",			"game/SSD/powerupDamageOpen",
 };
 
 #define POWERUP_MATERIAL_COUNT 6
 
 SSDPowerup	SSDPowerup::powerupPool[MAX_POWERUPS];
 
 SSDPowerup::SSDPowerup() {
 	
 }
 
 SSDPowerup::~SSDPowerup() {
 }
 
 void SSDPowerup::WriteToSaveGame( idFile *savefile ) {
 	SSDMover::WriteToSaveGame(savefile);
 
 	savefile->Write(&powerupState, sizeof(powerupState));
 	savefile->Write(&powerupType, sizeof(powerupType));
 }
 
 void SSDPowerup::ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  ) {
 	SSDMover::ReadFromSaveGame(savefile, _game);
 
 	savefile->Read(&powerupState, sizeof(powerupState));
 	savefile->Read(&powerupType, sizeof(powerupType));
 }
 
 void SSDPowerup::OnHit(int key) {
 
 	if(powerupState == POWERUP_STATE_CLOSED) {
 
 		//Small explosion to indicate it is opened
 		SSDExplosion* explosion = SSDExplosion::GetNewExplosion(game, position, size*2.0f, 300, SSDExplosion::EXPLOSION_NORMAL, this, false, true);
 		game->entities.Append(explosion);
 		
 
 		powerupState = POWERUP_STATE_OPEN;
 		SetMaterial(powerupMaterials[powerupType][powerupState]);
 	} else {
 		//Destory the powerup with a big explosion
 		SSDExplosion* explosion = SSDExplosion::GetNewExplosion(game, position, size*2, 300, SSDExplosion::EXPLOSION_NORMAL, this);
 		game->entities.Append(explosion);
 		game->PlaySound("arcade_explode");
 
 		noHit = true;
 		noPlayerDamage = true;
 	}
 }
 
 void SSDPowerup::OnStrikePlayer() {
 	
 	if(powerupState == POWERUP_STATE_OPEN) {
 		//The powerup was open so activate it
 		OnActivatePowerup();
 	}
 
 	//Just destroy the powerup
 	destroyed = true;
 }
 
 void SSDPowerup::OnOpenPowerup() {
 }
 
 void SSDPowerup::OnActivatePowerup() {
 	switch(powerupType) {
 		case POWERUP_TYPE_HEALTH:
 			{
 				game->AddHealth(10);
 				break;
 			}
 		case POWERUP_TYPE_SUPER_BLASTER:
 			{
 				game->OnSuperBlaster();
 				break;
 			}
 		case POWERUP_TYPE_ASTEROID_NUKE:
 			{
 				game->OnNuke();
 				break;
 			}
 		case POWERUP_TYPE_RESCUE_ALL:
 			{
 				game->OnRescueAll();
 				break;
 			}
 		case POWERUP_TYPE_BONUS_POINTS:
 			{
 				int points = (game->random.RandomInt(5)+1) * 100;
 				game->AddScore(this, points);
 				break;
 			}
 		case POWERUP_TYPE_DAMAGE:
 			{
 				game->AddDamage(10);
 				game->PlaySound("arcade_explode");
 				break;
 			}
 
 	}
 }
 
 
 void SSDPowerup::Init(idGameSSDWindow* _game, float _speed, float _rotation) {
 
 	EntityInit();
 	MoverInit(idVec3(0,0, -_speed), _rotation);
 
 	SetGame(_game);
 	SetSize(idVec2(200,200));
 	SetRadius(Max(size.x, size.y), 0.3f);
 
 	type = SSD_ENTITY_POWERUP;
 	
 	idVec3 startPosition;
 	startPosition.x = game->random.RandomInt(V_WIDTH)-(V_WIDTH/2.0f);
 	startPosition.y = game->random.RandomInt(V_HEIGHT)-(V_HEIGHT/2.0f);
 	startPosition.z = ENTITY_START_DIST;
 
 	position = startPosition;
 	//SetPosition(startPosition);
 
 	powerupState = POWERUP_STATE_CLOSED;
 	powerupType = game->random.RandomInt(POWERUP_TYPE_MAX+1);
 	if(powerupType >= POWERUP_TYPE_MAX) {
 		powerupType = 0;
 	}
 
 	/*OutputDebugString(va("Powerup: %d\n", powerupType));
 	if(powerupType == 0) {
 		int x = 0;
 	}*/
 
 	SetMaterial(powerupMaterials[powerupType][powerupState]);
 }
 
 SSDPowerup* SSDPowerup::GetNewPowerup(idGameSSDWindow* _game, float _speed, float _rotation) {
 
 	for(int i = 0; i < MAX_POWERUPS; i++) {
 		if(!powerupPool[i].inUse) {
 			powerupPool[i].Init(_game, _speed, _rotation);
 			powerupPool[i].inUse = true;
 			return &powerupPool[i];
 		}
 	}
 	return NULL;
 }
 
 SSDPowerup* SSDPowerup::GetSpecificPowerup(int id) {
 	return &powerupPool[id];
 }
 
 void SSDPowerup::WritePowerups(idFile* savefile) {
 	int count = 0;
 	for(int i = 0; i < MAX_POWERUPS; i++) {
 		if(powerupPool[i].inUse) {
 			count++;
 		}
 	}
 	savefile->Write(&count, sizeof(count));
 	for(int i = 0; i < MAX_POWERUPS; i++) {
 		if(powerupPool[i].inUse) {
 			savefile->Write(&(powerupPool[i].id), sizeof(powerupPool[i].id));
 			powerupPool[i].WriteToSaveGame(savefile);
 		}
 	}
 }
 
 void SSDPowerup::ReadPowerups(idFile* savefile, idGameSSDWindow* _game) {
 
 	int count;
 	savefile->Read(&count, sizeof(count));
 	for(int i = 0; i < count; i++) {
 		int id;
 		savefile->Read(&id, sizeof(id));
 		SSDPowerup* ent = GetSpecificPowerup(id);
 		ent->ReadFromSaveGame(savefile, _game);
 	}
 }
 
 /*
 *****************************************************************************
 * idGameSSDWindow
 ****************************************************************************
 */
 
 idRandom idGameSSDWindow::random;
 
 idGameSSDWindow::idGameSSDWindow(idUserInterfaceLocal *g) : idWindow(g) {
 	gui = g;
 	CommonInit();
 }
 
 idGameSSDWindow::~idGameSSDWindow() {
 	ResetGameStats();
 }
 
 void idGameSSDWindow::WriteToSaveGame( idFile *savefile ) {
 	idWindow::WriteToSaveGame(savefile);
 
 	savefile->Write(&ssdTime, sizeof(ssdTime));
 
 	beginLevel.WriteToSaveGame(savefile);
 	resetGame.WriteToSaveGame(savefile);
 	continueGame.WriteToSaveGame(savefile);
 	refreshGuiData.WriteToSaveGame(savefile);
 
 	crosshair.WriteToSaveGame(savefile);
 	savefile->Write(&screenBounds, sizeof(screenBounds));
 
 	savefile->Write(&levelCount, sizeof(levelCount));
 	for(int i = 0; i < levelCount; i++) {
 		savefile->Write(&(levelData[i]), sizeof(SSDLevelData_t));
 		savefile->Write(&(asteroidData[i]), sizeof(SSDAsteroidData_t));
 		savefile->Write(&(astronautData[i]), sizeof(SSDAstronautData_t));
 		savefile->Write(&(powerupData[i]), sizeof(SSDPowerupData_t));
 	}
 
 	savefile->Write(&weaponCount, sizeof(weaponCount));
 	for(int i = 0; i < weaponCount; i++) {
 		savefile->Write(&(weaponData[i]), sizeof(SSDWeaponData_t));
 	}
 
 	savefile->Write(&superBlasterTimeout, sizeof(superBlasterTimeout));
 	savefile->Write(&gameStats, sizeof(SSDGameStats_t));
 
 	//Write All Static Entities
 	SSDAsteroid::WriteAsteroids(savefile);
 	SSDAstronaut::WriteAstronauts(savefile);
 	SSDExplosion::WriteExplosions(savefile);
 	SSDPoints::WritePoints(savefile);
 	SSDProjectile::WriteProjectiles(savefile);
 	SSDPowerup::WritePowerups(savefile);
 
 	int entCount = entities.Num();
 	savefile->Write(&entCount, sizeof(entCount));
 	for(int i = 0; i < entCount; i++) {
 		savefile->Write(&(entities[i]->type), sizeof(entities[i]->type));
 		savefile->Write(&(entities[i]->id), sizeof(entities[i]->id));
 	}
 }
 
 void idGameSSDWindow::ReadFromSaveGame( idFile *savefile ) {
 	idWindow::ReadFromSaveGame(savefile);
 
 
 	savefile->Read(&ssdTime, sizeof(ssdTime));
 
 	beginLevel.ReadFromSaveGame(savefile);
 	resetGame.ReadFromSaveGame(savefile);
 	continueGame.ReadFromSaveGame(savefile);
 	refreshGuiData.ReadFromSaveGame(savefile);
 
 	crosshair.ReadFromSaveGame(savefile);
 	savefile->Read(&screenBounds, sizeof(screenBounds));
 
 	savefile->Read(&levelCount, sizeof(levelCount));
 	for(int i = 0; i < levelCount; i++) {
 		SSDLevelData_t newLevel;
 		savefile->Read(&newLevel, sizeof(SSDLevelData_t));
 		levelData.Append(newLevel);
 
 		SSDAsteroidData_t newAsteroid;
 		savefile->Read(&newAsteroid, sizeof(SSDAsteroidData_t));
 		asteroidData.Append(newAsteroid);
 
 		SSDAstronautData_t newAstronaut;
 		savefile->Read(&newAstronaut, sizeof(SSDAstronautData_t));
 		astronautData.Append(newAstronaut);
 		
 		SSDPowerupData_t newPowerup;
 		savefile->Read(&newPowerup, sizeof(SSDPowerupData_t));
 		powerupData.Append(newPowerup);
 	}
 
 	savefile->Read(&weaponCount, sizeof(weaponCount));
 	for(int i = 0; i < weaponCount; i++) {
 		SSDWeaponData_t newWeapon;
 		savefile->Read(&newWeapon, sizeof(SSDWeaponData_t));
 		weaponData.Append(newWeapon);
 	}
 
 	savefile->Read(&superBlasterTimeout, sizeof(superBlasterTimeout));
 	
 	savefile->Read(&gameStats, sizeof(SSDGameStats_t));
 	//Reset this because it is no longer valid
 	gameStats.levelStats.targetEnt = NULL;
 
 	SSDAsteroid::ReadAsteroids(savefile, this);
 	SSDAstronaut::ReadAstronauts(savefile, this);
 	SSDExplosion::ReadExplosions(savefile, this);
 	SSDPoints::ReadPoints(savefile, this);
 	SSDProjectile::ReadProjectiles(savefile, this);
 	SSDPowerup::ReadPowerups(savefile, this);
 
 	int entCount;
 	savefile->Read(&entCount, sizeof(entCount));
 
 	for(int i = 0; i < entCount; i++) {
 		int type, id;
 		savefile->Read(&type, sizeof(type));
 		savefile->Read(&id, sizeof(id));
 
 		SSDEntity* ent = GetSpecificEntity(type, id);
 		if(ent) {
 			entities.Append(ent);
 		}
 	}
 }
 
 const char *idGameSSDWindow::HandleEvent(const sysEvent_t *event, bool *updateVisuals) {
 	
 	// need to call this to allow proper focus and capturing on embedded children
 	const char *ret = idWindow::HandleEvent(event, updateVisuals);
 
 	if(!gameStats.gameRunning) {
 		return ret;
 	}
 
 	int key = event->evValue;
 
 	if ( event->evType == SE_KEY ) {
 
 		if ( !event->evValue2 ) {
 			return ret;
 		}
 
 		if ( key == K_MOUSE1 || key == K_MOUSE2) {
 			FireWeapon(key);	
 		} else {
 			return ret;
 		}
 	}
 	return ret;
 }
 
 idWinVar *idGameSSDWindow::GetWinVarByName	(const char *_name, bool winLookup, drawWin_t** owner) {
 
 	idWinVar *retVar = NULL;
 
 	if (idStr::Icmp(_name, "beginLevel") == 0) {
 		retVar = &beginLevel;
 	}
 
 	if (idStr::Icmp(_name, "resetGame") == 0) {
 		retVar = &resetGame;
 	}
 
 	if (idStr::Icmp(_name, "continueGame") == 0) {
 		retVar = &continueGame;
 	}
 	if (idStr::Icmp(_name, "refreshGuiData") == 0) {
 		retVar = &refreshGuiData;
 	}
 	
 
 	if(retVar) {
 		return retVar;
 	}
 
 	return idWindow::GetWinVarByName(_name, winLookup, owner);
 }
 
 
 void idGameSSDWindow::Draw(int time, float x, float y) {
 
 	//Update the game every frame before drawing
 	UpdateGame();
 
 	RefreshGuiData();
 
 	if(gameStats.gameRunning) {
 
 		ZOrderEntities();
 
 		//Draw from back to front
 		for(int i = entities.Num()-1; i >= 0; i--) {
 			entities[i]->Draw();
 		}
 
 		//The last thing to draw is the crosshair
 		idVec2 cursor;
 		//GetCursor(cursor);
 		cursor.x = gui->CursorX();
 		cursor.y = gui->CursorY();
 
 		crosshair.Draw(cursor);
 	}
 }
 
 
 bool idGameSSDWindow::ParseInternalVar(const char *_name, idTokenParser *src) {
 
 	if (idStr::Icmp(_name, "beginLevel") == 0) {
 		beginLevel = src->ParseBool();
 		return true;
 	}
 	if (idStr::Icmp(_name, "resetGame") == 0) {
 		resetGame = src->ParseBool();
 		return true;
 	}
 	if (idStr::Icmp(_name, "continueGame") == 0) {
 		continueGame = src->ParseBool();
 		return true;
 	}
 	if (idStr::Icmp(_name, "refreshGuiData") == 0) {
 		refreshGuiData = src->ParseBool();
 		return true;
 	}
 	
 	if(idStr::Icmp(_name, "levelcount") == 0) {
 		levelCount = src->ParseInt();
 		for(int i = 0; i < levelCount; i++) {
 			SSDLevelData_t newLevel;
 			memset(&newLevel, 0, sizeof(SSDLevelData_t));
 			levelData.Append(newLevel);
 
 			SSDAsteroidData_t newAsteroid;
 			memset(&newAsteroid, 0, sizeof(SSDAsteroidData_t));
 			asteroidData.Append(newAsteroid);
 
 			SSDAstronautData_t newAstronaut;
 			memset(&newAstronaut, 0, sizeof(SSDAstronautData_t));
 			astronautData.Append(newAstronaut);
 
 			SSDPowerupData_t newPowerup;
 			memset(&newPowerup, 0, sizeof(SSDPowerupData_t));
 			powerupData.Append(newPowerup);
 
 
 		}
 		return true;
 	}
 	if(idStr::Icmp(_name, "weaponCount") == 0) {
 		weaponCount = src->ParseInt();
 		for(int i = 0; i < weaponCount; i++) {
 			SSDWeaponData_t newWeapon;
 			memset(&newWeapon, 0, sizeof(SSDWeaponData_t));
 			weaponData.Append(newWeapon);
 		}
 		return true;
 	}
 
 	if(idStr::FindText(_name, "leveldata", false) >= 0) {
 		idStr tempName = _name;
 		int level = atoi(tempName.Right(2))-1;
 
 		idStr levelData;
 		ParseString(src, levelData);
 		ParseLevelData(level, levelData);
 		return true;
 	}
 
 	if(idStr::FindText(_name, "asteroiddata", false) >= 0) {
 		idStr tempName = _name;
 		int level = atoi(tempName.Right(2))-1;
 
 		idStr asteroidData;
 		ParseString(src, asteroidData);
 		ParseAsteroidData(level, asteroidData);
 		return true;
 	}
 
 	if(idStr::FindText(_name, "weapondata", false) >= 0) {
 		idStr tempName = _name;
 		int weapon = atoi(tempName.Right(2))-1;
 
 		idStr weaponData;
 		ParseString(src, weaponData);
 		ParseWeaponData(weapon, weaponData);
 		return true;
 	}
 
 	if(idStr::FindText(_name, "astronautdata", false) >= 0) {
 		idStr tempName = _name;
 		int level = atoi(tempName.Right(2))-1;
 
 		idStr astronautData;
 		ParseString(src, astronautData);
 		ParseAstronautData(level, astronautData);
 		return true;
 	}
 
 	if(idStr::FindText(_name, "powerupdata", false) >= 0) {
 		idStr tempName = _name;
 		int level = atoi(tempName.Right(2))-1;
 
 		idStr powerupData;
 		ParseString(src, powerupData);
 		ParsePowerupData(level, powerupData);
 		return true;
 	}
 
 	return idWindow::ParseInternalVar(_name, src);
 }
 
 void idGameSSDWindow::ParseLevelData(int level, const idStr& levelDataString) {
 
 	idParser parser;
 	idToken token;
 	parser.LoadMemory(levelDataString.c_str(), levelDataString.Length(), "LevelData");
 
 	levelData[level].spawnBuffer = parser.ParseFloat();
 	levelData[level].needToWin = parser.ParseInt(); //Required Destroyed
 
 }
 
 void idGameSSDWindow::ParseAsteroidData(int level, const idStr& asteroidDataString) {
 
 	idParser parser;
 	idToken token;
 	parser.LoadMemory(asteroidDataString.c_str(), asteroidDataString.Length(), "AsteroidData");
 
 	asteroidData[level].speedMin = parser.ParseFloat(); //Speed Min 
 	asteroidData[level].speedMax = parser.ParseFloat(); //Speed Max
 
 	asteroidData[level].sizeMin = parser.ParseFloat(); //Size Min 
 	asteroidData[level].sizeMax = parser.ParseFloat(); //Size Max
 
 	asteroidData[level].rotateMin = parser.ParseFloat(); //Rotate Min (rotations per second) 
 	asteroidData[level].rotateMax = parser.ParseFloat(); //Rotate Max (rotations per second)
 
 	asteroidData[level].spawnMin = parser.ParseInt(); //Spawn Min
 	asteroidData[level].spawnMax = parser.ParseInt(); //Spawn Max
 
 	asteroidData[level].asteroidHealth = parser.ParseInt(); //Health of the asteroid
 	asteroidData[level].asteroidDamage = parser.ParseInt(); //Asteroid Damage
 	asteroidData[level].asteroidPoints = parser.ParseInt(); //Points awarded for destruction
 }
 
 void idGameSSDWindow::ParsePowerupData(int level, const idStr& powerupDataString) {
 	
 	idParser parser;
 	idToken token;
 	parser.LoadMemory(powerupDataString.c_str(), powerupDataString.Length(), "PowerupData");
 
 	powerupData[level].speedMin = parser.ParseFloat(); //Speed Min 
 	powerupData[level].speedMax = parser.ParseFloat(); //Speed Max
 
 	powerupData[level].rotateMin = parser.ParseFloat(); //Rotate Min (rotations per second) 
 	powerupData[level].rotateMax = parser.ParseFloat(); //Rotate Max (rotations per second)
 
 	powerupData[level].spawnMin = parser.ParseInt(); //Spawn Min
 	powerupData[level].spawnMax = parser.ParseInt(); //Spawn Max
 
 }
 
 void idGameSSDWindow::ParseWeaponData(int weapon, const idStr& weaponDataString) {
 
 	idParser parser;
 	idToken token;
 	parser.LoadMemory(weaponDataString.c_str(), weaponDataString.Length(), "WeaponData");
 
 	weaponData[weapon].speed = parser.ParseFloat(); 
 	weaponData[weapon].damage = parser.ParseFloat();
 	weaponData[weapon].size = parser.ParseFloat();
 }
 
 void idGameSSDWindow::ParseAstronautData(int level, const idStr& astronautDataString) {
 	
 	idParser parser;
 	idToken token;
 	parser.LoadMemory(astronautDataString.c_str(), astronautDataString.Length(), "AstronautData");
 
 	astronautData[level].speedMin = parser.ParseFloat(); //Speed Min 
 	astronautData[level].speedMax = parser.ParseFloat(); //Speed Max
 
 	astronautData[level].rotateMin = parser.ParseFloat(); //Rotate Min (rotations per second) 
 	astronautData[level].rotateMax = parser.ParseFloat(); //Rotate Max (rotations per second)
 
 	astronautData[level].spawnMin = parser.ParseInt(); //Spawn Min
 	astronautData[level].spawnMax = parser.ParseInt(); //Spawn Max
 
 	astronautData[level].health = parser.ParseInt(); //Health of the asteroid
 	astronautData[level].points = parser.ParseInt(); //Asteroid Damage
 	astronautData[level].penalty = parser.ParseInt(); //Points awarded for destruction
 }
 
 void idGameSSDWindow::CommonInit() {
 	crosshair.InitCrosshairs();
 
 
 	beginLevel = false;
 	resetGame = false;
 	continueGame = false;
 	refreshGuiData = false;
 
 	ssdTime = 0;
 	levelCount = 0;
 	weaponCount = 0;
 	screenBounds = idBounds(idVec3(-320,-240,0), idVec3(320,240,0));
 
 	superBlasterTimeout = 0;
 
 	currentSound = 0;
 
 	//Precahce all assets that are loaded dynamically
 	declManager->FindMaterial(ASTEROID_MATERIAL);
 	declManager->FindMaterial(ASTRONAUT_MATERIAL);
 
 	for(int i = 0; i < EXPLOSION_MATERIAL_COUNT; i++) {
 		declManager->FindMaterial(explosionMaterials[i]);
 	}
 	declManager->FindMaterial(PROJECTILE_MATERIAL);
 	for(int i = 0; i < POWERUP_MATERIAL_COUNT; i++) {
 		declManager->FindMaterial(powerupMaterials[i][0]);
 		declManager->FindMaterial(powerupMaterials[i][1]);
 	}
 	
 	// Precache sounds
 	declManager->FindSound( "arcade_blaster" );
 	declManager->FindSound( "arcade_capture" );
 	declManager->FindSound( "arcade_explode" );
 
 	ResetGameStats();
 }
 
 void idGameSSDWindow::ResetGameStats() {
 
 	ResetEntities();
 
 	//Reset the gamestats structure
 	memset(&gameStats, 0, sizeof(gameStats));
 
 	gameStats.health = 100;
 
 } 
 
 void idGameSSDWindow::ResetLevelStats() {
 	
 	ResetEntities();
 	
 	//Reset the level statistics structure
 	memset(&gameStats.levelStats, 0, sizeof(gameStats.levelStats));
 
 	
 }
 
 void idGameSSDWindow::ResetEntities() {
 	//Destroy all of the entities
 	for(int i = 0; i < entities.Num(); i++) {
 		entities[i]->DestroyEntity();
 	}
 	entities.Clear();
 }
 
 void idGameSSDWindow::StartGame() {
 	
 	gameStats.gameRunning = true;
 }
 
 void idGameSSDWindow::StopGame() {
 	
 	gameStats.gameRunning = false;
 }
 
 void idGameSSDWindow::GameOver() {
 
 	
 	StopGame();
 
 	gui->HandleNamedEvent("gameOver");
 }
 
 void idGameSSDWindow::BeginLevel(int level) {
 	
 	ResetLevelStats();
 
 	gameStats.currentLevel = level;
 
 	StartGame();
 }
 
 /**
 * Continue game resets the players health
 */
 void idGameSSDWindow::ContinueGame() {
 	gameStats.health = 100; 
 
 	StartGame();
 }
 
 void idGameSSDWindow::LevelComplete() {
 	
 	gameStats.prebonusscore = gameStats.score;
 
 	// Add the bonuses
 	int accuracy;
 	if( !gameStats.levelStats.shotCount ) {
 		accuracy = 0;
 	} else {
 		accuracy = (int)( ( (float)gameStats.levelStats.hitCount / (float)gameStats.levelStats.shotCount ) * 100.0f );
 	}
 	int accuracyPoints = Max( 0, accuracy - 50 ) * 20;
 
 	gui->SetStateString("player_accuracy_score", va("%i", accuracyPoints));
 
 	gameStats.score += accuracyPoints;
 
 	int saveAccuracy;
 	int totalAst = gameStats.levelStats.savedAstronauts + gameStats.levelStats.killedAstronauts;
 	if( !totalAst ) {
 		saveAccuracy = 0;
 	} else {
 		saveAccuracy = (int)( ( (float)gameStats.levelStats.savedAstronauts / (float)totalAst ) * 100.0f );
 	}
 	accuracyPoints = Max( 0, saveAccuracy - 50 ) * 20;
 
 	gui->SetStateString("save_accuracy_score", va("%i", accuracyPoints));
 
 	gameStats.score += accuracyPoints;
 
 
 
 	StopSuperBlaster();
 
 	gameStats.nextLevel++;
 
 	if(gameStats.nextLevel >= levelCount) {
 		//Have they beaten the game
 		GameComplete();
 	} else {
 
 		//Make sure we don't go above the levelcount
 		//min(gameStats.nextLevel, levelCount-1);
 
 		StopGame();
 		gui->HandleNamedEvent("levelComplete");
 	}
 }
 
 void idGameSSDWindow::GameComplete() {
 	StopGame();
 	gui->HandleNamedEvent("gameComplete");
 }
 
 
 void idGameSSDWindow::UpdateGame() {
 
 	//Check to see if and functions where called by the gui
 	if(beginLevel == true) {
 		beginLevel = false;
 		BeginLevel(gameStats.nextLevel);
 	}
 	if(resetGame == true) {
 		resetGame = false;
 		ResetGameStats();
 	}
 	if(continueGame == true) {
 		continueGame = false;
 		ContinueGame();
 	}
 	if(refreshGuiData == true) {
 		refreshGuiData = false;
 		RefreshGuiData();
 	}
 
 	if(gameStats.gameRunning) {
 
 		//We assume an upate every 16 milliseconds
 		ssdTime += 16;
 
 		if(superBlasterTimeout && ssdTime > superBlasterTimeout) {
 			StopSuperBlaster();
 		}
 
 		//Find if we are targeting and enemy
 		idVec2 cursor;
 		//GetCursor(cursor);
 		cursor.x = gui->CursorX();
 		cursor.y = gui->CursorY();
 		gameStats.levelStats.targetEnt = EntityHitTest(cursor);
 
 		//Update from back to front
 		for(int i = entities.Num()-1; i >= 0; i--) {
 			entities[i]->Update();
 		}
 
 		CheckForHits();
 
 		//Delete entities that need to be deleted
 		for(int i = entities.Num()-1; i >= 0; i--) {
 			if(entities[i]->destroyed) {
 				SSDEntity* ent = entities[i];
 				ent->DestroyEntity();
 				entities.RemoveIndex(i);
 			}
 		}
 
 		//Check if we can spawn an asteroid
 		SpawnAsteroid();
 
 		//Check if we should spawn an astronaut
 		SpawnAstronaut();
 
 		//Check if we should spawn an asteroid
 		SpawnPowerup();
 	}
 }
 
 void idGameSSDWindow::CheckForHits() {
 	
 	//See if the entity has gotten close enough
 	for(int i = 0; i < entities.Num(); i++) {
 		SSDEntity* ent = entities[i];
 		if(ent->position.z <= Z_NEAR) {
 
 			if(!ent->noPlayerDamage) {
 
 				//Is the object still in the screen
 				idVec3 entPos = ent->position;
 				entPos.z = 0;
 
 				idBounds entBounds(entPos);
 				entBounds.ExpandSelf(ent->hitRadius);
 
 				if(screenBounds.IntersectsBounds(entBounds)) {
 
 					ent->OnStrikePlayer();
 
 					//The entity hit the player figure out what is was and act appropriately
 					if(ent->type == SSD_ENTITY_ASTEROID) {
 						AsteroidStruckPlayer(static_cast<SSDAsteroid*>(ent));
 					} else if(ent->type == SSD_ENTITY_ASTRONAUT) {
 						AstronautStruckPlayer(static_cast<SSDAstronaut*>(ent));
 					}
 				} else {
 					//Tag for removal later in the frame
 					ent->destroyed = true;
 				}
 			}
 		}
 	}
 }
 
 void idGameSSDWindow::ZOrderEntities() {
 	//Z-Order the entities
 	//Using a simple sorting method
 	for (int i = entities.Num()-1; i >= 0; i--) { 
 		bool flipped = false;
 		for (int j = 0;  j<i ; j++) { 
 			if (entities[j]->position.z > entities[j+1]->position.z) { 
 				SSDEntity* ent = entities[j];
 				entities[j] = entities[j+1]; 
 				entities[j+1] = ent; 
 				flipped = true; 
 			} 
 		} 
 		if (!flipped) { 
 			//Jump out because it is sorted
 			break; 
 		} 
 	}
 }
 
 void idGameSSDWindow::SpawnAsteroid() {
 
 	int currentTime = ssdTime;
 
 	if(currentTime < gameStats.levelStats.nextAsteroidSpawnTime) {
 		//Not time yet
 		return;
 	}
 
 	//Lets spawn it
 	idVec3 startPosition;
 
 	float spawnBuffer = levelData[gameStats.currentLevel].spawnBuffer*2.0f;
 	startPosition.x = random.RandomInt(V_WIDTH+spawnBuffer)-((V_WIDTH/2.0f)+spawnBuffer);
 	startPosition.y = random.RandomInt(V_HEIGHT+spawnBuffer)-((V_HEIGHT/2.0f)+spawnBuffer);
 	startPosition.z = ENTITY_START_DIST;
 
 	float speed = random.RandomInt(asteroidData[gameStats.currentLevel].speedMax - asteroidData[gameStats.currentLevel].speedMin) + asteroidData[gameStats.currentLevel].speedMin;
 	float size = random.RandomInt(asteroidData[gameStats.currentLevel].sizeMax - asteroidData[gameStats.currentLevel].sizeMin) + asteroidData[gameStats.currentLevel].sizeMin;
 	float rotate = (random.RandomFloat() * (asteroidData[gameStats.currentLevel].rotateMax - asteroidData[gameStats.currentLevel].rotateMin)) + asteroidData[gameStats.currentLevel].rotateMin;
 	
 	SSDAsteroid* asteroid = SSDAsteroid::GetNewAsteroid(this, startPosition, idVec2(size, size), speed, rotate, asteroidData[gameStats.currentLevel].asteroidHealth);
 	entities.Append(asteroid);
 	
 	gameStats.levelStats.nextAsteroidSpawnTime = currentTime + random.RandomInt(asteroidData[gameStats.currentLevel].spawnMax - asteroidData[gameStats.currentLevel].spawnMin) + asteroidData[gameStats.currentLevel].spawnMin;
 }
 
 void idGameSSDWindow::FireWeapon(int key) {
 
 	idVec2 cursorWorld = GetCursorWorld();
 	idVec2 cursor;
 	//GetCursor(cursor);
 	cursor.x = gui->CursorX();
 	cursor.y = gui->CursorY();
 
 	if(key == K_MOUSE1) {
 	
 		gameStats.levelStats.shotCount++;
 		
 		if(gameStats.levelStats.targetEnt) {
 			//Aim the projectile from the bottom of the screen directly at the ent
 			//SSDProjectile* newProj = new (TAG_OLD_UI) SSDProjectile(this, idVec3(320,0,0), gameStats.levelStats.targetEnt->position, weaponData[gameStats.currentWeapon].speed, weaponData[gameStats.currentWeapon].size);
 			SSDProjectile* newProj = SSDProjectile::GetNewProjectile(this, idVec3(0,-180,0), gameStats.levelStats.targetEnt->position, weaponData[gameStats.currentWeapon].speed, weaponData[gameStats.currentWeapon].size);
 			entities.Append(newProj);
 			//newProj = SSDProjectile::GetNewProjectile(this, idVec3(-320,-0,0), gameStats.levelStats.targetEnt->position, weaponData[gameStats.currentWeapon].speed, weaponData[gameStats.currentWeapon].size);
 			//entities.Append(newProj);
 
 			//We hit something
 			gameStats.levelStats.hitCount++;
 
 			gameStats.levelStats.targetEnt->OnHit(key);
 
 			if(gameStats.levelStats.targetEnt->type == SSD_ENTITY_ASTEROID) {
 				HitAsteroid(static_cast<SSDAsteroid*>(gameStats.levelStats.targetEnt), key);
 			} else if(gameStats.levelStats.targetEnt->type == SSD_ENTITY_ASTRONAUT) {
 				HitAstronaut(static_cast<SSDAstronaut*>(gameStats.levelStats.targetEnt), key);
 			}
 		} else {
 			////Aim the projectile at the cursor position all the way to the far clipping
 			//SSDProjectile* newProj = SSDProjectile::GetNewProjectile(this, idVec3(0,-180,0), idVec3(cursorWorld.x, cursorWorld.y, (Z_FAR-Z_NEAR)/2.0f), weaponData[gameStats.currentWeapon].speed, weaponData[gameStats.currentWeapon].size);
 
 			//Aim the projectile so it crosses the cursor 1/4 of screen
 			idVec3 vec = idVec3(cursorWorld.x, cursorWorld.y, (Z_FAR-Z_NEAR)/8.0f);
 			vec *= 8;
 			SSDProjectile* newProj = SSDProjectile::GetNewProjectile(this, idVec3(0,-180,0), vec, weaponData[gameStats.currentWeapon].speed, weaponData[gameStats.currentWeapon].size);
 			entities.Append(newProj);	
 			
 		}
 
 
 		//Play the blaster sound
 		PlaySound("arcade_blaster");
 
 	} /*else if (key == K_MOUSE2) {
 		if(gameStats.levelStats.targetEnt) {
 			if(gameStats.levelStats.targetEnt->type == SSD_ENTITY_ASTRONAUT) {
 				HitAstronaut(static_cast<SSDAstronaut*>(gameStats.levelStats.targetEnt), key);
 			}
 		}
 	}*/
 }
 
 SSDEntity* idGameSSDWindow::EntityHitTest(const idVec2& pt) {
 
 	for(int i = 0; i < entities.Num(); i++) {
 		//Since we ZOrder the entities every frame we can stop at the first entity we hit.
 		//ToDo: Make sure this assumption is true
 		if(entities[i]->HitTest(pt)) {
 			return entities[i];
 		}
 	}
 	return NULL;
 }
 
 void idGameSSDWindow::HitAsteroid(SSDAsteroid* asteroid, int key) {
 
 	
 
 	asteroid->health -= weaponData[gameStats.currentWeapon].damage;
 
 	if(asteroid->health <= 0) {
 		
 		//The asteroid has been destroyed
 		SSDExplosion* explosion = SSDExplosion::GetNewExplosion(this, asteroid->position, asteroid->size*2, 300, SSDExplosion::EXPLOSION_NORMAL, asteroid);
 		entities.Append(explosion);
 		PlaySound("arcade_explode");
 
 		AddScore(asteroid, asteroidData[gameStats.currentLevel].asteroidPoints);
 
 		//Don't let the player hit it anymore because 
 		asteroid->noHit = true;
 
 		gameStats.levelStats.destroyedAsteroids++;
 		//if(gameStats.levelStats.destroyedAsteroids >= levelData[gameStats.currentLevel].needToWin) {
 		//	LevelComplete();
 		//}
 
 	} else {
 		//This was a damage hit so create a real small quick explosion
 		SSDExplosion* explosion = SSDExplosion::GetNewExplosion(this, asteroid->position, asteroid->size/2.0f, 200, SSDExplosion::EXPLOSION_NORMAL, asteroid, false, false);
 		entities.Append(explosion);
 	}
 }
 
 void idGameSSDWindow::AsteroidStruckPlayer(SSDAsteroid* asteroid) {
 
 	asteroid->noPlayerDamage = true;
 	asteroid->noHit = true;
 	
 	AddDamage(asteroidData[gameStats.currentLevel].asteroidDamage);
 
 	SSDExplosion* explosion = SSDExplosion::GetNewExplosion(this, asteroid->position, asteroid->size*2, 300, SSDExplosion::EXPLOSION_NORMAL, asteroid);
 	entities.Append(explosion);
 	PlaySound("arcade_explode");
 }
 
 void idGameSSDWindow::AddScore(SSDEntity* ent, int points) {
 
 	SSDPoints* pointsEnt;
 	
 	if(points > 0) {
 		pointsEnt = SSDPoints::GetNewPoints(this, ent, points, 1000, 50, idVec4(0,1,0,1));
 	} else {
 		pointsEnt = SSDPoints::GetNewPoints(this, ent, points, 1000, 50, idVec4(1,0,0,1));
 	}
 	entities.Append(pointsEnt);
 
 	gameStats.score += points;
 	gui->SetStateString( "player_score", va("%i", gameStats.score ) );
 }
 
 void idGameSSDWindow::AddDamage(int damage) {
 	gameStats.health -= damage;
 	gui->SetStateString( "player_health", va("%i", gameStats.health ) );
 
 	gui->HandleNamedEvent( "playerDamage" );
 
 	if(gameStats.health <= 0) {
 		//The player is dead
 		GameOver();
 	}
 }
 
 void idGameSSDWindow::AddHealth(int health) {
 	gameStats.health += health;
 	gameStats.health = Min( 100, gameStats.health );
 }
 
 
 void idGameSSDWindow::OnNuke() {
 	
 	gui->HandleNamedEvent("nuke");
 
 	//Destory All Asteroids
 	for(int i = 0 ; i < entities.Num(); i++) {
 
 		if(entities[i]->type == SSD_ENTITY_ASTEROID) {
 			
 			//The asteroid has been destroyed
 			SSDExplosion* explosion = SSDExplosion::GetNewExplosion(this, entities[i]->position, entities[i]->size*2, 300, SSDExplosion::EXPLOSION_NORMAL, entities[i]);
 			entities.Append(explosion);
 
 			AddScore(entities[i], asteroidData[gameStats.currentLevel].asteroidPoints);
 
 			//Don't let the player hit it anymore because 
 			entities[i]->noHit = true;
 
 			gameStats.levelStats.destroyedAsteroids++;
 		}
 	}
 	PlaySound("arcade_explode");
 	
 	//Check to see if a nuke ends the level
 	/*if(gameStats.levelStats.destroyedAsteroids >= levelData[gameStats.currentLevel].needToWin) {
 		LevelComplete();
 
 	}*/
 }
 
 void idGameSSDWindow::OnRescueAll() {
 	
 	gui->HandleNamedEvent("rescueAll");
 
 	//Rescue All Astronauts
 	for(int i = 0 ; i < entities.Num(); i++) {
 
 		if(entities[i]->type == SSD_ENTITY_ASTRONAUT) {
 
 			AstronautStruckPlayer((SSDAstronaut*)entities[i]);
 		}
 	}
 }
 
 void idGameSSDWindow::OnSuperBlaster() {
 	
 	StartSuperBlaster();
 }
 
 
 
 void idGameSSDWindow::RefreshGuiData() {
 
 
 	gui->SetStateString("nextLevel", va("%i", gameStats.nextLevel+1));
 	gui->SetStateString("currentLevel", va("%i", gameStats.currentLevel+1));
 
 	float accuracy;
 	if(!gameStats.levelStats.shotCount) {
 		accuracy = 0;
 	} else {
 		accuracy = ((float)gameStats.levelStats.hitCount/(float)gameStats.levelStats.shotCount)*100.0f;
 	}
 	gui->SetStateString( "player_accuracy", va("%d%%", (int)accuracy));
 
 	float saveAccuracy;
 	int totalAst = gameStats.levelStats.savedAstronauts + gameStats.levelStats.killedAstronauts;
 
 	if(!totalAst) {
 		saveAccuracy = 0;
 	} else {
 		saveAccuracy = ((float)gameStats.levelStats.savedAstronauts/(float)totalAst)*100.0f;
 	}
 	gui->SetStateString( "save_accuracy", va("%d%%", (int)saveAccuracy));
 
 
 
 
 	if(gameStats.levelStats.targetEnt) {
 		int dist = (gameStats.levelStats.targetEnt->position.z/100.0f);
 		dist *= 100;
 		gui->SetStateString("target_info", va("%i meters", dist));
 	} else {
 		gui->SetStateString("target_info", "No Target");
 	}
 
 	gui->SetStateString( "player_health", va("%i", gameStats.health ) );
 	gui->SetStateString( "player_score", va("%i", gameStats.score ) );
 	gui->SetStateString( "player_prebonusscore", va("%i", gameStats.prebonusscore ) );
 	gui->SetStateString( "level_complete", va("%i/%i", gameStats.levelStats.savedAstronauts, levelData[gameStats.currentLevel].needToWin ));
 
 
 	if(superBlasterTimeout) {
 		float timeRemaining = (superBlasterTimeout - ssdTime)/1000.0f;
 		gui->SetStateString("super_blaster_time", va("%.2f", timeRemaining));
 	}
 }
 
 idVec2 idGameSSDWindow::GetCursorWorld() {
 	
 	idVec2 cursor;
 	//GetCursor(cursor);
 	cursor.x = gui->CursorX();
 	cursor.y = gui->CursorY();
 	cursor.x = cursor.x - 0.5f * V_WIDTH;
 	cursor.y = -(cursor.y  - 0.5f * V_HEIGHT);
 	return cursor;
 }
 
 void idGameSSDWindow::SpawnAstronaut() {
 	
 	int currentTime = ssdTime;
 
 	if(currentTime < gameStats.levelStats.nextAstronautSpawnTime) {
 		//Not time yet
 		return;
 	}
 
 	//Lets spawn it
 	idVec3 startPosition;
 
 	startPosition.x = random.RandomInt(V_WIDTH)-(V_WIDTH/2.0f);
 	startPosition.y = random.RandomInt(V_HEIGHT)-(V_HEIGHT/2.0f);
 	startPosition.z = ENTITY_START_DIST;
 
 	float speed = random.RandomInt(astronautData[gameStats.currentLevel].speedMax - astronautData[gameStats.currentLevel].speedMin) + astronautData[gameStats.currentLevel].speedMin;
 	float rotate = (random.RandomFloat() * (astronautData[gameStats.currentLevel].rotateMax - astronautData[gameStats.currentLevel].rotateMin)) + astronautData[gameStats.currentLevel].rotateMin;
 
 	SSDAstronaut* astronaut = SSDAstronaut::GetNewAstronaut(this, startPosition, speed, rotate, astronautData[gameStats.currentLevel].health);
 	entities.Append(astronaut);
 
 	gameStats.levelStats.nextAstronautSpawnTime = currentTime + random.RandomInt(astronautData[gameStats.currentLevel].spawnMax - astronautData[gameStats.currentLevel].spawnMin) + astronautData[gameStats.currentLevel].spawnMin;
 }
 
 void idGameSSDWindow::HitAstronaut(SSDAstronaut* astronaut, int key) {
 
 
 	if(key == K_MOUSE1) {
 		astronaut->health -= weaponData[gameStats.currentWeapon].damage;
 
 		if(astronaut->health <= 0) {
 
 			gameStats.levelStats.killedAstronauts++;
 
 			//The astronaut has been destroyed
 			SSDExplosion* explosion = SSDExplosion::GetNewExplosion(this, astronaut->position, astronaut->size*2, 300, SSDExplosion::EXPLOSION_NORMAL, astronaut);
 			entities.Append(explosion);
 			PlaySound("arcade_explode");
 
 			//Add the penalty for killing the astronaut
 			AddScore(astronaut, astronautData[gameStats.currentLevel].penalty);
 
 			//Don't let the player hit it anymore
 			astronaut->noHit = true;
 		} else {
 			//This was a damage hit so create a real small quick explosion
 			SSDExplosion* explosion = SSDExplosion::GetNewExplosion(this, astronaut->position, astronaut->size/2.0f, 200, SSDExplosion::EXPLOSION_NORMAL, astronaut, false, false);
 			entities.Append(explosion);
 		}
 	}
 }
 
 void idGameSSDWindow::AstronautStruckPlayer(SSDAstronaut* astronaut) {
 
 	gameStats.levelStats.savedAstronauts++;
 
 	astronaut->noPlayerDamage = true;
 	astronaut->noHit = true;
 
 	//We are saving an astronaut
 	SSDExplosion* explosion = SSDExplosion::GetNewExplosion(this, astronaut->position, astronaut->size*2, 300, SSDExplosion::EXPLOSION_TELEPORT, astronaut);
 	entities.Append(explosion);
 	PlaySound("arcade_capture");
 
 	//Give the player points for saving the astronaut
 	AddScore(astronaut, astronautData[gameStats.currentLevel].points);
 
 	if(gameStats.levelStats.savedAstronauts >= levelData[gameStats.currentLevel].needToWin) {
 		LevelComplete();
 	}
 
 }
 
 void idGameSSDWindow::SpawnPowerup() {
 
 	int currentTime = ssdTime;
 
 	if(currentTime < gameStats.levelStats.nextPowerupSpawnTime) {
 		//Not time yet
 		return;
 	}
 
 	float speed = random.RandomInt(powerupData[gameStats.currentLevel].speedMax - powerupData[gameStats.currentLevel].speedMin) + powerupData[gameStats.currentLevel].speedMin;
 	float rotate = (random.RandomFloat() * (powerupData[gameStats.currentLevel].rotateMax - powerupData[gameStats.currentLevel].rotateMin)) + powerupData[gameStats.currentLevel].rotateMin;
 
 	SSDPowerup* powerup = SSDPowerup::GetNewPowerup(this, speed, rotate);
 	entities.Append(powerup);
 
 	gameStats.levelStats.nextPowerupSpawnTime = currentTime + random.RandomInt(powerupData[gameStats.currentLevel].spawnMax - powerupData[gameStats.currentLevel].spawnMin) + powerupData[gameStats.currentLevel].spawnMin;
 
 }
 
 void idGameSSDWindow::StartSuperBlaster() {
 	
 	gui->HandleNamedEvent("startSuperBlaster");
 	gameStats.currentWeapon = 1;
 	superBlasterTimeout = ssdTime + 10000;
 
 }
 void idGameSSDWindow::StopSuperBlaster() {
 	gui->HandleNamedEvent("stopSuperBlaster");
 	gameStats.currentWeapon = 0;
 	superBlasterTimeout = 0;
 
 }
 
 SSDEntity* idGameSSDWindow::GetSpecificEntity(int type, int id) {
 	SSDEntity* ent = NULL;
 	switch(type) {
 			case SSD_ENTITY_ASTEROID:
 				ent = SSDAsteroid::GetSpecificAsteroid(id);
 				break;
 			case SSD_ENTITY_ASTRONAUT:
 				ent = SSDAstronaut::GetSpecificAstronaut(id);
 				break;
 			case SSD_ENTITY_EXPLOSION:
 				ent = SSDExplosion::GetSpecificExplosion(id);
 				break;
 			case SSD_ENTITY_POINTS:
 				ent = SSDPoints::GetSpecificPoints(id);
 				break;
 			case SSD_ENTITY_PROJECTILE:
 				ent = SSDProjectile::GetSpecificProjectile(id);
 				break;
 			case SSD_ENTITY_POWERUP:
 				ent = SSDPowerup::GetSpecificPowerup(id);
 				break;
 	}
 	return ent;
 }
 
 #define MAX_SOUND_CHANNEL 8
 
 void idGameSSDWindow::PlaySound(const char* sound) {
 
 	common->SW()->PlayShaderDirectly(sound, currentSound);
 
 	currentSound++;
 	if(currentSound >= MAX_SOUND_CHANNEL) {
 		currentSound = 0;
 	}
 }