jaildesigner-jailgames/coffee_crisis_arcade_edition
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 13 Wiki Activity

Treballant en els game_texts

Browse Source
This commit is contained in:
Sergio
2024-10-15 14:02:37 +02:00
parent 3b9885ab03
commit 3fdd60c9e2
5 changed files with 136 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
source/game.cpp
View File

@@ -21,7 +21,7 @@
#include "fade.h" // for Fade, FadeType #include "fade.h" // for Fade, FadeType
#include "global_inputs.h" // for check #include "global_inputs.h" // for check
#include "input.h" // for InputType, Input, INPUT_DO_NOT_ALL... #include "input.h" // for InputType, Input, INPUT_DO_NOT_ALL...
#include "item.h" // for Item, ITEM_COFFEE_MACHINE, ITEM_CLOCK #include "item.h" // for Item, ItemType::COFFEE_MACHINE, ItemType::CLOCK
#include "jail_audio.h" // for JA_PlaySound, JA_DeleteSound, JA_L... #include "jail_audio.h" // for JA_PlaySound, JA_DeleteSound, JA_L...
#include "lang.h" // for getText #include "lang.h" // for getText
#include "manage_hiscore_table.h" // for ManageHiScoreTable #include "manage_hiscore_table.h" // for ManageHiScoreTable
@@ -39,7 +39,8 @@ struct JA_Sound_t; // lines 36-36
// Constructor // Constructor
Game::Game(int player_id, int current_stage, bool demo, JA_Music_t *music) Game::Game(int player_id, int current_stage, bool demo, JA_Music_t *music)
: music_(music), current_stage_(current_stage) : music_(music),
current_stage_(current_stage)
{ {
// Copia los punteros // Copia los punteros
asset_ = Asset::get(); asset_ = Asset::get();
@@ -75,11 +76,11 @@ Game::Game(int player_id, int current_stage, bool demo, JA_Music_t *music)
background_->setPos(param.game.play_area.rect); background_->setPos(param.game.play_area.rect);
game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(0))); // game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(0)));
game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(1))); // game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(1)));
game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(2))); // game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(2)));
game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(3))); // game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(3)));
game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(4))); // game_text_sprites_.emplace_back(std::make_shared<SmartSprite>(game_text_textures_.at(4)));
explosions_->addTexture(1, explosions_textures_[0], explosions_animations_[0]); explosions_->addTexture(1, explosions_textures_[0], explosions_animations_[0]);
explosions_->addTexture(2, explosions_textures_[1], explosions_animations_[1]); explosions_->addTexture(2, explosions_textures_[1], explosions_animations_[1]);
@@ -298,11 +299,7 @@ void Game::init(int player_id)
evaluateAndSetMenace(); evaluateAndSetMenace();
// Inicializa los sprites con los textos que aparecen al coger items // Inicializa los sprites con los textos que aparecen al coger items
for (auto &sprite : game_text_sprites_) smart_sprites_.clear();
{
sprite->setVelY(-0.5f);
sprite->setAccelY(-0.1f);
}
} }
// Carga los recursos necesarios para la sección 'Game' // Carga los recursos necesarios para la sección 'Game'
@@ -341,83 +338,54 @@ void Game::loadMedia()
// Texturas - Globos // Texturas - Globos
{ {
auto balloon1_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon1.png")); balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("balloon1.png")));
balloon_textures_.push_back(balloon1_texture); balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("balloon2.png")));
balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("balloon3.png")));
auto balloon2_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon2.png")); balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("balloon4.png")));
balloon_textures_.push_back(balloon2_texture); balloon_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("powerball.png")));
}
auto balloon3_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon3.png"));
balloon_textures_.push_back(balloon3_texture);
auto balloon4_texture = std::make_shared<Texture>(renderer_, asset_->get("balloon4.png"));
balloon_textures_.push_back(balloon4_texture);
auto balloon5_texture = std::make_shared<Texture>(renderer_, asset_->get("powerball.png"));
balloon_textures_.push_back(balloon5_texture);
// Texturas - Explosiones // Texturas - Explosiones
auto explosion1_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion1.png")); {
explosions_textures_.push_back(explosion1_texture); explosions_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("explosion1.png")));
explosions_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("explosion2.png")));
auto explosion2_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion2.png")); explosions_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("explosion3.png")));
explosions_textures_.push_back(explosion2_texture); explosions_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("explosion4.png")));
auto explosion3_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion3.png"));
explosions_textures_.push_back(explosion3_texture);
auto explosion4_texture = std::make_shared<Texture>(renderer_, asset_->get("explosion4.png"));
explosions_textures_.push_back(explosion4_texture);
} }
// Texturas - Items // Texturas - Items
{ {
auto item1 = std::make_shared<Texture>(renderer_, asset_->get("item_points1_disk.png")); item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_points1_disk.png")));
item_textures_.push_back(item1); item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_points2_gavina.png")));
item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_points3_pacmar.png")));
auto item2 = std::make_shared<Texture>(renderer_, asset_->get("item_points2_gavina.png")); item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_clock.png")));
item_textures_.push_back(item2); item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_coffee.png")));
item_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("item_coffee_machine.png")));
auto item3 = std::make_shared<Texture>(renderer_, asset_->get("item_points3_pacmar.png"));
item_textures_.push_back(item3);
auto item4 = std::make_shared<Texture>(renderer_, asset_->get("item_clock.png"));
item_textures_.push_back(item4);
auto item5 = std::make_shared<Texture>(renderer_, asset_->get("item_coffee.png"));
item_textures_.push_back(item5);
auto item6 = std::make_shared<Texture>(renderer_, asset_->get("item_coffee_machine.png"));
item_textures_.push_back(item6);
} }
// Texturas - Player1 // Texturas - Player1
{ {
auto player1_texture = std::make_shared<Texture>(renderer_, asset_->get("player1.gif")); player1_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("player1.gif")));
player1_texture->addPalette(asset_->get("player1_pal1.gif")); player1_textures_.back()->addPalette(asset_->get("player1_pal1.gif"));
player1_texture->addPalette(asset_->get("player1_pal2.gif")); player1_textures_.back()->addPalette(asset_->get("player1_pal2.gif"));
player1_texture->addPalette(asset_->get("player1_pal3.gif")); player1_textures_.back()->addPalette(asset_->get("player1_pal3.gif"));
player1_textures_.push_back(player1_texture);
auto player1_power_texture = std::make_shared<Texture>(renderer_, asset_->get("player_power.gif")); player1_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("player_power.gif")));
player1_power_texture->addPalette(asset_->get("player_power_pal.gif")); player1_textures_.back()->addPalette(asset_->get("player_power_pal.gif"));
player1_textures_.push_back(player1_power_texture);
player_textures_.push_back(player1_textures_); player_textures_.push_back(player1_textures_);
} }
// Texturas - Player2 // Texturas - Player2
{ {
auto player2_texture = std::make_shared<Texture>(renderer_, asset_->get("player2.gif")); player2_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("player2.gif")));
player2_texture->addPalette(asset_->get("player2_pal1.gif")); player2_textures_.back()->addPalette(asset_->get("player2_pal1.gif"));
player2_texture->addPalette(asset_->get("player2_pal2.gif")); player2_textures_.back()->addPalette(asset_->get("player2_pal2.gif"));
player2_texture->addPalette(asset_->get("player2_pal3.gif")); player2_textures_.back()->addPalette(asset_->get("player2_pal3.gif"));
player2_textures_.push_back(player2_texture);
auto player2_power_texture = std::make_shared<Texture>(renderer_, asset_->get("player_power.gif")); player2_textures_.emplace_back(std::make_shared<Texture>(renderer_, asset_->get("player_power.gif")));
player2_power_texture->addPalette(asset_->get("player_power_pal.gif")); player2_textures_.back()->addPalette(asset_->get("player_power_pal.gif"));
player2_power_texture->setPalette(1); player2_textures_.back()->setPalette(1);
player2_textures_.push_back(player2_power_texture);
player_textures_.push_back(player2_textures_); player_textures_.push_back(player2_textures_);
} }
@@ -1161,55 +1129,55 @@ void Game::checkPlayerItemCollision(std::shared_ptr<Player> &player)
{ {
if (checkCollision(player->getCollider(), item->getCollider())) if (checkCollision(player->getCollider(), item->getCollider()))
{ {
switch (item->getClass()) switch (item->getType())
{ {
case ITEM_POINTS_1_DISK: case ItemType::DISK:
{ {
player->addScore(1000); player->addScore(1000);
createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[0]->getWidth() / 2), player->getPosY(), game_text_sprites_[0]); createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[0]->getWidth() / 2), player->getPosY(), game_text_textures_[0]);
break; break;
} }
case ITEM_POINTS_2_GAVINA: case ItemType::GAVINA:
{ {
player->addScore(2500); player->addScore(2500);
createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[1]->getWidth() / 2), player->getPosY(), game_text_sprites_[1]); createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[1]->getWidth() / 2), player->getPosY(), game_text_textures_[1]);
break; break;
} }
case ITEM_POINTS_3_PACMAR: case ItemType::PACMAR:
{ {
player->addScore(5000); player->addScore(5000);
createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[2]->getWidth() / 2), player->getPosY(), game_text_sprites_[2]); createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[2]->getWidth() / 2), player->getPosY(), game_text_textures_[2]);
break; break;
} }
case ITEM_CLOCK: case ItemType::CLOCK:
{ {
enableTimeStopItem(); enableTimeStopItem();
break; break;
} }
case ITEM_COFFEE: case ItemType::COFFEE:
{ {
if (player->getCoffees() == 2) if (player->getCoffees() == 2)
{ {
player->addScore(5000); player->addScore(5000);
createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[2]->getWidth() / 2), player->getPosY(), game_text_sprites_[2]); createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[2]->getWidth() / 2), player->getPosY(), game_text_textures_[2]);
} }
else else
{ {
player->giveExtraHit(); player->giveExtraHit();
createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[4]->getWidth() / 2), player->getPosY(), game_text_sprites_[4]); createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[4]->getWidth() / 2), player->getPosY(), game_text_textures_[4]);
} }
break; break;
} }
case ITEM_COFFEE_MACHINE: case ItemType::COFFEE_MACHINE:
{ {
player->setPowerUp(); player->setPowerUp();
coffee_machine_enabled_ = false; coffee_machine_enabled_ = false;
createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_sprites_[3]->getWidth() / 2), player->getPosY(), game_text_sprites_[3]); createItemScoreSprite(item->getPosX() + (item->getWidth() / 2) - (game_text_textures_[3]->getWidth() / 2), player->getPosY(), game_text_textures_[3]);
break; break;
} }
@@ -1248,9 +1216,9 @@ void Game::checkBulletBalloonCollision()
// Suelta el item si se da el caso // Suelta el item si se da el caso
const auto droppeditem = dropItem(); const auto droppeditem = dropItem();
if (droppeditem != ITEM_NULL && !demo_.recording) if (droppeditem != ItemType::NONE && !demo_.recording)
{ {
if (droppeditem != ITEM_COFFEE_MACHINE) if (droppeditem != ItemType::COFFEE_MACHINE)
{ {
createItem(droppeditem, balloon->getPosX(), balloon->getPosY()); createItem(droppeditem, balloon->getPosX(), balloon->getPosY());
JA_PlaySound(item_drop_sound_); JA_PlaySound(item_drop_sound_);
@@ -1354,7 +1322,7 @@ void Game::renderItems()
} }
// Devuelve un item al azar y luego segun sus probabilidades // Devuelve un item al azar y luego segun sus probabilidades
int Game::dropItem() ItemType Game::dropItem()
{ {
const auto lucky_number = rand() % 100; const auto lucky_number = rand() % 100;
const auto item = rand() % 6; const auto item = rand() % 6;
@@ -1364,28 +1332,28 @@ int Game::dropItem()
case 0: case 0:
if (lucky_number < helper_.item_disk_odds) if (lucky_number < helper_.item_disk_odds)
{ {
return ITEM_POINTS_1_DISK; return ItemType::DISK;
} }
break; break;
case 1: case 1:
if (lucky_number < helper_.item_gavina_odds) if (lucky_number < helper_.item_gavina_odds)
{ {
return ITEM_POINTS_2_GAVINA; return ItemType::GAVINA;
} }
break; break;
case 2: case 2:
if (lucky_number < helper_.item_pacmar_odds) if (lucky_number < helper_.item_pacmar_odds)
{ {
return ITEM_POINTS_3_PACMAR; return ItemType::GAVINA;
} }
break; break;
case 3: case 3:
if (lucky_number < helper_.item_clock_odds) if (lucky_number < helper_.item_clock_odds)
{ {
return ITEM_CLOCK; return ItemType::CLOCK;
} }
break; break;
@@ -1393,7 +1361,7 @@ int Game::dropItem()
if (lucky_number < helper_.item_coffee_odds) if (lucky_number < helper_.item_coffee_odds)
{ {
helper_.item_coffee_odds = ITEM_COFFEE_ODDS; helper_.item_coffee_odds = ITEM_COFFEE_ODDS;
return ITEM_COFFEE; return ItemType::COFFEE;
} }
else else
{ {
@@ -1410,7 +1378,7 @@ int Game::dropItem()
helper_.item_coffee_machine_odds = ITEM_COFFEE_MACHINE_ODDS; helper_.item_coffee_machine_odds = ITEM_COFFEE_MACHINE_ODDS;
if (!coffee_machine_enabled_ && helper_.need_coffee_machine) if (!coffee_machine_enabled_ && helper_.need_coffee_machine)
{ {
return ITEM_COFFEE_MACHINE; return ItemType::COFFEE_MACHINE;
} }
} }
else else
@@ -1426,14 +1394,13 @@ int Game::dropItem()
break; break;
} }
return ITEM_NULL; return ItemType::NONE;
} }
// Crea un objeto item // Crea un objeto item
void Game::createItem(int kind, float x, float y) void Game::createItem(ItemType type, float x, float y)
{ {
auto item = std::make_unique<Item>(kind, x, y, &(param.game.play_area.rect), item_textures_[kind - 1], item_animations_[kind - 1]); items_.emplace_back(std::make_unique<Item>(type, x, y, &(param.game.play_area.rect), item_textures_[static_cast<int>(type) - 1], item_animations_[static_cast<int>(type) - 1]));
items_.push_back(std::move(item));
} }
// Vacia el vector de items // Vacia el vector de items
@@ -1452,19 +1419,22 @@ void Game::freeItems()
} }
// Crea un objeto SmartSprite para mostrar la puntuación al coger un objeto // Crea un objeto SmartSprite para mostrar la puntuación al coger un objeto
void Game::createItemScoreSprite(int x, int y, std::shared_ptr<SmartSprite> sprite) void Game::createItemScoreSprite(int x, int y, std::shared_ptr<Texture> texture)
{ {
auto ss = sprite.get(); smart_sprites_.emplace_back(std::make_unique<SmartSprite>(texture));
smart_sprites_.push_back(ss);
// Crea una copia del objeto // Inicializa
*ss = *sprite; smart_sprites_.back()->init();
ss->setPosX(x); smart_sprites_.back()->setPos({0, 0, texture->getWidth(), texture->getHeight()});
ss->setPosY(y); smart_sprites_.back()->setSpriteClip(smart_sprites_.back()->getPos());
ss->setDestX(x); smart_sprites_.back()->setPosX(x);
ss->setDestY(y - 25); smart_sprites_.back()->setPosY(y);
ss->setEnabled(true); smart_sprites_.back()->setDestX(x);
ss->setFinishedCounter(100); smart_sprites_.back()->setDestY(y - 25);
smart_sprites_.back()->setVelY(-0.5f);
smart_sprites_.back()->setAccelY(-0.1f);
smart_sprites_.back()->setEnabled(true);
smart_sprites_.back()->setFinishedCounter(100);
} }
// Vacia el vector de smartsprites // Vacia el vector de smartsprites
@@ -1485,31 +1455,30 @@ void Game::freeSmartSprites()
// Crea un SmartSprite para arrojar el item café al recibir un impacto // Crea un SmartSprite para arrojar el item café al recibir un impacto
void Game::throwCoffee(int x, int y) void Game::throwCoffee(int x, int y)
{ {
auto ss = new SmartSprite(item_textures_[4]); smart_sprites_.emplace_back(std::make_unique<SmartSprite>(item_textures_[4]));
smart_sprites_.push_back(ss);
ss->setPosX(x - 8); smart_sprites_.back()->setPosX(x - 8);
ss->setPosY(y - 8); smart_sprites_.back()->setPosY(y - 8);
ss->setWidth(param.game.item_size); smart_sprites_.back()->setWidth(param.game.item_size);
ss->setHeight(param.game.item_size); smart_sprites_.back()->setHeight(param.game.item_size);
ss->setVelX(-1.0f + ((rand() % 5) * 0.5f)); smart_sprites_.back()->setVelX(-1.0f + ((rand() % 5) * 0.5f));
ss->setVelY(-4.0f); smart_sprites_.back()->setVelY(-4.0f);
ss->setAccelX(0.0f); smart_sprites_.back()->setAccelX(0.0f);
ss->setAccelY(0.2f); smart_sprites_.back()->setAccelY(0.2f);
ss->setDestX(x + (ss->getVelX() * 50)); smart_sprites_.back()->setDestX(x + (smart_sprites_.back()->getVelX() * 50));
ss->setDestY(param.game.height + 1); smart_sprites_.back()->setDestY(param.game.height + 1);
ss->setEnabled(true); smart_sprites_.back()->setEnabled(true);
ss->setFinishedCounter(1); smart_sprites_.back()->setFinishedCounter(1);
ss->setSpriteClip(0, param.game.item_size, param.game.item_size, param.game.item_size); smart_sprites_.back()->setSpriteClip(0, param.game.item_size, param.game.item_size, param.game.item_size);
ss->setRotate(true); smart_sprites_.back()->setRotate(true);
ss->setRotateSpeed(10); smart_sprites_.back()->setRotateSpeed(10);
ss->setRotateAmount(90.0); smart_sprites_.back()->setRotateAmount(90.0);
} }
// Actualiza los SmartSprites // Actualiza los SmartSprites
void Game::updateSmartSprites() void Game::updateSmartSprites()
{ {
for (auto ss : smart_sprites_) for (auto &ss : smart_sprites_)
{ {
ss->update(); ss->update();
} }
@@ -1518,7 +1487,7 @@ void Game::updateSmartSprites()
// Pinta los SmartSprites activos // Pinta los SmartSprites activos
void Game::renderSmartSprites() void Game::renderSmartSprites()
{ {
for (auto ss : smart_sprites_) for (auto &ss : smart_sprites_)
{ {
ss->render(); ss->render();
} }

11
source/game.h
View File

@@ -24,6 +24,7 @@ class Texture;
enum class BulletType; // lines 26-26 enum class BulletType; // lines 26-26
struct JA_Music_t; // lines 27-27 struct JA_Music_t; // lines 27-27
struct JA_Sound_t; // lines 28-28 struct JA_Sound_t; // lines 28-28
enum class ItemType;
// Modo demo // Modo demo
constexpr bool GAME_MODE_DEMO_OFF = false; constexpr bool GAME_MODE_DEMO_OFF = false;
@@ -122,7 +123,7 @@ private:
std::vector<std::shared_ptr<Balloon>> balloons_; // Vector con los globos std::vector<std::shared_ptr<Balloon>> balloons_; // Vector con los globos
std::vector<std::unique_ptr<Bullet>> bullets_; // Vector con las balas std::vector<std::unique_ptr<Bullet>> bullets_; // Vector con las balas
std::vector<std::unique_ptr<Item>> items_; // Vector con los items std::vector<std::unique_ptr<Item>> items_; // Vector con los items
std::vector<SmartSprite *> smart_sprites_; // Vector con los smartsprites std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites
std::shared_ptr<Texture> bullet_texture_; // Textura para las balas std::shared_ptr<Texture> bullet_texture_; // Textura para las balas
std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items std::vector<std::shared_ptr<Texture>> item_textures_; // Vector con las texturas de los items
@@ -133,7 +134,7 @@ private:
std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores; std::vector<std::vector<std::shared_ptr<Texture>>> player_textures_; // Vector con todas las texturas de los jugadores;
std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos std::vector<std::shared_ptr<Texture>> game_text_textures_; // Vector con las texturas para los sprites con textos
std::vector<std::shared_ptr<SmartSprite>> game_text_sprites_; // Sprite con el textos que aparecen al coger items //std::vector<std::shared_ptr<SmartSprite>> game_text_sprites_; // Sprite con el textos que aparecen al coger items
std::vector<std::vector<std::string> *> item_animations_; // Vector con las animaciones de los items std::vector<std::vector<std::string> *> item_animations_; // Vector con las animaciones de los items
std::vector<std::vector<std::string> *> player_animations_; // Vector con las animaciones del jugador std::vector<std::vector<std::string> *> player_animations_; // Vector con las animaciones del jugador
@@ -312,16 +313,16 @@ private:
void renderItems(); void renderItems();
// Devuelve un item en función del azar // Devuelve un item en función del azar
int dropItem(); ItemType dropItem();
// Crea un objeto item // Crea un objeto item
void createItem(int kind, float x, float y); void createItem(ItemType type, float x, float y);
// Vacia el vector de items // Vacia el vector de items
void freeItems(); void freeItems();
// Crea un objeto SmartSprite // Crea un objeto SmartSprite
void createItemScoreSprite(int x, int y, std::shared_ptr<SmartSprite> sprite); void createItemScoreSprite(int x, int y, std::shared_ptr<Texture> texture);
// Vacia el vector de smartsprites // Vacia el vector de smartsprites
void freeSmartSprites(); void freeSmartSprites();

14
source/item.cpp
View File

@@ -5,16 +5,16 @@
class Texture; class Texture;
// Constructor // Constructor
Item::Item(int kind, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation) Item::Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation)
: sprite_(std::make_unique<AnimatedSprite>(texture, "", animation)), : sprite_(std::make_unique<AnimatedSprite>(texture, "", animation)),
accel_x_(0.0f), accel_x_(0.0f),
floor_collision_(false), floor_collision_(false),
kind_(kind), type_(type),
enabled_(true), enabled_(true),
play_area_(play_area), play_area_(play_area),
time_to_live_(600) time_to_live_(600)
{ {
if (kind == ITEM_COFFEE_MACHINE) if (type == ItemType::COFFEE_MACHINE)
{ {
width_ = 28; width_ = 28;
height_ = 37; height_ = 37;
@@ -104,7 +104,7 @@ void Item::move()
} }
// Si se sale por arriba rebota (excepto la maquina de café) // Si se sale por arriba rebota (excepto la maquina de café)
if ((pos_y_ < param.game.play_area.rect.y) && !(kind_ == ITEM_COFFEE_MACHINE)) if ((pos_y_ < param.game.play_area.rect.y) && !(type_ == ItemType::COFFEE_MACHINE))
{ {
// Corrige // Corrige
pos_y_ = param.game.play_area.rect.y; pos_y_ = param.game.play_area.rect.y;
@@ -122,7 +122,7 @@ void Item::move()
accel_x_ = 0; accel_x_ = 0;
accel_y_ = 0; accel_y_ = 0;
pos_y_ = play_area_->h - height_; pos_y_ = play_area_->h - height_;
if (kind_ == ITEM_COFFEE_MACHINE) if (type_ == ItemType::COFFEE_MACHINE)
{ {
floor_collision_ = true; floor_collision_ = true;
} }
@@ -190,9 +190,9 @@ int Item::getHeight()
} }
// Obtiene del valor de la variable // Obtiene del valor de la variable
int Item::getClass() ItemType Item::getType()
{ {
return kind_; return type_;
} }
// Obtiene el valor de la variable // Obtiene el valor de la variable

23
source/item.h
View File

@@ -10,13 +10,16 @@
class Texture; class Texture;
// Tipos de objetos // Tipos de objetos
constexpr int ITEM_POINTS_1_DISK = 1; enum class ItemType : int
constexpr int ITEM_POINTS_2_GAVINA = 2; {
constexpr int ITEM_POINTS_3_PACMAR = 3; DISK = 1,
constexpr int ITEM_CLOCK = 4; GAVINA = 2,
constexpr int ITEM_COFFEE = 5; PACMAR = 3,
constexpr int ITEM_COFFEE_MACHINE = 6; CLOCK = 4,
constexpr int ITEM_NULL = 7; COFFEE = 5,
COFFEE_MACHINE = 6,
NONE = 7,
};
// Clase Item // Clase Item
class Item class Item
@@ -35,7 +38,7 @@ private:
float accel_x_; // Aceleración en el eje X float accel_x_; // Aceleración en el eje X
float accel_y_; // Aceleración en el eje Y float accel_y_; // Aceleración en el eje Y
bool floor_collision_; // Indica si el objeto colisiona con el suelo bool floor_collision_; // Indica si el objeto colisiona con el suelo
int kind_; // Especifica el tipo de objeto que es ItemType type_; // Especifica el tipo de objeto que es
bool enabled_; // Especifica si el objeto está habilitado bool enabled_; // Especifica si el objeto está habilitado
Circle collider_; // Circulo de colisión del objeto Circle collider_; // Circulo de colisión del objeto
SDL_Rect *play_area_; // Rectangulo con la zona de juego SDL_Rect *play_area_; // Rectangulo con la zona de juego
@@ -55,7 +58,7 @@ private:
public: public:
// Constructor // Constructor
Item(int kind, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation); Item(ItemType type, float x, float y, SDL_Rect *play_area, std::shared_ptr<Texture> texture, std::vector<std::string> *animation);
// Destructor // Destructor
~Item() = default; ~Item() = default;
@@ -85,7 +88,7 @@ public:
int getHeight(); int getHeight();
// Obtiene del valor de la variable // Obtiene del valor de la variable
int getClass(); ItemType getType();
// Obtiene el valor de la variable // Obtiene el valor de la variable
bool isEnabled(); bool isEnabled();

2
source/smart_sprite.cpp
View File

@@ -127,7 +127,7 @@ void SmartSprite::checkMove()
void SmartSprite::checkFinished() void SmartSprite::checkFinished()
{ {
// Comprueba si ha llegado a su destino // Comprueba si ha llegado a su destino
on_destination_ = (getPosX() == dest_x_ && getPosY() == dest_y_) ? true : false; on_destination_ = (getPosX() == dest_x_ && getPosY() == dest_y_);
if (on_destination_) if (on_destination_)
{ {