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

227
source/game.cpp
View File

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

19
source/game.h
View File

@@ -24,6 +24,7 @@ class Texture;
enum class BulletType; // lines 26-26
struct JA_Music_t; // lines 27-27
struct JA_Sound_t; // lines 28-28
enum class ItemType;
// Modo demo
constexpr bool GAME_MODE_DEMO_OFF = false;
@@ -118,11 +119,11 @@ private:
SDL_Texture *canvas_; // Textura para dibujar la zona de juego
std::vector<std::shared_ptr<Player>> players_; // Vector con los jugadores
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<Item>> items_; // Vector con los items
std::vector<SmartSprite *> smart_sprites_; // Vector con los smartsprites
std::vector<std::shared_ptr<Player>> players_; // Vector con los jugadores
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<Item>> items_; // Vector con los items
std::vector<std::unique_ptr<SmartSprite>> smart_sprites_; // Vector con los smartsprites
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
@@ -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::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> *> player_animations_; // Vector con las animaciones del jugador
@@ -312,16 +313,16 @@ private:
void renderItems();
// Devuelve un item en función del azar
int dropItem();
ItemType dropItem();
// 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
void freeItems();
// 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
void freeSmartSprites();

14
source/item.cpp
View File

@@ -5,16 +5,16 @@
class Texture;
// 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)),
accel_x_(0.0f),
floor_collision_(false),
kind_(kind),
type_(type),
enabled_(true),
play_area_(play_area),
time_to_live_(600)
{
if (kind == ITEM_COFFEE_MACHINE)
if (type == ItemType::COFFEE_MACHINE)
{
width_ = 28;
height_ = 37;
@@ -104,7 +104,7 @@ void Item::move()
}
// 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
pos_y_ = param.game.play_area.rect.y;
@@ -122,7 +122,7 @@ void Item::move()
accel_x_ = 0;
accel_y_ = 0;
pos_y_ = play_area_->h - height_;
if (kind_ == ITEM_COFFEE_MACHINE)
if (type_ == ItemType::COFFEE_MACHINE)
{
floor_collision_ = true;
}
@@ -190,9 +190,9 @@ int Item::getHeight()
}
// Obtiene del valor de la variable
int Item::getClass()
ItemType Item::getType()
{
return kind_;
return type_;
}
// Obtiene el valor de la variable

37
source/item.h
View File

@@ -1,22 +1,25 @@
#pragma once
#include <SDL2/SDL_rect.h> // for SDL_Rect
#include <SDL2/SDL_stdinc.h> // for Uint16
#include <memory> // for shared_ptr, unique_ptr
#include <string> // for string
#include <vector> // for vector
#include "animated_sprite.h" // for AnimatedSprite
#include "utils.h" // for Circle
#include <SDL2/SDL_rect.h> // for SDL_Rect
#include <SDL2/SDL_stdinc.h> // for Uint16
#include <memory> // for shared_ptr, unique_ptr
#include <string> // for string
#include <vector> // for vector
#include "animated_sprite.h" // for AnimatedSprite
#include "utils.h" // for Circle
class Texture;
// Tipos de objetos
constexpr int ITEM_POINTS_1_DISK = 1;
constexpr int ITEM_POINTS_2_GAVINA = 2;
constexpr int ITEM_POINTS_3_PACMAR = 3;
constexpr int ITEM_CLOCK = 4;
constexpr int ITEM_COFFEE = 5;
constexpr int ITEM_COFFEE_MACHINE = 6;
constexpr int ITEM_NULL = 7;
enum class ItemType : int
{
DISK = 1,
GAVINA = 2,
PACMAR = 3,
CLOCK = 4,
COFFEE = 5,
COFFEE_MACHINE = 6,
NONE = 7,
};
// Clase Item
class Item
@@ -35,7 +38,7 @@ private:
float accel_x_; // Aceleración en el eje X
float accel_y_; // Aceleración en el eje Y
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
Circle collider_; // Circulo de colisión del objeto
SDL_Rect *play_area_; // Rectangulo con la zona de juego
@@ -55,7 +58,7 @@ private:
public:
// 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
~Item() = default;
@@ -85,7 +88,7 @@ public:
int getHeight();
// Obtiene del valor de la variable
int getClass();
ItemType getType();
// Obtiene el valor de la variable
bool isEnabled();

2
source/smart_sprite.cpp
View File

@@ -127,7 +127,7 @@ void SmartSprite::checkMove()
void SmartSprite::checkFinished()
{
// 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_)
{