id/doom3
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
doom3/neo/ui/GameSSDWindow.cpp

2300 lines
60 KiB
C++
Raw Normal View History

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