mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-02 08:51:57 +00:00
2600 lines
63 KiB
C++
2600 lines
63 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition 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 BFG Edition 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 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition 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 BFG Edition 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.
|
|
|
|
===========================================================================
|
|
*/
|
|
#pragma hdrstop
|
|
#include "precompiled.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( ¤tCrosshair, sizeof( currentCrosshair ) );
|
|
savefile->Write( &crosshairWidth, sizeof( crosshairWidth ) );
|
|
savefile->Write( &crosshairHeight, sizeof( crosshairHeight ) );
|
|
|
|
}
|
|
|
|
void SSDCrossHair::ReadFromSaveGame( idFile* savefile )
|
|
{
|
|
|
|
InitCrosshairs();
|
|
|
|
savefile->Read( ¤tCrosshair, 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( 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( ¤tTime, 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( ¤tTime, 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()
|
|
{
|
|
|
|
|
|
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 += dc->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( 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();
|
|
}
|
|
|
|
//The last thing to draw is the crosshair
|
|
idVec2 cursor;
|
|
//GetCursor(cursor);
|
|
cursor.x = gui->CursorX();
|
|
cursor.y = gui->CursorY();
|
|
|
|
crosshair.Draw( cursor );
|
|
}
|
|
}
|
|
|
|
|
|
bool idGameSSDWindow::ParseInternalVar( const char* _name, idTokenParser* 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 (TAG_OLD_UI) 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
|
|
{
|
|
////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 )
|
|
{
|
|
|
|
common->SW()->PlayShaderDirectly( sound, currentSound );
|
|
|
|
currentSound++;
|
|
if( currentSound >= MAX_SOUND_CHANNEL )
|
|
{
|
|
currentSound = 0;
|
|
}
|
|
}
|