jaildesigner-jailgames/coffee_crisis
1
0
Fork 1
Code Issues Pull Requests Projects Releases 12 Wiki Activity

Actualizando el código

Browse Source
This commit is contained in:
Sergio
2022-09-27 13:06:04 +02:00
parent c8bebfd2d9
commit 8d56912765
13 changed files with 291 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
source/animatedsprite.cpp
View File

@@ -151,6 +151,12 @@ SDL_Rect AnimatedSprite::getAnimationClip(std::string name, Uint8 index)
return animation[getIndex(name)].frames[index];
}
// Devuelve el rectangulo de una animación y frame concreto
SDL_Rect AnimatedSprite::getAnimationClip(int indexA, Uint8 indexF)
{
return animation[indexA].frames[indexF];
}
// Carga la animación desde un fichero
bool AnimatedSprite::load(std::string filePath)
{

1
source/animatedsprite.h
View File

@@ -60,6 +60,7 @@ public:
// Devuelve el rectangulo de una animación y frame concreto
SDL_Rect getAnimationClip(std::string name, Uint8 index);
SDL_Rect getAnimationClip(int indexA, Uint8 indexF);
// Obtiene el indice de la animación a partir del nombre
int getIndex(std::string name);

43
source/bullet.cpp
View File

@@ -2,22 +2,10 @@
#include "bullet.h"
// Constructor
Bullet::Bullet()
Bullet::Bullet(int x, int y, int kind, bool poweredUp, int owner, LTexture *texture, SDL_Renderer *renderer)
{
mSprite = new Sprite();
mKind = NO_KIND;
}
mSprite = new Sprite({x,y,10,10},texture, renderer);
// Destructor
Bullet::~Bullet()
{
delete mSprite;
mSprite = nullptr;
}
// Iniciador
void Bullet::init(int x, int y, int kind, bool poweredUp, int owner, LTexture *texture, SDL_Renderer *renderer)
{
// Posición inicial del objeto
mPosX = x;
mPosY = y;
@@ -35,20 +23,6 @@ void Bullet::init(int x, int y, int kind, bool poweredUp, int owner, LTexture *t
// Identificador del dueño del objeto
mOwner = owner;
// Textura con los gráficos del objeto
mSprite->setTexture(texture);
// Renderizador
mSprite->setRenderer(renderer);
// Alto y ancho del sprite
mSprite->setWidth(mWidth);
mSprite->setHeight(mHeight);
// Posición inicial del sprite
mSprite->setPosX(mPosX);
mSprite->setPosY(mPosY);
// Valores especificos según el tipo
switch (kind)
{
@@ -96,6 +70,13 @@ void Bullet::init(int x, int y, int kind, bool poweredUp, int owner, LTexture *t
shiftColliders();
}
// Destructor
Bullet::~Bullet()
{
delete mSprite;
mSprite = nullptr;
}
// Pinta el objeto en pantalla
void Bullet::render()
{
@@ -144,12 +125,6 @@ Uint8 Bullet::move()
return msg;
}
// Deshabilita el objeto
void Bullet::erase()
{
init(0, 0, 0, false, -1, nullptr, nullptr);
}
// Comprueba si el objeto está activo
bool Bullet::isActive()
{

8
source/bullet.h
View File

@@ -36,23 +36,17 @@ private:
public:
// Constructor
Bullet();
Bullet(int x, int y, int kind, bool poweredUp, int owner, LTexture *texture, SDL_Renderer *renderer);
// Destructor
~Bullet();
// Iniciador
void init(int x, int y, int kind, bool poweredUp, int owner, LTexture *texture, SDL_Renderer *renderer);
// Pinta el objeto en pantalla
void render();
// Actualiza la posición y estado del objeto
Uint8 move();
// Deshabilita el objeto
void erase();
// Comprueba si el objeto está activo
bool isActive();

486
source/game.cpp
View File

@@ -38,30 +38,6 @@ Game::Game(int numPlayers, int currentStage, SDL_Renderer *renderer, Screen *scr
players.push_back(player1);
players.push_back(player2);
}
/*for (int i = 0; i < mNumPlayers; i++)
{
mPlayer[i] = new Player();
}
for (int i = 0; i < MAX_BALLOONS; i++)
{
mBalloon[i] = new Balloon();
}
for (int i = 0; i < MAX_BULLETS; i++)
{
mBullet[i] = new Bullet();
}
for (int i = 0; i < MAX_ITEMS; i++)
{
mItem[i] = new Item(mTextureItems, mRenderer);
}
for (int i = 0; i < MAX_SMART_SPRITES; i++)
{
mSmartSprite[i] = new SmartSprite(nullptr, mRenderer);
}*/
mTextureBalloon = new LTexture(mRenderer, mAsset->get("balloon.png"));
mTextureBullet = new LTexture(mRenderer, mAsset->get("bullet.png"));
@@ -126,7 +102,7 @@ Game::~Game()
delete player;
};
for (auto ballon : ballons)
for (auto ballon : balloons)
{
delete ballon;
};
@@ -441,26 +417,13 @@ void Game::init()
mSpriteScoreBoard->setSpriteClip(0, 160, 256, 32);
mSpritePowerMeter->setSpriteClip(256, 192 - 8, 40, 8);
// Establece a cero todos los valores del vector de objetos globo
resetBalloons();
// Con los globos creados, calcula el nivel de amenaza
evaluateAndSetMenace();
// 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 bitmap de GetReady!
mSpriteGetReady->setSpriteClip(0, 0, 109, 20);
// Inicializa el bitmap de 1000 puntos
m1000Bitmap->init();
m1000Bitmap->setPosX(0);
m1000Bitmap->setPosY(0);
m1000Bitmap->setWidth(26);
@@ -476,7 +439,6 @@ void Game::init()
m1000Bitmap->setDestY(0);
// Inicializa el bitmap de 2500 puntos
m2500Bitmap->init();
m2500Bitmap->setPosX(0);
m2500Bitmap->setPosY(0);
m2500Bitmap->setWidth(28);
@@ -492,7 +454,6 @@ void Game::init()
m2500Bitmap->setDestY(0);
// Inicializa el bitmap de 5000 puntos
m5000Bitmap->init();
m5000Bitmap->setPosX(0);
m5000Bitmap->setPosY(0);
m5000Bitmap->setWidth(28);
@@ -1820,19 +1781,17 @@ void Game::renderDeathFade(int counter)
void Game::updateBalloons()
{
for (auto balloon : balloons)
// for (int i = 0; i < MAX_BALLOONS; i++)
{
balloon->update();
}
}
// Pinta en pantalla todos los globos activos
void Game::renderBalloons()
{
for (auto balloon : balloons)
// for (int i = 0; i < MAX_BALLOONS; i++)
{
balloon->render();
if ((mDebug.enabled) && (balloon->isPopping() == false))
mText->writeCentered(balloon->getPosX() + (balloon->getWidth() / 2), balloon->getPosY() - 8, std::to_string(i));
}
}
@@ -1863,16 +1822,6 @@ void Game::createPowerBall()
mPowerBallCounter = POWERBALL_COUNTER;
}
// Establece a cero todos los valores del vector de objetos globo
void Game::resetBalloons()
{
for (auto balloon : balloons)
// for (int i = 0; i < MAX_BALLOONS; i++)
{
balloon->disable();
}
}
// Establece la velocidad de los globos
void Game::setBalloonSpeed(float speed)
{
@@ -1969,17 +1918,17 @@ void Game::popBalloon(Balloon *balloon)
increaseStageCurrentPower(1);
mBalloonsPopped++;
const Uint8 kind = mBalloon[index]->getKind();
const Uint8 kind = balloon->getKind();
Uint8 freeIndex = 0;
switch (kind)
{
// Si es del tipo más pequeño, simplemente elimina el globo
case BALLOON_1:
mBalloon[index]->pop();
balloon->pop();
break;
case HEXAGON_1:
mBalloon[index]->pop();
balloon->pop();
break;
// Si es del tipo PowerBall, destruye todos los globos
@@ -1991,32 +1940,32 @@ void Game::popBalloon(Balloon *balloon)
// En cualquier otro caso, crea dos globos de un tipo inferior
default:
freeIndex = getBalloonFreeIndex();
mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLOON_VELX_NEGATIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer);
mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2));
if (mBalloon[freeIndex]->getClass() == BALLOON_CLASS)
Balloon *b1 = new Balloon(0, balloon->getPosY(), balloon->getKind() - 1, BALLOON_VELX_NEGATIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer);
balloons.push_back(b1);
b1->allignTo(balloon->getPosX() + (balloon->getWidth() / 2));
if (b1->getClass() == BALLOON_CLASS)
{
mBalloon[freeIndex]->setVelY(-2.50f);
b1->setVelY(-2.50f);
}
else if (mBalloon[freeIndex]->getClass() == HEXAGON_CLASS)
else if (b1->getClass() == HEXAGON_CLASS)
{
mBalloon[freeIndex]->setVelY(BALLOON_VELX_NEGATIVE);
b1->setVelY(BALLOON_VELX_NEGATIVE);
}
freeIndex = getBalloonFreeIndex();
mBalloon[freeIndex]->init(0, mBalloon[index]->getPosY(), mBalloon[index]->getKind() - 1, BALLOON_VELX_POSITIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer);
mBalloon[freeIndex]->allignTo(mBalloon[index]->getPosX() + (mBalloon[index]->getWidth() / 2));
if (mBalloon[freeIndex]->getClass() == BALLOON_CLASS)
Balloon *b2 = new Balloon(0, balloon->getPosY(), balloon->getKind() - 1, BALLOON_VELX_POSITIVE, mEnemySpeed, 0, mTextureBalloon, mRenderer);
balloons.push_back(b2);
b2->allignTo(balloon->getPosX() + (balloon->getWidth() / 2));
if (b2->getClass() == BALLOON_CLASS)
{
mBalloon[freeIndex]->setVelY(-2.50f);
b2->setVelY(-2.50f);
}
else if (mBalloon[freeIndex]->getClass() == HEXAGON_CLASS)
else if (b2->getClass() == HEXAGON_CLASS)
{
mBalloon[freeIndex]->setVelY(BALLOON_VELX_NEGATIVE);
b2->setVelY(BALLOON_VELX_NEGATIVE);
}
// Elimina el globo
mBalloon[index]->pop();
balloon->pop();
break;
}
@@ -2025,13 +1974,13 @@ void Game::popBalloon(Balloon *balloon)
}
// Explosiona un globo. Lo destruye
void Game::destroyBalloon(Uint8 index)
void Game::destroyBalloon(Balloon *balloon)
{
int score = 0;
Uint8 power = 0;
// Calcula la puntuación y el poder que generaria el globo en caso de romperlo a él y a sus hijos
switch (mBalloon[index]->getSize())
switch (balloon->getSize())
{
case BALLOON_SIZE_4:
score = BALLOON_SCORE_4 + (2 * BALLOON_SCORE_3) + (4 * BALLOON_SCORE_2) + (8 * BALLOON_SCORE_1);
@@ -2060,9 +2009,9 @@ void Game::destroyBalloon(Uint8 index)
}
// Otorga los puntos correspondientes al globo
for (int i = 0; i < mNumPlayers; i++)
for (auto player : players)
{
mPlayer[i]->addScore(Uint32(score * mPlayer[i]->getScoreMultiplier() * mDifficultyScoreMultiplier));
player->addScore(Uint32(score * player->getScoreMultiplier() * mDifficultyScoreMultiplier));
}
updateHiScore();
@@ -2071,7 +2020,7 @@ void Game::destroyBalloon(Uint8 index)
mBalloonsPopped += power;
// Destruye el globo
mBalloon[index]->pop();
balloon->pop();
// Recalcula el nivel de amenaza
evaluateAndSetMenace();
@@ -2080,11 +2029,11 @@ void Game::destroyBalloon(Uint8 index)
// Explosiona todos los globos
void Game::popAllBalloons()
{
for (int i = 0; i < MAX_BALLOONS; i++)
for (auto balloon : balloons)
{
if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isPopping()) && (!mBalloon[i]->isBeingCreated()))
if ((balloon->isEnabled()) && (!balloon->isPopping()) && (!balloon->isBeingCreated()))
{
popBalloon(i);
popBalloon(balloon);
}
}
@@ -2094,11 +2043,11 @@ void Game::popAllBalloons()
// Destruye todos los globos
void Game::destroyAllBalloons()
{
for (int i = 0; i < MAX_BALLOONS; i++)
for (auto balloon : balloons)
{
if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isPopping()))
if ((balloon->isEnabled()) && (!balloon->isPopping()))
{
destroyBalloon(i);
destroyBalloon(balloon);
}
}
@@ -2111,12 +2060,12 @@ void Game::destroyAllBalloons()
// Detiene todos los globos
void Game::stopAllBalloons(Uint16 time)
{
for (int i = 0; i < MAX_BALLOONS; i++)
for (auto balloon : balloons)
{
if (mBalloon[i]->isEnabled())
if (balloon->isEnabled())
{
mBalloon[i]->setStop(true);
mBalloon[i]->setStoppedTimer(time);
balloon->setStop(true);
balloon->setStoppedTimer(time);
}
}
}
@@ -2124,12 +2073,12 @@ void Game::stopAllBalloons(Uint16 time)
// Pone en marcha todos los globos
void Game::startAllBalloons()
{
for (int i = 0; i < MAX_BALLOONS; i++)
for (auto balloon : balloons)
{
if ((mBalloon[i]->isEnabled()) && (!mBalloon[i]->isBeingCreated()))
if ((balloon->isEnabled()) && (!balloon->isBeingCreated()))
{
mBalloon[i]->setStop(false);
mBalloon[i]->setStoppedTimer(0);
balloon->setStop(false);
balloon->setStoppedTimer(0);
}
}
}
@@ -2139,11 +2088,11 @@ Uint8 Game::countBalloons()
{
Uint8 num = 0;
for (int i = 0; i < MAX_BALLOONS; i++)
for (auto balloon : balloons)
{
if (mBalloon[i]->isEnabled())
if (balloon->isEnabled())
{
if (!mBalloon[i]->isPopping())
if (!balloon->isPopping())
{
num++;
}
@@ -2154,13 +2103,13 @@ Uint8 Game::countBalloons()
}
// Comprueba la colisión entre el jugador y los globos activos
bool Game::checkPlayerBalloonCollision(int index)
bool Game::checkPlayerBalloonCollision(Player *player)
{
for (int i = 0; i < MAX_BALLOONS; i++)
for (auto balloon : balloons)
{
if ((mBalloon[i]->isEnabled()) && !(mBalloon[i]->isStopped()) && !(mBalloon[i]->isInvulnerable()))
if ((balloon->isEnabled()) && !(balloon->isStopped()) && !(balloon->isInvulnerable()))
{
if (checkCollision(mPlayer[index]->getCollider(), mBalloon[i]->getCollider()))
if (checkCollision(player->getCollider(), balloon->getCollider()))
{
return true;
}
@@ -2237,22 +2186,22 @@ void Game::checkPlayerItemCollision(Player *player)
// Comprueba y procesa la colisión entre las balas y los globos
void Game::checkBulletBalloonCollision()
{
for (int i = 0; i < MAX_BALLOONS; i++)
for (auto balloon : balloons)
{
for (int j = 0; j < MAX_BULLETS; j++)
for (auto bullet : bullets)
{
if (mBalloon[i]->isEnabled() && (!mBalloon[i]->isInvulnerable()) && mBullet[j]->isActive())
if (balloon->isEnabled() && (!balloon->isInvulnerable()) && bullet->isActive())
{
if (checkCollision(mBalloon[i]->getCollider(), mBullet[j]->getCollider()))
if (checkCollision(balloon->getCollider(), bullet->getCollider()))
{
// Otorga los puntos correspondientes al globo al jugador que disparó la bala
int index = mBullet[j]->getOwner();
mPlayer[index]->incScoreMultiplier();
mPlayer[index]->addScore(Uint32(mBalloon[i]->getScore() * mPlayer[index]->getScoreMultiplier() * mDifficultyScoreMultiplier));
int index = bullet->getOwner();
players[index]->incScoreMultiplier();
players[index]->addScore(Uint32(balloon->getScore() * players[index]->getScoreMultiplier() * mDifficultyScoreMultiplier));
updateHiScore();
// Explota el globo
popBalloon(i);
popBalloon(balloon);
// Si no es el modo demo, genera un sonido
if (!mDemo.enabled)
@@ -2261,7 +2210,7 @@ void Game::checkBulletBalloonCollision()
}
// Destruye la bala
mBullet[j]->erase();
delete bullet;
// Suelta el item en caso de que salga uno
const Uint8 droppeditem = dropItem();
@@ -2269,12 +2218,12 @@ void Game::checkBulletBalloonCollision()
{
if (droppeditem != ITEM_COFFEE_MACHINE)
{
createItem(mBalloon[i]->getPosX(), mBalloon[i]->getPosY(), droppeditem);
createItem(mTextureItems, mRenderer, balloon->getPosX(), balloon->getPosY(), droppeditem);
JA_PlaySound(mSoundItemDrop);
}
else
{
createItem(mPlayer[index]->getPosX(), 0, droppeditem);
createItem(mTextureItems, mRenderer, players[index]->getPosX(), 0, droppeditem);
mCoffeeMachineEnabled = true;
}
}
@@ -2288,13 +2237,13 @@ void Game::checkBulletBalloonCollision()
// Mueve las balas activas
void Game::moveBullets()
{
for (int i = 0; i < MAX_BULLETS; i++)
for (auto bullet : bullets)
{
if (mBullet[i]->isActive())
if (bullet->isActive())
{
if (mBullet[i]->move() == BULLET_MOVE_OUT)
if (bullet->move() == BULLET_MOVE_OUT)
{
mPlayer[mBullet[i]->getOwner()]->decScoreMultiplier();
players[bullet->getOwner()]->decScoreMultiplier();
}
}
}
@@ -2303,51 +2252,28 @@ void Game::moveBullets()
// Pinta las balas activas
void Game::renderBullets()
{
for (int i = 0; i < MAX_BULLETS; i++)
for (auto bullet : bullets)
{
if (mBullet[i]->isActive())
if (bullet->isActive())
{
mBullet[i]->render();
bullet->render();
}
}
}
// Devuelve el primer indice no activo del vector de balas
Uint8 Game::getBulletFreeIndex()
{
for (int i = 0; i < MAX_BULLETS; i++)
{
if (mBullet[i]->isActive() == false)
{
return i;
}
}
return 0;
}
// Establece a cero todos los valores del vector de objetos bala
void Game::resetBullets()
{
for (int i = 0; i < MAX_BULLETS; i++)
{
mBullet[i]->erase();
}
}
// Crea un objeto bala
void Game::createBullet(int x, int y, Uint8 kind, bool poweredUp, int owner)
{
mBullet[getBulletFreeIndex()]->init(x, y, kind, poweredUp, owner, mTextureBullet, mRenderer);
Bullet *b = new Bullet(x, y, kind, poweredUp, owner, mTextureBullet, mRenderer);
}
// Actualiza los items
void Game::updateItems()
{
for (int i = 0; i < MAX_ITEMS; i++)
for (auto item : items)
{
mItem[i]->update();
if (mItem[i]->floorCollision())
item->update();
if (item->floorCollision())
{
JA_PlaySound(mSoundCollision);
mEffect.shake = true;
@@ -2358,32 +2284,9 @@ void Game::updateItems()
// Pinta los items activos
void Game::renderItems()
{
for (int i = 0; i < MAX_ITEMS; i++)
for (auto item : items)
{
mItem[i]->render();
}
}
// Devuelve el primer indice no activo del vector de items
Uint8 Game::getItemFreeIndex()
{
for (int i = 0; i < MAX_ITEMS; i++)
{
if (mItem[i]->getClass() == NO_KIND)
{
return i;
}
}
return 0;
}
// Establece a cero todos los valores del vector de objetos item
void Game::resetItems()
{
for (int i = 0; i < MAX_ITEMS; i++)
{
mItem[i]->erase();
item->render();
}
}
@@ -2456,24 +2359,26 @@ Uint8 Game::dropItem()
}
// Crea un objeto item
void Game::createItem(int x, int y, Uint8 kind)
void Game::createItem(LTexture *texture, SDL_Renderer *renderer, Uint8 type, float x, float y)
{
mItem[getItemFreeIndex()]->init(kind, x, y);
Item *i = new Item(texture, renderer, type, x, y);
items.push_back(i);
}
// Crea un objeto SmartSprite para mostrar la puntuación al coger un objeto
void Game::createItemScoreSprite(int x, int y, SmartSprite *sprite)
{
const Uint8 index = getSmartSpriteFreeIndex();
SmartSprite *ss = new SmartSprite(nullptr, mRenderer);
smartSprites.push_back(ss);
// Crea una copia del objeto
*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);
*ss = *sprite;
ss->setPosX(x);
ss->setPosY(y);
ss->setDestX(x);
ss->setDestY(y - 15);
ss->setEnabled(true);
ss->setEnabledTimer(100);
}
// Dibuja el efecto de flash
@@ -2509,100 +2414,80 @@ void Game::updateShakeEffect()
// Crea un SmartSprite para arrojar el item café al recibir un impacto
void Game::throwCoffee(int x, int y)
{
const Uint8 index = getSmartSpriteFreeIndex();
SmartSprite *ss = new SmartSprite(nullptr, mRenderer);
smartSprites.push_back(ss);
mSmartSprite[index]->init();
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(GAME_HEIGHT + 1);
mSmartSprite[index]->setEnabled(true);
mSmartSprite[index]->setEnabledTimer(1);
mSmartSprite[index]->setSpriteClip(80, 16, 16, 16);
mSmartSprite[index]->setRotate(true);
mSmartSprite[index]->setRotateSpeed(10);
mSmartSprite[index]->setRotateAmount(90.0);
ss->setPosX(x - 8);
ss->setPosY(y - 8);
ss->setWidth(16);
ss->setHeight(16);
ss->setVelX(-1.0f + ((rand() % 5) * 0.5f));
ss->setVelY(-4.0f);
ss->setAccelX(0.0f);
ss->setAccelY(0.2f);
ss->setDestX(x + (ss->getVelX() * 50));
ss->setDestY(GAME_HEIGHT + 1);
ss->setEnabled(true);
ss->setEnabledTimer(1);
ss->setSpriteClip(80, 16, 16, 16);
ss->setRotate(true);
ss->setRotateSpeed(10);
ss->setRotateAmount(90.0);
}
// Crea un SmartSprite para arrojar al jugador al morir
void Game::throwPlayer(int x, int y, int index)
void Game::throwPlayer(int x, int y, Player *player)
{
const int sentit = ((rand() % 2) ? 1 : -1);
mPlayer[index]->mDeathIndex = getSmartSpriteFreeIndex();
// mSmartSprite[mPlayer[index]->mDeathIndex]->init(mPlayer[index]->getDeadTexture(), mRenderer);
mSmartSprite[mPlayer[index]->mDeathIndex]->setTexture(mPlayer[index]->getDeadTexture());
mSmartSprite[mPlayer[index]->mDeathIndex]->setPosX(x);
mSmartSprite[mPlayer[index]->mDeathIndex]->setPosY(y);
mSmartSprite[mPlayer[index]->mDeathIndex]->setWidth(24);
mSmartSprite[mPlayer[index]->mDeathIndex]->setHeight(24);
mSmartSprite[mPlayer[index]->mDeathIndex]->setVelX(2.0f * sentit);
mSmartSprite[mPlayer[index]->mDeathIndex]->setVelY(-5.0f);
mSmartSprite[mPlayer[index]->mDeathIndex]->setAccelX(0.0f);
mSmartSprite[mPlayer[index]->mDeathIndex]->setAccelY(0.2f);
mSmartSprite[mPlayer[index]->mDeathIndex]->setDestX(GAME_WIDTH * sentit);
mSmartSprite[mPlayer[index]->mDeathIndex]->setDestY(GAME_HEIGHT + 1);
mSmartSprite[mPlayer[index]->mDeathIndex]->setEnabled(true);
mSmartSprite[mPlayer[index]->mDeathIndex]->setEnabledTimer(1);
mSmartSprite[mPlayer[index]->mDeathIndex]->setSpriteClip(0, 0, 24, 24);
//player->mDeathIndex = getSmartSpriteFreeIndex();
SmartSprite *ss = new SmartSprite(nullptr, mRenderer);
smartSprites.push_back(ss);
ss->setTexture(player->getDeadTexture());
ss->setPosX(x);
ss->setPosY(y);
ss->setWidth(24);
ss->setHeight(24);
ss->setVelX(2.0f * sentit);
ss->setVelY(-5.0f);
ss->setAccelX(0.0f);
ss->setAccelY(0.2f);
ss->setDestX(GAME_WIDTH * sentit);
ss->setDestY(GAME_HEIGHT + 1);
ss->setEnabled(true);
ss->setEnabledTimer(1);
ss->setSpriteClip(0, 0, 24, 24);
}
// Actualiza los SmartSprites
void Game::updateSmartSprites()
{
for (int i = 0; i < MAX_SMART_SPRITES; i++)
for (auto ss:smartSprites)
{
mSmartSprite[i]->update();
ss->update();
}
}
// Pinta los SmartSprites activos
void Game::renderSmartSprites()
{
for (int i = 0; i < MAX_SMART_SPRITES; i++)
for (auto ss:smartSprites)
{
mSmartSprite[i]->render();
}
}
// Devuelve el primer indice no activo del vector de SmartSprites
Uint8 Game::getSmartSpriteFreeIndex()
{
for (int i = 0; i < MAX_SMART_SPRITES; i++)
{
if (!mSmartSprite[i]->isEnabled())
{
return i;
}
}
return 0;
}
// Establece a cero todos los valores del vector de objetos SmafrtSprite
void Game::resetSmartSprites()
{
for (int i = 0; i < MAX_SMART_SPRITES; i++)
{
mSmartSprite[i]->init();
ss->render();
}
}
// Acciones a realizar cuando el jugador muere
void Game::killPlayer(Player *player)
{
if (!mPlayer[index]->isInvulnerable())
if (!player->isInvulnerable())
{
if (mPlayer[index]->hasExtraHit())
if (player->hasExtraHit())
{
mPlayer[index]->removeExtraHit();
throwCoffee(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2), mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2));
player->removeExtraHit();
throwCoffee(player->getPosX() + (player->getWidth() / 2), player->getPosY() + (player->getHeight() / 2));
JA_PlaySound(mSoundCoffeeOut);
}
else
@@ -2613,8 +2498,8 @@ void Game::killPlayer(Player *player)
shakeScreen();
SDL_Delay(500);
JA_PlaySound(mSoundCoffeeOut);
throwPlayer(mPlayer[index]->getPosX(), mPlayer[index]->getPosY(), index);
mPlayer[index]->setAlive(false);
throwPlayer(player->getPosX(), player->getPosY(), player);
player->setAlive(false);
if (allPlayersAreDead())
{
JA_StopMusic();
@@ -2631,11 +2516,11 @@ void Game::killPlayer(Player *player)
void Game::evaluateAndSetMenace()
{
mMenaceCurrent = 0;
for (int i = 0; i < MAX_BALLOONS; i++)
for (auto balloon:balloons)
{
if (mBalloon[i]->isEnabled())
if (balloon->isEnabled())
{
mMenaceCurrent += mBalloon[i]->getMenace();
mMenaceCurrent += balloon->getMenace();
}
}
}
@@ -2828,12 +2713,12 @@ void Game::renderPlayField()
renderSmartSprites();
renderScoreBoard();
for (int i = 0; i < mNumPlayers; i++)
for (auto player:players)
{
mPlayer[i]->render();
player->render();
}
if ((mDeathCounter <= 150) && !mPlayer[0]->isAlive())
if ((mDeathCounter <= 150) && !players[0]->isAlive())
{
renderDeathFade(150 - mDeathCounter);
}
@@ -2882,45 +2767,45 @@ void Game::checkGameInput()
const int index = 0;
if (mDemo.dataFile[mDemo.counter].left == 1)
{
mPlayer[index]->setInput(INPUT_LEFT);
players[index]->setInput(INPUT_LEFT);
}
if (mDemo.dataFile[mDemo.counter].right == 1)
{
mPlayer[index]->setInput(INPUT_RIGHT);
players[index]->setInput(INPUT_RIGHT);
}
if (mDemo.dataFile[mDemo.counter].noInput == 1)
{
mPlayer[index]->setInput(INPUT_NULL);
players[index]->setInput(INPUT_NULL);
}
if (mDemo.dataFile[mDemo.counter].fire == 1)
{
if (mPlayer[index]->canFire())
if (players[index]->canFire())
{
mPlayer[index]->setInput(INPUT_BUTTON_2);
createBullet(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2) - 4, mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2), BULLET_UP, mPlayer[index]->isPowerUp(), index);
mPlayer[index]->setFireCooldown(10);
players[index]->setInput(INPUT_BUTTON_2);
createBullet(players[index]->getPosX() + (players[index]->getWidth() / 2) - 4, players[index]->getPosY() + (players[index]->getHeight() / 2), BULLET_UP, players[index]->isPowerUp(), index);
players[index]->setFireCooldown(10);
}
}
if (mDemo.dataFile[mDemo.counter].fireLeft == 1)
{
if (mPlayer[index]->canFire())
if (players[index]->canFire())
{
mPlayer[index]->setInput(INPUT_BUTTON_1);
createBullet(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2) - 4, mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2), BULLET_UP, mPlayer[index]->isPowerUp(), index);
mPlayer[index]->setFireCooldown(10);
players[index]->setInput(INPUT_BUTTON_1);
createBullet(players[index]->getPosX() + (players[index]->getWidth() / 2) - 4, players[index]->getPosY() + (players[index]->getHeight() / 2), BULLET_UP, players[index]->isPowerUp(), index);
players[index]->setFireCooldown(10);
}
}
if (mDemo.dataFile[mDemo.counter].fireRight == 1)
{
if (mPlayer[index]->canFire())
if (players[index]->canFire())
{
mPlayer[index]->setInput(INPUT_BUTTON_3);
createBullet(mPlayer[index]->getPosX() + (mPlayer[index]->getWidth() / 2) - 4, mPlayer[index]->getPosY() + (mPlayer[index]->getHeight() / 2), BULLET_UP, mPlayer[index]->isPowerUp(), index);
mPlayer[index]->setFireCooldown(10);
players[index]->setInput(INPUT_BUTTON_3);
createBullet(players[index]->getPosX() + (players[index]->getWidth() / 2) - 4, players[index]->getPosY() + (players[index]->getHeight() / 2), BULLET_UP, players[index]->isPowerUp(), index);
players[index]->setFireCooldown(10);
}
}
@@ -2943,14 +2828,15 @@ void Game::checkGameInput()
// Modo Demo no activo
else
{
for (int i = 0; i < mNumPlayers; i++)
int i = 0;
for (auto player:players)
{
if (mPlayer[i]->isAlive())
if (player->isAlive())
{
// Input a la izquierda
if (mInput->checkInput(INPUT_LEFT, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
{
mPlayer[i]->setInput(INPUT_LEFT);
player->setInput(INPUT_LEFT);
mDemo.keys.left = 1;
}
else
@@ -2958,24 +2844,24 @@ void Game::checkGameInput()
// Input a la derecha
if (mInput->checkInput(INPUT_RIGHT, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
{
mPlayer[i]->setInput(INPUT_RIGHT);
player->setInput(INPUT_RIGHT);
mDemo.keys.right = 1;
}
else
{
// Ninguno de los dos inputs anteriores
mPlayer[i]->setInput(INPUT_NULL);
player->setInput(INPUT_NULL);
mDemo.keys.noInput = 1;
}
}
// Comprueba el input de disparar al centro
if (mInput->checkInput(INPUT_BUTTON_2, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
{
if (mPlayer[i]->canFire())
if (player->canFire())
{
mPlayer[i]->setInput(INPUT_BUTTON_2);
createBullet(mPlayer[i]->getPosX() + (mPlayer[i]->getWidth() / 2) - 4, mPlayer[i]->getPosY() + (mPlayer[i]->getHeight() / 2), BULLET_UP, mPlayer[i]->isPowerUp(), i);
mPlayer[i]->setFireCooldown(10);
player->setInput(INPUT_BUTTON_2);
createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BULLET_UP, player->isPowerUp(), i);
player->setFireCooldown(10);
// Reproduce el sonido de disparo
JA_PlaySound(mSoundBullet);
@@ -2987,11 +2873,11 @@ void Game::checkGameInput()
// Comprueba el input de disparar a la izquierda
if (mInput->checkInput(INPUT_BUTTON_1, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
{
if (mPlayer[i]->canFire())
if (player->canFire())
{
mPlayer[i]->setInput(INPUT_BUTTON_1);
createBullet(mPlayer[i]->getPosX() + (mPlayer[i]->getWidth() / 2) - 4, mPlayer[i]->getPosY() + (mPlayer[i]->getHeight() / 2), BULLET_LEFT, mPlayer[i]->isPowerUp(), i);
mPlayer[i]->setFireCooldown(10);
player->setInput(INPUT_BUTTON_1);
createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BULLET_LEFT, player->isPowerUp(), i);
player->setFireCooldown(10);
// Reproduce el sonido de disparo
JA_PlaySound(mSoundBullet);
@@ -3003,11 +2889,11 @@ void Game::checkGameInput()
// Comprueba el input de disparar a la derecha
if (mInput->checkInput(INPUT_BUTTON_3, REPEAT_TRUE, mOptions->input[i].deviceType, mOptions->input[i].id))
{
if (mPlayer[i]->canFire())
if (player->canFire())
{
mPlayer[i]->setInput(INPUT_BUTTON_3);
createBullet(mPlayer[i]->getPosX() + (mPlayer[i]->getWidth() / 2) - 4, mPlayer[i]->getPosY() + (mPlayer[i]->getHeight() / 2), BULLET_RIGHT, mPlayer[i]->isPowerUp(), i);
mPlayer[i]->setFireCooldown(10);
player->setInput(INPUT_BUTTON_3);
createBullet(player->getPosX() + (player->getWidth() / 2) - 4, player->getPosY() + (player->getHeight() / 2), BULLET_RIGHT, player->isPowerUp(), i);
player->setFireCooldown(10);
// Reproduce el sonido de disparo
JA_PlaySound(mSoundBullet);
@@ -3039,6 +2925,8 @@ void Game::checkGameInput()
{
mSection.name = PROG_SECTION_QUIT;
}
i++;
}
}
}
@@ -3170,9 +3058,9 @@ void Game::shakeScreen()
renderBalloons();
renderBullets();
renderItems();
for (int i = 0; i < mNumPlayers; i++)
for (auto player:players)
{
mPlayer[i]->render();
player->render();
}
renderScoreBoard();
@@ -3210,7 +3098,7 @@ section_t Game::run()
// Reproduce la música
if (!mGameCompleted)
{
if (mPlayer[0]->isAlive())
if (players[0]->isAlive())
{
JA_PlayMusic(mMusicPlaying);
}
@@ -3420,13 +3308,13 @@ void Game::runGameOverScreen()
if (mNumPlayers == 1)
{
mTextBig->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - (BLOCK * 4), mLang->getText(43));
mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - (BLOCK * 1), mLang->getText(44) + std::to_string(mPlayer[0]->getScore()));
mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - (BLOCK * 1), mLang->getText(44) + std::to_string(players[0]->getScore()));
}
else
{
mTextBig->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - 36, mLang->getText(43));
mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - 12, mLang->getText(77) + std::to_string(mPlayer[0]->getScore()));
mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y, mLang->getText(78) + std::to_string(mPlayer[1]->getScore()));
mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y - 12, mLang->getText(77) + std::to_string(players[0]->getScore()));
mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y, mLang->getText(78) + std::to_string(players[1]->getScore()));
}
mText->writeCentered(PLAY_AREA_CENTER_X, PLAY_AREA_CENTER_Y + BLOCK * 2, mLang->getText(45));
mMenuGameOver->render();
@@ -3470,7 +3358,7 @@ void Game::renderDebugInfo()
mText->writeShadowed(2, 2 + 3 * BLOCK, "mCounter: " + std::to_string(mCounter), color);
mText->writeShadowed(2, 2 + 4 * BLOCK, "(R)enemyset: " + std::to_string(mDebug.enemySet), color);
mText->writeShadowed(2, 2 + 5 * BLOCK, "RGB: " + std::to_string(mDebug.gradR) + "," + std::to_string(mDebug.gradG) + "," + std::to_string(mDebug.gradB), color);
mText->writeShadowed(2, 2 + 6 * BLOCK, "(I)invuln: " + std::to_string(mPlayer[0]->getInvulnerableCounter()), color);
mText->writeShadowed(2, 2 + 6 * BLOCK, "(I)invuln: " + std::to_string(players[0]->getInvulnerableCounter()), color);
mText->writeShadowed(2, 2 + 7 * BLOCK, "balloons: " + std::to_string(countBalloons()), color);
mText->writeShadowed(2, 2 + 8 * BLOCK, "balloonsPop: " + std::to_string(mBalloonsPopped), color);
mText->writeShadowed(2, 2 + 9 * BLOCK, "(Z-X)ballSped:" + std::to_string(mEnemySpeed), color);
@@ -3494,11 +3382,11 @@ int Game::calculateScreenPower()
{
int power = 0;
for (int i = 0; i < MAX_BALLOONS; i++)
for (auto balloon:balloons)
{
if (mBalloon[i]->isEnabled())
if (balloon->isEnabled())
{
power += mBalloon[i]->getPower();
power += balloon->getPower();
}
}
@@ -3585,9 +3473,9 @@ void Game::updateHelper()
// Solo ofrece ayuda cuando la amenaza es elevada
if (mMenaceCurrent > 15)
{
for (int i = 0; i < mNumPlayers; i++)
for (auto player:players)
{
if (mPlayer[i]->getCoffees() == 0)
if (player->getCoffees() == 0)
{
mHelper.needCoffee = true;
}
@@ -3596,7 +3484,7 @@ void Game::updateHelper()
mHelper.needCoffee = false;
}
if (!mPlayer[i]->isPowerUp())
if (!player->isPowerUp())
{
mHelper.needCoffeeMachine = true;
}
@@ -3617,9 +3505,9 @@ void Game::updateHelper()
bool Game::allPlayersAreDead()
{
bool success = true;
for (int i = 0; i < mNumPlayers; i++)
for (auto player:players)
{
success &= (!mPlayer[i]->isAlive());
success &= (!player->isAlive());
}
return success;

24
source/game.h
View File

@@ -134,15 +134,9 @@ private:
Lang *mLang; // Objeto para gestionar los textos en diferentes idiomas
Input *mInput; // Manejador de entrada
// Player *mPlayer[2]; // Vector con los jugadores jugador
// Balloon *mBalloon[MAX_BALLOONS]; // Vector con los objetos globo
// Bullet *mBullet[MAX_BULLETS]; // Vector con los objetos bala
// Item *mItem[MAX_ITEMS]; // Vector con los objetos item
// SmartSprite *mSmartSprite[MAX_SMART_SPRITES]; // Vector para almacenar y gestionar SmartSprites
int mNumPlayers; // Numero de jugadores
std::vector<Player *> players; // Vector con los jugadores
std::vector<Balloon *> balloons; // Vector con los globos
std::vector<Balloon *> balloons; // Vector con los globos
std::vector<Bullet *> bullets; // Vector con las balas
std::vector<Item *> items; // Vector con los items
std::vector<SmartSprite *> smartSprites; // Vector con los smartsprites
@@ -322,9 +316,6 @@ private:
// Crea una PowerBall
void createPowerBall();
// Establece a cero todos los valores del vector de objetos globo
void resetBalloons();
// Establece la velocidad de los globos
void setBalloonSpeed(float speed);
@@ -373,9 +364,6 @@ private:
// Pinta las balas activas
void renderBullets();
// Establece a cero todos los valores del vector de objetos bala
void resetBullets();
// Crea un objeto bala
void createBullet(int x, int y, Uint8 kind, bool poweredUp, int owner);
@@ -385,14 +373,11 @@ private:
// Pinta los items activos
void renderItems();
// Establece a cero todos los valores del vector de objetos item
void resetItems();
// Devuelve un item en función del azar
Uint8 dropItem();
// Crea un objeto item
void createItem(int x, int y, Uint8 kind);
void createItem(LTexture *texture, SDL_Renderer *renderer, Uint8 type, float x, float y);
// Crea un objeto SmartSprite
void createItemScoreSprite(int x, int y, SmartSprite *sprite);
@@ -407,7 +392,7 @@ private:
void throwCoffee(int x, int y);
// Crea un SmartSprite para arrojar al jugador al morir
void throwPlayer(int x, int y, int index);
void throwPlayer(int x, int y, Player *player);
// Actualiza los SmartSprites
void updateSmartSprites();
@@ -415,9 +400,6 @@ private:
// Pinta los SmartSprites activos
void renderSmartSprites();
// Establece a cero todos los valores del vector de objetos SmafrtSprite
void resetSmartSprites();
// Acciones a realizar cuando el jugador muere
void killPlayer(Player *player);

1
source/intro.cpp
View File

@@ -74,7 +74,6 @@ void Intro::init()
// Inicializa los bitmaps de la intro
for (int i = 0; i < INTRO_TOTAL_BITMAPS; i++)
{
mBitmap[i]->init();
mBitmap[i]->setId(i);
mBitmap[i]->setIntroEvents(&mEvents[0]);
mBitmap[i]->setWidth(128);

21
source/item.cpp
View File

@@ -2,22 +2,10 @@
#include "item.h"
// Constructor
Item::Item(LTexture *texture, SDL_Renderer *renderer)
Item::Item(LTexture *texture, SDL_Renderer *renderer, Uint8 type, float x, float y)
{
mSprite = new AnimatedSprite(texture, renderer);
init(NO_KIND, 0.0f, 0.0f);
}
// Destructor
Item::~Item()
{
delete mSprite;
mSprite = nullptr;
}
// Inicializador
void Item::init(Uint8 type, float x, float y)
{
mClass = type;
mEnabled = true;
mTimeToLive = 600;
@@ -104,6 +92,13 @@ void Item::init(Uint8 type, float x, float y)
}
}
// Destructor
Item::~Item()
{
delete mSprite;
mSprite = nullptr;
}
// Centra el objeto en la posición X
void Item::allignTo(int x)
{

5
source/item.h
View File

@@ -43,14 +43,11 @@ public:
Uint16 mTimeToLive; // Temporizador con el tiempo que el objeto está presente
// Constructor
Item(LTexture *texture, SDL_Renderer *renderer);
Item(LTexture *texture, SDL_Renderer *renderer, Uint8 type, float x, float y);
// Destructor
~Item();
// Inicializador
void init(Uint8 type, float x, float y);
// Centra el objeto en la posición X
void allignTo(int x);

126
source/player.cpp
View File

@@ -75,11 +75,6 @@ void Player::init()
// Inicia el contador para la cadencia de disparo
mCooldown = 10;
// Inicia el sprite
mSpriteLegs->init();
mSpriteBody->init();
mSpriteHead->init();
// Establece el alto y ancho del sprite
mSpriteLegs->setWidth(mWidth);
mSpriteLegs->setHeight(mHeight);
@@ -110,25 +105,6 @@ void Player::init()
mSpriteHead->setCurrentFrame(0);
mSpriteHead->setAnimationCounter(0);
// Establece el numero de frames de cada animacion
mSpriteLegs->setAnimationNumFrames(PLAYER_ANIMATION_LEGS_WALKING_STOP, 4);
mSpriteLegs->setAnimationNumFrames(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 4);
mSpriteLegs->setAnimationNumFrames(PLAYER_ANIMATION_LEGS_WALKING_RIGHT, 4);
mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_LEFT, 4);
mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_LEFT, 4);
mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_RIGHT, 4);
mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_RIGHT, 4);
mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_WALKING_STOP, 4);
mSpriteBody->setAnimationNumFrames(PLAYER_ANIMATION_BODY_FIRING_UP, 4);
mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_WALKING_LEFT, 4);
mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_FIRING_LEFT, 4);
mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_WALKING_RIGHT, 4);
mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_FIRING_RIGHT, 4);
mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_WALKING_STOP, 4);
mSpriteHead->setAnimationNumFrames(PLAYER_ANIMATION_HEAD_FIRING_UP, 4);
// Establece la velocidad de cada animación
mSpriteLegs->setAnimationSpeed(PLAYER_ANIMATION_LEGS_WALKING_STOP, 10);
mSpriteLegs->setAnimationSpeed(PLAYER_ANIMATION_LEGS_WALKING_LEFT, 5);
@@ -381,100 +357,134 @@ void Player::setAnimation()
switch (mStatusWalking)
{
case PLAYER_STATUS_WALKING_LEFT:
mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_LEFT);
mSpriteLegs->setCurrentAnimation(PLAYER_ANIMATION_LEGS_WALKING_LEFT);
mSpriteLegs->animate();
switch (mStatusFiring)
{
case PLAYER_STATUS_FIRING_UP:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_UP);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_UP);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_UP);
mSpriteHead->animate();
break;
case PLAYER_STATUS_FIRING_LEFT:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_LEFT);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
mSpriteHead->animate();
break;
case PLAYER_STATUS_FIRING_RIGHT:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
mSpriteHead->animate();
break;
case PLAYER_STATUS_FIRING_NO:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_LEFT);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_LEFT);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_LEFT);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_LEFT);
mSpriteHead->animate();
break;
default:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_STOP);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_STOP);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_STOP);
mSpriteHead->animate();
break;
}
break;
case PLAYER_STATUS_WALKING_RIGHT:
mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_RIGHT);
mSpriteLegs->setCurrentAnimation(PLAYER_ANIMATION_LEGS_WALKING_RIGHT);
mSpriteLegs->animate();
switch (mStatusFiring)
{
case PLAYER_STATUS_FIRING_UP:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_UP);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_UP);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_UP);
mSpriteHead->animate();
break;
case PLAYER_STATUS_FIRING_LEFT:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_LEFT);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
mSpriteHead->animate();
break;
case PLAYER_STATUS_FIRING_RIGHT:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
mSpriteHead->animate();
break;
case PLAYER_STATUS_FIRING_NO:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_RIGHT);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_RIGHT);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_RIGHT);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_RIGHT);
mSpriteHead->animate();
break;
default:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_STOP);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_STOP);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_STOP);
mSpriteHead->animate();
break;
}
break;
case PLAYER_STATUS_WALKING_STOP:
mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_STOP);
mSpriteLegs->setCurrentAnimation(PLAYER_ANIMATION_LEGS_WALKING_STOP);
mSpriteLegs->animate();
switch (mStatusFiring)
{
case PLAYER_STATUS_FIRING_UP:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_UP);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_UP);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_UP);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_UP);
mSpriteHead->animate();
break;
case PLAYER_STATUS_FIRING_LEFT:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_LEFT);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_LEFT);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_LEFT);
mSpriteHead->animate();
break;
case PLAYER_STATUS_FIRING_RIGHT:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_FIRING_RIGHT);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_FIRING_RIGHT);
mSpriteHead->animate();
break;
case PLAYER_STATUS_FIRING_NO:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_STOP);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_STOP);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_STOP);
mSpriteHead->animate();
break;
default:
mSpriteBody->animate(PLAYER_ANIMATION_BODY_WALKING_STOP);
mSpriteHead->animate(PLAYER_ANIMATION_HEAD_WALKING_STOP);
mSpriteBody->setCurrentAnimation(PLAYER_ANIMATION_BODY_WALKING_STOP);
mSpriteBody->animate();
mSpriteHead->setCurrentAnimation(PLAYER_ANIMATION_HEAD_WALKING_STOP);
mSpriteHead->animate();
break;
}
break;
default:
mSpriteLegs->animate(PLAYER_ANIMATION_LEGS_WALKING_STOP);
mSpriteLegs->setCurrentAnimation(PLAYER_ANIMATION_LEGS_WALKING_STOP);
mSpriteLegs->animate();
break;
}
}

14
source/smartsprite.cpp
View File

@@ -6,16 +6,7 @@ SmartSprite::SmartSprite(LTexture *texture, SDL_Renderer *renderer)
{
setTexture(texture);
setRenderer(renderer);
}
// Destructor
SmartSprite::~SmartSprite()
{
}
// Inicializador
void SmartSprite::init()
{
setPosX(0);
setPosY(0);
setWidth(0);
@@ -47,6 +38,11 @@ void SmartSprite::init()
introEvents = nullptr;
}
// Destructor
SmartSprite::~SmartSprite()
{
}
// Obtiene el valor de la variable
bool SmartSprite::isEnabled()
{

3
source/smartsprite.h
View File

@@ -26,9 +26,6 @@ public:
// Destructor
~SmartSprite();
// Inicializador
void init();
// Obtiene el valor de la variable
bool isEnabled();

2
source/title.cpp
View File

@@ -28,7 +28,7 @@ Title::Title(SDL_Window *window, SDL_Renderer *renderer, Screen *screen, Input *
mGradient = new Sprite();
mText = new Text(mAsset->get("smb2.png"), mAsset->get("smb2.txt"), mRenderer);
mText2 = new Text(mAsset->get("8bithud.png"), mAsset->get("8bithud.txt"), mRenderer);
mMenu.title = new Menu(mRenderer, mInput, mAsset);
mMenu.title = new Menu(this->mRenderer, this->mInput, this->mAsset);
mMenu.options = new Menu(mRenderer, mInput, mAsset);
// Crea la textura para el mosaico de fondo