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

1343 lines
31 KiB
C++
Raw Permalink Normal View History

Initial commit
2020-06-12 21:06:25 +00:00
/*
===========================================================================
Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#include "../idlib/precompiled.h"
#pragma hdrstop
#include "../framework/Session_local.h"
#include "../renderer/Image.h"
#include "DeviceContext.h"
#include "Window.h"
#include "UserInterfaceLocal.h"
#include "GameBustOutWindow.h"
#define BALL_RADIUS 12.f
#define BALL_SPEED 250.f
#define BALL_MAXSPEED 450.f
#define S_UNIQUE_CHANNEL 6
/*
*****************************************************************************
* BOEntity
****************************************************************************
*/
BOEntity::BOEntity(idGameBustOutWindow* _game) {
game = _game;
visible = true;
materialName = "";
material = NULL;
width = height = 8;
color = colorWhite;
powerup = POWERUP_NONE;
position.Zero();
velocity.Zero();
removed = false;
fadeOut = 0;
}
BOEntity::~BOEntity() {
}
/*
======================
BOEntity::WriteToSaveGame
======================
*/
void BOEntity::WriteToSaveGame( idFile *savefile ) {
savefile->Write( &visible, sizeof(visible) );
game->WriteSaveGameString( materialName, savefile );
savefile->Write( &width, sizeof(width) );
savefile->Write( &height, sizeof(height) );
savefile->Write( &color, sizeof(color) );
savefile->Write( &position, sizeof(position) );
savefile->Write( &velocity, sizeof(velocity) );
savefile->Write( &powerup, sizeof(powerup) );
savefile->Write( &removed, sizeof(removed) );
savefile->Write( &fadeOut, sizeof(fadeOut) );
}
/*
======================
BOEntity::ReadFromSaveGame
======================
*/
void BOEntity::ReadFromSaveGame( idFile *savefile, idGameBustOutWindow* _game ) {
game = _game;
savefile->Read( &visible, sizeof(visible) );
game->ReadSaveGameString( materialName, savefile );
SetMaterial( materialName );
savefile->Read( &width, sizeof(width) );
savefile->Read( &height, sizeof(height) );
savefile->Read( &color, sizeof(color) );
savefile->Read( &position, sizeof(position) );
savefile->Read( &velocity, sizeof(velocity) );
savefile->Read( &powerup, sizeof(powerup) );
savefile->Read( &removed, sizeof(removed) );
savefile->Read( &fadeOut, sizeof(fadeOut) );
}
/*
======================
BOEntity::SetMaterial
======================
*/
void BOEntity::SetMaterial(const char* name) {
materialName = name;
material = declManager->FindMaterial( name );
material->SetSort( SS_GUI );
}
/*
======================
BOEntity::SetSize
======================
*/
void BOEntity::SetSize( float _width, float _height ) {
width = _width;
height = _height;
}
/*
======================
BOEntity::SetVisible
======================
*/
void BOEntity::SetColor( float r, float g, float b, float a ) {
color.x = r;
color.y = g;
color.z = b;
color.w = a;
}
/*
======================
BOEntity::SetVisible
======================
*/
void BOEntity::SetVisible( bool isVisible ) {
visible = isVisible;
}
/*
======================
BOEntity::Update
======================
*/
void BOEntity::Update( float timeslice, int guiTime ) {
if ( !visible ) {
return;
}
// Move the entity
position += velocity * timeslice;
// Fade out the ent
if ( fadeOut ) {
color.w -= timeslice * 2.5;
if ( color.w <= 0.f ) {
color.w = 0.f;
removed = true;
}
}
}
/*
======================
BOEntity::Draw
======================
*/
void BOEntity::Draw(idDeviceContext *dc) {
if ( visible ) {
dc->DrawMaterialRotated( position.x, position.y, width, height, material, color, 1.0f, 1.0f, DEG2RAD(0.f) );
}
}
/*
*****************************************************************************
* BOBrick
****************************************************************************
*/
BOBrick::BOBrick( void ) {
ent = NULL;
x = y = width = height = 0;
powerup = POWERUP_NONE;
isBroken = false;
}
BOBrick::BOBrick( BOEntity *_ent, float _x, float _y, float _width, float _height ) {
ent = _ent;
x = _x;
y = _y;
width = _width;
height = _height;
powerup = POWERUP_NONE;
isBroken = false;
ent->position.x = x;
ent->position.y = y;
ent->SetSize( width, height );
ent->SetMaterial( "game/bustout/brick" );
ent->game->entities.Append( ent );
}
BOBrick::~BOBrick( void ) {
}
/*
======================
BOBrick::WriteToSaveGame
======================
*/
void BOBrick::WriteToSaveGame( idFile *savefile ) {
savefile->Write( &x, sizeof(x) );
savefile->Write( &y, sizeof(y) );
savefile->Write( &width, sizeof(width) );
savefile->Write( &height, sizeof(height) );
savefile->Write( &powerup, sizeof(powerup) );
savefile->Write( &isBroken, sizeof(isBroken) );
int index = ent->game->entities.FindIndex( ent );
savefile->Write( &index, sizeof(index) );
}
/*
======================
BOBrick::ReadFromSaveGame
======================
*/
void BOBrick::ReadFromSaveGame( idFile *savefile, idGameBustOutWindow *game ) {
savefile->Read( &x, sizeof(x) );
savefile->Read( &y, sizeof(y) );
savefile->Read( &width, sizeof(width) );
savefile->Read( &height, sizeof(height) );
savefile->Read( &powerup, sizeof(powerup) );
savefile->Read( &isBroken, sizeof(isBroken) );
int index;
savefile->Read( &index, sizeof(index) );
ent = game->entities[index];
}
/*
======================
BOBrick::SetColor
======================
*/
void BOBrick::SetColor( idVec4 bcolor ) {
ent->SetColor( bcolor.x, bcolor.y, bcolor.z, bcolor.w );
}
/*
======================
BOBrick::checkCollision
======================
*/
collideDir_t BOBrick::checkCollision( idVec2 pos, idVec2 vel ) {
idVec2 ptA, ptB;
float dist;
collideDir_t result = COLLIDE_NONE;
if ( isBroken ) {
return result;
}
// Check for collision with each edge
idVec2 vec;
// Bottom
ptA.x = x;
ptA.y = y + height;
ptB.x = x + width;
ptB.y = y + height;
if ( vel.y < 0 && pos.y > ptA.y ) {
if( pos.x > ptA.x && pos.x < ptB.x ) {
dist = pos.y - ptA.y;
if ( dist < BALL_RADIUS ) {
result = COLLIDE_DOWN;
}
} else {
if ( pos.x <= ptA.x ) {
vec = pos - ptA;
} else {
vec = pos - ptB;
}
if ( (idMath::Fabs(vec.y) > idMath::Fabs(vec.x)) && (vec.LengthFast() < BALL_RADIUS) ) {
result = COLLIDE_DOWN;
}
}
}
if ( result == COLLIDE_NONE ) {
// Top
ptA.y = y;
ptB.y = y;
if ( vel.y > 0 && pos.y < ptA.y ) {
if( pos.x > ptA.x && pos.x < ptB.x ) {
dist = ptA.y - pos.y;
if ( dist < BALL_RADIUS ) {
result = COLLIDE_UP;
}
} else {
if ( pos.x <= ptA.x ) {
vec = pos - ptA;
} else {
vec = pos - ptB;
}
if ( (idMath::Fabs(vec.y) > idMath::Fabs(vec.x)) && (vec.LengthFast() < BALL_RADIUS) ) {
result = COLLIDE_UP;
}
}
}
if ( result == COLLIDE_NONE ) {
// Left side
ptA.x = x;
ptA.y = y;
ptB.x = x;
ptB.y = y + height;
if ( vel.x > 0 && pos.x < ptA.x ) {
if( pos.y > ptA.y && pos.y < ptB.y ) {
dist = ptA.x - pos.x;
if ( dist < BALL_RADIUS ) {
result = COLLIDE_LEFT;
}
} else {
if ( pos.y <= ptA.y ) {
vec = pos - ptA;
} else {
vec = pos - ptB;
}
if ( (idMath::Fabs(vec.x) >= idMath::Fabs(vec.y)) && (vec.LengthFast() < BALL_RADIUS) ) {
result = COLLIDE_LEFT;
}
}
}
if ( result == COLLIDE_NONE ) {
// Right side
ptA.x = x + width;
ptB.x = x + width;
if ( vel.x < 0 && pos.x > ptA.x ) {
if( pos.y > ptA.y && pos.y < ptB.y ) {
dist = pos.x - ptA.x;
if ( dist < BALL_RADIUS ) {
result = COLLIDE_LEFT;
}
} else {
if ( pos.y <= ptA.y ) {
vec = pos - ptA;
} else {
vec = pos - ptB;
}
if ( (idMath::Fabs(vec.x) >= idMath::Fabs(vec.y)) && (vec.LengthFast() < BALL_RADIUS) ) {
result = COLLIDE_LEFT;
}
}
}
}
}
}
return result;
}
/*
*****************************************************************************
* idGameBustOutWindow
****************************************************************************
*/
idGameBustOutWindow::idGameBustOutWindow(idDeviceContext *d, idUserInterfaceLocal *g) : idWindow(d, g) {
dc = d;
gui = g;
CommonInit();
}
idGameBustOutWindow::idGameBustOutWindow(idUserInterfaceLocal *g) : idWindow(g) {
gui = g;
CommonInit();
}
idGameBustOutWindow::~idGameBustOutWindow() {
entities.DeleteContents(true);
Mem_Free( levelBoardData );
}
/*
=============================
idGameBustOutWindow::WriteToSaveGame
=============================
*/
void idGameBustOutWindow::WriteToSaveGame( idFile *savefile ) {
idWindow::WriteToSaveGame( savefile );
gamerunning.WriteToSaveGame( savefile );
onFire.WriteToSaveGame( savefile );
onContinue.WriteToSaveGame( savefile );
onNewGame.WriteToSaveGame( savefile );
onNewLevel.WriteToSaveGame( savefile );
savefile->Write( &timeSlice, sizeof(timeSlice) );
savefile->Write( &gameOver, sizeof(gameOver) );
savefile->Write( &numLevels, sizeof(numLevels) );
// Board Data is loaded when GUI is loaded, don't need to save
savefile->Write( &numBricks, sizeof(numBricks) );
savefile->Write( &currentLevel, sizeof(currentLevel) );
savefile->Write( &updateScore, sizeof(updateScore) );
savefile->Write( &gameScore, sizeof(gameScore) );
savefile->Write( &nextBallScore, sizeof(nextBallScore) );
savefile->Write( &bigPaddleTime, sizeof(bigPaddleTime) );
savefile->Write( &paddleVelocity, sizeof(paddleVelocity) );
savefile->Write( &ballSpeed, sizeof(ballSpeed) );
savefile->Write( &ballsRemaining, sizeof(ballsRemaining) );
savefile->Write( &ballsInPlay, sizeof(ballsInPlay) );
savefile->Write( &ballHitCeiling, sizeof(ballHitCeiling) );
// Write Entities
int i;
int numberOfEnts = entities.Num();
savefile->Write( &numberOfEnts, sizeof(numberOfEnts) );
for ( i=0; i<numberOfEnts; i++ ) {
entities[i]->WriteToSaveGame( savefile );
}
// Write Balls
numberOfEnts = balls.Num();
savefile->Write( &numberOfEnts, sizeof(numberOfEnts) );
for ( i=0; i<numberOfEnts; i++ ) {
int ballIndex = entities.FindIndex( balls[i] );
savefile->Write( &ballIndex, sizeof(ballIndex) );
}
// Write Powerups
numberOfEnts = powerUps.Num();
savefile->Write( &numberOfEnts, sizeof(numberOfEnts) );
for ( i=0; i<numberOfEnts; i++ ) {
int powerIndex = entities.FindIndex( powerUps[i] );
savefile->Write( &powerIndex, sizeof(powerIndex) );
}
// Write paddle
paddle->WriteToSaveGame( savefile );
// Write Bricks
int row;
for ( row=0; row<BOARD_ROWS; row++ ) {
numberOfEnts = board[row].Num();
savefile->Write( &numberOfEnts, sizeof(numberOfEnts) );
for ( i=0; i<numberOfEnts; i++ ) {
board[row][i]->WriteToSaveGame( savefile );
}
}
}
/*
=============================
idGameBustOutWindow::ReadFromSaveGame
=============================
*/
void idGameBustOutWindow::ReadFromSaveGame( idFile *savefile ) {
idWindow::ReadFromSaveGame( savefile );
// Clear out existing paddle and entities from GUI load
delete paddle;
entities.DeleteContents( true );
gamerunning.ReadFromSaveGame( savefile );
onFire.ReadFromSaveGame( savefile );
onContinue.ReadFromSaveGame( savefile );
onNewGame.ReadFromSaveGame( savefile );
onNewLevel.ReadFromSaveGame( savefile );
savefile->Read( &timeSlice, sizeof(timeSlice) );
savefile->Read( &gameOver, sizeof(gameOver) );
savefile->Read( &numLevels, sizeof(numLevels) );
// Board Data is loaded when GUI is loaded, don't need to save
savefile->Read( &numBricks, sizeof(numBricks) );
savefile->Read( &currentLevel, sizeof(currentLevel) );
savefile->Read( &updateScore, sizeof(updateScore) );
savefile->Read( &gameScore, sizeof(gameScore) );
savefile->Read( &nextBallScore, sizeof(nextBallScore) );
savefile->Read( &bigPaddleTime, sizeof(bigPaddleTime) );
savefile->Read( &paddleVelocity, sizeof(paddleVelocity) );
savefile->Read( &ballSpeed, sizeof(ballSpeed) );
savefile->Read( &ballsRemaining, sizeof(ballsRemaining) );
savefile->Read( &ballsInPlay, sizeof(ballsInPlay) );
savefile->Read( &ballHitCeiling, sizeof(ballHitCeiling) );
int i;
int numberOfEnts;
// Read entities
savefile->Read( &numberOfEnts, sizeof(numberOfEnts) );
for ( i=0; i<numberOfEnts; i++ ) {
BOEntity *ent;
ent = new BOEntity( this );
ent->ReadFromSaveGame( savefile, this );
entities.Append( ent );
}
// Read balls
savefile->Read( &numberOfEnts, sizeof(numberOfEnts) );
for ( i=0; i<numberOfEnts; i++ ) {
int ballIndex;
savefile->Read( &ballIndex, sizeof(ballIndex) );
balls.Append( entities[ballIndex] );
}
// Read powerups
savefile->Read( &numberOfEnts, sizeof(numberOfEnts) );
for ( i=0; i<numberOfEnts; i++ ) {
int powerIndex;
savefile->Read( &powerIndex, sizeof(powerIndex) );
balls.Append( entities[powerIndex] );
}
// Read paddle
paddle = new BOBrick();
paddle->ReadFromSaveGame( savefile, this );
// Read board
int row;
for ( row=0; row<BOARD_ROWS; row++ ) {
savefile->Read( &numberOfEnts, sizeof(numberOfEnts) );
for ( i=0; i<numberOfEnts; i++ ) {
BOBrick *brick = new BOBrick();
brick->ReadFromSaveGame( savefile, this );
board[row].Append( brick );
}
}
}
/*
=============================
idGameBustOutWindow::ResetGameState
=============================
*/
void idGameBustOutWindow::ResetGameState() {
gamerunning = false;
gameOver = false;
onFire = false;
onContinue = false;
onNewGame = false;
onNewLevel = false;
// Game moves forward 16 milliseconds every frame
timeSlice = 0.016f;
ballsRemaining = 3;
ballSpeed = BALL_SPEED;
ballsInPlay = 0;
updateScore = false;
numBricks = 0;
currentLevel = 1;
gameScore = 0;
bigPaddleTime = 0;
nextBallScore = gameScore + 10000;
ClearBoard();
}
/*
=============================
idGameBustOutWindow::CommonInit
=============================
*/
void idGameBustOutWindow::CommonInit() {
BOEntity *ent;
// Precache images
declManager->FindMaterial( "game/bustout/ball" );
declManager->FindMaterial( "game/bustout/doublepaddle" );
declManager->FindMaterial( "game/bustout/powerup_bigpaddle" );
declManager->FindMaterial( "game/bustout/powerup_multiball" );
declManager->FindMaterial( "game/bustout/brick" );
// Precache sounds
declManager->FindSound( "arcade_ballbounce" );
declManager->FindSound( "arcade_brickhit" );
declManager->FindSound( "arcade_missedball" );
declManager->FindSound( "arcade_sadsound" );
declManager->FindSound( "arcade_extraball" );
declManager->FindSound( "arcade_powerup" );
ResetGameState();
numLevels = 0;
boardDataLoaded = false;
levelBoardData = NULL;
// Create Paddle
ent = new BOEntity( this );
paddle = new BOBrick( ent, 260.f, 440.f, 96.f, 24.f );
paddle->ent->SetMaterial( "game/bustout/paddle" );
}
/*
=============================
idGameBustOutWindow::HandleEvent
=============================
*/
const char *idGameBustOutWindow::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
if ( ballsInPlay == 0 ) {
BOEntity *ball = CreateNewBall();
ball->SetVisible( true );
ball->position.x = paddle->ent->position.x + 48.f;
ball->position.y = 430.f;
ball->velocity.x = ballSpeed;
ball->velocity.y = -ballSpeed*2.f;
ball->velocity.NormalizeFast();
ball->velocity *= ballSpeed;
}
} else {
return ret;
}
}
return ret;
}
/*
=============================
idGameBustOutWindow::ParseInternalVar
=============================
*/
bool idGameBustOutWindow::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;
}
if ( idStr::Icmp(_name, "onNewLevel") == 0 ) {
onNewLevel = src->ParseBool();
return true;
}
if ( idStr::Icmp(_name, "numLevels") == 0 ) {
numLevels = src->ParseInt();
// Load all the level images
LoadBoardFiles();
return true;
}
return idWindow::ParseInternalVar(_name, src);
}
/*
=============================
idGameBustOutWindow::GetWinVarByName
=============================
*/
idWinVar *idGameBustOutWindow::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;
} else if ( idStr::Icmp(_name, "onNewLevel") == 0 ) {
retVar = &onNewLevel;
}
if(retVar) {
return retVar;
}
return idWindow::GetWinVarByName(_name, winLookup, owner);
}
/*
=============================
idGameBustOutWindow::PostParse
=============================
*/
void idGameBustOutWindow::PostParse() {
idWindow::PostParse();
}
/*
=============================
idGameBustOutWindow::Draw
=============================
*/
void idGameBustOutWindow::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);
}
}
/*
=============================
idGameBustOutWindow::Activate
=============================
*/
const char *idGameBustOutWindow::Activate(bool activate) {
return "";
}
/*
=============================
idGameBustOutWindow::UpdateScore
=============================
*/
void idGameBustOutWindow::UpdateScore() {
if ( gameOver ) {
gui->HandleNamedEvent( "GameOver" );
return;
}
// Check for level progression
if ( numBricks == 0 ) {
ClearBalls();
gui->HandleNamedEvent( "levelComplete" );
}
// Check for new ball score
if ( gameScore >= nextBallScore ) {
ballsRemaining++;
gui->HandleNamedEvent( "extraBall" );
// Play sound
session->sw->PlayShaderDirectly( "arcade_extraball", S_UNIQUE_CHANNEL );
nextBallScore = gameScore + 10000;
}
gui->SetStateString( "player_score", va("%i", gameScore ) );
gui->SetStateString( "balls_remaining", va("%i", ballsRemaining ) );
gui->SetStateString( "current_level", va("%i", currentLevel ) );
gui->SetStateString( "next_ball_score", va("%i", nextBallScore ) );
}
/*
=============================
idGameBustOutWindow::ClearBoard
=============================
*/
void idGameBustOutWindow::ClearBoard( void ) {
int i,j;
ClearPowerups();
ballHitCeiling = false;
for ( i=0; i<BOARD_ROWS; i++ ) {
for ( j=0; j<board[i].Num(); j++ ) {
BOBrick *brick = board[i][j];
brick->ent->removed = true;
}
board[i].DeleteContents( true );
}
}
/*
=============================
idGameBustOutWindow::ClearPowerups
=============================
*/
void idGameBustOutWindow::ClearPowerups( void ) {
while ( powerUps.Num() ) {
powerUps[0]->removed = true;
powerUps.RemoveIndex( 0 );
}
}
/*
=============================
idGameBustOutWindow::ClearBalls
=============================
*/
void idGameBustOutWindow::ClearBalls( void ) {
while ( balls.Num() ) {
balls[0]->removed = true;
balls.RemoveIndex( 0 );
}
ballsInPlay = 0;
}
/*
=============================
idGameBustOutWindow::LoadBoardFiles
=============================
*/
void idGameBustOutWindow::LoadBoardFiles( void ) {
int i;
int w,h;
ID_TIME_T time;
int boardSize;
byte *currentBoard;
if ( boardDataLoaded ) {
return;
}
boardSize = 9 * 12 * 4;
levelBoardData = (byte*)Mem_Alloc( boardSize * numLevels );
currentBoard = levelBoardData;
for ( i=0; i<numLevels; i++ ) {
byte *pic;
idStr name = "guis/assets/bustout/level";
name += (i+1);
name += ".tga";
R_LoadImage( name, &pic, &w, &h, &time, false );
if ( pic != NULL ) {
if ( w != 9 || h != 12 ) {
common->DWarning( "Hell Bust-Out level image not correct dimensions! (%d x %d)", w, h );
}
memcpy( currentBoard, pic, boardSize );
Mem_Free(pic);
}
currentBoard += boardSize;
}
boardDataLoaded = true;
}
/*
=============================
idGameBustOutWindow::SetCurrentBoard
=============================
*/
void idGameBustOutWindow::SetCurrentBoard( void ) {
int i,j;
int realLevel = ((currentLevel-1) % numLevels);
int boardSize;
byte *currentBoard;
float bx = 11.f;
float by = 24.f;
float stepx = 619.f / 9.f;
float stepy = ( 256 / 12.f );
boardSize = 9 * 12 * 4;
currentBoard = levelBoardData + ( realLevel * boardSize );
for ( j=0; j<BOARD_ROWS; j++ ) {
bx = 11.f;
for ( i=0; i<9; i++ ) {
int pixelindex = (j*9*4) + (i*4);
if ( currentBoard[pixelindex + 3] ) {
idVec4 bcolor;
float pType = 0.f;
BOEntity *bent = new BOEntity( this );
BOBrick *brick = new BOBrick( bent, bx, by, stepx, stepy );
bcolor.x = currentBoard[pixelindex + 0] / 255.f;
bcolor.y = currentBoard[pixelindex + 1] / 255.f;
bcolor.z = currentBoard[pixelindex + 2] / 255.f;
bcolor.w = 1.f;
brick->SetColor( bcolor );
pType = currentBoard[pixelindex + 3] / 255.f;
if ( pType > 0.f && pType < 1.f ) {
if ( pType < 0.5f ) {
brick->powerup = POWERUP_BIGPADDLE;
} else {
brick->powerup = POWERUP_MULTIBALL;
}
}
board[j].Append( brick );
numBricks++;
}
bx += stepx;
}
by += stepy;
}
}
/*
=============================
idGameBustOutWindow::CreateNewBall
=============================
*/
BOEntity * idGameBustOutWindow::CreateNewBall( void ) {
BOEntity *ball;
ball = new BOEntity( this );
ball->position.x = 300.f;
ball->position.y = 416.f;
ball->SetMaterial( "game/bustout/ball" );
ball->SetSize( BALL_RADIUS*2.f, BALL_RADIUS*2.f );
ball->SetVisible( false );
ballsInPlay++;
balls.Append( ball );
entities.Append( ball );
return ball;
}
/*
=============================
idGameBustOutWindow::CreatePowerup
=============================
*/
BOEntity * idGameBustOutWindow::CreatePowerup( BOBrick *brick ) {
BOEntity *powerEnt = new BOEntity( this );
powerEnt->position.x = brick->x;
powerEnt->position.y = brick->y;
powerEnt->velocity.x = 0.f;
powerEnt->velocity.y = 64.f;
powerEnt->powerup = brick->powerup;
switch( powerEnt->powerup ) {
case POWERUP_BIGPADDLE:
powerEnt->SetMaterial( "game/bustout/powerup_bigpaddle" );
break;
case POWERUP_MULTIBALL:
powerEnt->SetMaterial( "game/bustout/powerup_multiball" );
break;
default:
powerEnt->SetMaterial( "textures/common/nodraw" );
break;
}
powerEnt->SetSize( 619/9, 256/12 );
powerEnt->SetVisible( true );
powerUps.Append( powerEnt );
entities.Append( powerEnt );
return powerEnt;
}
/*
=============================
idGameBustOutWindow::UpdatePowerups
=============================
*/
void idGameBustOutWindow::UpdatePowerups( void ) {
idVec2 pos;
for ( int i=0; i < powerUps.Num(); i++ ) {
BOEntity *pUp = powerUps[i];
// Check for powerup falling below screen
if ( pUp->position.y > 480 ) {
powerUps.RemoveIndex( i );
pUp->removed = true;
continue;
}
// Check for the paddle catching a powerup
pos.x = pUp->position.x + ( pUp->width / 2 );
pos.y = pUp->position.y + ( pUp->height / 2 );
collideDir_t collision = paddle->checkCollision( pos, pUp->velocity );
if ( collision != COLLIDE_NONE ) {
BOEntity *ball;
// Give the powerup to the player
switch( pUp->powerup ) {
case POWERUP_BIGPADDLE:
bigPaddleTime = gui->GetTime() + 15000;
break;
case POWERUP_MULTIBALL:
// Create 2 new balls in the spot of the existing ball
for ( int b=0; b<2; b++ ) {
ball = CreateNewBall();
ball->position = balls[0]->position;
ball->velocity = balls[0]->velocity;
if ( b == 0 ) {
ball->velocity.x -= 35.f;
} else {
ball->velocity.x += 35.f;
}
ball->velocity.NormalizeFast();
ball->velocity *= ballSpeed;
ball->SetVisible( true );
}
break;
default:
break;
}
// Play the sound
session->sw->PlayShaderDirectly( "arcade_powerup", S_UNIQUE_CHANNEL );
// Remove it
powerUps.RemoveIndex( i );
pUp->removed = true;
}
}
}
/*
=============================
idGameBustOutWindow::UpdatePaddle
=============================
*/
void idGameBustOutWindow::UpdatePaddle( void ) {
idVec2 cursorPos;
float oldPos = paddle->x;
cursorPos.x = gui->CursorX();
cursorPos.y = gui->CursorY();
if ( bigPaddleTime > gui->GetTime() ) {
paddle->x = cursorPos.x - 80.f;
paddle->width = 160;
paddle->ent->width = 160;
paddle->ent->SetMaterial( "game/bustout/doublepaddle" );
} else {
paddle->x = cursorPos.x - 48.f;
paddle->width = 96;
paddle->ent->width = 96;
paddle->ent->SetMaterial( "game/bustout/paddle" );
}
paddle->ent->position.x = paddle->x;
paddleVelocity = (paddle->x - oldPos);
}
/*
=============================
idGameBustOutWindow::UpdateBall
=============================
*/
void idGameBustOutWindow::UpdateBall( void ) {
int ballnum,i,j;
bool playSoundBounce = false;
bool playSoundBrick = false;
static int bounceChannel = 1;
if ( ballsInPlay == 0 ) {
return;
}
for ( ballnum = 0; ballnum < balls.Num(); ballnum++ ) {
BOEntity *ball = balls[ballnum];
// Check for ball going below screen, lost ball
if ( ball->position.y > 480.f ) {
ball->removed = true;
continue;
}
// Check world collision
if ( ball->position.y < 20 && ball->velocity.y < 0 ) {
ball->velocity.y = -ball->velocity.y;
// Increase ball speed when it hits ceiling
if ( !ballHitCeiling ) {
ballSpeed *= 1.25f;
ballHitCeiling = true;
}
playSoundBounce = true;
}
if ( ball->position.x > 608 && ball->velocity.x > 0 ) {
ball->velocity.x = -ball->velocity.x;
playSoundBounce = true;
} else if ( ball->position.x < 8 && ball->velocity.x < 0 ) {
ball->velocity.x = -ball->velocity.x;
playSoundBounce = true;
}
// Check for Paddle collision
idVec2 ballCenter = ball->position + idVec2( BALL_RADIUS, BALL_RADIUS );
collideDir_t collision = paddle->checkCollision( ballCenter, ball->velocity );
if ( collision == COLLIDE_UP ) {
if ( ball->velocity.y > 0 ) {
idVec2 paddleVec( paddleVelocity*2, 0 );
float centerX;
if ( bigPaddleTime > gui->GetTime() ) {
centerX = paddle->x + 80.f;
} else {
centerX = paddle->x + 48.f;
}
ball->velocity.y = -ball->velocity.y;
paddleVec.x += (ball->position.x - centerX) * 2;
ball->velocity += paddleVec;
ball->velocity.NormalizeFast();
ball->velocity *= ballSpeed;
playSoundBounce = true;
}
} else if ( collision == COLLIDE_LEFT || collision == COLLIDE_RIGHT ) {
if ( ball->velocity.y > 0 ) {
ball->velocity.x = -ball->velocity.x;
playSoundBounce = true;
}
}
collision = COLLIDE_NONE;
// Check for collision with bricks
for ( i=0; i<BOARD_ROWS; i++ ) {
int num = board[i].Num();
for ( j=0; j<num; j++ ) {
BOBrick *brick = (board[i])[j];
collision = brick->checkCollision( ballCenter, ball->velocity );
if ( collision ) {
// Now break the brick if there was a collision
brick->isBroken = true;
brick->ent->fadeOut = true;
if ( brick->powerup > POWERUP_NONE ) {
BOEntity *pUp = CreatePowerup( brick );
}
numBricks--;
gameScore += 100;
updateScore = true;
// Go ahead an forcibly remove the last brick, no fade
if ( numBricks == 0 ) {
brick->ent->removed = true;
}
board[i].Remove( brick );
break;
}
}
if ( collision ) {
playSoundBrick = true;
break;
}
}
if ( collision == COLLIDE_DOWN || collision == COLLIDE_UP ) {
ball->velocity.y *= -1;
} else if ( collision == COLLIDE_LEFT || collision == COLLIDE_RIGHT ) {
ball->velocity.x *= -1;
}
if ( playSoundBounce ) {
session->sw->PlayShaderDirectly( "arcade_ballbounce", bounceChannel );
} else if ( playSoundBrick ) {
session->sw->PlayShaderDirectly( "arcade_brickhit", bounceChannel );
}
if ( playSoundBounce || playSoundBrick ) {
bounceChannel++;
if ( bounceChannel == 4 ) {
bounceChannel = 1;
}
}
}
// Check to see if any balls were removed from play
for ( ballnum=0; ballnum<balls.Num(); ballnum++ ) {
if ( balls[ballnum]->removed ) {
ballsInPlay--;
balls.RemoveIndex( ballnum );
}
}
// If all the balls were removed, update the game accordingly
if ( ballsInPlay == 0 ) {
if ( ballsRemaining == 0 ) {
gameOver = true;
// Game Over sound
session->sw->PlayShaderDirectly( "arcade_sadsound", S_UNIQUE_CHANNEL );
} else {
ballsRemaining--;
// Ball was lost, but game is not over
session->sw->PlayShaderDirectly( "arcade_missedball", S_UNIQUE_CHANNEL );
}
ClearPowerups();
updateScore = true;
}
}
/*
=============================
idGameBustOutWindow::UpdateGame
=============================
*/
void idGameBustOutWindow::UpdateGame() {
int i;
if ( onNewGame ) {
ResetGameState();
// Create Board
SetCurrentBoard();
gamerunning = true;
}
if ( onContinue ) {
gameOver = false;
ballsRemaining = 3;
onContinue = false;
}
if ( onNewLevel ) {
currentLevel++;
ClearBoard();
SetCurrentBoard();
ballSpeed = BALL_SPEED * ( 1.f + ((float)currentLevel/5.f) );
if ( ballSpeed > BALL_MAXSPEED ) {
ballSpeed = BALL_MAXSPEED;
}
updateScore = true;
onNewLevel = false;
}
if(gamerunning == true) {
UpdatePaddle();
UpdateBall();
UpdatePowerups();
for( i = 0; i < entities.Num(); i++ ) {
entities[i]->Update( timeSlice, gui->GetTime() );
}
// Delete entities that need to be deleted
for( i = entities.Num()-1; i >= 0; i-- ) {
if( entities[i]->removed ) {
BOEntity* ent = entities[i];
delete ent;
entities.RemoveIndex(i);
}
}
if ( updateScore ) {
UpdateScore();
updateScore = false;
}
}
}