617 lines
15 KiB
C++
617 lines
15 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
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
|
|
|
|
/**
|
|
* Powerups work in two phases:
|
|
* 1.) Closed container hurls at you
|
|
* If you shoot the container it open
|
|
* 3.) If an opened powerup hits the player he aquires the powerup
|
|
* Powerup Types:
|
|
* Health - Give a specific amount of health
|
|
* Super Blaster - Increases the power of the blaster (lasts a specific amount of time)
|
|
* Asteroid Nuke - Destroys all asteroids on screen as soon as it is aquired
|
|
* Rescue Powerup - Rescues all astronauts as soon as it is acquited
|
|
* Bonus Points - Gives some bonus points when acquired
|
|
*/
|
|
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;
|
|
|
|
/**
|
|
* SSDLevelStats_t
|
|
* Data that is used for each level. This data is reset
|
|
* each new level.
|
|
*/
|
|
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;
|
|
|
|
/**
|
|
* SSDGameStats_t
|
|
* Data that is used for the game that is currently running. Memset this
|
|
* to completely reset the game
|
|
*/
|
|
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__
|