/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").

Doom 3 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 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 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 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 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.

===========================================================================
*/
#include "../idlib/precompiled.h"
#pragma hdrstop

#include "../framework/Session_local.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(idDeviceContext *dc, 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(idDeviceContext *dc) {


	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 += game->GetDC()->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(idDeviceContext *d, idUserInterfaceLocal *g) : idWindow(d, g) {
	dc = d;
	gui = g;
	CommonInit();
}

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(dc);
		}

		//The last thing to draw is the crosshair
		idVec2 cursor;
		//GetCursor(cursor);
		cursor.x = gui->CursorX();
		cursor.y = gui->CursorY();

		crosshair.Draw(dc, cursor);
	}
}


bool idGameSSDWindow::ParseInternalVar(const char *_name, idParser *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 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 if(gameStats.levelStats.targetEnt->type == SSD_ENTITY_ASTRONAUT) {

			}
		} 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) {

	session->sw->PlayShaderDirectly(sound, currentSound);

	currentSound++;
	if(currentSound >= MAX_SOUND_CHANNEL) {
		currentSound = 0;
	}
}