GameSSDWindow.h

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.

===========================================================================
*/
#ifndef __GAME_SSD_WINDOW_H__
#define __GAME_SSD_WINDOW_H__

class idGameSSDWindow;

class SSDCrossHair {

public:
        enum {
                CROSSHAIR_STANDARD = 0,
                CROSSHAIR_SUPER,
                CROSSHAIR_COUNT
        };
        const idMaterial*       crosshairMaterial[CROSSHAIR_COUNT];
        int                                     currentCrosshair;
        float                           crosshairWidth, crosshairHeight;

public:
                                SSDCrossHair();
                                ~SSDCrossHair();

        virtual void    WriteToSaveGame( idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile );

        void            InitCrosshairs();
        void            Draw(idDeviceContext *dc, const idVec2& cursor);
};

enum {
        SSD_ENTITY_BASE = 0,
        SSD_ENTITY_ASTEROID,
        SSD_ENTITY_ASTRONAUT,
        SSD_ENTITY_EXPLOSION,
        SSD_ENTITY_POINTS,
        SSD_ENTITY_PROJECTILE,
        SSD_ENTITY_POWERUP
};

class SSDEntity  {

public:
        //SSDEntity Information
        int                                     type;
        int                                     id;
        idStr                           materialName;
        const idMaterial*       material;
        idVec3                          position;
        idVec2                          size;
        float                           radius;
        float                           hitRadius;
        float                           rotation;

        idVec4                          matColor;

        idStr                           text;
        float                           textScale;
        idVec4                          foreColor;

        idGameSSDWindow*        game;
        int                                     currentTime;
        int                                     lastUpdate;
        int                                     elapsed;

        bool                            destroyed;
        bool                            noHit;
        bool                            noPlayerDamage;

        bool                            inUse;

        
public:
                                                SSDEntity();
        virtual                         ~SSDEntity();

        virtual void            WriteToSaveGame( idFile *savefile );
        virtual void            ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game );

        void                            EntityInit();

        void                            SetGame(idGameSSDWindow* _game);
        void                            SetMaterial(const char* _name);
        void                            SetPosition(const idVec3& _position);
        void                            SetSize(const idVec2& _size);
        void                            SetRadius(float _radius, float _hitFactor = 1.0f);
        void                            SetRotation(float _rotation);

        void                            Update();
        bool                            HitTest(const idVec2& pt);
        

        virtual void            EntityUpdate() {};
        virtual void            Draw(idDeviceContext *dc);
        virtual void            DestroyEntity();

        virtual void            OnHit(int key) {};
        virtual void            OnStrikePlayer() {};

        idBounds                        WorldToScreen(const idBounds worldBounds);
        idVec3                          WorldToScreen(const idVec3& worldPos);

        idVec3                          ScreenToWorld(const idVec3& screenPos);

};

/*
*****************************************************************************
* SSDMover      
****************************************************************************
*/

class SSDMover : public SSDEntity {

public:
        idVec3                          speed;
        float                           rotationSpeed;

public:
                                                SSDMover();
        virtual                         ~SSDMover();

        virtual void    WriteToSaveGame( idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  );

        void                            MoverInit(const idVec3& _speed, float _rotationSpeed);

        virtual void            EntityUpdate();


};

/*
*****************************************************************************
* SSDAsteroid   
****************************************************************************
*/

#define MAX_ASTEROIDS 64

class SSDAsteroid : public SSDMover {

public:

        int                                     health;

public:
                                                SSDAsteroid();
                                                ~SSDAsteroid();

        virtual void    WriteToSaveGame( idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  );

        void                            Init(idGameSSDWindow* _game, const idVec3& startPosition, const idVec2& _size, float _speed, float rotate, int _health);

        virtual void            EntityUpdate();
        static SSDAsteroid*     GetNewAsteroid(idGameSSDWindow* _game, const idVec3& startPosition, const idVec2& _size, float _speed, float rotate, int _health);
        static SSDAsteroid*     GetSpecificAsteroid(int id);
        static void                     WriteAsteroids(idFile* savefile);
        static void                     ReadAsteroids(idFile* savefile, idGameSSDWindow* _game);


        
protected:
        static SSDAsteroid      asteroidPool[MAX_ASTEROIDS];
        
};

/*
*****************************************************************************
* SSDAstronaut  
****************************************************************************
*/
#define MAX_ASTRONAUT 8

class SSDAstronaut : public SSDMover {

public:

        int                                     health;

public:
                                                        SSDAstronaut();
                                                        ~SSDAstronaut();
        
        virtual void    WriteToSaveGame( idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  );

        void                                    Init(idGameSSDWindow* _game, const idVec3& startPosition, float _speed, float rotate, int _health);

        static SSDAstronaut*    GetNewAstronaut(idGameSSDWindow* _game, const idVec3& startPosition, float _speed, float rotate, int _health);
        static SSDAstronaut*    GetSpecificAstronaut(int id);
        static void                             WriteAstronauts(idFile* savefile);
        static void                             ReadAstronauts(idFile* savefile, idGameSSDWindow* _game);

protected:
        static SSDAstronaut     astronautPool[MAX_ASTRONAUT];

};

/*
*****************************************************************************
* SSDExplosion  
****************************************************************************
*/
#define MAX_EXPLOSIONS 64

class SSDExplosion : public SSDEntity {

public:
        idVec2  finalSize;
        int             length;
        int             beginTime;
        int             endTime;
        int             explosionType;

        //The entity that is exploding
        SSDEntity*                      buddy;
        bool                            killBuddy;
        bool                            followBuddy;

        enum {
                EXPLOSION_NORMAL = 0,
                EXPLOSION_TELEPORT = 1
        };

public:
        SSDExplosion();
        ~SSDExplosion();

        virtual void    WriteToSaveGame( idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  );

        void                            Init(idGameSSDWindow* _game, const idVec3& _position, const idVec2& _size, int _length, int _type, SSDEntity* _buddy, bool _killBuddy = true, bool _followBuddy = true);

        virtual void            EntityUpdate();
        static SSDExplosion*    GetNewExplosion(idGameSSDWindow* _game, const idVec3& _position, const idVec2& _size, int _length, int _type, SSDEntity* _buddy, bool _killBuddy = true, bool _followBuddy = true);
        static SSDExplosion*    GetSpecificExplosion(int id);
        static void                             WriteExplosions(idFile* savefile);
        static void                             ReadExplosions(idFile* savefile, idGameSSDWindow* _game);

protected:
        static SSDExplosion     explosionPool[MAX_EXPLOSIONS];
};

#define MAX_POINTS 16

class SSDPoints : public SSDEntity {

        int             length;
        int             distance;
        int             beginTime;
        int             endTime;

        idVec3  beginPosition;
        idVec3  endPosition;

        idVec4  beginColor;
        idVec4  endColor;

        
public:
        SSDPoints();
        ~SSDPoints();

        virtual void    WriteToSaveGame( idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  );

        void                            Init(idGameSSDWindow* _game, SSDEntity* _ent, int _points, int _length, int _distance, const idVec4& color);
        virtual void            EntityUpdate();

        static SSDPoints*       GetNewPoints(idGameSSDWindow* _game, SSDEntity* _ent, int _points, int _length, int _distance, const idVec4& color);
        static SSDPoints*       GetSpecificPoints(int id);
        static void                     WritePoints(idFile* savefile);
        static void                     ReadPoints(idFile* savefile, idGameSSDWindow* _game);

protected:
        static SSDPoints        pointsPool[MAX_POINTS];
};

#define MAX_PROJECTILES 64

class SSDProjectile : public SSDEntity {

        idVec3  dir;
        idVec3  speed;
        int             beginTime;
        int             endTime;

        idVec3  endPosition;

public:
        SSDProjectile();
        ~SSDProjectile();

        virtual void    WriteToSaveGame( idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  );

        void                            Init(idGameSSDWindow* _game, const idVec3& _beginPosition, const idVec3& _endPosition, float _speed, float _size);
        virtual void            EntityUpdate();

        static SSDProjectile* GetNewProjectile(idGameSSDWindow* _game, const idVec3& _beginPosition, const idVec3& _endPosition, float _speed, float _size);
        static SSDProjectile* GetSpecificProjectile(int id);
        static void                             WriteProjectiles(idFile* savefile);
        static void                             ReadProjectiles(idFile* savefile, idGameSSDWindow* _game);

protected:
        static SSDProjectile    projectilePool[MAX_PROJECTILES];
};


#define MAX_POWERUPS 64

class SSDPowerup : public SSDMover {

        enum {
                POWERUP_STATE_CLOSED = 0,
                POWERUP_STATE_OPEN
        };

        enum {
                POWERUP_TYPE_HEALTH = 0,
                POWERUP_TYPE_SUPER_BLASTER,
                POWERUP_TYPE_ASTEROID_NUKE,
                POWERUP_TYPE_RESCUE_ALL,
                POWERUP_TYPE_BONUS_POINTS,
                POWERUP_TYPE_DAMAGE,
                POWERUP_TYPE_MAX
        };

        int powerupState;
        int powerupType;


public:


public:
        SSDPowerup();
        virtual ~SSDPowerup();

        virtual void    WriteToSaveGame( idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile,  idGameSSDWindow* _game  );

        virtual void            OnHit(int key);
        virtual void            OnStrikePlayer();

        void    OnOpenPowerup();
        void    OnActivatePowerup();

        

        void    Init(idGameSSDWindow* _game, float _speed, float _rotation);

        static SSDPowerup* GetNewPowerup(idGameSSDWindow* _game, float _speed, float _rotation);
        static SSDPowerup* GetSpecificPowerup(int id);
        static void                     WritePowerups(idFile* savefile);
        static void                     ReadPowerups(idFile* savefile, idGameSSDWindow* _game);

protected:
        static SSDPowerup       powerupPool[MAX_POWERUPS];

};


typedef struct {
        float   spawnBuffer;
        int             needToWin;
} SSDLevelData_t;

typedef struct {
        float   speedMin, speedMax;
        float   sizeMin, sizeMax;
        float   rotateMin, rotateMax;
        int             spawnMin, spawnMax;
        int             asteroidHealth;
        int             asteroidPoints;
        int             asteroidDamage;
} SSDAsteroidData_t;

typedef struct {
        float   speedMin, speedMax;
        float   rotateMin, rotateMax;
        int             spawnMin, spawnMax;
        int             health;
        int             points;
        int             penalty;
} SSDAstronautData_t;

typedef struct {
        float   speedMin, speedMax;
        float   rotateMin, rotateMax;
        int             spawnMin, spawnMax;
} SSDPowerupData_t;

typedef struct {
        float   speed;
        int             damage;
        int             size;
} SSDWeaponData_t;

typedef struct {
        int                                     shotCount;
        int                                     hitCount;
        int                                     destroyedAsteroids;
        int                                     nextAsteroidSpawnTime;

        int                                     killedAstronauts;
        int                                     savedAstronauts;

        //Astronaut Level Data
        int                                     nextAstronautSpawnTime;

        //Powerup Level Data
        int                                     nextPowerupSpawnTime;

        SSDEntity*                      targetEnt;
} SSDLevelStats_t;

typedef struct {
        bool                            gameRunning;

        int                                     score;
        int                                     prebonusscore;

        int                                     health;

        int                                     currentWeapon;
        int                                     currentLevel;
        int                                     nextLevel;

        SSDLevelStats_t         levelStats;
} SSDGameStats_t;


class idGameSSDWindow : public idWindow {
public:
        idGameSSDWindow(idUserInterfaceLocal *gui);
        idGameSSDWindow(idDeviceContext *d, idUserInterfaceLocal *gui);
        ~idGameSSDWindow();

        virtual void    WriteToSaveGame( idFile *savefile );
        virtual void    ReadFromSaveGame( idFile *savefile );

        virtual const char*     HandleEvent(const sysEvent_t *event, bool *updateVisuals);
        virtual idWinVar*       GetWinVarByName (const char *_name, bool winLookup = false, drawWin_t** owner = NULL);
        
        
        virtual void            Draw(int time, float x, float y);

        void                            AddHealth(int health);
        void                            AddScore(SSDEntity* ent, int points);
        void                            AddDamage(int damage);

        void                            OnNuke();
        void                            OnRescueAll();
        void                            OnSuperBlaster();

        SSDEntity*                      GetSpecificEntity(int type, int id);

        void                            PlaySound(const char* sound);




        static idRandom         random; 
        int                                     ssdTime;
        
private:
        
        //Initialization
        virtual bool            ParseInternalVar(const char *name, idParser *src);
        void                            ParseLevelData(int level, const idStr& levelDataString);
        void                            ParseAsteroidData(int level, const idStr& asteroidDataString);
        void                            ParseWeaponData(int weapon, const idStr& weaponDataString);
        void                            ParseAstronautData(int level, const idStr& astronautDataString);
        void                            ParsePowerupData(int level, const idStr& powerupDataString);

        void                            CommonInit();
        void                            ResetGameStats();
        void                            ResetLevelStats();
        void                            ResetEntities();

        //Game Running Methods
        void                            StartGame();
        void                            StopGame();
        void                            GameOver();

        //Starting the Game
        void                            BeginLevel(int level);
        void                            ContinueGame();

        //Stopping the Game
        void                            LevelComplete();
        void                            GameComplete();

        

        void                            UpdateGame();
        void                            CheckForHits();
        void                            ZOrderEntities();

        void                            SpawnAsteroid();

        void                            FireWeapon(int key);
        SSDEntity*                      EntityHitTest(const idVec2& pt);

        void                            HitAsteroid(SSDAsteroid* asteroid, int key);
        void                            AsteroidStruckPlayer(SSDAsteroid* asteroid);

        
        

        
        void                            RefreshGuiData();

        idVec2                          GetCursorWorld();

        //Astronaut Methods
        void                            SpawnAstronaut();
        void                            HitAstronaut(SSDAstronaut* astronaut, int key);
        void                            AstronautStruckPlayer(SSDAstronaut* astronaut);

        //Powerup Methods
        void                            SpawnPowerup();


        void                            StartSuperBlaster();
        void                            StopSuperBlaster();

        //void                          FreeSoundEmitter( bool immediate );

        


public:

        //WinVars used to call functions from the guis
        idWinBool                                       beginLevel;
        idWinBool                                       resetGame;
        idWinBool                                       continueGame;
        idWinBool                                       refreshGuiData;

        SSDCrossHair                            crosshair;
        idBounds                                        screenBounds;

        //Level Data
        int                                                     levelCount;
        idList<SSDLevelData_t>          levelData;
        idList<SSDAsteroidData_t>       asteroidData;
        idList<SSDAstronautData_t>      astronautData;
        idList<SSDPowerupData_t>        powerupData;

        
        //Weapon Data
        int                                                     weaponCount;
        idList<SSDWeaponData_t>         weaponData;

        int                                                     superBlasterTimeout;

        //All current game data is stored in this structure (except the entity list)
        SSDGameStats_t                          gameStats;
        idList<SSDEntity*>                      entities;

        int                                                     currentSound;
        
};

#endif //__GAME_SSD_WINDOW_H__