3937 lines
108 KiB
C++
3937 lines
108 KiB
C++
#include "const.h"
|
|
#include "struct.h"
|
|
#include "gamedirector.h"
|
|
#include <iostream>
|
|
|
|
const Uint8 *keystates;
|
|
|
|
// Calcula el cuadrado de la distancia entre dos puntos
|
|
double distanceSquared(int x1, int y1, int x2, int y2)
|
|
{
|
|
int deltaX = x2 - x1;
|
|
int deltaY = y2 - y1;
|
|
return deltaX * deltaX + deltaY * deltaY;
|
|
}
|
|
|
|
// Detector de colisiones entre dos circulos
|
|
bool checkCollision(Circle &a, Circle &b)
|
|
{
|
|
// Calcula el radio total al cuadrado
|
|
int totalRadiusSquared = a.r + b.r;
|
|
totalRadiusSquared = totalRadiusSquared * totalRadiusSquared;
|
|
|
|
// Si la distancia entre el centro de los circulos es inferior a la suma de sus radios
|
|
if (distanceSquared(a.x, a.y, b.x, b.y) < (totalRadiusSquared))
|
|
{
|
|
// Los circulos han colisionado
|
|
return true;
|
|
}
|
|
|
|
// En caso contrario
|
|
return false;
|
|
}
|
|
|
|
// Constructor
|
|
GameDirector::GameDirector()
|
|
{
|
|
// Texturas
|
|
mTexture[TEXTURE_BALLOON].texture = new LTexture();
|
|
mTexture[TEXTURE_BULLET].texture = new LTexture();
|
|
mTexture[TEXTURE_FONT_BLACK].texture = new LTexture();
|
|
mTexture[TEXTURE_FONT_NOKIA].texture = new LTexture();
|
|
mTexture[TEXTURE_FONT_WHITE].texture = new LTexture();
|
|
mTexture[TEXTURE_GAME_BG].texture = new LTexture();
|
|
mTexture[TEXTURE_GAME_TEXT].texture = new LTexture();
|
|
mTexture[TEXTURE_INTRO].texture = new LTexture();
|
|
mTexture[TEXTURE_ITEMS].texture = new LTexture();
|
|
mTexture[TEXTURE_LOGO].texture = new LTexture();
|
|
mTexture[TEXTURE_MENU].texture = new LTexture();
|
|
mTexture[TEXTURE_PLAYER_BODY].texture = new LTexture();
|
|
mTexture[TEXTURE_PLAYER_LEGS].texture = new LTexture();
|
|
mTexture[TEXTURE_PLAYER_DEATH].texture = new LTexture();
|
|
mTexture[TEXTURE_TITLE].texture = new LTexture();
|
|
|
|
// Manejador de eventos
|
|
mEventHandler = new SDL_Event();
|
|
|
|
// Objetos para el juego
|
|
mPlayer = new Player();
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
mBalloon[i] = new Balloon();
|
|
}
|
|
for (Uint8 i = 0; i < MAX_BULLETS; i++)
|
|
{
|
|
mBullet[i] = new Bullet();
|
|
}
|
|
for (Uint8 i = 0; i < MAX_ITEMS; i++)
|
|
{
|
|
mItem[i] = new Item();
|
|
}
|
|
for (Uint8 i = 0; i < MAX_SMART_SPRITES; i++)
|
|
{
|
|
mSmartSprite[i] = new SmartSprite();
|
|
}
|
|
mGameBackgroundFront = new Sprite();
|
|
mGameBackgroundSky = new Sprite();
|
|
mGBClouds1 = new MovingSprite();
|
|
mGBClouds1b = new MovingSprite();
|
|
mGBClouds2 = new MovingSprite();
|
|
mGBClouds2b = new MovingSprite();
|
|
mGrass = new Sprite();
|
|
mTitleTile = new Sprite();
|
|
mText.white = new Text();
|
|
mText.black = new Text();
|
|
mText.nokia = new Text();
|
|
mMenu.title = new Menu();
|
|
mMenu.pause = new Menu();
|
|
mMenu.gameOver = new Menu();
|
|
mMenu.options = new Menu();
|
|
mMenu.active = new Menu();
|
|
mGetReadyBitmap = new SmartSprite();
|
|
mCoffeeBitmap = new SmartSprite();
|
|
mCrisisBitmap = new SmartSprite();
|
|
mDustSpriteLeft = new AnimatedSprite();
|
|
mDustSpriteRight = new AnimatedSprite();
|
|
m1000Bitmap = new SmartSprite();
|
|
m2500Bitmap = new SmartSprite();
|
|
m5000Bitmap = new SmartSprite();
|
|
mInstructions = new Sprite();
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++)
|
|
{
|
|
mIntroBitmap[i] = new SmartSprite();
|
|
}
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++)
|
|
{
|
|
mIntroText[i] = new Text2();
|
|
}
|
|
mLogo.sprite = new Sprite();
|
|
}
|
|
|
|
GameDirector::~GameDirector()
|
|
{
|
|
// Libera los recursos globales
|
|
unLoadMedia(GAME_STATE_INIT);
|
|
|
|
// Libera el mando
|
|
if (mGameControllerFound)
|
|
{
|
|
SDL_JoystickClose(mGameController);
|
|
mGameController = NULL;
|
|
}
|
|
|
|
// Destuye el manejador de eventos
|
|
delete mEventHandler;
|
|
|
|
// Destruye los objetos
|
|
delete mTexture[TEXTURE_BALLOON].texture;
|
|
delete mTexture[TEXTURE_BULLET].texture;
|
|
delete mTexture[TEXTURE_FONT_BLACK].texture;
|
|
delete mTexture[TEXTURE_FONT_NOKIA].texture;
|
|
delete mTexture[TEXTURE_FONT_WHITE].texture;
|
|
delete mTexture[TEXTURE_GAME_BG].texture;
|
|
delete mTexture[TEXTURE_GAME_TEXT].texture;
|
|
delete mTexture[TEXTURE_INTRO].texture;
|
|
delete mTexture[TEXTURE_ITEMS].texture;
|
|
delete mTexture[TEXTURE_LOGO].texture;
|
|
delete mTexture[TEXTURE_MENU].texture;
|
|
delete mTexture[TEXTURE_PLAYER_BODY].texture;
|
|
delete mTexture[TEXTURE_PLAYER_LEGS].texture;
|
|
delete mTexture[TEXTURE_PLAYER_DEATH].texture;
|
|
delete mTexture[TEXTURE_TITLE].texture;
|
|
|
|
delete mPlayer;
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
delete mBalloon[i];
|
|
}
|
|
for (Uint8 i = 0; i < MAX_BULLETS; i++)
|
|
{
|
|
delete mBullet[i];
|
|
}
|
|
for (Uint8 i = 0; i < MAX_ITEMS; i++)
|
|
{
|
|
delete mItem[i];
|
|
}
|
|
for (Uint8 i = 0; i < MAX_SMART_SPRITES; i++)
|
|
{
|
|
delete mSmartSprite[i];
|
|
}
|
|
delete mGameBackgroundFront;
|
|
delete mGameBackgroundSky;
|
|
delete mGBClouds1;
|
|
delete mGBClouds1b;
|
|
delete mGBClouds2;
|
|
delete mGBClouds2b;
|
|
delete mGrass;
|
|
delete mTitleTile;
|
|
delete mText.white;
|
|
delete mText.black;
|
|
delete mText.nokia;
|
|
delete mMenu.title;
|
|
delete mMenu.pause;
|
|
delete mMenu.gameOver;
|
|
delete mMenu.options;
|
|
mMenu.active = nullptr;
|
|
delete mGetReadyBitmap;
|
|
delete mCoffeeBitmap;
|
|
delete mCrisisBitmap;
|
|
delete mDustSpriteLeft;
|
|
delete mDustSpriteRight;
|
|
delete m1000Bitmap;
|
|
delete m2500Bitmap;
|
|
delete m5000Bitmap;
|
|
delete mInstructions;
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++)
|
|
{
|
|
delete mIntroBitmap[i];
|
|
}
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++)
|
|
{
|
|
delete mIntroText[i];
|
|
}
|
|
delete mLogo.sprite;
|
|
|
|
// Destruye la ventana
|
|
SDL_DestroyTexture(mBackbuffer);
|
|
SDL_DestroyTexture(mTitleSurface);
|
|
SDL_DestroyTexture(mInstructionsSurface);
|
|
SDL_DestroyRenderer(mRenderer);
|
|
SDL_DestroyWindow(mWindow);
|
|
mBackbuffer = nullptr;
|
|
mTitleSurface = nullptr;
|
|
mInstructionsSurface = nullptr;
|
|
mWindow = nullptr;
|
|
mRenderer = nullptr;
|
|
|
|
// Sal del subsistema SDL
|
|
SDL_Quit();
|
|
}
|
|
|
|
// Iniciador
|
|
void GameDirector::init(bool reset)
|
|
{
|
|
if (true)
|
|
{
|
|
// Variables
|
|
mTicks = 0;
|
|
mTicksSpeed = 15;
|
|
mMenaceLevel = 0;
|
|
mMenaceLevelThreshold = 0;
|
|
mGame.score = 0;
|
|
mGame.hiScoreAchieved = false;
|
|
mGame.stage = 1;
|
|
mGame.stageCounter = 0;
|
|
mGame.paused = false;
|
|
mGame.deathCounter = DEATH_COUNTER;
|
|
for (Uint8 i = 0; i < STAGE_COUNTER; i++)
|
|
{
|
|
mGame.stagePath[i] = (sin(double(i * 180.0 / double(STAGE_COUNTER)) * 3.14 / 180.0) * (BLOCK * 4)) - BLOCK;
|
|
}
|
|
mPlayFieldDrawOnly = true;
|
|
mDebug = false;
|
|
mTitleStatus = 0;
|
|
mTitleTimer = TITLE_TIMER;
|
|
mExplosionTime = false;
|
|
mRemainingExplosions = REMAINING_EXPLOSIONS;
|
|
mRemainingExplosionsTimer = REMAINING_EXPLOSIONS_TIMER;
|
|
mTimeStopped = false;
|
|
mTimeStoppedTimer = TIME_STOPPED_TIMER;
|
|
mInstructionsCounter = INSTRUCTIONS_COUNTER;
|
|
mDemo = false;
|
|
mDemoRecording = false;
|
|
mDemoCounter = 0;
|
|
mGameCounter = 0;
|
|
mMenuKeyPressed = false;
|
|
mMenu.active = mMenu.title;
|
|
for (int i = 0; i < 360; i++)
|
|
{
|
|
mSen[i] = sin(i * 3.14 / 180);
|
|
}
|
|
mTitleBackgroundTimer = 0;
|
|
mTitleBackgroundMode = rand() % 2;
|
|
mTitleMenuVisible = false;
|
|
mLogo.counter = 0;
|
|
|
|
// Fondo animado
|
|
mGBClouds1->init(0, 0, 256, 52, -0.1f, 0.0f, 0.0f, 0.0f, mTexture[TEXTURE_GAME_BG].texture, mRenderer);
|
|
mGBClouds1->setSpriteClip(256, 0, 256, 52);
|
|
|
|
mGBClouds1b->init(256, 0, 256, 52, -0.1f, 0.0f, 0.0f, 0.0f, mTexture[TEXTURE_GAME_BG].texture, mRenderer);
|
|
mGBClouds1b->setSpriteClip(256, 0, 256, 52);
|
|
|
|
mGBClouds2->init(0, 52, 256, 32, -0.05f, 0.0f, 0.0f, 0.0f, mTexture[TEXTURE_GAME_BG].texture, mRenderer);
|
|
mGBClouds2->setSpriteClip(256, 52, 256, 32);
|
|
|
|
mGBClouds2b->init(256, 52, 256, 32, -0.05f, 0.0f, 0.0f, 0.0f, mTexture[TEXTURE_GAME_BG].texture, mRenderer);
|
|
mGBClouds2b->setSpriteClip(256, 52, 256, 32);
|
|
|
|
mGrass->init(0, 85, SCREEN_WIDTH, 6, mTexture[TEXTURE_GAME_BG].texture, mRenderer);
|
|
mGrass->setPosY(154);
|
|
|
|
// Objeto jugador
|
|
mPlayer->init(PLAY_AREA_CENTER_X - 12, PLAY_AREA_BOTTOM - 24, mTexture[TEXTURE_PLAYER_LEGS].texture, mTexture[TEXTURE_PLAYER_BODY].texture, mRenderer);
|
|
|
|
// Establece a cero todos los valores del vector de objetos globo
|
|
resetBalloons();
|
|
|
|
// Crea objetos globo y los centra en el area de juego
|
|
mBalloon[0]->init(0, BLOCK, BALLOON_4, BALLON_VELX_POSITIVE, 0, mTexture[TEXTURE_BALLOON].texture, mRenderer);
|
|
mBalloon[0]->allignTo(PLAY_AREA_CENTER_X);
|
|
|
|
// Con los globos creados, calcula el nivel de amenaza
|
|
calculateMenaceLevel();
|
|
|
|
// Establece a cero todos los valores del vector de objetos bala
|
|
resetBullets();
|
|
|
|
// Establece a cero todos los valores del vector de objetos item
|
|
resetItems();
|
|
|
|
// Establece a cero todos los valores del vector de objetos SmafrtSprite
|
|
resetSmartSprites();
|
|
|
|
// Inicializa el sprite del logo
|
|
mLogo.sprite->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTexture[TEXTURE_LOGO].texture, mRenderer);
|
|
|
|
// Inicializa el bitmap de GetReady!
|
|
mGetReadyBitmap->init(mTexture[TEXTURE_GAME_TEXT].texture, mRenderer);
|
|
mGetReadyBitmap->setPosX(-113);
|
|
mGetReadyBitmap->setPosY(PLAY_AREA_CENTER_Y - 10);
|
|
mGetReadyBitmap->setWidth(109);
|
|
mGetReadyBitmap->setHeight(20);
|
|
mGetReadyBitmap->setVelX(2.0f);
|
|
mGetReadyBitmap->setVelY(0.0f);
|
|
mGetReadyBitmap->setAccelX(0.00f);
|
|
mGetReadyBitmap->setAccelY(0.0f);
|
|
mGetReadyBitmap->setSpriteClip(0, 0, 109, 20);
|
|
mGetReadyBitmap->setEnabled(true);
|
|
mGetReadyBitmap->setEnabledTimer(0);
|
|
mGetReadyBitmap->setDestX(PLAY_AREA_RIGHT);
|
|
mGetReadyBitmap->setDestY(PLAY_AREA_CENTER_Y - 10);
|
|
|
|
// Inicializa el bitmap de Coffee
|
|
mCoffeeBitmap->init(mTexture[TEXTURE_TITLE].texture, mRenderer);
|
|
mCoffeeBitmap->setId(0);
|
|
mCoffeeBitmap->setIntroEvents(&mTitleEvents[0]);
|
|
mCoffeeBitmap->setPosX(45);
|
|
mCoffeeBitmap->setPosY(11 - 200);
|
|
mCoffeeBitmap->setWidth(167);
|
|
mCoffeeBitmap->setHeight(46);
|
|
mCoffeeBitmap->setVelX(0.0f);
|
|
mCoffeeBitmap->setVelY(2.5f);
|
|
mCoffeeBitmap->setAccelX(0.0f);
|
|
mCoffeeBitmap->setAccelY(0.1f);
|
|
//mCoffeeBitmap->setSpriteClip(45, 11, 167, 46);
|
|
mCoffeeBitmap->setSpriteClip(0, 0, 167, 46);
|
|
mCoffeeBitmap->setEnabled(true);
|
|
mCoffeeBitmap->setEnabledTimer(0);
|
|
mCoffeeBitmap->setDestX(45);
|
|
mCoffeeBitmap->setDestY(11);
|
|
|
|
// Inicializa el bitmap de Crisis
|
|
mCrisisBitmap->init(mTexture[TEXTURE_TITLE].texture, mRenderer);
|
|
mCrisisBitmap->setId(1);
|
|
mCrisisBitmap->setIntroEvents(&mTitleEvents[0]);
|
|
mCrisisBitmap->setPosX(60);
|
|
mCrisisBitmap->setPosY(57 + 200);
|
|
mCrisisBitmap->setWidth(137);
|
|
mCrisisBitmap->setHeight(46);
|
|
mCrisisBitmap->setVelX(0.0f);
|
|
mCrisisBitmap->setVelY(-2.5f);
|
|
mCrisisBitmap->setAccelX(0.0f);
|
|
mCrisisBitmap->setAccelY(-0.1f);
|
|
//mCrisisBitmap->setSpriteClip(60, 57, 137, 46);
|
|
mCrisisBitmap->setSpriteClip(0, 46, 137, 46);
|
|
mCrisisBitmap->setEnabled(true);
|
|
mCrisisBitmap->setEnabledTimer(0);
|
|
mCrisisBitmap->setDestX(60);
|
|
mCrisisBitmap->setDestY(57);
|
|
|
|
// Inicializa el bitmap de DustRight
|
|
mDustSpriteRight->init(mTexture[TEXTURE_TITLE].texture, mRenderer);
|
|
mDustSpriteRight->setPosX(218);
|
|
mDustSpriteRight->setPosY(47);
|
|
mDustSpriteRight->setWidth(16);
|
|
mDustSpriteRight->setHeight(14);
|
|
mDustSpriteRight->setCurrentFrame(0);
|
|
mDustSpriteRight->setAnimationCounter(0);
|
|
mDustSpriteRight->setAnimationNumFrames(0, 7);
|
|
mDustSpriteRight->setAnimationSpeed(0, 8);
|
|
mDustSpriteRight->setAnimationLoop(0, false);
|
|
mDustSpriteRight->setAnimationFrames(0, 0, 160 + (mDustSpriteRight->getWidth() * 0), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight());
|
|
mDustSpriteRight->setAnimationFrames(0, 1, 160 + (mDustSpriteRight->getWidth() * 1), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight());
|
|
mDustSpriteRight->setAnimationFrames(0, 2, 160 + (mDustSpriteRight->getWidth() * 2), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight());
|
|
mDustSpriteRight->setAnimationFrames(0, 3, 160 + (mDustSpriteRight->getWidth() * 3), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight());
|
|
mDustSpriteRight->setAnimationFrames(0, 4, 160 + (mDustSpriteRight->getWidth() * 4), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight());
|
|
mDustSpriteRight->setAnimationFrames(0, 5, 160 + (mDustSpriteRight->getWidth() * 5), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight());
|
|
mDustSpriteRight->setAnimationFrames(0, 6, 160 + (mDustSpriteRight->getWidth() * 6), 80, mDustSpriteRight->getWidth(), mDustSpriteRight->getHeight());
|
|
|
|
// Inicializa el bitmap de DustLeft
|
|
mDustSpriteLeft->init(mTexture[TEXTURE_TITLE].texture, mRenderer);
|
|
mDustSpriteLeft->setPosX(33);
|
|
mDustSpriteLeft->setPosY(47);
|
|
mDustSpriteLeft->setWidth(16);
|
|
mDustSpriteLeft->setHeight(14);
|
|
mDustSpriteLeft->setCurrentFrame(0);
|
|
mDustSpriteLeft->setAnimationCounter(0);
|
|
mDustSpriteLeft->setAnimationNumFrames(0, 7);
|
|
mDustSpriteLeft->setAnimationSpeed(0, 8);
|
|
mDustSpriteLeft->setAnimationLoop(0, false);
|
|
mDustSpriteLeft->setAnimationFrames(0, 0, 160 + (mDustSpriteLeft->getWidth() * 0), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight());
|
|
mDustSpriteLeft->setAnimationFrames(0, 1, 160 + (mDustSpriteLeft->getWidth() * 1), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight());
|
|
mDustSpriteLeft->setAnimationFrames(0, 2, 160 + (mDustSpriteLeft->getWidth() * 2), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight());
|
|
mDustSpriteLeft->setAnimationFrames(0, 3, 160 + (mDustSpriteLeft->getWidth() * 3), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight());
|
|
mDustSpriteLeft->setAnimationFrames(0, 4, 160 + (mDustSpriteLeft->getWidth() * 4), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight());
|
|
mDustSpriteLeft->setAnimationFrames(0, 5, 160 + (mDustSpriteLeft->getWidth() * 5), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight());
|
|
mDustSpriteLeft->setAnimationFrames(0, 6, 160 + (mDustSpriteLeft->getWidth() * 6), 66, mDustSpriteLeft->getWidth(), mDustSpriteLeft->getHeight());
|
|
|
|
// Inicializa el bitmap de 1000 puntos
|
|
m1000Bitmap->init(mTexture[TEXTURE_GAME_TEXT].texture, mRenderer);
|
|
m1000Bitmap->setPosX(0);
|
|
m1000Bitmap->setPosY(0);
|
|
m1000Bitmap->setWidth(26);
|
|
m1000Bitmap->setHeight(9);
|
|
m1000Bitmap->setVelX(0.0f);
|
|
m1000Bitmap->setVelY(-0.5f);
|
|
m1000Bitmap->setAccelX(0.0f);
|
|
m1000Bitmap->setAccelY(-0.1f);
|
|
m1000Bitmap->setSpriteClip(0, 20, 26, 9);
|
|
m1000Bitmap->setEnabled(false);
|
|
m1000Bitmap->setEnabledTimer(0);
|
|
m1000Bitmap->setDestX(0);
|
|
m1000Bitmap->setDestY(0);
|
|
|
|
// Inicializa el bitmap de 2500 puntos
|
|
m2500Bitmap->init(mTexture[TEXTURE_GAME_TEXT].texture, mRenderer);
|
|
m2500Bitmap->setPosX(0);
|
|
m2500Bitmap->setPosY(0);
|
|
m2500Bitmap->setWidth(28);
|
|
m2500Bitmap->setHeight(9);
|
|
m2500Bitmap->setVelX(0.0f);
|
|
m2500Bitmap->setVelY(-0.5f);
|
|
m2500Bitmap->setAccelX(0.0f);
|
|
m2500Bitmap->setAccelY(-0.1f);
|
|
m2500Bitmap->setSpriteClip(26, 20, 28, 9);
|
|
m2500Bitmap->setEnabled(false);
|
|
m2500Bitmap->setEnabledTimer(0);
|
|
m2500Bitmap->setDestX(0);
|
|
m2500Bitmap->setDestY(0);
|
|
|
|
// Inicializa el bitmap de 5000 puntos
|
|
m5000Bitmap->init(mTexture[TEXTURE_GAME_TEXT].texture, mRenderer);
|
|
m5000Bitmap->setPosX(0);
|
|
m5000Bitmap->setPosY(0);
|
|
m5000Bitmap->setWidth(28);
|
|
m5000Bitmap->setHeight(9);
|
|
m5000Bitmap->setVelX(0.0f);
|
|
m5000Bitmap->setVelY(-0.5f);
|
|
m5000Bitmap->setAccelX(0.0f);
|
|
m5000Bitmap->setAccelY(-0.1f);
|
|
m5000Bitmap->setSpriteClip(54, 20, 28, 9);
|
|
m5000Bitmap->setEnabled(false);
|
|
m5000Bitmap->setEnabledTimer(0);
|
|
m5000Bitmap->setDestX(0);
|
|
m5000Bitmap->setDestY(0);
|
|
|
|
// Inicializa el vector de eventos de la intro
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_EVENTS; i++)
|
|
{
|
|
mIntroEvents[i] = EVENT_WAITING;
|
|
}
|
|
|
|
// Inicializa el vector de eventos de la pantalla de titulo
|
|
for (Uint8 i = 0; i < TITLE_TOTAL_EVENTS; i++)
|
|
{
|
|
mTitleEvents[i] = EVENT_WAITING;
|
|
}
|
|
|
|
// Inicializa los bitmaps de la intro
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++)
|
|
{
|
|
mIntroBitmap[i]->init(mTexture[TEXTURE_INTRO].texture, mRenderer);
|
|
mIntroBitmap[i]->setId(i);
|
|
mIntroBitmap[i]->setIntroEvents(&mIntroEvents[0]);
|
|
mIntroBitmap[i]->setWidth(128);
|
|
mIntroBitmap[i]->setHeight(96);
|
|
mIntroBitmap[i]->setEnabled(false);
|
|
mIntroBitmap[i]->setEnabledTimer(20);
|
|
mIntroBitmap[i]->setDestX(SCREEN_CENTER_X - 64);
|
|
mIntroBitmap[i]->setDestY(SCREEN_FIRST_QUARTER_Y - 24);
|
|
}
|
|
|
|
mIntroBitmap[0]->setPosX(-128);
|
|
mIntroBitmap[0]->setPosY(SCREEN_FIRST_QUARTER_Y - 24);
|
|
mIntroBitmap[0]->setVelX(0.0f);
|
|
mIntroBitmap[0]->setVelY(0.0f);
|
|
mIntroBitmap[0]->setAccelX(0.6f);
|
|
mIntroBitmap[0]->setAccelY(0.0f);
|
|
mIntroBitmap[0]->setSpriteClip(0, 0, 128, 96);
|
|
|
|
mIntroBitmap[1]->setPosX(SCREEN_WIDTH);
|
|
mIntroBitmap[1]->setPosY(SCREEN_FIRST_QUARTER_Y - 24);
|
|
mIntroBitmap[1]->setVelX(-1.0f);
|
|
mIntroBitmap[1]->setVelY(0.0f);
|
|
mIntroBitmap[1]->setAccelX(-0.3f);
|
|
mIntroBitmap[1]->setAccelY(0.0f);
|
|
mIntroBitmap[1]->setSpriteClip(128, 0, 128, 96);
|
|
|
|
mIntroBitmap[2]->setPosX(SCREEN_CENTER_X - 64);
|
|
mIntroBitmap[2]->setPosY(-96);
|
|
mIntroBitmap[2]->setVelX(0.0f);
|
|
mIntroBitmap[2]->setVelY(3.0f);
|
|
mIntroBitmap[2]->setAccelX(0.1f);
|
|
mIntroBitmap[2]->setAccelY(0.3f);
|
|
mIntroBitmap[2]->setSpriteClip(0, 96, 128, 96);
|
|
|
|
mIntroBitmap[2]->setEnabledTimer(250);
|
|
|
|
mIntroBitmap[3]->setPosX(SCREEN_CENTER_X - 64);
|
|
mIntroBitmap[3]->setPosY(SCREEN_HEIGHT);
|
|
mIntroBitmap[3]->setVelX(0.0f);
|
|
mIntroBitmap[3]->setVelY(-0.7f);
|
|
mIntroBitmap[3]->setAccelX(0.0f);
|
|
mIntroBitmap[3]->setAccelY(0.0f);
|
|
mIntroBitmap[3]->setSpriteClip(128, 96, 128, 96);
|
|
|
|
mIntroBitmap[4]->setPosX(SCREEN_CENTER_X - 64);
|
|
mIntroBitmap[4]->setPosY(-96);
|
|
mIntroBitmap[4]->setVelX(0.0f);
|
|
mIntroBitmap[4]->setVelY(3.0f);
|
|
mIntroBitmap[4]->setAccelX(0.1f);
|
|
mIntroBitmap[4]->setAccelY(0.3f);
|
|
mIntroBitmap[4]->setSpriteClip(0, 192, 128, 96);
|
|
|
|
mIntroBitmap[5]->setPosX(SCREEN_WIDTH);
|
|
mIntroBitmap[5]->setPosY(SCREEN_FIRST_QUARTER_Y - 24);
|
|
mIntroBitmap[5]->setVelX(-0.7f);
|
|
mIntroBitmap[5]->setVelY(0.0f);
|
|
mIntroBitmap[5]->setAccelX(0.0f);
|
|
mIntroBitmap[5]->setAccelY(0.0f);
|
|
mIntroBitmap[5]->setSpriteClip(128, 192, 128, 96);
|
|
|
|
// Inicializa los textos de la intro
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++)
|
|
{
|
|
mIntroText[i]->init(mTexture[TEXTURE_FONT_NOKIA].texture, mRenderer, TEXT_VARIABLE, 10);
|
|
mIntroText[i]->setId(6 + i);
|
|
mIntroText[i]->setIntroEvents(&mIntroEvents[0]);
|
|
mIntroText[i]->setPosX(BLOCK * 0);
|
|
mIntroText[i]->setPosY(SCREEN_HEIGHT - (BLOCK * 6));
|
|
mIntroText[i]->setKerning(-1);
|
|
mIntroText[i]->setEnabled(false);
|
|
mIntroText[i]->setEnabledTimer(180);
|
|
}
|
|
|
|
mIntroText[0]->setCaption("Un dia qualsevol de l'any 2000");
|
|
mIntroText[0]->setWrittingSpeed(10);
|
|
|
|
mIntroText[1]->setCaption("Tot esta tranquil a la UPV");
|
|
mIntroText[1]->setWrittingSpeed(10);
|
|
|
|
mIntroText[2]->setCaption("Fins que un desaprensiu...");
|
|
mIntroText[2]->setWrittingSpeed(15);
|
|
|
|
mIntroText[3]->setCaption("HEY! ME ANE A FERME UN CORTAET...");
|
|
mIntroText[3]->setWrittingSpeed(10);
|
|
|
|
mIntroText[4]->setCaption("UAAAAAAAAAAAAA!!!");
|
|
mIntroText[4]->setWrittingSpeed(1);
|
|
|
|
mIntroText[5]->setCaption("Espera un moment...");
|
|
mIntroText[5]->setWrittingSpeed(20);
|
|
|
|
mIntroText[6]->setCaption("Si resulta que no tinc solt!");
|
|
mIntroText[6]->setWrittingSpeed(2);
|
|
|
|
mIntroText[7]->setCaption("MERDA DE MAQUINA!");
|
|
mIntroText[7]->setWrittingSpeed(3);
|
|
|
|
mIntroText[8]->setCaption("Blop... blop... blop...");
|
|
mIntroText[8]->setWrittingSpeed(20);
|
|
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++)
|
|
{
|
|
mIntroText[i]->center(SCREEN_CENTER_X);
|
|
}
|
|
}
|
|
|
|
// Esta parte solo se ejecuta al arrancar la aplicación
|
|
if (reset == false)
|
|
{
|
|
// Variables
|
|
mGame.status = GAME_STATE_LOGO;
|
|
mTitleStatus = 0;
|
|
mTiteNextGS = GAME_STATE_PLAYING;
|
|
|
|
// Teclado
|
|
mKeyboard.up = SDL_SCANCODE_UP;
|
|
mKeyboard.down = SDL_SCANCODE_DOWN;
|
|
mKeyboard.left = SDL_SCANCODE_LEFT;
|
|
mKeyboard.right = SDL_SCANCODE_RIGHT;
|
|
mKeyboard.accept = SDL_SCANCODE_RETURN;
|
|
mKeyboard.cancel = SDL_SCANCODE_ESCAPE;
|
|
mKeyboard.fire = SDL_SCANCODE_W;
|
|
mKeyboard.fireLeft = SDL_SCANCODE_Q;
|
|
mKeyboard.fireRight = SDL_SCANCODE_E;
|
|
mKeyboard.pause = SDL_SCANCODE_ESCAPE;
|
|
mKeyboard.escape = SDL_SCANCODE_ESCAPE;
|
|
|
|
// Buffer de teclado
|
|
mKeyboardBuffer.up = 0;
|
|
mKeyboardBuffer.down = 0;
|
|
mKeyboardBuffer.left = 0;
|
|
mKeyboardBuffer.right = 0;
|
|
mKeyboardBuffer.accept = 0;
|
|
mKeyboardBuffer.cancel = 0;
|
|
mKeyboardBuffer.fire = 0;
|
|
mKeyboardBuffer.fireLeft = 0;
|
|
mKeyboardBuffer.fireRight = 0;
|
|
mKeyboardBuffer.pause = 0;
|
|
mKeyboardBuffer.escape = 0;
|
|
|
|
// Carga la máxima puntuación a partir del fichero de datos
|
|
if (mScoreDataFile[0] == 0)
|
|
{
|
|
mGame.hiScore = 10000;
|
|
}
|
|
// Comprueba el checksum para ver si se ha modificado el fichero
|
|
else if (mScoreDataFile[0] % 43 == mScoreDataFile[1])
|
|
{
|
|
mGame.hiScore = mScoreDataFile[0];
|
|
}
|
|
else
|
|
{
|
|
mGame.hiScore = 10000;
|
|
}
|
|
|
|
// Los fondos
|
|
mGameBackgroundFront->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTexture[TEXTURE_GAME_BG].texture, mRenderer);
|
|
mGameBackgroundSky->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTexture[TEXTURE_GAME_BG].texture, mRenderer);
|
|
|
|
// El tile de fondo
|
|
mTitleTile->init(0, 0, 64, 64, mTexture[TEXTURE_TITLE].texture, mRenderer);
|
|
mTitleTile->setSpriteClip(192, 0, 64, 64);
|
|
|
|
// Las instrucciones
|
|
//mInstructions->init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, mTexture.instructions, mRenderer);
|
|
|
|
// Objetos texto, uno de cada color
|
|
mText.white->init(mTexture[TEXTURE_FONT_WHITE].texture, mRenderer, TEXT_FIXED, BLOCK);
|
|
mText.black->init(mTexture[TEXTURE_FONT_BLACK].texture, mRenderer, TEXT_FIXED, BLOCK);
|
|
mText.nokia->init(mTexture[TEXTURE_FONT_NOKIA].texture, mRenderer, TEXT_VARIABLE, 10);
|
|
|
|
// Inicializa el objeto con el menu del titulo
|
|
mMenu.title->init("TITLE", 0, 15 * BLOCK, MENU_BACKGROUND_SOLID, mTexture[TEXTURE_MENU].texture, mRenderer, mText.white);
|
|
mMenu.title->addItem("PLAY");
|
|
mMenu.title->addItem("OPTIONS", 0, 5);
|
|
mMenu.title->addItem("QUIT");
|
|
mMenu.title->setDefaultActionWhenCancel(2);
|
|
mMenu.title->setBackgroundColor(0x30, 0x30, 0x40, 192);
|
|
mMenu.title->setSelectorColor(0xe5, 0x1c, 0x23, 255);
|
|
mMenu.title->setSelectorTextColor(0xFF, 0xF1, 0x76);
|
|
mMenu.title->centerMenu(SCREEN_CENTER_X);
|
|
mMenu.title->centerMenuElements();
|
|
|
|
// Inicializa el objeto con el menu de pausa
|
|
mMenu.pause->init("PAUSE", 0, 12 * BLOCK, MENU_BACKGROUND_SOLID, mTexture[TEXTURE_MENU].texture, mRenderer, mText.white);
|
|
mMenu.pause->addItem("CONTINUE");
|
|
mMenu.pause->addItem("EXIT TO TITLE");
|
|
mMenu.pause->setDefaultActionWhenCancel(0);
|
|
mMenu.pause->setBackgroundColor(0x29, 0x39, 0x41, 240);
|
|
mMenu.pause->setSelectorColor(0xFF, 0x7A, 0x00, 255);
|
|
mMenu.pause->setSelectorTextColor(0xFF, 0xFF, 0xFF);
|
|
mMenu.pause->centerMenu(SCREEN_CENTER_X);
|
|
mMenu.pause->centerMenuElements();
|
|
|
|
// Inicializa el objeto con el menu de la pantalla de game over
|
|
mMenu.gameOver->init("GAME OVER", 0, PLAY_AREA_CENTER_Y + BLOCK * 4, MENU_BACKGROUND_TRANSPARENT, mTexture[TEXTURE_MENU].texture, mRenderer, mText.white);
|
|
mMenu.gameOver->addItem("YES");
|
|
mMenu.gameOver->addItem("NO");
|
|
mMenu.gameOver->setDefaultActionWhenCancel(1);
|
|
mMenu.gameOver->setBackgroundColor(0, 0, 0, 255);
|
|
mMenu.gameOver->setSelectorColor(0x54, 0x6e, 0x7a, 255);
|
|
mMenu.gameOver->setSelectorColor(0x54, 0x6e, 0x7a, 0);
|
|
mMenu.gameOver->setSelectorTextColor(0xFF, 0xFF, 0xFF);
|
|
mMenu.gameOver->setSelectorTextColor(0xFF, 0xF1, 0x76);
|
|
mMenu.gameOver->centerMenu(SCREEN_CENTER_X);
|
|
mMenu.gameOver->centerMenuElements();
|
|
|
|
// Inicializa el objeto con el menu de las opciones
|
|
mMenu.options->init("OPTIONS", 0, 15 * BLOCK, MENU_BACKGROUND_SOLID, mTexture[TEXTURE_MENU].texture, mRenderer, mText.white);
|
|
mMenu.options->addItem("FULLSCREEN");
|
|
mMenu.options->addItem("WINDOWS SIZE", 0, 5);
|
|
mMenu.options->addItem("[OK]");
|
|
mMenu.options->addItem("[CANCEL]");
|
|
mMenu.options->setDefaultActionWhenCancel(3);
|
|
mMenu.options->setBackgroundColor(0x30, 0x30, 0x40, 192);
|
|
mMenu.options->setSelectorColor(0xe5, 0x1c, 0x23, 255);
|
|
mMenu.options->setSelectorTextColor(0xFF, 0xF1, 0x76);
|
|
mMenu.options->centerMenu(SCREEN_CENTER_X);
|
|
mMenu.options->centerMenuElements();
|
|
|
|
// Actualiza los elementos del menu de opciones con los valores correspondientes
|
|
updateOptionsMenu();
|
|
}
|
|
}
|
|
|
|
// Arranca SDL y crea la ventana
|
|
bool GameDirector::initSDL()
|
|
{
|
|
// Indicador de inicialización
|
|
bool success = true;
|
|
|
|
// Inicializa SDL
|
|
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO | SDL_INIT_HAPTIC) < 0)
|
|
{
|
|
printf("SDL could not initialize!\nSDL Error: %s\n", SDL_GetError());
|
|
success = false;
|
|
}
|
|
else
|
|
{
|
|
// Establece el filtro de la textura a nearest
|
|
if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0"))
|
|
{
|
|
printf("Warning: Nearest texture filtering not enabled!\n");
|
|
}
|
|
|
|
// Inicializa jail_audio
|
|
JA_Init(48000, AUDIO_S16, 2);
|
|
|
|
// Comprueba si hay algun mando conectado
|
|
if (SDL_NumJoysticks() < 1)
|
|
{
|
|
printf("Warning: No joysticks connected!\n");
|
|
mGameControllerFound = false;
|
|
}
|
|
else
|
|
{
|
|
// Carga el mando
|
|
mGameController = SDL_JoystickOpen(0);
|
|
mGameControllerFound = true;
|
|
|
|
if (mGameController == NULL)
|
|
{
|
|
printf("Warning: Unable to open game controller!\nSDL Error: %s\n", SDL_GetError());
|
|
mGameControllerFound = false;
|
|
}
|
|
else
|
|
{
|
|
printf("%i joysticks were found.\n", SDL_NumJoysticks());
|
|
std::cout << SDL_JoystickNumButtons(mGameController) << " buttons\n";
|
|
|
|
//Get controller haptic device
|
|
mControllerHaptic = SDL_HapticOpenFromJoystick(mGameController);
|
|
if (mControllerHaptic == NULL)
|
|
{
|
|
printf("Warning: Controller does not support haptics!\nSDL Error: %s\n", SDL_GetError());
|
|
}
|
|
else
|
|
{
|
|
printf("Haptics detected\n");
|
|
|
|
//Get initialize rumble
|
|
if (SDL_HapticRumbleInit(mControllerHaptic) < 0)
|
|
{
|
|
printf("Warning: Unable to initialize rumble!\nSDL Error: %s\n", SDL_GetError());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Crea la ventana
|
|
mWindow = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, VIEW_WIDTH, VIEW_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI);
|
|
if (mWindow == NULL)
|
|
{
|
|
printf("Window could not be created!\nSDL Error: %s\n", SDL_GetError());
|
|
success = false;
|
|
}
|
|
else
|
|
{
|
|
// Crea un renderizador para la ventana con vsync
|
|
mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
|
|
if (mRenderer == NULL)
|
|
{
|
|
printf("Renderer could not be created!\nSDL Error: %s\n", SDL_GetError());
|
|
success = false;
|
|
}
|
|
else
|
|
{
|
|
// Inicializa el color de renderizado
|
|
SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF);
|
|
|
|
// Establece el tamaño del buffer de renderizado
|
|
SDL_RenderSetLogicalSize(mRenderer, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
|
|
// Establece el modo de mezcla
|
|
SDL_SetRenderDrawBlendMode(mRenderer, SDL_BLENDMODE_BLEND);
|
|
}
|
|
|
|
// Crea un backbuffer para el renderizador
|
|
mBackbuffer = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
if (mBackbuffer == NULL)
|
|
{
|
|
printf("Backbuffer could not be created!\nSDL Error: %s\n", SDL_GetError());
|
|
success = false;
|
|
}
|
|
|
|
// Crea una textura para dibujar el fondo del titulo
|
|
mTitleSurface = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH * 2, SCREEN_HEIGHT * 2);
|
|
if (mTitleSurface == NULL)
|
|
{
|
|
printf("TitleSurface could not be created!\nSDL Error: %s\n", SDL_GetError());
|
|
success = false;
|
|
}
|
|
|
|
// Crea una textura para dibujar las instrucciones
|
|
mInstructionsSurface = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
if (mInstructionsSurface == NULL)
|
|
{
|
|
printf("InstructionsSurface could not be created!\nSDL Error: %s\n", SDL_GetError());
|
|
success = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
return success;
|
|
}
|
|
|
|
// Crea el indice de ficheros
|
|
void GameDirector::setFileList()
|
|
{
|
|
// Ficheros binarios
|
|
mBinFile[BINFILE_SCORE].file = mExecutablePath + "/" + "../data/score.bin";
|
|
mBinFile[BINFILE_DEMO].file = mExecutablePath + "/" + "../data/demo.bin";
|
|
mBinFile[BINFILE_CONFIG].file = mExecutablePath + "/" + "../data/config.bin";
|
|
|
|
// Musicas
|
|
mMusic[MUSIC_INTRO].file = mExecutablePath + "/" + "../media/music/intro.ogg";
|
|
mMusic[MUSIC_PLAYING].file = mExecutablePath + "/" + "../media/music/playing.ogg";
|
|
mMusic[MUSIC_TITLE].file = mExecutablePath + "/" + "../media/music/title.ogg";
|
|
|
|
// Sonidos
|
|
mSound[SOUND_BALLON].file = mExecutablePath + "/" + "../media/sound/balloon.wav";
|
|
mSound[SOUND_BULLET].file = mExecutablePath + "/" + "../media/sound/bullet.wav";
|
|
mSound[SOUND_MENU_SELECT].file = mExecutablePath + "/" + "../media/sound/menu_select.wav";
|
|
mSound[SOUND_MENU_CANCEL].file = mExecutablePath + "/" + "../media/sound/menu_cancel.wav";
|
|
mSound[SOUND_MENU_MOVE].file = mExecutablePath + "/" + "../media/sound/menu_move.wav";
|
|
mSound[SOUND_TITLE].file = mExecutablePath + "/" + "../media/sound/title.wav";
|
|
mSound[SOUND_PLAYER_COLLISION].file = mExecutablePath + "/" + "../media/sound/player_collision.wav";
|
|
mSound[SOUND_HISCORE].file = mExecutablePath + "/" + "../media/sound/hiscore.wav";
|
|
mSound[SOUND_ITEM_DROP].file = mExecutablePath + "/" + "../media/sound/itemdrop.wav";
|
|
mSound[SOUND_ITEM_PICKUP].file = mExecutablePath + "/" + "../media/sound/itempickup.wav";
|
|
mSound[SOUND_COFFEE_OUT].file = mExecutablePath + "/" + "../media/sound/coffeeout.wav";
|
|
mSound[SOUND_STAGE_CHANGE].file = mExecutablePath + "/" + "../media/sound/stage_change.wav";
|
|
mSound[SOUND_BUBBLE1].file = mExecutablePath + "/" + "../media/sound/bubble1.wav";
|
|
mSound[SOUND_BUBBLE2].file = mExecutablePath + "/" + "../media/sound/bubble2.wav";
|
|
mSound[SOUND_BUBBLE3].file = mExecutablePath + "/" + "../media/sound/bubble3.wav";
|
|
mSound[SOUND_BUBBLE4].file = mExecutablePath + "/" + "../media/sound/bubble4.wav";
|
|
|
|
// Texturas
|
|
mTexture[TEXTURE_BALLOON].file = mExecutablePath + "/" + "../media/gfx/balloon.png";
|
|
mTexture[TEXTURE_BULLET].file = mExecutablePath + "/" + "../media/gfx/bullet.png";
|
|
mTexture[TEXTURE_FONT_BLACK].file = mExecutablePath + "/" + "../media/gfx/font_black.png";
|
|
mTexture[TEXTURE_FONT_NOKIA].file = mExecutablePath + "/" + "../media/gfx/font_nokia.png";
|
|
mTexture[TEXTURE_FONT_WHITE].file = mExecutablePath + "/" + "../media/gfx/font_white.png";
|
|
mTexture[TEXTURE_GAME_BG].file = mExecutablePath + "/" + "../media/gfx/game_bg.png";
|
|
mTexture[TEXTURE_GAME_TEXT].file = mExecutablePath + "/" + "../media/gfx/game_text.png";
|
|
mTexture[TEXTURE_INTRO].file = mExecutablePath + "/" + "../media/gfx/intro.png";
|
|
mTexture[TEXTURE_ITEMS].file = mExecutablePath + "/" + "../media/gfx/items.png";
|
|
mTexture[TEXTURE_LOGO].file = mExecutablePath + "/" + "../media/gfx/logo.png";
|
|
mTexture[TEXTURE_MENU].file = mExecutablePath + "/" + "../media/gfx/menu.png";
|
|
mTexture[TEXTURE_PLAYER_LEGS].file = mExecutablePath + "/" + "../media/gfx/player_legs.png";
|
|
mTexture[TEXTURE_PLAYER_BODY].file = mExecutablePath + "/" + "../media/gfx/player_body.png";
|
|
mTexture[TEXTURE_PLAYER_DEATH].file = mExecutablePath + "/" + "../media/gfx/player_death.png";
|
|
mTexture[TEXTURE_TITLE].file = mExecutablePath + "/" + "../media/gfx/title.png";
|
|
}
|
|
|
|
// Comprueba que todos los ficheros existen
|
|
bool GameDirector::checkFileList()
|
|
{
|
|
bool success = true;
|
|
std::string p;
|
|
std::string filename;
|
|
SDL_RWops *file;
|
|
|
|
// Comprueba los ficheros de musica
|
|
printf("\n>> MUSIC FILES\n");
|
|
for (Uint8 i = 0; i < TOTAL_MUSIC; i++)
|
|
{
|
|
p = mMusic[i].file.c_str();
|
|
filename = p.substr(p.find_last_of("\\/") + 1);
|
|
file = SDL_RWFromFile(p.c_str(), "r+b");
|
|
if (file != NULL)
|
|
{
|
|
printf("Checking file %-20s [OK]\n", filename.c_str());
|
|
}
|
|
else
|
|
{
|
|
success = false;
|
|
printf("Checking file %-20s [ERROR]\n", filename.c_str());
|
|
}
|
|
SDL_RWclose(file);
|
|
}
|
|
|
|
// Comprueba los ficheros de sonidos
|
|
printf("\n>> SOUND FILES\n");
|
|
for (Uint8 i = 0; i < TOTAL_SOUND; i++)
|
|
{
|
|
p = mSound[i].file.c_str();
|
|
filename = p.substr(p.find_last_of("\\/") + 1);
|
|
file = SDL_RWFromFile(p.c_str(), "r+b");
|
|
if (file != NULL)
|
|
{
|
|
printf("Checking file %-20s [OK]\n", filename.c_str());
|
|
}
|
|
else
|
|
{
|
|
success = false;
|
|
printf("Checking file %-20s [ERROR]\n", filename.c_str());
|
|
}
|
|
SDL_RWclose(file);
|
|
}
|
|
|
|
// Comprueba los ficheros con texturas
|
|
printf("\n>> TEXTURE FILES\n");
|
|
for (Uint8 i = 0; i < TOTAL_TEXTURE; i++)
|
|
{
|
|
p = mTexture[i].file.c_str();
|
|
filename = p.substr(p.find_last_of("\\/") + 1);
|
|
file = SDL_RWFromFile(p.c_str(), "r+b");
|
|
if (file != NULL)
|
|
{
|
|
printf("Checking file %-20s [OK]\n", filename.c_str());
|
|
}
|
|
else
|
|
{
|
|
success = false;
|
|
printf("Checking file %-20s [ERROR]\n", filename.c_str());
|
|
}
|
|
SDL_RWclose(file);
|
|
}
|
|
|
|
// Resultado
|
|
if (success)
|
|
{
|
|
printf("\n** All files OK.\n\n");
|
|
}
|
|
else
|
|
{
|
|
printf("\n** File is missing. Exiting.\n\n");
|
|
}
|
|
return success;
|
|
}
|
|
|
|
// Carga un archivo de imagen en una textura
|
|
bool GameDirector::loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer)
|
|
{
|
|
bool success = true;
|
|
if (!texture->loadFromFile(path, renderer))
|
|
{
|
|
printf("Failed to load %s texture!\n", path.c_str());
|
|
success = false;
|
|
}
|
|
return success;
|
|
}
|
|
|
|
// Carga los recursos necesarios
|
|
bool GameDirector::loadMedia(Uint8 section)
|
|
{
|
|
// Indicador de éxito en la carga
|
|
bool success = true;
|
|
std::string path = mExecutablePath + "/";
|
|
std::string p;
|
|
|
|
switch (section)
|
|
{
|
|
case GAME_STATE_INIT:
|
|
{
|
|
p = mBinFile[BINFILE_SCORE].file.c_str();
|
|
std::string filename = p.substr(p.find_last_of("\\/") + 1);
|
|
// Abrimos el fichero con la puntuacion para leer en binario
|
|
SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b");
|
|
|
|
// El fichero no existe
|
|
if (file == NULL)
|
|
{
|
|
printf("Warning: Unable to open %s file\n", filename.c_str());
|
|
|
|
// Creamos el fichero para escritura
|
|
file = SDL_RWFromFile(p.c_str(), "w+b");
|
|
if (file != NULL)
|
|
{
|
|
printf("New file (%s) created!\n", filename.c_str());
|
|
|
|
// Inicializamos los datos
|
|
for (int i = 0; i < TOTAL_SCORE_DATA; ++i)
|
|
{
|
|
mScoreDataFile[i] = 0;
|
|
SDL_RWwrite(file, &mScoreDataFile[i], sizeof(Uint32), 1);
|
|
}
|
|
|
|
// Cerramos el fichero
|
|
SDL_RWclose(file);
|
|
}
|
|
else
|
|
{
|
|
printf("Error: Unable to create file %s\n", filename.c_str());
|
|
success = false;
|
|
}
|
|
}
|
|
// El fichero existe
|
|
else
|
|
{
|
|
// Cargamos los datos
|
|
printf("Reading file %s\n", filename.c_str());
|
|
for (int i = 0; i < TOTAL_SCORE_DATA; ++i)
|
|
{
|
|
SDL_RWread(file, &mScoreDataFile[i], sizeof(Uint32), 1);
|
|
}
|
|
|
|
// Cierra el fichero
|
|
SDL_RWclose(file);
|
|
}
|
|
|
|
p = mBinFile[BINFILE_DEMO].file.c_str();
|
|
filename = p.substr(p.find_last_of("\\/") + 1);
|
|
// Abrimos el fichero con los datos para el modo demo para leer en binario
|
|
file = SDL_RWFromFile(p.c_str(), "r+b");
|
|
|
|
// El fichero no existe
|
|
if (file == NULL)
|
|
{
|
|
printf("Warning: Unable to open %s file\n", filename.c_str());
|
|
|
|
// Creamos el fichero para escritura
|
|
file = SDL_RWFromFile(p.c_str(), "w+b");
|
|
if (file != NULL)
|
|
{
|
|
printf("New file (%s) created!\n", filename.c_str());
|
|
|
|
// Inicializamos los datos
|
|
for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
|
|
{
|
|
mDemoKeys.left = 0;
|
|
mDemoKeys.right = 0;
|
|
mDemoKeys.noInput = 0;
|
|
mDemoKeys.fire = 0;
|
|
mDemoKeys.fireLeft = 0;
|
|
mDemoKeys.fireRight = 0;
|
|
mDemoDataFile[i] = mDemoKeys;
|
|
SDL_RWwrite(file, &mDemoDataFile[i], sizeof(DemoKeys), 1);
|
|
}
|
|
|
|
// Cerramos el fichero
|
|
SDL_RWclose(file);
|
|
}
|
|
else
|
|
{
|
|
printf("Error: Unable to create file %s\n", filename.c_str());
|
|
success = false;
|
|
}
|
|
}
|
|
// El fichero existe
|
|
else
|
|
{
|
|
// Cargamos los datos
|
|
printf("Reading file %s\n", filename.c_str());
|
|
for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
|
|
{
|
|
SDL_RWread(file, &mDemoDataFile[i], sizeof(DemoKeys), 1);
|
|
}
|
|
|
|
// Cierra el fichero
|
|
SDL_RWclose(file);
|
|
}
|
|
|
|
p = mBinFile[BINFILE_CONFIG].file.c_str();
|
|
filename = p.substr(p.find_last_of("\\/") + 1);
|
|
// Abrimos el fichero con la configuracion de las opciones leer en binario
|
|
file = SDL_RWFromFile(p.c_str(), "r+b");
|
|
|
|
// El fichero no existe
|
|
if (file == NULL)
|
|
{
|
|
printf("Warning: Unable to open %s file\n", filename.c_str());
|
|
|
|
// Creamos el fichero para escritura
|
|
file = SDL_RWFromFile(p.c_str(), "w+b");
|
|
if (file != NULL)
|
|
{
|
|
printf("New file (%s) created!\n", filename.c_str());
|
|
|
|
// Inicializamos los datos
|
|
mFullScreenMode = 0;
|
|
SDL_RWwrite(file, &mFullScreenMode, sizeof(mFullScreenMode), 1);
|
|
|
|
mWindowSize = 3;
|
|
SDL_RWwrite(file, &mWindowSize, sizeof(mWindowSize), 1);
|
|
|
|
// Cerramos el fichero
|
|
SDL_RWclose(file);
|
|
}
|
|
else
|
|
{
|
|
printf("Error: Unable to create file %s\n", filename.c_str());
|
|
success = false;
|
|
}
|
|
}
|
|
// El fichero existe
|
|
else
|
|
{
|
|
// Cargamos los datos
|
|
printf("Reading file %s\n", filename.c_str());
|
|
SDL_RWread(file, &mFullScreenMode, sizeof(mFullScreenMode), 1);
|
|
SDL_SetWindowFullscreen(mWindow, mFullScreenMode);
|
|
SDL_RWread(file, &mWindowSize, sizeof(mWindowSize), 1);
|
|
SDL_SetWindowSize(mWindow, SCREEN_WIDTH * mWindowSize, SCREEN_HEIGHT * mWindowSize);
|
|
|
|
// Cierra el fichero
|
|
SDL_RWclose(file);
|
|
}
|
|
printf("\n");
|
|
|
|
// Texturas
|
|
loadTextureFromFile(mTexture[TEXTURE_MENU].texture, mTexture[TEXTURE_MENU].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_FONT_WHITE].texture, mTexture[TEXTURE_FONT_WHITE].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_FONT_BLACK].texture, mTexture[TEXTURE_FONT_BLACK].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_FONT_NOKIA].texture, mTexture[TEXTURE_FONT_NOKIA].file, mRenderer);
|
|
|
|
// Sonidos
|
|
mSound[SOUND_MENU_SELECT].sound = JA_LoadSound(mSound[SOUND_MENU_SELECT].file.c_str());
|
|
mSound[SOUND_MENU_CANCEL].sound = JA_LoadSound(mSound[SOUND_MENU_CANCEL].file.c_str());
|
|
mSound[SOUND_MENU_MOVE].sound = JA_LoadSound(mSound[SOUND_MENU_MOVE].file.c_str());
|
|
|
|
// Musicas
|
|
mMusic[MUSIC_TITLE].music = JA_LoadMusic(mMusic[MUSIC_TITLE].file.c_str());
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_TITLE:
|
|
{
|
|
// Texturas
|
|
loadTextureFromFile(mTexture[TEXTURE_TITLE].texture, mTexture[TEXTURE_TITLE].file, mRenderer);
|
|
|
|
// Crea el mosaico de fondo del titulo
|
|
SDL_SetRenderTarget(mRenderer, mTitleSurface);
|
|
SDL_SetRenderDrawColor(mRenderer, 0x43, 0x43, 0x4F, 0xFF);
|
|
SDL_RenderClear(mRenderer);
|
|
for (Uint8 i = 0; i < 8; i++)
|
|
for (Uint8 j = 0; j < 6; j++)
|
|
{
|
|
mTitleTile->setPosX(i * 64);
|
|
mTitleTile->setPosY(j * 64);
|
|
mTitleTile->render();
|
|
}
|
|
mBackgroundWindow.x = 0;
|
|
mBackgroundWindow.y = 0;
|
|
mBackgroundWindow.w = SCREEN_WIDTH;
|
|
mBackgroundWindow.h = SCREEN_HEIGHT;
|
|
SDL_SetRenderTarget(mRenderer, nullptr);
|
|
|
|
// Sonidos
|
|
mSound[SOUND_TITLE].sound = JA_LoadSound(mSound[SOUND_TITLE].file.c_str());
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_PLAYING:
|
|
{
|
|
// Texturas
|
|
loadTextureFromFile(mTexture[TEXTURE_PLAYER_LEGS].texture, mTexture[TEXTURE_PLAYER_LEGS].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_PLAYER_BODY].texture, mTexture[TEXTURE_PLAYER_BODY].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_PLAYER_DEATH].texture, mTexture[TEXTURE_PLAYER_DEATH].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_BALLOON].texture, mTexture[TEXTURE_BALLOON].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_BULLET].texture, mTexture[TEXTURE_BULLET].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_GAME_BG].texture, mTexture[TEXTURE_GAME_BG].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_GAME_TEXT].texture, mTexture[TEXTURE_GAME_TEXT].file, mRenderer);
|
|
loadTextureFromFile(mTexture[TEXTURE_ITEMS].texture, mTexture[TEXTURE_ITEMS].file, mRenderer);
|
|
|
|
// Sonidos
|
|
mSound[SOUND_BALLON].sound = JA_LoadSound(mSound[SOUND_BALLON].file.c_str());
|
|
mSound[SOUND_BULLET].sound = JA_LoadSound(mSound[SOUND_BULLET].file.c_str());
|
|
mSound[SOUND_PLAYER_COLLISION].sound = JA_LoadSound(mSound[SOUND_PLAYER_COLLISION].file.c_str());
|
|
mSound[SOUND_HISCORE].sound = JA_LoadSound(mSound[SOUND_HISCORE].file.c_str());
|
|
mSound[SOUND_ITEM_DROP].sound = JA_LoadSound(mSound[SOUND_ITEM_DROP].file.c_str());
|
|
mSound[SOUND_ITEM_PICKUP].sound = JA_LoadSound(mSound[SOUND_ITEM_PICKUP].file.c_str());
|
|
mSound[SOUND_COFFEE_OUT].sound = JA_LoadSound(mSound[SOUND_COFFEE_OUT].file.c_str());
|
|
mSound[SOUND_STAGE_CHANGE].sound = JA_LoadSound(mSound[SOUND_STAGE_CHANGE].file.c_str());
|
|
mSound[SOUND_TITLE].sound = JA_LoadSound(mSound[SOUND_TITLE].file.c_str());
|
|
mSound[SOUND_BUBBLE1].sound = JA_LoadSound(mSound[SOUND_BUBBLE1].file.c_str());
|
|
mSound[SOUND_BUBBLE2].sound = JA_LoadSound(mSound[SOUND_BUBBLE2].file.c_str());
|
|
mSound[SOUND_BUBBLE3].sound = JA_LoadSound(mSound[SOUND_BUBBLE3].file.c_str());
|
|
mSound[SOUND_BUBBLE4].sound = JA_LoadSound(mSound[SOUND_BUBBLE4].file.c_str());
|
|
|
|
// Musicas
|
|
mMusic[MUSIC_PLAYING].music = JA_LoadMusic(mMusic[MUSIC_PLAYING].file.c_str());
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_GAME_OVER_SCREEN:
|
|
{
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_INTRO:
|
|
{
|
|
// Texturas
|
|
loadTextureFromFile(mTexture[TEXTURE_INTRO].texture, mTexture[TEXTURE_INTRO].file, mRenderer);
|
|
|
|
// Musicas
|
|
mMusic[MUSIC_INTRO].music = JA_LoadMusic(mMusic[MUSIC_INTRO].file.c_str());
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_DEMO:
|
|
{
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_INSTRUCTIONS:
|
|
{
|
|
// Texturas
|
|
loadTextureFromFile(mTexture[TEXTURE_ITEMS].texture, mTexture[TEXTURE_ITEMS].file, mRenderer);
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_LOGO:
|
|
{
|
|
// Texturas
|
|
loadTextureFromFile(mTexture[TEXTURE_LOGO].texture, mTexture[TEXTURE_LOGO].file, mRenderer);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
}
|
|
break;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
// Descrga los recursos necesarios
|
|
bool GameDirector::unLoadMedia(Uint8 section)
|
|
{
|
|
// Indicador de éxito en la carga
|
|
bool success = true;
|
|
std::string path = mExecutablePath + "/";
|
|
std::string p;
|
|
|
|
switch (section)
|
|
{
|
|
case GAME_STATE_INIT:
|
|
{
|
|
p = mBinFile[BINFILE_SCORE].file;
|
|
std::string filename = p.substr(p.find_last_of("\\/") + 1);
|
|
// Abre el fichero de puntuación para escribir
|
|
SDL_RWops *file = SDL_RWFromFile(p.c_str(), "w+b");
|
|
if (file != NULL)
|
|
{
|
|
// Guardamos los datos
|
|
for (int i = 0; i < TOTAL_SCORE_DATA; ++i)
|
|
{
|
|
SDL_RWwrite(file, &mScoreDataFile[i], sizeof(Uint32), 1);
|
|
}
|
|
|
|
printf("Writing file %s\n", filename.c_str());
|
|
|
|
// Cerramos el fichero
|
|
SDL_RWclose(file);
|
|
}
|
|
else
|
|
{
|
|
printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError());
|
|
}
|
|
|
|
p = mBinFile[BINFILE_CONFIG].file;
|
|
filename = p.substr(p.find_last_of("\\/") + 1);
|
|
// Abre el fichero de puntuación para escribir
|
|
SDL_RWops *file2 = SDL_RWFromFile(p.c_str(), "w+b");
|
|
if (file != NULL)
|
|
{
|
|
// Guardamos los datos
|
|
SDL_RWwrite(file2, &mFullScreenMode, sizeof(Uint32), 1);
|
|
SDL_RWwrite(file2, &mWindowSize, sizeof(Uint8), 1);
|
|
|
|
printf("Writing file %s\n", filename.c_str());
|
|
|
|
// Cerramos el fichero
|
|
SDL_RWclose(file2);
|
|
}
|
|
else
|
|
{
|
|
printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError());
|
|
}
|
|
|
|
p = mBinFile[BINFILE_DEMO].file;
|
|
filename = p.substr(p.find_last_of("\\/") + 1);
|
|
// Abre el fichero de demo para escribir
|
|
if (mDemoRecording)
|
|
{
|
|
SDL_RWops *file2 = SDL_RWFromFile(p.c_str(), "w+b");
|
|
if (file2 != NULL)
|
|
{
|
|
// Guardamos los datos
|
|
for (int i = 0; i < TOTAL_DEMO_DATA; ++i)
|
|
{
|
|
SDL_RWwrite(file2, &mDemoDataFile[i], sizeof(DemoKeys), 1);
|
|
}
|
|
|
|
printf("Writing file %s\n", filename.c_str());
|
|
|
|
// Cerramos el fichero
|
|
SDL_RWclose(file2);
|
|
}
|
|
else
|
|
{
|
|
printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError());
|
|
}
|
|
}
|
|
printf("\n");
|
|
|
|
// Texturas
|
|
mTexture[TEXTURE_MENU].texture->free();
|
|
mTexture[TEXTURE_FONT_WHITE].texture->free();
|
|
mTexture[TEXTURE_FONT_BLACK].texture->free();
|
|
mTexture[TEXTURE_FONT_NOKIA].texture->free();
|
|
|
|
// Sonidos
|
|
JA_DeleteSound(mSound[SOUND_MENU_SELECT].sound);
|
|
JA_DeleteSound(mSound[SOUND_MENU_CANCEL].sound);
|
|
JA_DeleteSound(mSound[SOUND_MENU_MOVE].sound);
|
|
|
|
// Musicas
|
|
JA_DeleteMusic(mMusic[MUSIC_TITLE].music);
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_TITLE:
|
|
{
|
|
// Texturas
|
|
mTexture[TEXTURE_TITLE].texture->free();
|
|
|
|
// Sonidos
|
|
JA_DeleteSound(mSound[SOUND_TITLE].sound);
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_PLAYING:
|
|
{
|
|
// Texturas
|
|
mTexture[TEXTURE_PLAYER_LEGS].texture->free();
|
|
mTexture[TEXTURE_PLAYER_BODY].texture->free();
|
|
mTexture[TEXTURE_PLAYER_DEATH].texture->free();
|
|
mTexture[TEXTURE_BALLOON].texture->free();
|
|
mTexture[TEXTURE_BULLET].texture->free();
|
|
mTexture[TEXTURE_GAME_BG].texture->free();
|
|
mTexture[TEXTURE_GAME_TEXT].texture->free();
|
|
mTexture[TEXTURE_ITEMS].texture->free();
|
|
|
|
// Sonidos
|
|
JA_DeleteSound(mSound[SOUND_BALLON].sound);
|
|
JA_DeleteSound(mSound[SOUND_BULLET].sound);
|
|
JA_DeleteSound(mSound[SOUND_PLAYER_COLLISION].sound);
|
|
JA_DeleteSound(mSound[SOUND_HISCORE].sound);
|
|
JA_DeleteSound(mSound[SOUND_ITEM_DROP].sound);
|
|
JA_DeleteSound(mSound[SOUND_ITEM_PICKUP].sound);
|
|
JA_DeleteSound(mSound[SOUND_COFFEE_OUT].sound);
|
|
JA_DeleteSound(mSound[SOUND_STAGE_CHANGE].sound);
|
|
JA_DeleteSound(mSound[SOUND_TITLE].sound);
|
|
JA_DeleteSound(mSound[SOUND_BUBBLE1].sound);
|
|
JA_DeleteSound(mSound[SOUND_BUBBLE2].sound);
|
|
JA_DeleteSound(mSound[SOUND_BUBBLE3].sound);
|
|
JA_DeleteSound(mSound[SOUND_BUBBLE4].sound);
|
|
|
|
// Musicas
|
|
JA_DeleteMusic(mMusic[MUSIC_PLAYING].music);
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_GAME_OVER_SCREEN:
|
|
{
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_INTRO:
|
|
{
|
|
// Texturas
|
|
mTexture[TEXTURE_INTRO].texture->free();
|
|
|
|
// Musicas
|
|
JA_DeleteMusic(mMusic[MUSIC_INTRO].music);
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_DEMO:
|
|
{
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_INSTRUCTIONS:
|
|
{
|
|
// Texturas
|
|
mTexture[TEXTURE_ITEMS].texture->free();
|
|
}
|
|
break;
|
|
|
|
case GAME_STATE_LOGO:
|
|
{
|
|
// Texturas
|
|
mTexture[TEXTURE_LOGO].texture->free();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
}
|
|
break;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void GameDirector::setExecutablePath(std::string path)
|
|
{
|
|
mExecutablePath = path.substr(0, path.find_last_of("\\/"));
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void GameDirector::setScore(Uint32 score)
|
|
{
|
|
mGame.score = score;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void GameDirector::setHiScore(Uint32 score)
|
|
{
|
|
mGame.hiScore = score;
|
|
}
|
|
|
|
// Actualiza el valor de HiScore en caso necesario
|
|
void GameDirector::updateHiScore()
|
|
{
|
|
// La puntuación es mayor que la máxima puntuación
|
|
if (mGame.score > mGame.hiScore)
|
|
{
|
|
// Actualiza la máxima puntuación
|
|
mGame.hiScore = mGame.score;
|
|
|
|
// Almacena la máxima puntuación en el fichero junto con un checksum
|
|
mScoreDataFile[0] = mGame.hiScore;
|
|
mScoreDataFile[1] = mGame.hiScore % 43;
|
|
|
|
// Si superamos la máxima puntuación
|
|
if (mGame.hiScoreAchieved == false)
|
|
{
|
|
mGame.hiScoreAchieved = true;
|
|
JA_PlaySound(mSound[SOUND_HISCORE].sound);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Transforma un valor numérico en una cadena de 6 cifras
|
|
std::string GameDirector::updateScoreText(Uint32 num)
|
|
{
|
|
if ((num >= 0) && (num <= 9))
|
|
{
|
|
return ("00000" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 10) && (num <= 99))
|
|
{
|
|
return ("0000" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 100) && (num <= 999))
|
|
{
|
|
return ("000" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 1000) && (num <= 9999))
|
|
{
|
|
return ("00" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 010000) && (num <= 99999))
|
|
{
|
|
return ("0" + std::to_string(num));
|
|
}
|
|
|
|
if ((num >= 100000) && (num <= 999999))
|
|
{
|
|
return (std::to_string(num));
|
|
}
|
|
|
|
return (std::to_string(num));
|
|
}
|
|
|
|
// Pinta el marcador en pantalla usando un objeto texto
|
|
void GameDirector::renderScoreBoard()
|
|
{
|
|
mText.white->write(SCORE_WORD_X, SCORE_WORD_Y, "SCORE", 0);
|
|
mText.white->write(SCORE_NUMBER_X, SCORE_NUMBER_Y, updateScoreText(mGame.score), 0);
|
|
|
|
mText.white->write(MULTIPLIER_WORD_X, MULTIPLIER_WORD_Y, "MULT", 0);
|
|
mText.white->write(MULTIPLIER_NUMBER_X, MULTIPLIER_NUMBER_Y, std::to_string(mPlayer->getScoreMultiplier()), 0, 3);
|
|
|
|
mText.white->write(HISCORE_WORD_X, HISCORE_WORD_Y, "HI-SCORE", 0);
|
|
mText.white->write(HISCORE_NUMBER_X, HISCORE_NUMBER_Y, updateScoreText(mGame.hiScore), 0);
|
|
}
|
|
|
|
// Actualiza el valor de la variable mGame.stage
|
|
void GameDirector::updateStage()
|
|
{
|
|
Uint8 realStage;
|
|
realStage = (mGame.score / 10000) + 1;
|
|
if (realStage > mGame.stage)
|
|
{
|
|
mGame.stage = realStage;
|
|
JA_PlaySound(mSound[SOUND_STAGE_CHANGE].sound);
|
|
mGame.stageCounter = STAGE_COUNTER;
|
|
}
|
|
|
|
if (mGame.stageCounter > 0)
|
|
{
|
|
mGame.stageCounter--;
|
|
}
|
|
}
|
|
|
|
// Actualiza el estado de muerte
|
|
void GameDirector::updateDeath()
|
|
{
|
|
if (!mPlayer->isAlive())
|
|
{
|
|
if (mGame.deathCounter > 0)
|
|
{
|
|
mGame.deathCounter--;
|
|
if ((mGame.deathCounter == 250) || (mGame.deathCounter == 200) || (mGame.deathCounter == 180) || (mGame.deathCounter == 120) || (mGame.deathCounter == 60))
|
|
{
|
|
Uint8 sound = rand() % 4;
|
|
switch (sound)
|
|
{
|
|
case 0:
|
|
JA_PlaySound(mSound[SOUND_BUBBLE1].sound, 0);
|
|
break;
|
|
case 1:
|
|
JA_PlaySound(mSound[SOUND_BUBBLE2].sound, 0);
|
|
break;
|
|
case 2:
|
|
JA_PlaySound(mSound[SOUND_BUBBLE3].sound, 0);
|
|
break;
|
|
case 3:
|
|
JA_PlaySound(mSound[SOUND_BUBBLE4].sound, 0);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Animación
|
|
if ((mGame.deathCounter / 5) % 2 == 0)
|
|
{
|
|
mSmartSprite[mGame.deathIndex]->setSpriteClip(0, 0, 24, 24);
|
|
}
|
|
else
|
|
{
|
|
mSmartSprite[mGame.deathIndex]->setSpriteClip(24, 0, 24, 24);
|
|
}
|
|
|
|
// Rebote en los laterales
|
|
if (mSmartSprite[mGame.deathIndex]->getVelX() > 0)
|
|
{
|
|
if (mSmartSprite[mGame.deathIndex]->getPosX() > (SCREEN_WIDTH - mSmartSprite[mGame.deathIndex]->getWidth()))
|
|
{
|
|
mSmartSprite[mGame.deathIndex]->setPosX(SCREEN_WIDTH - mSmartSprite[mGame.deathIndex]->getWidth());
|
|
mSmartSprite[mGame.deathIndex]->setVelX(mSmartSprite[mGame.deathIndex]->getVelX() * (-1));
|
|
mSmartSprite[mGame.deathIndex]->setDestX(mSmartSprite[mGame.deathIndex]->getDestX() * (-1));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (mSmartSprite[mGame.deathIndex]->getPosX() < 0)
|
|
{
|
|
mSmartSprite[mGame.deathIndex]->setPosX(0);
|
|
mSmartSprite[mGame.deathIndex]->setVelX(mSmartSprite[mGame.deathIndex]->getVelX() * (-1));
|
|
mSmartSprite[mGame.deathIndex]->setDestX(mSmartSprite[mGame.deathIndex]->getDestX() * (-1));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
setGameStatus(GAME_STATE_GAME_OVER_SCREEN);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Renderiza el fade final cuando se acaba la partida
|
|
void GameDirector::renderDeathFade()
|
|
{
|
|
if (!mPlayer->isAlive() && (mGame.deathCounter < 150))
|
|
{
|
|
// 192 / 6 = 32, 6 cuadrados de 32 pixeles
|
|
SDL_Rect rect[12];
|
|
Uint8 h = (150 - mGame.deathCounter) / 3;
|
|
SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255);
|
|
for (Uint8 i = 0; i < 12; i++)
|
|
{
|
|
rect[i].x = 0;
|
|
rect[i].y = i * 16;
|
|
rect[i].w = SCREEN_WIDTH;
|
|
if (i == 0)
|
|
rect[i].h = h;
|
|
else
|
|
rect[i].h = std::max(rect[i - 1].h - 3, 0);
|
|
SDL_RenderFillRect(mRenderer, &rect[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mueve todos los globos activos
|
|
void GameDirector::moveBalloons()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
if (mBalloon[i]->isActive())
|
|
{
|
|
mBalloon[i]->update();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pinta en pantalla todos los globos activos
|
|
void GameDirector::renderBalloons()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
if (mBalloon[i]->isActive())
|
|
{
|
|
mBalloon[i]->render();
|
|
if ((mDebug) && (mBalloon[i]->isPopping() == false))
|
|
mText.white->write(mBalloon[i]->getPosX() + (mBalloon[i]->getWidth() / 2) - 4, mBalloon[i]->getPosY() - 8, std::to_string(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Devuelve el primer indice no activo del vector de globos
|
|
Uint8 GameDirector::getBallonFreeIndex()
|
|
{
|
|
int index = 0;
|
|
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
if (mBalloon[i]->isActive() == false)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
// Crea un globo nuevo en el vector de globos
|
|
Uint8 GameDirector::createNewBalloon(float x, int y, Uint8 kind, float velx, Uint16 creationtimer, LTexture *texture)
|
|
{
|
|
Uint8 index = getBallonFreeIndex();
|
|
mBalloon[index]->init(x, y, kind, velx, creationtimer, texture, mRenderer);
|
|
return index;
|
|
}
|
|
|
|
// Establece a cero todos los valores del vector de objetos globo
|
|
void GameDirector::resetBalloons()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
mBalloon[i]->erase();
|
|
}
|
|
}
|
|
|
|
// Explosiona un globo. Lo destruye y crea otros dos si es el caso
|
|
void GameDirector::popBalloon(Uint8 index)
|
|
{
|
|
if (mBalloon[index]->isActive())
|
|
{
|
|
// Otorga los puntos correspondientes al globo
|
|
mPlayer->addScore(Uint32(mBalloon[index]->getScore() * mPlayer->getScoreMultiplier()));
|
|
setScore(mPlayer->getScore());
|
|
updateHiScore();
|
|
|
|
Uint8 kind = mBalloon[index]->getKind();
|
|
Uint8 freeIndex = 0;
|
|
switch (kind)
|
|
{
|
|
// Si es del tipo más pequeño, simplemente elimina el globo
|
|
case BALLOON_1:
|
|
mBalloon[index]->pop();
|
|
break;
|
|
|
|
// En cualquier otro caso, crea dos globos de un tipo inferior
|
|
default:
|
|
freeIndex = getBallonFreeIndex();
|
|
mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLON_VELX_NEGATIVE, 0, mTexture[TEXTURE_BALLOON].texture, mRenderer);
|
|
mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2));
|
|
mBalloon[freeIndex]->setVelY(-2.5);
|
|
// if (isTimeStopped()) mBalloon[freeIndex]->setStop(true);
|
|
|
|
freeIndex = getBallonFreeIndex();
|
|
mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLON_VELX_POSITIVE, 0, mTexture[TEXTURE_BALLOON].texture, mRenderer);
|
|
mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2));
|
|
mBalloon[freeIndex]->setVelY(-2.5);
|
|
// if (isTimeStopped()) mBalloon[freeIndex]->setStop(true);
|
|
|
|
// Elimina el globo
|
|
mBalloon[index]->pop();
|
|
break;
|
|
}
|
|
// Reproduce el sonido de explotar el globo
|
|
// JA_PlaySound(mFX.popBalloon);
|
|
|
|
// Recalcula el nivel de amenaza
|
|
calculateMenaceLevel();
|
|
}
|
|
}
|
|
|
|
// Explosiona todos los globos
|
|
void GameDirector::popAllBallons()
|
|
{
|
|
int candidate[MAX_BALLOONS];
|
|
Uint8 j = 0;
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
if ((mBalloon[i]->isActive()) && (mBalloon[i]->isPopping() == false) && (mBalloon[i]->isBeingCreated() == false))
|
|
{
|
|
candidate[j] = i;
|
|
}
|
|
else
|
|
{
|
|
candidate[j] = -1;
|
|
}
|
|
j += 1;
|
|
}
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
if (candidate[i] >= 0)
|
|
{
|
|
popBalloon(i);
|
|
}
|
|
}
|
|
JA_PlaySound(mSound[SOUND_BALLON].sound);
|
|
}
|
|
|
|
// Detiene todos los globos
|
|
void GameDirector::stopAllBalloons(Uint16 time)
|
|
{
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
if (mBalloon[i]->isActive())
|
|
{
|
|
mBalloon[i]->setStop(true);
|
|
mBalloon[i]->setStoppedTimer(time);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pone en marcha todos los globos
|
|
void GameDirector::startAllBalloons()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
if ((mBalloon[i]->isActive()) && (mBalloon[i]->isBeingCreated() == false))
|
|
{
|
|
mBalloon[i]->setStop(false);
|
|
mBalloon[i]->setStoppedTimer(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Obtiene el numero de globos activos
|
|
Uint8 GameDirector::countBalloons()
|
|
{
|
|
Uint8 num = 0;
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
if (mBalloon[i]->isActive())
|
|
{
|
|
++num;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Comprueba la colisión entre el jugador y los globos activos
|
|
bool GameDirector::checkPlayerBallonCollision()
|
|
|
|
{
|
|
bool result = false;
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
//if ((mBalloon[i]->isActive()) && (mBalloon[i]->isStopped() == false))
|
|
if ((mBalloon[i]->isActive()) && !(mBalloon[i]->isStopped()) && !(mBalloon[i]->isInvulnerable()))
|
|
{
|
|
if (checkCollision(mPlayer->getCollider(), mBalloon[i]->getCollider()))
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Comprueba la colisión entre el jugador y los items
|
|
void GameDirector::checkPlayerItemCollision()
|
|
{
|
|
if (mPlayer->isAlive())
|
|
for (Uint8 i = 0; i < MAX_ITEMS; i++)
|
|
{
|
|
if (mItem[i]->isEnabled())
|
|
{
|
|
if (checkCollision(mPlayer->getCollider(), mItem[i]->getCollider()))
|
|
{
|
|
switch (mItem[i]->getClass())
|
|
{
|
|
case ITEM_POINTS_1_DISK:
|
|
mPlayer->addScore(1000);
|
|
setScore(mPlayer->getScore());
|
|
updateHiScore();
|
|
createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m1000Bitmap->getWidth() / 2), mItem[i]->getPosY(), m1000Bitmap);
|
|
JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound);
|
|
break;
|
|
case ITEM_POINTS_2_GAVINA:
|
|
mPlayer->addScore(2500);
|
|
setScore(mPlayer->getScore());
|
|
updateHiScore();
|
|
createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m2500Bitmap->getWidth() / 2), mItem[i]->getPosY(), m2500Bitmap);
|
|
JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound);
|
|
break;
|
|
case ITEM_POINTS_3_PACMAR:
|
|
mPlayer->addScore(5000);
|
|
setScore(mPlayer->getScore());
|
|
updateHiScore();
|
|
createItemScoreSprite(mItem[i]->getPosX() + (mItem[i]->getWidth() / 2) - (m5000Bitmap->getWidth() / 2), mItem[i]->getPosY(), m5000Bitmap);
|
|
JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound);
|
|
break;
|
|
case ITEM_CLOCK:
|
|
enableTimeStopItem();
|
|
JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound);
|
|
break;
|
|
case ITEM_TNT:
|
|
popAllBallons();
|
|
setExplosionTime(true);
|
|
JA_PlaySound(mSound[SOUND_TITLE].sound);
|
|
break;
|
|
case ITEM_COFFEE:
|
|
mPlayer->giveExtraHit();
|
|
JA_PlaySound(mSound[SOUND_ITEM_PICKUP].sound);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
mItem[i]->erase();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Comprueba y procesa la colisión entre las balas y los globos
|
|
void GameDirector::checkBulletBallonCollision()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
for (Uint8 j = 0; j < MAX_BULLETS; j++)
|
|
{
|
|
if (mBalloon[i]->isActive() && !(mBalloon[i]->isInvulnerable()) && mBullet[j]->isActive())
|
|
{
|
|
if (checkCollision(mBalloon[i]->getCollider(), mBullet[j]->getCollider()))
|
|
{
|
|
mPlayer->incScoreMultiplier();
|
|
popBalloon(i);
|
|
if (mDemo == false)
|
|
JA_PlaySound(mSound[SOUND_BALLON].sound);
|
|
mBullet[j]->erase();
|
|
calculateMenaceLevel();
|
|
Uint8 droppeditem = dropItem();
|
|
if ((droppeditem != NO_KIND) && (mDemo == false) && (mDemoRecording == false))
|
|
{
|
|
createItem(mBalloon[i]->getPosX(), mBalloon[i]->getPosY(), droppeditem);
|
|
JA_PlaySound(mSound[SOUND_ITEM_DROP].sound);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Mueve las balas activas
|
|
void GameDirector::moveBullets()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_BULLETS; i++)
|
|
{
|
|
if (mBullet[i]->isActive())
|
|
{
|
|
if (mBullet[i]->move() == MSG_BULLET_OUT)
|
|
{
|
|
mPlayer->decScoreMultiplier();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pinta las balas activas
|
|
void GameDirector::renderBullets()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_BULLETS; i++)
|
|
{
|
|
if (mBullet[i]->isActive())
|
|
{
|
|
mBullet[i]->render();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Devuelve el primer indice no activo del vector de balas
|
|
Uint8 GameDirector::getBulletFreeIndex()
|
|
{
|
|
Uint8 index = 0;
|
|
|
|
for (int i = 0; i < MAX_BULLETS; i++)
|
|
{
|
|
if (mBullet[i]->isActive() == false)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
// Establece a cero todos los valores del vector de objetos bala
|
|
void GameDirector::resetBullets()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_BULLETS; i++)
|
|
{
|
|
mBullet[i]->erase();
|
|
}
|
|
}
|
|
|
|
// Crea un objeto bala
|
|
void GameDirector::createBullet(int x, int y, Uint8 kind)
|
|
{
|
|
mBullet[getBulletFreeIndex()]->init(x, y, kind, mTexture[TEXTURE_BULLET].texture, mRenderer);
|
|
}
|
|
|
|
// Actualiza los items
|
|
void GameDirector::updateItems()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_ITEMS; i++)
|
|
{
|
|
mItem[i]->update();
|
|
}
|
|
}
|
|
|
|
// Pinta los items activos
|
|
void GameDirector::renderItems()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_ITEMS; i++)
|
|
{
|
|
mItem[i]->render();
|
|
}
|
|
}
|
|
|
|
// Devuelve el primer indice no activo del vector de items
|
|
Uint8 GameDirector::getItemFreeIndex()
|
|
{
|
|
Uint8 index = 0;
|
|
|
|
for (int i = 0; i < MAX_ITEMS; i++)
|
|
{
|
|
if (mItem[i]->getClass() == NO_KIND)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
// Establece a cero todos los valores del vector de objetos item
|
|
void GameDirector::resetItems()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_ITEMS; i++)
|
|
{
|
|
mItem[i]->erase();
|
|
}
|
|
}
|
|
|
|
// Devuelve un item en función del azar
|
|
Uint8 GameDirector::dropItem()
|
|
{
|
|
// return ITEM_COFFEE;
|
|
Uint8 luckyNumber = rand() % 99;
|
|
Uint8 item = rand() % 6;
|
|
switch (item)
|
|
{
|
|
case 0:
|
|
if (luckyNumber < 10)
|
|
{
|
|
return ITEM_POINTS_1_DISK;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (luckyNumber < 6)
|
|
{
|
|
return ITEM_POINTS_2_GAVINA;
|
|
}
|
|
break;
|
|
case 2:
|
|
if (luckyNumber < 3)
|
|
{
|
|
return ITEM_POINTS_3_PACMAR;
|
|
}
|
|
break;
|
|
case 3:
|
|
if (luckyNumber < 5)
|
|
{
|
|
return ITEM_CLOCK;
|
|
}
|
|
break;
|
|
case 4:
|
|
if (luckyNumber < 5)
|
|
{
|
|
return ITEM_TNT;
|
|
}
|
|
break;
|
|
case 5:
|
|
if (luckyNumber < 5)
|
|
{
|
|
return ITEM_COFFEE;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return NO_KIND;
|
|
}
|
|
|
|
// Crea un objeto item
|
|
void GameDirector::createItem(int x, int y, Uint8 kind)
|
|
{
|
|
mItem[getItemFreeIndex()]->init(kind, x, y, mTexture[TEXTURE_ITEMS].texture, mRenderer);
|
|
}
|
|
|
|
// Crea un objeto SmartSprite para mostrar la puntuación al coger un objeto
|
|
void GameDirector::createItemScoreSprite(int x, int y, SmartSprite *sprite)
|
|
{
|
|
Uint8 index = getSmartSpriteFreeIndex();
|
|
*mSmartSprite[index] = *sprite;
|
|
mSmartSprite[index]->setPosX(x);
|
|
mSmartSprite[index]->setPosY(y);
|
|
mSmartSprite[index]->setDestX(x);
|
|
mSmartSprite[index]->setDestY(y - 15);
|
|
mSmartSprite[index]->setEnabled(true);
|
|
mSmartSprite[index]->setEnabledTimer(100);
|
|
}
|
|
|
|
// Crea un SmartSprite para arrojar el item café al recibir un impacto
|
|
void GameDirector::throwCoffee(int x, int y)
|
|
{
|
|
Uint8 index = getSmartSpriteFreeIndex();
|
|
mSmartSprite[index]->init(mTexture[TEXTURE_ITEMS].texture, mRenderer);
|
|
mSmartSprite[index]->setPosX(x - 8);
|
|
mSmartSprite[index]->setPosY(y - 8);
|
|
mSmartSprite[index]->setWidth(16);
|
|
mSmartSprite[index]->setHeight(16);
|
|
mSmartSprite[index]->setVelX(-1.0f + ((rand() % 5) * 0.5f));
|
|
mSmartSprite[index]->setVelY(-4.0f);
|
|
mSmartSprite[index]->setAccelX(0.0f);
|
|
mSmartSprite[index]->setAccelY(0.2f);
|
|
mSmartSprite[index]->setDestX(x + (mSmartSprite[index]->getVelX() * 50));
|
|
mSmartSprite[index]->setDestY(SCREEN_HEIGHT + 1);
|
|
mSmartSprite[index]->setEnabled(true);
|
|
mSmartSprite[index]->setEnabledTimer(1);
|
|
mSmartSprite[index]->setSpriteClip(80, 16, 16, 16);
|
|
}
|
|
|
|
// Crea un SmartSprite para arrojar el item café al recibir un impacto
|
|
void GameDirector::throwPlayer(int x, int y)
|
|
{
|
|
int sentit = ((rand() % 2) ? 1 : -1);
|
|
mGame.deathIndex = getSmartSpriteFreeIndex();
|
|
mSmartSprite[mGame.deathIndex]->init(mTexture[TEXTURE_PLAYER_DEATH].texture, mRenderer);
|
|
mSmartSprite[mGame.deathIndex]->setPosX(x);
|
|
mSmartSprite[mGame.deathIndex]->setPosY(y);
|
|
mSmartSprite[mGame.deathIndex]->setWidth(24);
|
|
mSmartSprite[mGame.deathIndex]->setHeight(24);
|
|
mSmartSprite[mGame.deathIndex]->setVelX(2.0f * sentit);
|
|
mSmartSprite[mGame.deathIndex]->setVelY(-5.0f);
|
|
mSmartSprite[mGame.deathIndex]->setAccelX(0.0f);
|
|
mSmartSprite[mGame.deathIndex]->setAccelY(0.2f);
|
|
mSmartSprite[mGame.deathIndex]->setDestX(SCREEN_WIDTH * sentit);
|
|
mSmartSprite[mGame.deathIndex]->setDestY(SCREEN_HEIGHT + 1);
|
|
mSmartSprite[mGame.deathIndex]->setEnabled(true);
|
|
mSmartSprite[mGame.deathIndex]->setEnabledTimer(1);
|
|
mSmartSprite[mGame.deathIndex]->setSpriteClip(0, 0, 24, 24);
|
|
}
|
|
|
|
// Actualiza los SmartSprites
|
|
void GameDirector::updateSmartSprites()
|
|
{
|
|
for (int i = 0; i < MAX_SMART_SPRITES; i++)
|
|
{
|
|
mSmartSprite[i]->update();
|
|
}
|
|
}
|
|
|
|
// Pinta los SmartSprites activos
|
|
void GameDirector::renderSmartSprites()
|
|
{
|
|
for (int i = 0; i < MAX_SMART_SPRITES; i++)
|
|
{
|
|
mSmartSprite[i]->render();
|
|
}
|
|
}
|
|
|
|
// Devuelve el primer indice no activo del vector de SmartSprites
|
|
Uint8 GameDirector::getSmartSpriteFreeIndex()
|
|
{
|
|
Uint8 index = 0;
|
|
|
|
for (int i = 0; i < MAX_SMART_SPRITES; i++)
|
|
{
|
|
if (mSmartSprite[i]->isEnabled() == false)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
// Establece a cero todos los valores del vector de objetos SmafrtSprite
|
|
void GameDirector::resetSmartSprites()
|
|
{
|
|
for (Uint8 i = 0; i < MAX_SMART_SPRITES; i++)
|
|
{
|
|
mSmartSprite[i]->erase();
|
|
}
|
|
}
|
|
|
|
// Acciones a realizar cuando el jugador muere
|
|
void GameDirector::killPlayer()
|
|
{
|
|
if (mPlayer->hasExtraHit())
|
|
{
|
|
mPlayer->removeExtraHit();
|
|
throwCoffee(mPlayer->getPosX() + (mPlayer->getWidth() / 2), mPlayer->getPosY() + (mPlayer->getHeight() / 2));
|
|
JA_PlaySound(mSound[SOUND_COFFEE_OUT].sound);
|
|
}
|
|
else if (!mPlayer->isInvulnerable())
|
|
{
|
|
stopAllBalloons(10); // 5000
|
|
JA_StopMusic();
|
|
JA_PlaySound(mSound[SOUND_PLAYER_COLLISION].sound);
|
|
shakeScreen();
|
|
SDL_Delay(500); // 1000
|
|
JA_PlaySound(mSound[SOUND_COFFEE_OUT].sound);
|
|
throwPlayer(mPlayer->getPosX(), mPlayer->getPosY());
|
|
mPlayer->setAlive(false);
|
|
}
|
|
}
|
|
|
|
// Calcula y establece el valor de amenaza en funcion de los globos activos
|
|
void GameDirector::calculateMenaceLevel()
|
|
{
|
|
mMenaceLevel = 0;
|
|
for (Uint8 i = 0; i < MAX_BALLOONS; i++)
|
|
{
|
|
mMenaceLevel += mBalloon[i]->getMenace();
|
|
}
|
|
}
|
|
|
|
// Obtiene el valor de la variable
|
|
Uint8 GameDirector::getMenaceLevel()
|
|
{
|
|
return mMenaceLevel;
|
|
}
|
|
|
|
// Obtiene el valor de la variable
|
|
bool GameDirector::isPlayFieldDrawOnly()
|
|
{
|
|
return mPlayFieldDrawOnly;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void GameDirector::setPlayFieldDrawOnly(bool state)
|
|
{
|
|
mPlayFieldDrawOnly = state;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void GameDirector::setTimeStopped(bool value)
|
|
{
|
|
mTimeStopped = value;
|
|
}
|
|
|
|
// Obtiene el valor de la variable
|
|
bool GameDirector::isTimeStopped()
|
|
{
|
|
return mTimeStopped;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void GameDirector::setTimeStoppedTimer(Uint16 value)
|
|
{
|
|
mTimeStoppedTimer = value;
|
|
}
|
|
|
|
// Actualiza y comprueba el valor de la variable
|
|
void GameDirector::updateTimeStoppedTimer()
|
|
{
|
|
if (isTimeStopped())
|
|
{
|
|
if (mTimeStoppedTimer > 0)
|
|
{
|
|
mTimeStoppedTimer--;
|
|
stopAllBalloons(TIME_STOPPED_TIMER);
|
|
}
|
|
else
|
|
{
|
|
disableTimeStopItem();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void GameDirector::setExplosionTime(bool value)
|
|
{
|
|
mExplosionTime = value;
|
|
}
|
|
|
|
// Obtiene el valor de la variable
|
|
bool GameDirector::isExplosionTime()
|
|
{
|
|
return mExplosionTime;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void GameDirector::setRemainingExplosions(Uint8 value)
|
|
{
|
|
mRemainingExplosions = value;
|
|
}
|
|
|
|
// Actualiza y comprueba el valor de la variable
|
|
void GameDirector::updateRemainingExplosionsTimer()
|
|
{
|
|
if (isExplosionTime())
|
|
{
|
|
if (mRemainingExplosionsTimer > 0)
|
|
{
|
|
--mRemainingExplosionsTimer;
|
|
}
|
|
else if (mRemainingExplosions > 0)
|
|
{
|
|
popAllBallons();
|
|
--mRemainingExplosions;
|
|
mRemainingExplosionsTimer = REMAINING_EXPLOSIONS_TIMER;
|
|
}
|
|
else
|
|
{
|
|
mExplosionTime = false;
|
|
mRemainingExplosions = REMAINING_EXPLOSIONS;
|
|
mRemainingExplosionsTimer = REMAINING_EXPLOSIONS_TIMER;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Actualiza el campo de juego
|
|
void GameDirector::updatePlayField()
|
|
{
|
|
if (isPlayFieldDrawOnly() == false)
|
|
{
|
|
// Comprueba el teclado/mando
|
|
checkGameInput();
|
|
|
|
// Actualiza el jugador
|
|
mPlayer->update();
|
|
|
|
// Mueve los globos
|
|
moveBalloons();
|
|
|
|
// Mueve las balas
|
|
moveBullets();
|
|
|
|
// Actualiza los items
|
|
updateItems();
|
|
|
|
// Actualiza el valor de mGame.stage
|
|
updateStage();
|
|
|
|
// Actualiza el estado de muerte
|
|
updateDeath();
|
|
|
|
// Actualiza los SmartSprites
|
|
updateSmartSprites();
|
|
|
|
// Actualiza los contadores de estado
|
|
updateTimeStoppedTimer();
|
|
updateRemainingExplosionsTimer();
|
|
|
|
// Comprueba las colisiones entre globos y balas
|
|
checkBulletBallonCollision();
|
|
|
|
// Comprueba las colisiones entre elk jugador y los items
|
|
checkPlayerItemCollision();
|
|
|
|
// Comprueba el nivel de amenaza
|
|
checkMenaceLevel();
|
|
|
|
// Comprueba la colisión entre el jugador y los globos
|
|
if (checkPlayerBallonCollision())
|
|
{
|
|
if (mPlayer->isAlive())
|
|
{
|
|
if (mDemo)
|
|
{
|
|
mGame.status = GAME_STATE_INSTRUCTIONS;
|
|
}
|
|
else
|
|
{
|
|
killPlayer();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Actualiza el mensaje de GetReady
|
|
mGetReadyBitmap->update();
|
|
}
|
|
}
|
|
|
|
// Actualiza el fondo
|
|
void GameDirector::updateBackground()
|
|
{
|
|
mGBClouds1->move();
|
|
mGBClouds1b->move();
|
|
mGBClouds2->move();
|
|
mGBClouds2b->move();
|
|
if (mGBClouds1->getPosX() < -mGBClouds1->getWidth())
|
|
{
|
|
mGBClouds1->setPosX(mGBClouds1->getWidth());
|
|
}
|
|
if (mGBClouds1b->getPosX() < -mGBClouds1b->getWidth())
|
|
{
|
|
mGBClouds1b->setPosX(mGBClouds1b->getWidth());
|
|
}
|
|
if (mGBClouds2->getPosX() < -mGBClouds2->getWidth())
|
|
{
|
|
mGBClouds2->setPosX(mGBClouds2->getWidth());
|
|
}
|
|
if (mGBClouds2b->getPosX() < -mGBClouds2b->getWidth())
|
|
{
|
|
mGBClouds2b->setPosX(mGBClouds2b->getWidth());
|
|
}
|
|
mGrass->setSpriteClip(256, 85 + (6 * (mGameCounter / 20 % 2)), SCREEN_WIDTH, 6);
|
|
}
|
|
|
|
// Dibuja el fondo
|
|
void GameDirector::renderBackground()
|
|
{
|
|
int alpha = (255 - (mGame.score / 392));
|
|
|
|
if (alpha < 0)
|
|
{
|
|
alpha = 0;
|
|
}
|
|
|
|
updateBackground();
|
|
mGameBackgroundSky->setSpriteClip(SCREEN_WIDTH, 192, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
mTexture[TEXTURE_GAME_BG].texture->setAlpha(255);
|
|
mGameBackgroundSky->render();
|
|
|
|
mGameBackgroundSky->setSpriteClip(0, 192, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
mTexture[TEXTURE_GAME_BG].texture->setAlpha(alpha);
|
|
mGameBackgroundSky->render();
|
|
|
|
mTexture[TEXTURE_GAME_BG].texture->setAlpha(255);
|
|
mGBClouds1->render();
|
|
mGBClouds1b->render();
|
|
mGBClouds2->render();
|
|
mGBClouds2b->render();
|
|
mGameBackgroundFront->render();
|
|
mGrass->render();
|
|
}
|
|
|
|
// Dibuja el campo de juego
|
|
void GameDirector::renderPlayField()
|
|
{
|
|
renderBackground();
|
|
renderBalloons();
|
|
renderBullets();
|
|
renderItems();
|
|
renderSmartSprites();
|
|
mPlayer->render();
|
|
renderDeathFade();
|
|
if (!mDemo)
|
|
{
|
|
renderScoreBoard();
|
|
}
|
|
else
|
|
{
|
|
mText.nokia->writeCentered(SCREEN_FIRST_QUARTER_X, SCORE_WORD_Y - 3, "A game by", -1);
|
|
mText.nokia->writeCentered(SCREEN_FIRST_QUARTER_X, SCORE_NUMBER_Y, "JailDesigner", -1);
|
|
mText.nokia->writeCentered(SCREEN_THIRD_QUARTER_X, HISCORE_WORD_Y - 3, "Intro music by", -1);
|
|
mText.nokia->writeCentered(SCREEN_THIRD_QUARTER_X, HISCORE_NUMBER_Y, "JailDoctor", -1);
|
|
}
|
|
renderMessages();
|
|
renderDebugInfo();
|
|
}
|
|
|
|
// Gestiona el nivel de amenaza
|
|
void GameDirector::checkMenaceLevel()
|
|
{
|
|
// Aumenta el nivel de amenaza en función de la puntuación
|
|
mMenaceLevelThreshold = 7 + (4 * (mGame.score / 10000));
|
|
|
|
// Si el nivel de amenza es inferior al umbral
|
|
if (mMenaceLevel < mMenaceLevelThreshold)
|
|
{
|
|
Uint8 index = 0;
|
|
|
|
// Obtiene el centro del jugador en el eje X
|
|
int x = mPlayer->getPosX() + (mPlayer->getWidth() / 2);
|
|
|
|
// Crea un globo sobre el jugador en dirección hacia el centro
|
|
if (x < (PLAY_AREA_WIDTH / 2))
|
|
{
|
|
index = createNewBalloon(0, PLAY_AREA_TOP + BLOCK - 37, BALLOON_4, BALLON_VELX_POSITIVE, 400, mTexture[TEXTURE_BALLOON].texture);
|
|
}
|
|
else
|
|
{
|
|
index = createNewBalloon(0, PLAY_AREA_TOP + BLOCK - 37, BALLOON_4, BALLON_VELX_NEGATIVE, 400, mTexture[TEXTURE_BALLOON].texture);
|
|
}
|
|
mBalloon[index]->allignTo(x);
|
|
|
|
// Recalcula el nivel de amenaza con el nuevo globo
|
|
calculateMenaceLevel();
|
|
}
|
|
}
|
|
|
|
// Gestiona las entradas desde el mando de juego
|
|
bool GameDirector::checkGameController(Uint8 state)
|
|
{
|
|
// No hay mando. Siempre devuelve falso salvo NO_INPUT que siempre es cierto
|
|
if (!mGameControllerFound)
|
|
{
|
|
if (state == NO_INPUT)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool success = false;
|
|
|
|
switch (state)
|
|
{
|
|
case NO_INPUT:
|
|
success = !checkGameController(INPUT_UP) && !checkGameController(INPUT_DOWN) && !checkGameController(INPUT_LEFT) && !checkGameController(INPUT_RIGHT) &&
|
|
!checkGameController(INPUT_ACCEPT) && !checkGameController(INPUT_CANCEL) && !checkGameController(INPUT_PAUSE) &&
|
|
!checkGameController(INPUT_FIRE_UP) && !checkGameController(INPUT_FIRE_LEFT) && !checkGameController(INPUT_FIRE_RIGHT);
|
|
break;
|
|
case INPUT_UP:
|
|
success = (SDL_JoystickGetAxis(mGameController, 1) < -JOYSTICK_DEAD_ZONE) || (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_DPAD_UP));
|
|
break;
|
|
case INPUT_DOWN:
|
|
success = (SDL_JoystickGetAxis(mGameController, 1) > JOYSTICK_DEAD_ZONE) || (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_DPAD_DOWN));
|
|
break;
|
|
case INPUT_LEFT:
|
|
success = (SDL_JoystickGetAxis(mGameController, 0) < -JOYSTICK_DEAD_ZONE) || (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_DPAD_LEFT));
|
|
break;
|
|
case INPUT_RIGHT:
|
|
success = (SDL_JoystickGetAxis(mGameController, 0) > JOYSTICK_DEAD_ZONE) || (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_DPAD_RIGHT));
|
|
break;
|
|
case INPUT_ACCEPT:
|
|
success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_B));
|
|
break;
|
|
case INPUT_CANCEL:
|
|
success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_A));
|
|
break;
|
|
case INPUT_PAUSE:
|
|
success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_START));
|
|
break;
|
|
case INPUT_FIRE_UP:
|
|
success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_Y));
|
|
break;
|
|
case INPUT_FIRE_LEFT:
|
|
success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_X));
|
|
break;
|
|
case INPUT_FIRE_RIGHT:
|
|
success = (SDL_JoystickGetButton(mGameController, SDL_CONTROLLER_BUTTON_B));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return success;
|
|
}
|
|
|
|
// Gestiona la entrada durante el juego
|
|
void GameDirector::checkGameInput()
|
|
{
|
|
// Obtiene el estado de las teclas pulsadas del teclado
|
|
keystates = SDL_GetKeyboardState(NULL);
|
|
|
|
mDemoKeys.left = 0;
|
|
mDemoKeys.right = 0;
|
|
mDemoKeys.noInput = 0;
|
|
mDemoKeys.fire = 0;
|
|
mDemoKeys.fireLeft = 0;
|
|
mDemoKeys.fireRight = 0;
|
|
|
|
// Modo Demo activo
|
|
if (mDemo)
|
|
{
|
|
if (mDemoDataFile[mDemoCounter].left == 1)
|
|
mPlayer->setInput(INPUT_LEFT);
|
|
if (mDemoDataFile[mDemoCounter].right == 1)
|
|
mPlayer->setInput(INPUT_RIGHT);
|
|
if (mDemoDataFile[mDemoCounter].noInput == 1)
|
|
mPlayer->setInput(NO_INPUT);
|
|
if (mDemoDataFile[mDemoCounter].fire == 1)
|
|
if (mPlayer->canFire())
|
|
{
|
|
mPlayer->setInput(INPUT_FIRE_UP);
|
|
createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_UP);
|
|
mPlayer->setFireCooldown(10);
|
|
}
|
|
if (mDemoDataFile[mDemoCounter].fireLeft == 1)
|
|
if (mPlayer->canFire())
|
|
{
|
|
mPlayer->setInput(INPUT_FIRE_LEFT);
|
|
createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_UP);
|
|
mPlayer->setFireCooldown(10);
|
|
}
|
|
if (mDemoDataFile[mDemoCounter].fireRight == 1)
|
|
if (mPlayer->canFire())
|
|
{
|
|
mPlayer->setInput(INPUT_FIRE_RIGHT);
|
|
createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_UP);
|
|
mPlayer->setFireCooldown(10);
|
|
}
|
|
|
|
// Comprobamos la tecla o el botón de pausa/menu
|
|
if ((keystates[mKeyboard.accept] != 0) || (keystates[mKeyboard.cancel] != 0) || (checkGameController(INPUT_PAUSE)) || (checkGameController(INPUT_ACCEPT)) || (checkGameController(INPUT_CANCEL)))
|
|
{
|
|
setGameStatus(GAME_STATE_TITLE);
|
|
}
|
|
|
|
if (mDemoCounter < TOTAL_DEMO_DATA)
|
|
{
|
|
mDemoCounter++;
|
|
}
|
|
else
|
|
{
|
|
mGame.status = GAME_STATE_INSTRUCTIONS;
|
|
//mDemoCounter = 0;
|
|
}
|
|
}
|
|
// Modo Demo no activo
|
|
else if (mPlayer->isAlive())
|
|
{
|
|
// Tecla izquierda o el mando hacia la izquierda
|
|
if ((keystates[mKeyboard.left] != 0) || (checkGameController(INPUT_LEFT)))
|
|
{
|
|
mPlayer->setInput(INPUT_LEFT);
|
|
mDemoKeys.left = 1;
|
|
}
|
|
else
|
|
{
|
|
// Tecla derecha o el mando hacia la derecha
|
|
if ((keystates[mKeyboard.right] != 0) || (checkGameController(INPUT_RIGHT)))
|
|
{
|
|
mPlayer->setInput(INPUT_RIGHT);
|
|
mDemoKeys.right = 1;
|
|
}
|
|
else
|
|
{
|
|
// Ninguna de las dos direcciones pulsadas
|
|
mPlayer->setInput(NO_INPUT);
|
|
mDemoKeys.noInput = 1;
|
|
}
|
|
}
|
|
// Comprueba la tecla o el botón de disparo central
|
|
if ((keystates[mKeyboard.fire] != 0) || (checkGameController(INPUT_FIRE_UP)))
|
|
{
|
|
if (mPlayer->canFire())
|
|
{
|
|
mPlayer->setInput(INPUT_FIRE_UP);
|
|
createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_UP);
|
|
mPlayer->setFireCooldown(10);
|
|
|
|
// Reproduce el sonido de disparo
|
|
JA_PlaySound(mSound[SOUND_BULLET].sound);
|
|
|
|
mDemoKeys.fire = 1;
|
|
}
|
|
}
|
|
|
|
// Comprueba la tecla o el botón de disparo izquierdo
|
|
if ((keystates[mKeyboard.fireLeft] != 0) || (checkGameController(INPUT_FIRE_LEFT)))
|
|
{
|
|
if (mPlayer->canFire())
|
|
{
|
|
mPlayer->setInput(INPUT_FIRE_LEFT);
|
|
createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_LEFT);
|
|
mPlayer->setFireCooldown(10);
|
|
|
|
// Reproduce el sonido de disparo
|
|
JA_PlaySound(mSound[SOUND_BULLET].sound);
|
|
|
|
mDemoKeys.fireLeft = 1;
|
|
}
|
|
}
|
|
|
|
// Comprueba la tecla o el botón de disparo derecho
|
|
if ((keystates[mKeyboard.fireRight] != 0) || (checkGameController(INPUT_FIRE_RIGHT)))
|
|
{
|
|
if (mPlayer->canFire())
|
|
{
|
|
mPlayer->setInput(INPUT_FIRE_RIGHT);
|
|
createBullet(mPlayer->getPosX() + (mPlayer->getWidth() / 2) - 4, mPlayer->getPosY() + (mPlayer->getHeight() / 2), BULLET_RIGHT);
|
|
mPlayer->setFireCooldown(10);
|
|
|
|
// Reproduce el sonido de disparo
|
|
JA_PlaySound(mSound[SOUND_BULLET].sound);
|
|
|
|
mDemoKeys.fireRight = 1;
|
|
}
|
|
}
|
|
|
|
// Para la pausa actuaremos cuando se suelte la tecla de pausa
|
|
// Comprueba la tecla o el botón de pausa/menu y su buffer
|
|
if (((keystates[mKeyboard.pause] != 0) || (checkGameController(INPUT_PAUSE))) && (mKeyboardBuffer.pause == 0)) //|| ((mGameControllerFound) && (SDL_JoystickGetButton(mGameController, BUTTON_START))))
|
|
{
|
|
// Se acaba de pulsar la tecla. Lo anotamos en su buffer
|
|
mKeyboardBuffer.pause = 1;
|
|
}
|
|
else
|
|
{
|
|
// Aqui sigue la tecla pulsada, mantenemos el buffer activo
|
|
if (((keystates[mKeyboard.pause] != 0) || (checkGameController(INPUT_PAUSE))) && (mKeyboardBuffer.pause != 0))
|
|
{
|
|
mKeyboardBuffer.pause = 1;
|
|
}
|
|
else
|
|
{
|
|
// Se ha soltado la tecla, procedemos a ejecutar la accion
|
|
if (((keystates[mKeyboard.pause] == 0) || (!checkGameController(INPUT_PAUSE))) && (mKeyboardBuffer.pause != 0))
|
|
{
|
|
//setGameStatus(GAME_STATE_PAUSED);
|
|
mGame.paused = true;
|
|
|
|
if (JA_GetMusicState() == JA_MUSIC_PLAYING)
|
|
{
|
|
JA_PauseMusic();
|
|
}
|
|
|
|
mKeyboardBuffer.pause = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mDemoCounter < TOTAL_DEMO_DATA)
|
|
{
|
|
if (mDemoRecording)
|
|
{
|
|
mDemoDataFile[mDemoCounter] = mDemoKeys;
|
|
}
|
|
mDemoCounter++;
|
|
}
|
|
else if (mDemoRecording)
|
|
{
|
|
mGame.status = GAME_STATE_QUIT;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Gestiona la entrada de teclado y mando durante el menu
|
|
void GameDirector::checkMenuInput(Menu *menu)
|
|
{
|
|
// Obtiene el estado de las teclas pulsadas del teclado
|
|
keystates = SDL_GetKeyboardState(NULL);
|
|
|
|
if (!mMenuKeyPressed)
|
|
{
|
|
// Tecla arriba o el mando hacia arriba
|
|
if ((keystates[mKeyboard.up] != 0) || (checkGameController(INPUT_UP)))
|
|
{
|
|
if (menu->checkInput(INPUT_UP))
|
|
{
|
|
mMenuKeyPressed = true;
|
|
JA_PlaySound(mSound[SOUND_MENU_MOVE].sound);
|
|
}
|
|
}
|
|
|
|
// Tecla abajo o el mando hacia abajo
|
|
if ((keystates[mKeyboard.down] != 0) || (checkGameController(INPUT_DOWN)))
|
|
{
|
|
if (menu->checkInput(INPUT_DOWN))
|
|
{
|
|
mMenuKeyPressed = true;
|
|
JA_PlaySound(mSound[SOUND_MENU_MOVE].sound);
|
|
}
|
|
}
|
|
|
|
// Tecla o el botón de aceptar
|
|
if ((keystates[mKeyboard.accept] != 0) || (checkGameController(INPUT_ACCEPT)))
|
|
{
|
|
menu->checkInput(INPUT_ACCEPT);
|
|
mMenuKeyPressed = true;
|
|
}
|
|
|
|
// Tecla o el botón de cancelar
|
|
if ((keystates[mKeyboard.cancel] != 0) || (checkGameController(INPUT_CANCEL)))
|
|
{
|
|
menu->checkInput(INPUT_CANCEL);
|
|
mMenuKeyPressed = true;
|
|
}
|
|
}
|
|
|
|
// Ningún botón, libera la variable
|
|
if ((keystates[mKeyboard.up] == 0) && (keystates[mKeyboard.down] == 0) && (keystates[mKeyboard.accept] == 0) &&
|
|
(keystates[mKeyboard.cancel] == 0) && (checkGameController(NO_INPUT)))
|
|
{
|
|
mMenuKeyPressed = false;
|
|
}
|
|
}
|
|
|
|
// Obtiene el valor de la variable
|
|
Uint8 GameDirector::getGameStatus()
|
|
{
|
|
return mGame.status;
|
|
}
|
|
|
|
// Establece el valor de la variable
|
|
void GameDirector::setGameStatus(Uint8 status)
|
|
{
|
|
mGame.status = status;
|
|
}
|
|
|
|
// Pinta una transición en pantalla
|
|
void GameDirector::renderFade(Uint8 index)
|
|
{
|
|
SDL_Rect rect1;
|
|
SDL_Rect rect2;
|
|
Uint8 R, G, B;
|
|
|
|
// Copia el backbuffer al renderer
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
SDL_RenderPresent(mRenderer);
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
SDL_RenderPresent(mRenderer);
|
|
|
|
switch (index)
|
|
{
|
|
case 0:
|
|
rect1 = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT};
|
|
R = 0x27;
|
|
G = 0x27;
|
|
B = 0x36;
|
|
|
|
for (int i = 0; i < 256; i += 4)
|
|
{
|
|
// Dibujamos sobre el renderizador
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
|
|
// Copia el backbuffer con la imagen que había al renderizador
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
|
|
SDL_SetRenderDrawColor(mRenderer, R, G, B, i);
|
|
SDL_RenderFillRect(mRenderer, &rect1);
|
|
|
|
// Vuelca el renderizador en pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
}
|
|
|
|
// Deja todos los bufferes del mismo color
|
|
SDL_SetRenderTarget(mRenderer, mBackbuffer);
|
|
SDL_SetRenderDrawColor(mRenderer, R, G, B, 255);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
SDL_SetRenderDrawColor(mRenderer, R, G, B, 255);
|
|
SDL_RenderClear(mRenderer);
|
|
break;
|
|
|
|
case 1:
|
|
rect1 = {0, 0, SCREEN_WIDTH, 0};
|
|
rect2 = {0, 0, SCREEN_WIDTH, 0};
|
|
R = 0x27;
|
|
G = 0x27;
|
|
B = 0x36;
|
|
|
|
SDL_SetRenderDrawColor(mRenderer, R, G, B, 64);
|
|
|
|
for (Uint16 i = 0; i < (SCREEN_HEIGHT / 2); i += 4)
|
|
{
|
|
// Dibujamos sobre el backbuffer
|
|
SDL_SetRenderTarget(mRenderer, mBackbuffer);
|
|
|
|
rect1.h = rect2.h = i;
|
|
rect2.y = SCREEN_HEIGHT - (i);
|
|
|
|
SDL_RenderFillRect(mRenderer, &rect1);
|
|
SDL_RenderFillRect(mRenderer, &rect2);
|
|
|
|
// Volvemos a usar el renderizador de forma normal
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
|
|
// Copiamos el backbuffer al renderizador
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
|
|
// Volcamos el renderizador en pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
}
|
|
|
|
rect1 = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT};
|
|
|
|
for (Uint8 i = 0; i < 32; i++)
|
|
{
|
|
// Dibujamos sobre el backbuffer
|
|
SDL_SetRenderTarget(mRenderer, mBackbuffer);
|
|
SDL_RenderFillRect(mRenderer, &rect1);
|
|
|
|
// Volvemos a usar el renderizador de forma normal
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
|
|
// Copiamos el backbuffer al renderizador
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
|
|
// Volcamos el renderizador en pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
rect1 = {0, 0, 32, 32};
|
|
|
|
for (Uint16 i = 0; i < 50; i++)
|
|
{
|
|
// Crea un color al azar
|
|
R = 255 * (rand() % 2);
|
|
G = 255 * (rand() % 2);
|
|
B = 255 * (rand() % 2);
|
|
SDL_SetRenderDrawColor(mRenderer, R, G, B, 64);
|
|
|
|
// Dibujamos sobre el backbuffer
|
|
SDL_SetRenderTarget(mRenderer, mBackbuffer);
|
|
|
|
rect1.x = rand() % (SCREEN_WIDTH - rect1.w);
|
|
rect1.y = rand() % (SCREEN_HEIGHT - rect1.h);
|
|
SDL_RenderFillRect(mRenderer, &rect1);
|
|
|
|
// Volvemos a usar el renderizador de forma normal
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
|
|
// Copiamos el backbuffer al renderizador
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
|
|
// Volcamos el renderizador en pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
SDL_Delay(100);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Pinta diferentes mensajes en la pantalla
|
|
void GameDirector::renderMessages()
|
|
{
|
|
//mGetReadyBitmap->update();
|
|
mGetReadyBitmap->render();
|
|
if (!mGetReadyBitmap->isEnabled())
|
|
setPlayFieldDrawOnly(false);
|
|
|
|
if (mTimeStopped)
|
|
{
|
|
if ((mTimeStoppedTimer > 100) || (mTimeStoppedTimer % 10 > 4))
|
|
{
|
|
mText.black->writeCentered(PLAY_AREA_CENTER_X + 1, PLAY_AREA_FIRST_QUARTER_Y + 1, "Time Stopped: " + std::to_string(mTimeStoppedTimer / 10), 0);
|
|
mText.white->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_FIRST_QUARTER_Y, "Time Stopped: " + std::to_string(mTimeStoppedTimer / 10), 0);
|
|
}
|
|
}
|
|
|
|
if (mDemo)
|
|
{
|
|
if (mDemoCounter % 30 > 14)
|
|
{
|
|
mText.black->writeCentered(PLAY_AREA_CENTER_X + 1, PLAY_AREA_FIRST_QUARTER_Y + 1, "D E M O", 0);
|
|
mText.white->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_FIRST_QUARTER_Y, "D E M O", 0);
|
|
}
|
|
}
|
|
|
|
if (mGame.stageCounter > 0)
|
|
{
|
|
mText.black->writeCentered(PLAY_AREA_CENTER_X + 1, int(mGame.stagePath[mGame.stageCounter - 1]) + 1, "STAGE " + std::to_string(mGame.stage), 0);
|
|
mText.white->writeCentered(PLAY_AREA_CENTER_X, int(mGame.stagePath[mGame.stageCounter - 1]), "STAGE " + std::to_string(mGame.stage), 0);
|
|
}
|
|
}
|
|
|
|
// Habilita el efecto del item de detener el tiempo
|
|
void GameDirector::enableTimeStopItem()
|
|
{
|
|
stopAllBalloons(TIME_STOPPED_TIMER);
|
|
setTimeStopped(true);
|
|
setTimeStoppedTimer(TIME_STOPPED_TIMER);
|
|
if (JA_GetMusicState() == JA_MUSIC_PLAYING)
|
|
{
|
|
JA_PauseMusic();
|
|
}
|
|
}
|
|
|
|
// Deshabilita el efecto del item de detener el tiempo
|
|
void GameDirector::disableTimeStopItem()
|
|
{
|
|
mTimeStopped = false;
|
|
mTimeStoppedTimer = TIME_STOPPED_TIMER;
|
|
startAllBalloons();
|
|
if (JA_GetMusicState() == JA_MUSIC_PAUSED)
|
|
{
|
|
JA_ResumeMusic();
|
|
}
|
|
}
|
|
|
|
// Cambia el valor de la variable de modo de pantalla completa
|
|
void GameDirector::changeFullScreenMode()
|
|
{
|
|
switch (mFullScreenMode)
|
|
{
|
|
case 0:
|
|
mFullScreenMode = SDL_WINDOW_FULLSCREEN;
|
|
break;
|
|
case SDL_WINDOW_FULLSCREEN:
|
|
mFullScreenMode = SDL_WINDOW_FULLSCREEN_DESKTOP;
|
|
break;
|
|
case SDL_WINDOW_FULLSCREEN_DESKTOP:
|
|
mFullScreenMode = 0;
|
|
break;
|
|
|
|
default:
|
|
mFullScreenMode = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Actualiza los elementos del menu de opciones
|
|
void GameDirector::updateOptionsMenu()
|
|
{
|
|
switch (mFullScreenMode)
|
|
{
|
|
case 0:
|
|
mMenu.options->setItemCaption(0, "WINDOWED");
|
|
break;
|
|
case SDL_WINDOW_FULLSCREEN:
|
|
mMenu.options->setItemCaption(0, "FULLSCREEN");
|
|
break;
|
|
case SDL_WINDOW_FULLSCREEN_DESKTOP:
|
|
mMenu.options->setItemCaption(0, "FAKE FULLSCREEN");
|
|
break;
|
|
|
|
default:
|
|
mMenu.options->setItemCaption(0, "WINDOWED");
|
|
break;
|
|
}
|
|
mMenu.options->setItemCaption(1, "WINDOWS SIZE " + std::to_string(mWindowSize));
|
|
mMenu.options->centerMenu(SCREEN_CENTER_X);
|
|
mMenu.options->centerMenuElements();
|
|
}
|
|
|
|
// Agita la pantalla
|
|
void GameDirector::shakeScreen()
|
|
{
|
|
int v[] = {-1, 1, -1, 1, -1, 1, -1, 0};
|
|
for (Uint8 n = 0; n < 8; n++)
|
|
{
|
|
// Limpia la pantalla
|
|
SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
// Dibuja los objetos
|
|
mGameBackgroundFront->setPosX(0);
|
|
mGameBackgroundFront->setWidth(1);
|
|
mGameBackgroundFront->setSpriteClip(0, 0, 1, 192);
|
|
renderBackground();
|
|
|
|
mGameBackgroundFront->setPosX(255);
|
|
mGameBackgroundFront->setSpriteClip(255, 0, 1, 192);
|
|
mGameBackgroundFront->render();
|
|
|
|
mGameBackgroundFront->setPosX(v[n]);
|
|
mGameBackgroundFront->setWidth(256);
|
|
mGameBackgroundFront->setSpriteClip(0, 0, 256, 192);
|
|
mGameBackgroundFront->render();
|
|
|
|
mGrass->render();
|
|
renderBalloons();
|
|
renderBullets();
|
|
renderItems();
|
|
mPlayer->render();
|
|
renderScoreBoard();
|
|
|
|
// Actualiza la pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
SDL_Delay(50);
|
|
}
|
|
}
|
|
|
|
// Bucle para el logo del juego
|
|
void GameDirector::runLogo()
|
|
{
|
|
while (mGame.status == GAME_STATE_LOGO)
|
|
{
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(mEventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (mEventHandler->type == SDL_QUIT)
|
|
{
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
break;
|
|
}
|
|
|
|
// Cualquier tecla pulsada
|
|
if ((mEventHandler->type == SDL_KEYDOWN) || (mEventHandler->type == SDL_JOYBUTTONDOWN))
|
|
{
|
|
setGameStatus(GAME_STATE_TITLE);
|
|
}
|
|
}
|
|
|
|
// Cambia el destino donde se pinta todo
|
|
SDL_SetRenderTarget(mRenderer, mBackbuffer);
|
|
|
|
// Limpia el destino
|
|
SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
// Dibuja los objetos
|
|
mLogo.sprite->render();
|
|
|
|
// Dibuja el fade
|
|
if (mLogo.counter >= 200)
|
|
{
|
|
SDL_Rect rect = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT};
|
|
Uint16 alpha = mLogo.counter - 200;
|
|
if (alpha < 256)
|
|
{
|
|
SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, alpha);
|
|
}
|
|
else
|
|
{
|
|
SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255); // alpha - 0 trans, 255 opaco
|
|
}
|
|
SDL_RenderFillRect(mRenderer, &rect);
|
|
}
|
|
|
|
// Vuelve a usar el renderizador como destino
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
|
|
// Copia el backbufer al renderizador
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
|
|
// Actualiza la pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
|
|
// Comprueba si ha terminado el logo
|
|
if (SDL_GetTicks() - mTicks > mTicksSpeed)
|
|
{
|
|
// Actualiza el contador de ticks
|
|
mTicks = SDL_GetTicks();
|
|
|
|
if (mLogo.counter == 0)
|
|
{
|
|
if (JA_GetMusicState() == JA_MUSIC_PLAYING)
|
|
{
|
|
JA_StopMusic();
|
|
}
|
|
}
|
|
|
|
if (mLogo.counter == 500) // minimo 200 + 255
|
|
{
|
|
mLogo.counter = 0;
|
|
setGameStatus(GAME_STATE_INTRO);
|
|
}
|
|
else
|
|
{
|
|
mLogo.counter++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bucle para la intro del juego
|
|
void GameDirector::runIntro()
|
|
{
|
|
// Si la música no está sonando
|
|
if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
|
|
{
|
|
// Reproduce la música
|
|
JA_PlayMusic(mMusic[MUSIC_INTRO].music, false);
|
|
}
|
|
|
|
while (mGame.status == GAME_STATE_INTRO)
|
|
{
|
|
if (SDL_GetTicks() - mTicks > mTicksSpeed)
|
|
{
|
|
// Actualiza el contador de ticks
|
|
mTicks = SDL_GetTicks();
|
|
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(mEventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (mEventHandler->type == SDL_QUIT)
|
|
{
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
break;
|
|
}
|
|
|
|
if ((mEventHandler->type == SDL_KEYDOWN) || (mEventHandler->type == SDL_JOYBUTTONDOWN))
|
|
{
|
|
JA_StopMusic();
|
|
setGameStatus(GAME_STATE_TITLE);
|
|
}
|
|
}
|
|
|
|
// Actualiza los objetos
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++)
|
|
{
|
|
mIntroBitmap[i]->update();
|
|
}
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++)
|
|
{
|
|
mIntroText[i]->update();
|
|
}
|
|
|
|
// Guión de eventos
|
|
// Primera imagen - UPV
|
|
if (mIntroEvents[BITMAP0] == EVENT_WAITING)
|
|
{
|
|
mIntroBitmap[0]->setEnabled(true);
|
|
mIntroEvents[BITMAP0] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Primer texto de la primera imagen
|
|
if ((mIntroEvents[BITMAP0] == EVENT_COMPLETED) && (mIntroEvents[TEXT0] == EVENT_WAITING))
|
|
{
|
|
mIntroText[0]->setEnabled(true);
|
|
mIntroEvents[TEXT0] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Segundo texto de la primera imagen
|
|
if ((mIntroEvents[TEXT0] == EVENT_COMPLETED) && (mIntroEvents[TEXT1] == EVENT_WAITING))
|
|
{
|
|
mIntroText[0]->setEnabled(false);
|
|
mIntroText[1]->setEnabled(true);
|
|
mIntroEvents[TEXT1] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Tercer texto de la primera imagen
|
|
if ((mIntroEvents[TEXT1] == EVENT_COMPLETED) && (mIntroEvents[TEXT2] == EVENT_WAITING))
|
|
{
|
|
mIntroText[1]->setEnabled(false);
|
|
mIntroText[2]->setEnabled(true);
|
|
mIntroEvents[TEXT2] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Segunda imagen - Máquina
|
|
if ((mIntroEvents[TEXT2] == EVENT_COMPLETED) && (mIntroEvents[BITMAP1] == EVENT_WAITING))
|
|
{
|
|
mIntroBitmap[0]->setEnabled(false);
|
|
mIntroText[2]->setEnabled(false);
|
|
mIntroBitmap[1]->setEnabled(true);
|
|
mIntroEvents[BITMAP1] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Primer texto de la segunda imagen
|
|
if ((mIntroEvents[BITMAP1] == EVENT_COMPLETED) && (mIntroEvents[TEXT3] == EVENT_WAITING))
|
|
{
|
|
mIntroText[3]->setEnabled(true);
|
|
mIntroEvents[TEXT3] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Tercera imagen junto con primer texto - GRITO
|
|
if ((mIntroEvents[TEXT3] == EVENT_COMPLETED) && (mIntroEvents[BITMAP2] == EVENT_WAITING) && (mIntroEvents[TEXT4] == EVENT_WAITING))
|
|
{
|
|
mIntroBitmap[1]->setEnabled(false);
|
|
mIntroText[3]->setEnabled(false);
|
|
mIntroBitmap[2]->setEnabled(true);
|
|
mIntroText[4]->setEnabled(true);
|
|
mIntroEvents[BITMAP2] = EVENT_RUNNING;
|
|
mIntroEvents[TEXT4] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Cuarta imagen junto con primer texto - Reflexión
|
|
if ((mIntroEvents[TEXT4] == EVENT_COMPLETED) && (mIntroEvents[BITMAP3] == EVENT_WAITING) && (mIntroEvents[TEXT5] == EVENT_WAITING))
|
|
{
|
|
mIntroBitmap[2]->setEnabled(false);
|
|
mIntroText[4]->setEnabled(false);
|
|
mIntroBitmap[3]->setEnabled(true);
|
|
mIntroText[5]->setEnabled(true);
|
|
mIntroEvents[BITMAP3] = EVENT_RUNNING;
|
|
mIntroEvents[TEXT5] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Segundo texto de la cuarta imagen
|
|
if ((mIntroEvents[TEXT5] == EVENT_COMPLETED) && (mIntroEvents[TEXT6] == EVENT_WAITING))
|
|
{
|
|
mIntroText[5]->setEnabled(false);
|
|
mIntroText[6]->setEnabled(true);
|
|
mIntroEvents[TEXT6] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Quinta imagen - Patada
|
|
if ((mIntroEvents[TEXT6] == EVENT_COMPLETED) && (mIntroEvents[BITMAP4] == EVENT_WAITING))
|
|
{
|
|
mIntroBitmap[3]->setEnabled(false);
|
|
mIntroText[6]->setEnabled(false);
|
|
mIntroBitmap[4]->setEnabled(true);
|
|
mIntroEvents[BITMAP4] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Primer texto de la quinta imagen
|
|
if ((mIntroEvents[BITMAP4] == EVENT_COMPLETED) && (mIntroEvents[TEXT7] == EVENT_WAITING))
|
|
{
|
|
mIntroText[7]->setEnabled(true);
|
|
mIntroEvents[TEXT7] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Sexta imagen junto con texto - Globos de café
|
|
if ((mIntroEvents[TEXT7] == EVENT_COMPLETED) && (mIntroEvents[BITMAP5] == EVENT_WAITING) && (mIntroEvents[TEXT8] == EVENT_WAITING))
|
|
{
|
|
mIntroBitmap[4]->setEnabled(false);
|
|
mIntroText[7]->setEnabled(false);
|
|
mIntroBitmap[5]->setEnabled(true);
|
|
mIntroText[8]->setEnabled(true);
|
|
mIntroEvents[BITMAP5] = EVENT_RUNNING;
|
|
mIntroEvents[TEXT8] = EVENT_RUNNING;
|
|
}
|
|
|
|
// Acaba el último texto
|
|
if (mIntroEvents[TEXT8] == EVENT_COMPLETED)
|
|
{
|
|
mIntroText[8]->setEnabled(false);
|
|
JA_StopMusic();
|
|
mGame.status = GAME_STATE_TITLE;
|
|
}
|
|
}
|
|
|
|
// Limpia la pantalla
|
|
SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 0xFF);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
// Dibuja los objetos
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_BITMAPS; i++)
|
|
{
|
|
mIntroBitmap[i]->render();
|
|
}
|
|
for (Uint8 i = 0; i < INTRO_TOTAL_TEXTS; i++)
|
|
{
|
|
mIntroText[i]->render();
|
|
}
|
|
|
|
// Actualiza la pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
}
|
|
}
|
|
|
|
// Bucle para el titulo del juego
|
|
void GameDirector::runTitle()
|
|
{
|
|
Uint8 R, G, B;
|
|
R = 0x27;
|
|
G = 0x27;
|
|
B = 0x36;
|
|
|
|
while (mGame.status == GAME_STATE_TITLE)
|
|
{
|
|
// Estado 0 - Titulo desplazandose
|
|
if (mTitleStatus == 0)
|
|
{
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(mEventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (mEventHandler->type == SDL_QUIT)
|
|
{
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Calcula la lógica de los objetos
|
|
if (SDL_GetTicks() - mTicks > mTicksSpeed)
|
|
{
|
|
// Actualiza el contador de ticks
|
|
mTicks = SDL_GetTicks();
|
|
|
|
// Actualiza los objetos
|
|
mCoffeeBitmap->update();
|
|
mCrisisBitmap->update();
|
|
}
|
|
|
|
// Limpia la pantalla
|
|
SDL_SetRenderDrawColor(mRenderer, R, G, B, 255);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
// Dibuja los objetos
|
|
mCoffeeBitmap->render();
|
|
mCrisisBitmap->render();
|
|
|
|
// Actualiza la pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
|
|
// Si los objetos han llegado a su destino, cambiamos de estado
|
|
if ((mTitleEvents[0] == EVENT_COMPLETED) && (mTitleEvents[0] == EVENT_COMPLETED))
|
|
{
|
|
mTitleStatus = 1;
|
|
|
|
// Pantallazo blanco
|
|
SDL_SetRenderDrawColor(mRenderer, 0xFF, 0xFF, 0xFF, 0xFF);
|
|
SDL_RenderClear(mRenderer);
|
|
SDL_RenderPresent(mRenderer);
|
|
}
|
|
}
|
|
|
|
// Estado 1 - Titulo vibrando
|
|
if (mTitleStatus == 1)
|
|
{
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(mEventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (mEventHandler->type == SDL_QUIT)
|
|
{
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Reproduce el efecto sonoro
|
|
JA_PlaySound(mSound[SOUND_TITLE].sound);
|
|
|
|
// Agita la pantalla
|
|
int v[] = {-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 0};
|
|
int a = mCoffeeBitmap->getPosX();
|
|
int b = mCrisisBitmap->getPosX();
|
|
for (Uint8 n = 0; n < 11 * 3; n++)
|
|
{
|
|
// Limpia la pantalla
|
|
SDL_SetRenderDrawColor(mRenderer, R, G, B, 255);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
// Dibuja los objetos
|
|
mCoffeeBitmap->setPosX(a + v[n / 3]);
|
|
mCrisisBitmap->setPosX(b + v[n / 3]);
|
|
mCoffeeBitmap->render();
|
|
mCrisisBitmap->render();
|
|
mDustSpriteRight->animate(0);
|
|
mDustSpriteLeft->animate(0);
|
|
mDustSpriteRight->render();
|
|
mDustSpriteLeft->render();
|
|
|
|
// Actualiza la pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
}
|
|
|
|
mTitleStatus = 2;
|
|
}
|
|
|
|
// Estado 2 - La pantalla de titulo con el menú y la música
|
|
if (mTitleStatus == 2)
|
|
{
|
|
if (mTitleTimer > 0)
|
|
{
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(mEventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (mEventHandler->type == SDL_QUIT)
|
|
{
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
break;
|
|
}
|
|
|
|
if ((mEventHandler->type == SDL_KEYUP) || (mEventHandler->type == SDL_JOYBUTTONUP))
|
|
{
|
|
mTitleMenuVisible = true;
|
|
mTitleTimer = TITLE_TIMER;
|
|
}
|
|
}
|
|
// Si la música no está sonando
|
|
if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
|
|
{
|
|
// Reproduce la música
|
|
JA_PlayMusic(mMusic[MUSIC_TITLE].music, true);
|
|
}
|
|
|
|
// Calcula la lógica de los objetos
|
|
if (SDL_GetTicks() - mTicks > mTicksSpeed)
|
|
{
|
|
// Actualiza el contador de ticks
|
|
mTicks = SDL_GetTicks();
|
|
|
|
// Actualiza la lógica del menu
|
|
mMenu.active->update();
|
|
}
|
|
|
|
// Cambia el destino donde se pinta todo
|
|
SDL_SetRenderTarget(mRenderer, mBackbuffer);
|
|
|
|
// Limpia la pantalla
|
|
SDL_SetRenderDrawColor(mRenderer, R, G, B, 255);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
// Pinta el tileado de fondo
|
|
switch (mTitleBackgroundMode)
|
|
{
|
|
case 0:
|
|
mBackgroundWindow.x++;
|
|
mBackgroundWindow.x %= 64;
|
|
mBackgroundWindow.y++;
|
|
mBackgroundWindow.y %= 64;
|
|
break;
|
|
|
|
case 1:
|
|
mTitleBackgroundTimer++;
|
|
mTitleBackgroundTimer %= 360;
|
|
mBackgroundWindow.x = 128 + (int(mSen[(mTitleBackgroundTimer + 270) % 360] * 128));
|
|
mBackgroundWindow.y = 96 + (int(mSen[(360 - mTitleBackgroundTimer) % 360] * 96));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
SDL_RenderCopy(mRenderer, mTitleSurface, &mBackgroundWindow, NULL);
|
|
|
|
// Dibuja los objetos
|
|
mCoffeeBitmap->render();
|
|
mCrisisBitmap->render();
|
|
if (mTitleMenuVisible == true)
|
|
{
|
|
mMenu.active->render();
|
|
}
|
|
mDustSpriteRight->animate(0);
|
|
mDustSpriteLeft->animate(0);
|
|
mDustSpriteRight->render();
|
|
mDustSpriteLeft->render();
|
|
|
|
if ((mTitleTimer % 50 > 14) && (mTitleMenuVisible == false))
|
|
{
|
|
mText.black->writeCentered(SCREEN_CENTER_X + 1, PLAY_AREA_THIRD_QUARTER_Y + BLOCK + 1, "PRESS ANY KEY!", 0);
|
|
mText.white->writeCentered(SCREEN_CENTER_X, PLAY_AREA_THIRD_QUARTER_Y + BLOCK, "PRESS ANY KEY!", 0);
|
|
}
|
|
|
|
mText.black->writeCentered(SCREEN_CENTER_X + 1, SCREEN_HEIGHT - (BLOCK * 2) + 1, TEXT_COPYRIGHT, 0);
|
|
mText.white->writeCentered(SCREEN_CENTER_X, SCREEN_HEIGHT - (BLOCK * 2), TEXT_COPYRIGHT, 0);
|
|
|
|
// Vuelve a usar el renderizador como destino
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
|
|
// Volca el contenido de la textura en el renderizador
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
|
|
// Actualiza la pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
|
|
// Comprueba las entradas para el menu
|
|
if (mTitleMenuVisible == true)
|
|
{
|
|
checkMenuInput(mMenu.active);
|
|
}
|
|
|
|
// Comprueba si se ha seleccionado algún item del menú
|
|
if (mMenu.active->getName() == "TITLE")
|
|
{
|
|
switch (mMenu.active->getItemSelected())
|
|
{
|
|
case 0:
|
|
setGameStatus(GAME_STATE_PLAYING);
|
|
mMenu.active->reset();
|
|
mMenuKeyPressed = false;
|
|
JA_PlaySound(mSound[SOUND_MENU_SELECT].sound);
|
|
renderFade(1);
|
|
JA_StopMusic();
|
|
init(true);
|
|
disableDemoMode();
|
|
break;
|
|
case 1:
|
|
JA_PlaySound(mSound[SOUND_MENU_SELECT].sound);
|
|
mMenu.active->reset();
|
|
mMenu.active = mMenu.options;
|
|
mFullScreenModePrevious = mFullScreenMode;
|
|
mWindowSizePrevious = mWindowSize;
|
|
break;
|
|
case 2:
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
mMenu.active->reset();
|
|
mMenuKeyPressed = false;
|
|
JA_PlaySound(mSound[SOUND_MENU_CANCEL].sound);
|
|
renderFade(1);
|
|
JA_StopMusic();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Comprueba si se ha seleccionado algún item de opciones
|
|
if (mMenu.active->getName() == "OPTIONS")
|
|
{
|
|
switch (mMenu.active->getItemSelected())
|
|
{
|
|
case 0: // Fullscreen mode
|
|
JA_PlaySound(mSound[SOUND_MENU_SELECT].sound);
|
|
changeFullScreenMode();
|
|
updateOptionsMenu();
|
|
mMenu.active->deselectItem();
|
|
break;
|
|
case 1: // Windows size
|
|
JA_PlaySound(mSound[SOUND_MENU_SELECT].sound);
|
|
mWindowSize++;
|
|
if (mWindowSize == 5)
|
|
mWindowSize = 1;
|
|
updateOptionsMenu();
|
|
mMenu.active->deselectItem();
|
|
break;
|
|
case 2: // OK
|
|
JA_PlaySound(mSound[SOUND_MENU_SELECT].sound);
|
|
SDL_SetWindowFullscreen(mWindow, mFullScreenMode);
|
|
SDL_SetWindowSize(mWindow, SCREEN_WIDTH * mWindowSize, SCREEN_HEIGHT * mWindowSize);
|
|
mMenu.active->reset();
|
|
mMenu.active = mMenu.title;
|
|
break;
|
|
case 3: // CANCEL
|
|
JA_PlaySound(mSound[SOUND_MENU_CANCEL].sound);
|
|
mFullScreenMode = mFullScreenModePrevious;
|
|
mWindowSize = mWindowSizePrevious;
|
|
updateOptionsMenu();
|
|
mMenu.active->reset();
|
|
mMenu.active = mMenu.title;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (mMenu.active->getName() == "TITLE")
|
|
{
|
|
mTitleTimer--;
|
|
}
|
|
}
|
|
else if (mTitleTimer == 0)
|
|
{
|
|
mTitleTimer = TITLE_TIMER;
|
|
mGame.status = mTiteNextGS;
|
|
mMenu.active->reset();
|
|
toogleTitleNextGS();
|
|
renderFade(1);
|
|
if (mGame.status == GAME_STATE_INTRO)
|
|
{
|
|
JA_StopMusic();
|
|
}
|
|
init(true);
|
|
enableDemoMode();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bucle para el juego
|
|
void GameDirector::runGame()
|
|
{
|
|
while (mGame.status == GAME_STATE_PLAYING)
|
|
{
|
|
// Si la música no está sonando
|
|
if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
|
|
{
|
|
// Reproduce la música
|
|
if (mPlayer->isAlive())
|
|
JA_PlayMusic(mMusic[MUSIC_PLAYING].music, true);
|
|
}
|
|
|
|
// Lógica del juego
|
|
if (mGame.paused)
|
|
runPausedGame();
|
|
|
|
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
|
|
if (SDL_GetTicks() - mTicks > mTicksSpeed)
|
|
{
|
|
// Actualiza el contador de ticks
|
|
mTicks = SDL_GetTicks();
|
|
|
|
// Actualiza el contador de juego
|
|
mGameCounter++;
|
|
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(mEventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (mEventHandler->type == SDL_QUIT)
|
|
{
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Actualiza la lógica del juego
|
|
updatePlayField();
|
|
}
|
|
|
|
// Cambia el destino donde se pinta todo
|
|
SDL_SetRenderTarget(mRenderer, mBackbuffer);
|
|
|
|
// Limpia la pantalla
|
|
SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
// Dibuja los objetos
|
|
renderPlayField();
|
|
|
|
// Vuelve a usar el renderizador como destino
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
|
|
// Volca el contenido de la textura en el renderizador
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
|
|
// Actualiza la pantalla
|
|
if (mGame.status == GAME_STATE_PLAYING)
|
|
SDL_RenderPresent(mRenderer);
|
|
}
|
|
}
|
|
|
|
// Bucle para el menu de pausa del juego
|
|
void GameDirector::runPausedGame()
|
|
{
|
|
while (mGame.paused)
|
|
{
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(mEventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (mEventHandler->type == SDL_QUIT)
|
|
{
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Calcula la lógica de los objetos
|
|
if (SDL_GetTicks() - mTicks > mTicksSpeed)
|
|
{
|
|
// Actualiza el contador de ticks
|
|
mTicks = SDL_GetTicks();
|
|
|
|
// Actualiza la lógica del menu
|
|
mMenu.pause->update();
|
|
}
|
|
|
|
// Cambia el destino donde se pinta todo
|
|
SDL_SetRenderTarget(mRenderer, mBackbuffer);
|
|
|
|
// Dibuja los objetos
|
|
renderBackground();
|
|
renderBalloons();
|
|
renderBullets();
|
|
mPlayer->render();
|
|
renderScoreBoard();
|
|
mMenu.pause->render();
|
|
|
|
// Vuelve a usar el renderizador como destino
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
|
|
// Volca el contenido de la textura en el renderizador
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
|
|
// Actualiza la pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
|
|
// Comprueba las entradas para el menu
|
|
checkMenuInput(mMenu.pause);
|
|
|
|
// Comprueba si se ha seleccionado algún item del menú
|
|
switch (mMenu.pause->getItemSelected())
|
|
{
|
|
case 0:
|
|
JA_PlaySound(mSound[SOUND_MENU_SELECT].sound);
|
|
//setGameStatus(GAME_STATE_PLAYING);
|
|
mGame.paused = false;
|
|
mMenu.pause->reset();
|
|
mMenuKeyPressed = false;
|
|
if (JA_GetMusicState() == JA_MUSIC_PAUSED)
|
|
{
|
|
JA_ResumeMusic();
|
|
}
|
|
break;
|
|
case 1:
|
|
JA_PlaySound(mSound[SOUND_MENU_CANCEL].sound);
|
|
setGameStatus(GAME_STATE_TITLE);
|
|
mMenu.pause->reset();
|
|
mMenuKeyPressed = false;
|
|
JA_StopMusic();
|
|
renderFade(1);
|
|
init(true);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bucle para la pantalla de instrucciones
|
|
void GameDirector::runInstructions()
|
|
{
|
|
SDL_Rect window = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT};
|
|
Sprite *sprite = new Sprite();
|
|
SDL_Rect rect1 = {60, 88, 16, 16};
|
|
SDL_Rect rect2 = {60, 104, 16, 16};
|
|
SDL_Rect rect3 = {60, 120, 16, 16};
|
|
SDL_Rect rect4 = {60, 136, 16, 16};
|
|
SDL_Rect rect5 = {60, 152, 16, 16};
|
|
SDL_Rect rect6 = {60, 168, 16, 16};
|
|
SDL_Rect rect = {0, 0, 16, 16};
|
|
|
|
sprite->init(rect1, mTexture[TEXTURE_ITEMS].texture, mRenderer);
|
|
while (mGame.status == GAME_STATE_INSTRUCTIONS)
|
|
{
|
|
int y = 0;
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(mEventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (mEventHandler->type == SDL_QUIT)
|
|
{
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
break;
|
|
}
|
|
|
|
if ((mEventHandler->type == SDL_KEYDOWN) || (mEventHandler->type == SDL_JOYBUTTONDOWN))
|
|
{
|
|
JA_StopMusic();
|
|
setGameStatus(GAME_STATE_TITLE);
|
|
}
|
|
}
|
|
|
|
// Pinta en la surface el texto y los sprites
|
|
SDL_SetRenderTarget(mRenderer, mInstructionsSurface);
|
|
SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255);
|
|
SDL_RenderClear(mRenderer);
|
|
mText.white->writeCentered(SCREEN_CENTER_X, 8, "OBJECTIVE", 0);
|
|
mText.white->writeCentered(SCREEN_CENTER_X, 24, "YOU HAVE TO POP AS MANY", 0);
|
|
mText.white->writeCentered(SCREEN_CENTER_X, 34, "BALLOONS AS YOU CAN", 0);
|
|
mText.white->writeCentered(SCREEN_CENTER_X, 48, "DIFFICULTY WILL BE INCREASED", 0);
|
|
mText.white->writeCentered(SCREEN_CENTER_X, 58, "AS YOU SCORE POINTS", 0);
|
|
mText.white->writeCentered(SCREEN_CENTER_X, 75, "ITEMS", 0);
|
|
mText.white->write(84, 92, "1.000 POINTS", 0);
|
|
mText.white->write(84, 108, "2.500 POINTS", 0);
|
|
mText.white->write(84, 124, "5.000 POINTS", 0);
|
|
mText.white->write(84, 140, "TIME STOPPER", 0);
|
|
mText.white->write(84, 156, "FOUR EXPLOSIONS", 0);
|
|
mText.white->write(84, 172, "EXTRA HIT", 0);
|
|
|
|
sprite->init(rect1, mTexture[TEXTURE_ITEMS].texture, mRenderer);
|
|
sprite->setSpriteClip(rect);
|
|
rect.x += rect.w;
|
|
rect.y = 16 * (((mInstructionsCounter + 3) / 36) % 2);
|
|
sprite->render();
|
|
sprite->init(rect2, mTexture[TEXTURE_ITEMS].texture, mRenderer);
|
|
sprite->setSpriteClip(rect);
|
|
rect.x += rect.w;
|
|
rect.y = 16 * (((mInstructionsCounter + 6) / 36) % 2);
|
|
sprite->render();
|
|
sprite->init(rect3, mTexture[TEXTURE_ITEMS].texture, mRenderer);
|
|
sprite->setSpriteClip(rect);
|
|
rect.x += rect.w;
|
|
rect.y = 16 * (((mInstructionsCounter + 9) / 36) % 2);
|
|
sprite->render();
|
|
sprite->init(rect4, mTexture[TEXTURE_ITEMS].texture, mRenderer);
|
|
sprite->setSpriteClip(rect);
|
|
rect.x += rect.w;
|
|
rect.y = 16 * (((mInstructionsCounter + 12) / 36) % 2);
|
|
sprite->render();
|
|
sprite->init(rect5, mTexture[TEXTURE_ITEMS].texture, mRenderer);
|
|
sprite->setSpriteClip(rect);
|
|
rect.x += rect.w;
|
|
rect.y = 16 * (((mInstructionsCounter + 15) / 36) % 2);
|
|
sprite->render();
|
|
sprite->init(rect6, mTexture[TEXTURE_ITEMS].texture, mRenderer);
|
|
sprite->setSpriteClip(rect);
|
|
rect.x = 0;
|
|
rect.y = 16 * (((mInstructionsCounter + 0) / 36) % 2);
|
|
sprite->render();
|
|
|
|
SDL_SetRenderTarget(mRenderer, nullptr);
|
|
|
|
// Limpia la pantalla
|
|
SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 255);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
// Dibuja los objetos
|
|
y = SCREEN_HEIGHT - (INSTRUCTIONS_COUNTER - mInstructionsCounter) + 100;
|
|
if (y < 0)
|
|
{
|
|
y = 0;
|
|
}
|
|
|
|
window.y = y;
|
|
SDL_RenderCopy(mRenderer, mInstructionsSurface, NULL, &window);
|
|
|
|
// Muestra la pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
|
|
mInstructionsCounter--;
|
|
|
|
if (mInstructionsCounter == 0)
|
|
{
|
|
mInstructionsCounter = INSTRUCTIONS_COUNTER;
|
|
setGameStatus(GAME_STATE_TITLE);
|
|
}
|
|
}
|
|
delete sprite;
|
|
}
|
|
|
|
// Bucle para la pantalla de game over
|
|
void GameDirector::runGameOverScreen()
|
|
{
|
|
while (mGame.status == GAME_STATE_GAME_OVER_SCREEN)
|
|
{
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(mEventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (mEventHandler->type == SDL_QUIT)
|
|
{
|
|
setGameStatus(GAME_STATE_QUIT);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Calcula la lógica de los objetos
|
|
if (SDL_GetTicks() - mTicks > mTicksSpeed)
|
|
{
|
|
// Actualiza el contador de ticks
|
|
mTicks = SDL_GetTicks();
|
|
|
|
// Actualiza la lógica del menu
|
|
mMenu.gameOver->update();
|
|
}
|
|
|
|
// Cambia el destino donde se pinta todo
|
|
SDL_SetRenderTarget(mRenderer, mBackbuffer);
|
|
|
|
// Limpia la pantalla
|
|
SDL_SetRenderDrawColor(mRenderer, 0x27, 0x27, 0x36, 0xFF);
|
|
SDL_RenderClear(mRenderer);
|
|
|
|
// Dibuja los objetos
|
|
renderScoreBoard();
|
|
mText.white->write(PLAY_AREA_CENTER_X - (mText.white->lenght("GAME OVER", 0) / 2), PLAY_AREA_CENTER_Y - BLOCK, "GAME OVER", 0);
|
|
mText.white->write(PLAY_AREA_CENTER_X - (mText.white->lenght("RETRY?", 0) / 2), PLAY_AREA_CENTER_Y + BLOCK * 2, "RETRY?", 0);
|
|
mMenu.gameOver->render();
|
|
|
|
// Vuelve a usar el renderizador como destino
|
|
SDL_SetRenderTarget(mRenderer, NULL);
|
|
|
|
// Volca el contenido de la textura en el renderizador
|
|
SDL_RenderCopy(mRenderer, mBackbuffer, NULL, NULL);
|
|
|
|
// Muestra la pantalla
|
|
SDL_RenderPresent(mRenderer);
|
|
|
|
// Comprueba las entradas para el menu
|
|
checkMenuInput(mMenu.gameOver);
|
|
|
|
// Comprueba si se ha seleccionado algún item del menú
|
|
switch (mMenu.gameOver->getItemSelected())
|
|
{
|
|
case 0:
|
|
setGameStatus(GAME_STATE_PLAYING);
|
|
mMenu.gameOver->reset();
|
|
mMenuKeyPressed = false;
|
|
JA_PlaySound(mSound[SOUND_MENU_SELECT].sound);
|
|
JA_StopMusic();
|
|
init(true);
|
|
renderFade(1);
|
|
disableDemoMode();
|
|
break;
|
|
case 1:
|
|
setGameStatus(GAME_STATE_TITLE);
|
|
mMenu.gameOver->reset();
|
|
mMenuKeyPressed = false;
|
|
JA_PlaySound(mSound[SOUND_MENU_CANCEL].sound);
|
|
JA_StopMusic();
|
|
init(true);
|
|
renderFade(1);
|
|
mTiteNextGS = GAME_STATE_PLAYING;
|
|
enableDemoMode();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Dibuja la informacion de debug en pantalla
|
|
void GameDirector::renderDebugInfo()
|
|
{
|
|
if (mDebug)
|
|
{
|
|
mText.white->write(0, 0 * BLOCK, "menace: " + std::to_string(mMenaceLevelThreshold) + "/" + std::to_string(mMenaceLevel));
|
|
mText.white->write(0, 1 * BLOCK, "item[0].TTL: " + std::to_string(mItem[0]->mTimeToLive));
|
|
mText.white->write(0, 2 * BLOCK, "mGame.stage: " + std::to_string(mGame.stage));
|
|
mText.white->write(0, 3 * BLOCK, "mGameCounter : " + std::to_string(mGameCounter));
|
|
mText.white->write(0, 4 * BLOCK, ": ");
|
|
mText.white->write(0, 5 * BLOCK, ": ");
|
|
}
|
|
}
|
|
|
|
// Activa el modo Demo
|
|
void GameDirector::enableDemoMode()
|
|
{
|
|
mDemo = true;
|
|
mGetReadyBitmap->setEnabled(false);
|
|
}
|
|
|
|
// Desactiva el modo Demo
|
|
void GameDirector::disableDemoMode()
|
|
{
|
|
mDemo = false;
|
|
mGetReadyBitmap->setEnabled(true);
|
|
}
|
|
|
|
// Actualiza el proximo estado del juego despues del titulo
|
|
void GameDirector::toogleTitleNextGS()
|
|
{
|
|
if (mTiteNextGS == GAME_STATE_LOGO)
|
|
{
|
|
mTiteNextGS = GAME_STATE_PLAYING;
|
|
}
|
|
else
|
|
{
|
|
mTiteNextGS = GAME_STATE_LOGO;
|
|
}
|
|
} |