GameSSDWindow.cpp

Go to the documentation of this file.

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

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

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 {
                        //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;
        }
}