blendo
/
quadrilateralcowboy
mirror of https://github.com/blendogames/quadrilateralcowboy.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quadrilateralcowboy/ui/GameBearShootWindow.cpp

896 lines
22 KiB
C++
Raw Blame History

/*
===========================================================================
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 "GameBearShootWindow.h"
#define BEAR_GRAVITY 240
#define BEAR_SIZE 24.f
#define BEAR_SHRINK_TIME 2000.f
#define MAX_WINDFORCE 100.f
idCVar bearTurretAngle( "bearTurretAngle", "0", CVAR_FLOAT, "" );
idCVar bearTurretForce( "bearTurretForce", "200", CVAR_FLOAT, "" );
/*
*****************************************************************************
* BSEntity
****************************************************************************
*/
BSEntity::BSEntity(idGameBearShootWindow* _game) {
game = _game;
visible = true;
entColor = colorWhite;
materialName = "";
material = NULL;
width = height = 8;
rotation = 0.f;
rotationSpeed = 0.f;
fadeIn = false;
fadeOut = false;
position.Zero();
velocity.Zero();
}
BSEntity::~BSEntity() {
}
/*
======================
BSEntity::WriteToSaveGame
======================
*/
void BSEntity::WriteToSaveGame( idFile *savefile ) {
game->WriteSaveGameString( materialName, savefile );
savefile->Write( &width, sizeof(width) );
savefile->Write( &height, sizeof(height) );
savefile->Write( &visible, sizeof(visible) );
savefile->Write( &entColor, sizeof(entColor) );
savefile->Write( &position, sizeof(position) );
savefile->Write( &rotation, sizeof(rotation) );
savefile->Write( &rotationSpeed, sizeof(rotationSpeed) );
savefile->Write( &velocity, sizeof(velocity) );
savefile->Write( &fadeIn, sizeof(fadeIn) );
savefile->Write( &fadeOut, sizeof(fadeOut) );
}
/*
======================
BSEntity::ReadFromSaveGame
======================
*/
void BSEntity::ReadFromSaveGame( idFile *savefile, idGameBearShootWindow* _game ) {
game = _game;
game->ReadSaveGameString( materialName, savefile );
SetMaterial( materialName );
savefile->Read( &width, sizeof(width) );
savefile->Read( &height, sizeof(height) );
savefile->Read( &visible, sizeof(visible) );
savefile->Read( &entColor, sizeof(entColor) );
savefile->Read( &position, sizeof(position) );
savefile->Read( &rotation, sizeof(rotation) );
savefile->Read( &rotationSpeed, sizeof(rotationSpeed) );
savefile->Read( &velocity, sizeof(velocity) );
savefile->Read( &fadeIn, sizeof(fadeIn) );
savefile->Read( &fadeOut, sizeof(fadeOut) );
}
/*
======================
BSEntity::SetMaterial
======================
*/
void BSEntity::SetMaterial(const char* name) {
materialName = name;
material = declManager->FindMaterial( name );
material->SetSort( SS_GUI );
}
/*
======================
BSEntity::SetSize
======================
*/
void BSEntity::SetSize( float _width, float _height ) {
width = _width;
height = _height;
}
/*
======================
BSEntity::SetVisible
======================
*/
void BSEntity::SetVisible( bool isVisible ) {
visible = isVisible;
}
/*
======================
BSEntity::Update
======================
*/
void BSEntity::Update( float timeslice ) {
if ( !visible ) {
return;
}
// Fades
if ( fadeIn && entColor.w < 1.f ) {
entColor.w += 1 * timeslice;
if ( entColor.w >= 1.f ) {
entColor.w = 1.f;
fadeIn = false;
}
}
if ( fadeOut && entColor.w > 0.f ) {
entColor.w -= 1 * timeslice;
if ( entColor.w <= 0.f ) {
entColor.w = 0.f;
fadeOut = false;
}
}
// Move the entity
position += velocity * timeslice;
// Rotate Entity
rotation += rotationSpeed * timeslice;
}
/*
======================
BSEntity::Draw
======================
*/
void BSEntity::Draw(idDeviceContext *dc) {
if ( visible ) {
dc->DrawMaterialRotated( position.x, position.y, width, height, material, entColor, 1.0f, 1.0f, DEG2RAD(rotation) );
}
}
/*
*****************************************************************************
* idGameBearShootWindow
****************************************************************************
*/
idGameBearShootWindow::idGameBearShootWindow(idDeviceContext *d, idUserInterfaceLocal *g) : idWindow(d, g) {
dc = d;
gui = g;
CommonInit();
}
idGameBearShootWindow::idGameBearShootWindow(idUserInterfaceLocal *g) : idWindow(g) {
gui = g;
CommonInit();
}
idGameBearShootWindow::~idGameBearShootWindow() {
entities.DeleteContents(true);
}
/*
=============================
idGameBearShootWindow::WriteToSaveGame
=============================
*/
void idGameBearShootWindow::WriteToSaveGame( idFile *savefile ) {
idWindow::WriteToSaveGame( savefile );
gamerunning.WriteToSaveGame( savefile );
onFire.WriteToSaveGame( savefile );
onContinue.WriteToSaveGame( savefile );
onNewGame.WriteToSaveGame( savefile );
savefile->Write( &timeSlice, sizeof(timeSlice) );
savefile->Write( &timeRemaining, sizeof(timeRemaining) );
savefile->Write( &gameOver, sizeof(gameOver) );
savefile->Write( &currentLevel, sizeof(currentLevel) );
savefile->Write( &goalsHit, sizeof(goalsHit) );
savefile->Write( &updateScore, sizeof(updateScore) );
savefile->Write( &bearHitTarget, sizeof(bearHitTarget) );
savefile->Write( &bearScale, sizeof(bearScale) );
savefile->Write( &bearIsShrinking, sizeof(bearIsShrinking) );
savefile->Write( &bearShrinkStartTime, sizeof(bearShrinkStartTime) );
savefile->Write( &turretAngle, sizeof(turretAngle) );
savefile->Write( &turretForce, sizeof(turretForce) );
savefile->Write( &windForce, sizeof(windForce) );
savefile->Write( &windUpdateTime, sizeof(windUpdateTime) );
int numberOfEnts = entities.Num();
savefile->Write( &numberOfEnts, sizeof(numberOfEnts) );
for ( int i=0; i<numberOfEnts; i++ ) {
entities[i]->WriteToSaveGame( savefile );
}
int index;
index = entities.FindIndex( turret );
savefile->Write( &index, sizeof(index) );
index = entities.FindIndex( bear );
savefile->Write( &index, sizeof(index) );
index = entities.FindIndex( helicopter );
savefile->Write( &index, sizeof(index) );
index = entities.FindIndex( goal );
savefile->Write( &index, sizeof(index) );
index = entities.FindIndex( wind );
savefile->Write( &index, sizeof(index) );
index = entities.FindIndex( gunblast );
savefile->Write( &index, sizeof(index) );
}
/*
=============================
idGameBearShootWindow::ReadFromSaveGame
=============================
*/
void idGameBearShootWindow::ReadFromSaveGame( idFile *savefile ) {
idWindow::ReadFromSaveGame( savefile );
// Remove all existing entities
entities.DeleteContents(true);
gamerunning.ReadFromSaveGame( savefile );
onFire.ReadFromSaveGame( savefile );
onContinue.ReadFromSaveGame( savefile );
onNewGame.ReadFromSaveGame( savefile );
savefile->Read( &timeSlice, sizeof(timeSlice) );
savefile->Read( &timeRemaining, sizeof(timeRemaining) );
savefile->Read( &gameOver, sizeof(gameOver) );
savefile->Read( &currentLevel, sizeof(currentLevel) );
savefile->Read( &goalsHit, sizeof(goalsHit) );
savefile->Read( &updateScore, sizeof(updateScore) );
savefile->Read( &bearHitTarget, sizeof(bearHitTarget) );
savefile->Read( &bearScale, sizeof(bearScale) );
savefile->Read( &bearIsShrinking, sizeof(bearIsShrinking) );
savefile->Read( &bearShrinkStartTime, sizeof(bearShrinkStartTime) );
savefile->Read( &turretAngle, sizeof(turretAngle) );
savefile->Read( &turretForce, sizeof(turretForce) );
savefile->Read( &windForce, sizeof(windForce) );
savefile->Read( &windUpdateTime, sizeof(windUpdateTime) );
int numberOfEnts;
savefile->Read( &numberOfEnts, sizeof(numberOfEnts) );
for ( int i=0; i<numberOfEnts; i++ ) {
BSEntity *ent;
ent = new BSEntity( this );
ent->ReadFromSaveGame( savefile, this );
entities.Append( ent );
}
int index;
savefile->Read( &index, sizeof(index) );
turret = entities[index];
savefile->Read( &index, sizeof(index) );
bear = entities[index];
savefile->Read( &index, sizeof(index) );
helicopter = entities[index];
savefile->Read( &index, sizeof(index) );
goal = entities[index];
savefile->Read( &index, sizeof(index) );
wind = entities[index];
savefile->Read( &index, sizeof(index) );
gunblast = entities[index];
}
/*
=============================
idGameBearShootWindow::ResetGameState
=============================
*/
void idGameBearShootWindow::ResetGameState() {
gamerunning = false;
gameOver = false;
onFire = false;
onContinue = false;
onNewGame = false;
// Game moves forward 16 milliseconds every frame
timeSlice = 0.016f;
timeRemaining = 60.f;
goalsHit = 0;
updateScore = false;
bearHitTarget = false;
currentLevel = 1;
turretAngle = 0.f;
turretForce = 200.f;
windForce = 0.f;
windUpdateTime = 0;
bearIsShrinking = false;
bearShrinkStartTime = 0;
bearScale = 1.f;
}
/*
=============================
idGameBearShootWindow::CommonInit
=============================
*/
void idGameBearShootWindow::CommonInit() {
BSEntity * ent;
// Precache sounds
declManager->FindSound( "arcade_beargroan" );
declManager->FindSound( "arcade_sargeshoot" );
declManager->FindSound( "arcade_balloonpop" );
declManager->FindSound( "arcade_levelcomplete1" );
// Precache dynamically used materials
declManager->FindMaterial( "game/bearshoot/helicopter_broken" );
declManager->FindMaterial( "game/bearshoot/goal_dead" );
declManager->FindMaterial( "game/bearshoot/gun_blast" );
ResetGameState();
ent = new BSEntity( this );
turret = ent;
ent->SetMaterial( "game/bearshoot/turret" );
ent->SetSize( 272, 144 );
ent->position.x = -44;
ent->position.y = 260;
entities.Append( ent );
ent = new BSEntity( this );
ent->SetMaterial( "game/bearshoot/turret_base" );
ent->SetSize( 144, 160 );
ent->position.x = 16;
ent->position.y = 280;
entities.Append( ent );
ent = new BSEntity( this );
bear = ent;
ent->SetMaterial( "game/bearshoot/bear" );
ent->SetSize( BEAR_SIZE, BEAR_SIZE );
ent->SetVisible( false );
ent->position.x = 0;
ent->position.y = 0;
entities.Append( ent );
ent = new BSEntity( this );
helicopter = ent;
ent->SetMaterial( "game/bearshoot/helicopter" );
ent->SetSize( 64, 64 );
ent->position.x = 550;
ent->position.y = 100;
entities.Append( ent );
ent = new BSEntity( this );
goal = ent;
ent->SetMaterial( "game/bearshoot/goal" );
ent->SetSize( 64, 64 );
ent->position.x = 550;
ent->position.y = 164;
entities.Append( ent );
ent = new BSEntity( this );
wind = ent;
ent->SetMaterial( "game/bearshoot/wind" );
ent->SetSize( 100, 40 );
ent->position.x = 500;
ent->position.y = 430;
entities.Append( ent );
ent = new BSEntity( this );
gunblast = ent;
ent->SetMaterial( "game/bearshoot/gun_blast" );
ent->SetSize( 64, 64 );
ent->SetVisible( false );
entities.Append( ent );
}
/*
=============================
idGameBearShootWindow::HandleEvent
=============================
*/
const char *idGameBearShootWindow::HandleEvent(const sysEvent_t *event, bool *updateVisuals) {
int key = event->evValue;
// need to call this to allow proper focus and capturing on embedded children
const char *ret = idWindow::HandleEvent(event, updateVisuals);
if ( event->evType == SE_KEY ) {
if ( !event->evValue2 ) {
return ret;
}
if ( key == K_MOUSE1) {
// Mouse was clicked
} else {
return ret;
}
}
return ret;
}
/*
=============================
idGameBearShootWindow::ParseInternalVar
=============================
*/
bool idGameBearShootWindow::ParseInternalVar(const char *_name, idParser *src) {
if ( idStr::Icmp(_name, "gamerunning") == 0 ) {
gamerunning = src->ParseBool();
return true;
}
if ( idStr::Icmp(_name, "onFire") == 0 ) {
onFire = src->ParseBool();
return true;
}
if ( idStr::Icmp(_name, "onContinue") == 0 ) {
onContinue = src->ParseBool();
return true;
}
if ( idStr::Icmp(_name, "onNewGame") == 0 ) {
onNewGame = src->ParseBool();
return true;
}
return idWindow::ParseInternalVar(_name, src);
}
/*
=============================
idGameBearShootWindow::GetWinVarByName
=============================
*/
idWinVar *idGameBearShootWindow::GetWinVarByName(const char *_name, bool winLookup, drawWin_t** owner) {
idWinVar *retVar = NULL;
if ( idStr::Icmp(_name, "gamerunning") == 0 ) {
retVar = &gamerunning;
} else if ( idStr::Icmp(_name, "onFire") == 0 ) {
retVar = &onFire;
} else if ( idStr::Icmp(_name, "onContinue") == 0 ) {
retVar = &onContinue;
} else if ( idStr::Icmp(_name, "onNewGame") == 0 ) {
retVar = &onNewGame;
}
if(retVar) {
return retVar;
}
return idWindow::GetWinVarByName(_name, winLookup, owner);
}
/*
=============================
idGameBearShootWindow::PostParse
=============================
*/
void idGameBearShootWindow::PostParse() {
idWindow::PostParse();
}
/*
=============================
idGameBearShootWindow::Draw
=============================
*/
void idGameBearShootWindow::Draw(int time, float x, float y) {
int i;
//Update the game every frame before drawing
UpdateGame();
for( i = entities.Num()-1; i >= 0; i-- ) {
entities[i]->Draw(dc);
}
}
/*
=============================
idGameBearShootWindow::Activate
=============================
*/
const char *idGameBearShootWindow::Activate(bool activate) {
return "";
}
/*
=============================
idGameBearShootWindow::UpdateTurret
=============================
*/
void idGameBearShootWindow::UpdateTurret() {
idVec2 pt;
idVec2 turretOrig;
idVec2 right;
float dot, angle;
pt.x = gui->CursorX();
pt.y = gui->CursorY();
turretOrig.Set( 80.f, 348.f );
pt = pt - turretOrig;
pt.NormalizeFast();
right.x = 1.f;
right.y = 0.f;
dot = pt * right;
angle = RAD2DEG( acosf( dot ) );
turretAngle = idMath::ClampFloat( 0.f, 90.f, angle );
}
/*
=============================
idGameBearShootWindow::UpdateBear
=============================
*/
void idGameBearShootWindow::UpdateBear() {
int time = gui->GetTime();
bool startShrink = false;
// Apply gravity
bear->velocity.y += BEAR_GRAVITY * timeSlice;
// Apply wind
bear->velocity.x += windForce * timeSlice;
// Check for collisions
if ( !bearHitTarget && !gameOver ) {
idVec2 bearCenter;
bool collision = false;
bearCenter.x = bear->position.x + bear->width/2;
bearCenter.y = bear->position.y + bear->height/2;
if ( bearCenter.x > (helicopter->position.x + 16) && bearCenter.x < (helicopter->position.x + helicopter->width - 29) ) {
if ( bearCenter.y > (helicopter->position.y + 12) && bearCenter.y < (helicopter->position.y + helicopter->height - 7) ) {
collision = true;
}
}
if ( collision ) {
// balloons pop and bear tumbles to ground
helicopter->SetMaterial( "game/bearshoot/helicopter_broken" );
helicopter->velocity.y = 230.f;
goal->velocity.y = 230.f;
session->sw->PlayShaderDirectly( "arcade_balloonpop" );
bear->SetVisible( false );
if ( bear->velocity.x > 0 ) {
bear->velocity.x *= -1.f;
}
bear->velocity *= 0.666f;
bearHitTarget = true;
updateScore = true;
startShrink = true;
}
}
// Check for ground collision
if ( bear->position.y > 380 ) {
bear->position.y = 380;
if ( bear->velocity.Length() < 25 ) {
bear->velocity.Zero();
} else {
startShrink = true;
bear->velocity.y *= -1.f;
bear->velocity *= 0.5f;
if ( bearScale ) {
session->sw->PlayShaderDirectly( "arcade_balloonpop" );
}
}
}
// Bear rotation is based on velocity
float angle;
idVec2 dir;
dir = bear->velocity;
dir.NormalizeFast();
angle = RAD2DEG( atan2( dir.x, dir.y ) );
bear->rotation = angle - 90;
// Update Bear scale
if ( bear->position.x > 650 ) {
startShrink = true;
}
if ( !bearIsShrinking && bearScale && startShrink ) {
bearShrinkStartTime = time;
bearIsShrinking = true;
}
if ( bearIsShrinking ) {
if ( bearHitTarget ) {
bearScale = 1 - ( (float)(time - bearShrinkStartTime) / BEAR_SHRINK_TIME );
} else {
bearScale = 1 - ( (float)(time - bearShrinkStartTime) / 750 );
}
bearScale *= BEAR_SIZE;
bear->SetSize( bearScale, bearScale );
if ( bearScale < 0 ) {
gui->HandleNamedEvent( "EnableFireButton" );
bearIsShrinking = false;
bearScale = 0.f;
if ( bearHitTarget ) {
goal->SetMaterial( "game/bearshoot/goal" );
goal->position.x = 550;
goal->position.y = 164;
goal->velocity.Zero();
goal->velocity.y = (currentLevel-1) * 30;
goal->entColor.w = 0.f;
goal->fadeIn = true;
goal->fadeOut = false;
helicopter->SetVisible( true );
helicopter->SetMaterial( "game/bearshoot/helicopter" );
helicopter->position.x = 550;
helicopter->position.y = 100;
helicopter->velocity.Zero();
helicopter->velocity.y = goal->velocity.y;
helicopter->entColor.w = 0.f;
helicopter->fadeIn = true;
helicopter->fadeOut = false;
}
}
}
}
/*
=============================
idGameBearShootWindow::UpdateHelicopter
=============================
*/
void idGameBearShootWindow::UpdateHelicopter() {
if ( bearHitTarget && bearIsShrinking ) {
if ( helicopter->velocity.y != 0 && helicopter->position.y > 264 ) {
helicopter->velocity.y = 0;
goal->velocity.y = 0;
helicopter->SetVisible( false );
goal->SetMaterial( "game/bearshoot/goal_dead" );
session->sw->PlayShaderDirectly( "arcade_beargroan", 1 );
helicopter->fadeOut = true;
goal->fadeOut = true;
}
} else if ( currentLevel > 1 ) {
int height = helicopter->position.y;
float speed = (currentLevel-1) * 30;
if ( height > 240 ) {
helicopter->velocity.y = -speed;
goal->velocity.y = -speed;
} else if ( height < 30 ) {
helicopter->velocity.y = speed;
goal->velocity.y = speed;
}
}
}
/*
=============================
idGameBearShootWindow::UpdateButtons
=============================
*/
void idGameBearShootWindow::UpdateButtons() {
if ( onFire ) {
idVec2 vec;
gui->HandleNamedEvent( "DisableFireButton" );
session->sw->PlayShaderDirectly( "arcade_sargeshoot" );
bear->SetVisible( true );
bearScale = 1.f;
bear->SetSize( BEAR_SIZE, BEAR_SIZE );
vec.x = idMath::Cos( DEG2RAD(turretAngle) );
vec.x += ( 1 - vec.x ) * 0.18f;
vec.y = -idMath::Sin( DEG2RAD(turretAngle) );
turretForce = bearTurretForce.GetFloat();
bear->position.x = 80 + ( 96 * vec.x );
bear->position.y = 334 + ( 96 * vec.y );
bear->velocity.x = vec.x * turretForce;
bear->velocity.y = vec.y * turretForce;
gunblast->position.x = 55 + ( 96 * vec.x );
gunblast->position.y = 310 + ( 100 * vec.y );
gunblast->SetVisible( true );
gunblast->entColor.w = 1.f;
gunblast->rotation = turretAngle;
gunblast->fadeOut = true;
bearHitTarget = false;
onFire = false;
}
}
/*
=============================
idGameBearShootWindow::UpdateScore
=============================
*/
void idGameBearShootWindow::UpdateScore() {
if ( gameOver ) {
gui->HandleNamedEvent( "GameOver" );
return;
}
goalsHit++;
gui->SetStateString( "player_score", va("%i", goalsHit ) );
// Check for level progression
if ( !(goalsHit % 5) ) {
currentLevel++;
gui->SetStateString( "current_level", va("%i", currentLevel ) );
session->sw->PlayShaderDirectly( "arcade_levelcomplete1", 3 );
timeRemaining += 30;
}
}
/*
=============================
idGameBearShootWindow::UpdateGame
=============================
*/
void idGameBearShootWindow::UpdateGame() {
int i;
if ( onNewGame ) {
ResetGameState();
goal->position.x = 550;
goal->position.y = 164;
goal->velocity.Zero();
helicopter->position.x = 550;
helicopter->position.y = 100;
helicopter->velocity.Zero();
bear->SetVisible( false );
bearTurretAngle.SetFloat( 0.f );
bearTurretForce.SetFloat( 200.f );
gamerunning = true;
}
if ( onContinue ) {
gameOver = false;
timeRemaining = 60.f;
onContinue = false;
}
if(gamerunning == true) {
int current_time = gui->GetTime();
idRandom rnd( current_time );
// Check for button presses
UpdateButtons();
if ( bear ) {
UpdateBear();
}
if ( helicopter && goal ) {
UpdateHelicopter();
}
// Update Wind
if ( windUpdateTime < current_time ) {
float scale;
int width;
windForce = rnd.CRandomFloat() * ( MAX_WINDFORCE * 0.75f );
if (windForce > 0) {
windForce += ( MAX_WINDFORCE * 0.25f );
wind->rotation = 0;
} else {
windForce -= ( MAX_WINDFORCE * 0.25f );
wind->rotation = 180;
}
scale = 1.f - (( MAX_WINDFORCE - idMath::Fabs(windForce) ) / MAX_WINDFORCE);
width = 100*scale;
if ( windForce < 0 ) {
wind->position.x = 500 - width + 1;
} else {
wind->position.x = 500;
}
wind->SetSize( width, 40 );
windUpdateTime = current_time + 7000 + rnd.RandomInt(5000);
}
// Update turret rotation angle
if ( turret ) {
turretAngle = bearTurretAngle.GetFloat();
turret->rotation = turretAngle;
}
for( i = 0; i < entities.Num(); i++ ) {
entities[i]->Update( timeSlice );
}
// Update countdown timer
timeRemaining -= timeSlice;
timeRemaining = idMath::ClampFloat( 0.f, 99999.f, timeRemaining );
gui->SetStateString( "time_remaining", va("%2.1f", timeRemaining ) );
if ( timeRemaining <= 0.f && !gameOver ) {
gameOver = true;
updateScore = true;
}
if ( updateScore ) {
UpdateScore();
updateScore = false;
}
}
}
Reference in New Issue View Git Blame Copy Permalink