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

Abans de renombrar player.cpp

Browse Source
This commit is contained in:
Sergio
2024-10-11 21:58:59 +02:00
parent 3a6950f3a4
commit d50cf23721
4 changed files with 332 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

288
source/scoreboard.cpp
View File

@@ -12,67 +12,67 @@
#include "texture.h" // for Texture
// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
Scoreboard *Scoreboard::scoreboard = nullptr;
Scoreboard *Scoreboard::scoreboard_ = nullptr;
// [SINGLETON] Crearemos el objeto scoreboard con esta función estática
// [SINGLETON] Crearemos el objeto score_board con esta función estática
void Scoreboard::init(SDL_Renderer *renderer)
{
Scoreboard::scoreboard = new Scoreboard(renderer);
Scoreboard::scoreboard_ = new Scoreboard(renderer);
}
// [SINGLETON] Destruiremos el objeto scoreboard con esta función estática
// [SINGLETON] Destruiremos el objeto score_board con esta función estática
void Scoreboard::destroy()
{
delete Scoreboard::scoreboard;
delete Scoreboard::scoreboard_;
}
// [SINGLETON] Con este método obtenemos el objeto scoreboard y podemos trabajar con él
// [SINGLETON] Con este método obtenemos el objeto score_board y podemos trabajar con él
Scoreboard *Scoreboard::get()
{
return Scoreboard::scoreboard;
return Scoreboard::scoreboard_;
}
// Constructor
Scoreboard::Scoreboard(SDL_Renderer *renderer)
: renderer(renderer)
: renderer_(renderer)
{
// Inicializa punteros
gamePowerMeterTexture = nullptr;
powerMeterSprite = nullptr;
textScoreBoard = nullptr;
game_power_meter_texture_ = nullptr;
power_meter_sprite_ = nullptr;
text_scoreboard_ = nullptr;
// Inicializa variables
stage = 1;
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
name[i] = "";
recordName[i] = "";
selectorPos[i] = 0;
score[i] = 0;
mult[i] = 0;
continueCounter[i] = 0;
name_[i] = "";
record_name_[i] = "";
selector_pos_[i] = 0;
score_[i] = 0;
mult_[i] = 0;
continue_counter_[i] = 0;
}
hiScore = 0;
power = 0;
hiScoreName = "";
color = {0, 0, 0};
rect = {0, 0, 320, 40};
panel[SCOREBOARD_LEFT_PANEL].mode = ScoreboardMode::SCORE;
panel[SCOREBOARD_RIGHT_PANEL].mode = ScoreboardMode::SCORE;
panel[SCOREBOARD_CENTER_PANEL].mode = ScoreboardMode::STAGE_INFO;
ticks = SDL_GetTicks();
counter = 0;
stage_ = 1;
hi_score_ = 0;
power_ = 0;
hi_score_name_ = "";
color_ = {0, 0, 0};
rect_ = {0, 0, 320, 40};
panel_[SCOREBOARD_LEFT_PANEL].mode = ScoreboardMode::SCORE;
panel_[SCOREBOARD_RIGHT_PANEL].mode = ScoreboardMode::SCORE;
panel_[SCOREBOARD_CENTER_PANEL].mode = ScoreboardMode::STAGE_INFO;
ticks_ = SDL_GetTicks();
counter_ = 0;
// Recalcula las anclas de los elementos
recalculateAnchors();
// Crea objetos
gamePowerMeterTexture = std::make_shared<Texture>(renderer, Asset::get()->get("game_power_meter.png"));
powerMeterSprite = std::make_unique<Sprite>(slot4_2.x - 20, slot4_2.y, 40, 7, gamePowerMeterTexture);
textScoreBoard = std::make_unique<Text>(Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), renderer);
game_power_meter_texture_ = std::make_shared<Texture>(renderer_, Asset::get()->get("game_power_meter.png"));
power_meter_sprite_ = std::make_unique<Sprite>(slot4_2_.x - 20, slot4_2_.y, 40, 7, game_power_meter_texture_);
text_scoreboard_ = std::make_unique<Text>(Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), renderer_);
// Crea la textura de fondo
background = nullptr;
background_ = nullptr;
createBackgroundTexture();
// Crea las texturas de los paneles
@@ -84,12 +84,12 @@ Scoreboard::Scoreboard(SDL_Renderer *renderer)
Scoreboard::~Scoreboard()
{
if (background)
if (background_)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(background_);
}
for (auto texture : panelTexture)
for (auto texture : panel_texture_)
{
if (texture)
{
@@ -109,10 +109,10 @@ std::string Scoreboard::updateScoreText(int num)
// Actualiza el contador
void Scoreboard::updateCounter()
{
if (SDL_GetTicks() - ticks > SCOREBOARD_TICK_SPEED)
if (SDL_GetTicks() - ticks_ > SCOREBOARD_TICK_SPEED)
{
ticks = SDL_GetTicks();
counter++;
ticks_ = SDL_GetTicks();
counter_++;
}
}
@@ -126,80 +126,80 @@ void Scoreboard::update()
// Pinta el marcador
void Scoreboard::render()
{
SDL_RenderCopy(renderer, background, nullptr, &rect);
SDL_RenderCopy(renderer_, background_, nullptr, &rect_);
}
// Establece el valor de la variable
void Scoreboard::setName(int panel, std::string name)
void Scoreboard::setName(int panel_, std::string name_)
{
this->name[panel] = name;
this->name_[panel_] = name_;
}
// Establece el valor de la variable
void Scoreboard::setRecordName(int panel, std::string recordName)
void Scoreboard::setRecordName(int panel_, std::string record_name_)
{
this->recordName[panel] = recordName;
this->record_name_[panel_] = record_name_;
}
// Establece el valor de la variable
void Scoreboard::setSelectorPos(int panel, int pos)
void Scoreboard::setSelectorPos(int panel_, int pos)
{
selectorPos[panel] = pos;
selector_pos_[panel_] = pos;
}
// Establece el valor de la variable
void Scoreboard::setScore(int panel, int score)
void Scoreboard::setScore(int panel_, int score_)
{
this->score[panel] = score;
this->score_[panel_] = score_;
}
// Establece el valor de la variable
void Scoreboard::setMult(int panel, float mult)
void Scoreboard::setMult(int panel_, float mult_)
{
this->mult[panel] = mult;
this->mult_[panel_] = mult_;
}
// Establece el valor de la variable
void Scoreboard::setContinue(int panel, int value)
void Scoreboard::setContinue(int panel_, int value)
{
continueCounter[panel] = value;
continue_counter_[panel_] = value;
}
// Establece el valor de la variable
void Scoreboard::setStage(int stage)
void Scoreboard::setStage(int stage_)
{
this->stage = stage;
this->stage_ = stage_;
}
// Establece el valor de la variable
void Scoreboard::setHiScore(int hiScore)
void Scoreboard::setHiScore(int hi_score_)
{
this->hiScore = hiScore;
this->hi_score_ = hi_score_;
}
// Establece el valor de la variable
void Scoreboard::setPower(float power)
void Scoreboard::setPower(float power_)
{
this->power = power;
this->power_ = power_;
}
// Establece el valor de la variable
void Scoreboard::setHiScoreName(std::string name)
void Scoreboard::setHiScoreName(std::string name_)
{
hiScoreName = name;
hi_score_name_ = name_;
}
// Establece el valor de la variable
void Scoreboard::setColor(Color color)
void Scoreboard::setColor(Color color_)
{
this->color = color;
this->color_ = color_;
fillBackgroundTexture();
}
// Establece el valor de la variable
void Scoreboard::setPos(SDL_Rect rect)
void Scoreboard::setPos(SDL_Rect rect_)
{
this->rect = rect;
this->rect_ = rect_;
// Recalcula las anclas de los elementos
recalculateAnchors();
@@ -218,42 +218,42 @@ void Scoreboard::setPos(SDL_Rect rect)
void Scoreboard::fillPanelTextures()
{
// Guarda a donde apunta actualmente el renderizador
SDL_Texture *temp = SDL_GetRenderTarget(renderer);
SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
// Genera el contenidoi de cada panel
// Genera el contenidoi de cada panel_
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
// Cambia el destino del renderizador
SDL_SetRenderTarget(renderer, panelTexture[i]);
SDL_SetRenderTarget(renderer_, panel_texture_[i]);
// Dibuja el fondo de la textura
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
SDL_RenderClear(renderer_);
switch (panel[i].mode)
switch (panel_[i].mode)
{
case ScoreboardMode::SCORE:
{
// SCORE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, name[i]);
textScoreBoard->writeCentered(slot4_2.x, slot4_2.y, updateScoreText(score[i]));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
// MULT
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(55));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y, std::to_string(mult[i]).substr(0, 3));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(55));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, std::to_string(mult_[i]).substr(0, 3));
break;
}
case ScoreboardMode::DEMO:
{
// DEMO MODE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y + 4, lang::getText(101));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(101));
// PRESS START TO PLAY
if (counter % 10 < 8)
if (counter_ % 10 < 8)
{
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y - 2, lang::getText(103));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y - 2, lang::getText(104));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
}
break;
}
@@ -261,13 +261,13 @@ void Scoreboard::fillPanelTextures()
case ScoreboardMode::WAITING:
{
// GAME OVER
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y + 4, lang::getText(102));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
// PRESS START TO PLAY
if (counter % 10 < 8)
if (counter_ % 10 < 8)
{
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y - 2, lang::getText(103));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y - 2, lang::getText(104));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(103));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(104));
}
break;
}
@@ -275,13 +275,13 @@ void Scoreboard::fillPanelTextures()
case ScoreboardMode::GAME_OVER:
{
// GAME OVER
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y + 4, lang::getText(102));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y + 4, lang::getText(102));
// PLEASE WAIT
if (counter % 10 < 8)
if (counter_ % 10 < 8)
{
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y - 2, lang::getText(114));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y - 2, lang::getText(115));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y - 2, lang::getText(114));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y - 2, lang::getText(115));
}
break;
}
@@ -289,58 +289,58 @@ void Scoreboard::fillPanelTextures()
case ScoreboardMode::STAGE_INFO:
{
// STAGE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, lang::getText(57) + std::to_string(stage));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, lang::getText(57) + std::to_string(stage_));
// POWERMETER
powerMeterSprite->setSpriteClip(0, 0, 40, 7);
powerMeterSprite->render();
powerMeterSprite->setSpriteClip(40, 0, int(power * 40.0f), 7);
powerMeterSprite->render();
power_meter_sprite_->setSpriteClip(0, 0, 40, 7);
power_meter_sprite_->render();
power_meter_sprite_->setSpriteClip(40, 0, int(power_ * 40.0f), 7);
power_meter_sprite_->render();
// HI-SCORE
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(56));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y, hiScoreName + " - " + updateScoreText(hiScore));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(56));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, hi_score_name_ + " - " + updateScoreText(hi_score_));
break;
}
case ScoreboardMode::CONTINUE:
{
// SCORE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, name[i]);
textScoreBoard->writeCentered(slot4_2.x, slot4_2.y, updateScoreText(score[i]));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
// CONTINUE
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(105));
textScoreBoard->writeCentered(slot4_4.x, slot4_4.y, std::to_string(continueCounter[i]));
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(105));
text_scoreboard_->writeCentered(slot4_4_.x, slot4_4_.y, std::to_string(continue_counter_[i]));
break;
}
case ScoreboardMode::ENTER_NAME:
{
// SCORE
textScoreBoard->writeCentered(slot4_1.x, slot4_1.y, name[i]);
textScoreBoard->writeCentered(slot4_2.x, slot4_2.y, updateScoreText(score[i]));
text_scoreboard_->writeCentered(slot4_1_.x, slot4_1_.y, name_[i]);
text_scoreboard_->writeCentered(slot4_2_.x, slot4_2_.y, updateScoreText(score_[i]));
// ENTER NAME
textScoreBoard->writeCentered(slot4_3.x, slot4_3.y, lang::getText(106));
SDL_Rect rect = {enterNamePos.x, enterNamePos.y, 5, 7};
SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xEB, 255);
for (int j = 0; j < (int)recordName[i].size(); ++j)
text_scoreboard_->writeCentered(slot4_3_.x, slot4_3_.y, lang::getText(106));
SDL_Rect rect_ = {enter_name_pos_.x, enter_name_pos_.y, 5, 7};
SDL_SetRenderDrawColor(renderer_, 0xFF, 0xFF, 0xEB, 255);
for (int j = 0; j < (int)record_name_[i].size(); ++j)
{
if (j == selectorPos[i])
if (j == selector_pos_[i])
{ // La letra seleccionada se pinta de forma intermitente
if (counter % 3 > 0)
if (counter_ % 3 > 0)
{
SDL_RenderDrawLine(renderer, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
textScoreBoard->write(rect.x, rect.y, recordName[i].substr(j, 1));
SDL_RenderDrawLine(renderer_, rect_.x, rect_.y + rect_.h, rect_.x + rect_.w, rect_.y + rect_.h);
text_scoreboard_->write(rect_.x, rect_.y, record_name_[i].substr(j, 1));
}
}
else
{
SDL_RenderDrawLine(renderer, rect.x, rect.y + rect.h, rect.x + rect.w, rect.y + rect.h);
textScoreBoard->write(rect.x, rect.y, recordName[i].substr(j, 1));
SDL_RenderDrawLine(renderer_, rect_.x, rect_.y + rect_.h, rect_.x + rect_.w, rect_.y + rect_.h);
text_scoreboard_->write(rect_.x, rect_.y, record_name_[i].substr(j, 1));
}
rect.x += 7;
rect_.x += 7;
}
break;
}
@@ -351,7 +351,7 @@ void Scoreboard::fillPanelTextures()
}
// Deja el renderizador apuntando donde estaba
SDL_SetRenderTarget(renderer, temp);
SDL_SetRenderTarget(renderer_, temp);
}
// Rellena la textura de fondo
@@ -361,41 +361,41 @@ void Scoreboard::fillBackgroundTexture()
fillPanelTextures();
// Cambia el destino del renderizador
SDL_Texture *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, background);
SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, background_);
// Dibuja el fondo del marcador
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, color_.r, color_.g, color_.b, 255);
SDL_RenderClear(renderer_);
// Copia las texturas de los paneles
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
SDL_RenderCopy(renderer, panelTexture[i], nullptr, &panel[i].pos);
SDL_RenderCopy(renderer_, panel_texture_[i], nullptr, &panel_[i].pos);
}
// Dibuja la linea que separa la zona de juego del marcador
renderSeparator();
// Deja el renderizador apuntando donde estaba
SDL_SetRenderTarget(renderer, temp);
SDL_SetRenderTarget(renderer_, temp);
}
// Recalcula las anclas de los elementos
void Scoreboard::recalculateAnchors()
{
// Recalcula la posición y el tamaño de los paneles
const float panelWidth = (float)rect.w / (float)SCOREBOARD_MAX_PANELS;
const float panelWidth = (float)rect_.w / (float)SCOREBOARD_MAX_PANELS;
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
panel[i].pos.x = roundf(panelWidth * i);
panel[i].pos.y = 0;
panel[i].pos.w = roundf(panelWidth * (i + 1)) - panel[i].pos.x;
panel[i].pos.h = rect.h;
panel_[i].pos.x = roundf(panelWidth * i);
panel_[i].pos.y = 0;
panel_[i].pos.w = roundf(panelWidth * (i + 1)) - panel_[i].pos.x;
panel_[i].pos.h = rect_.h;
}
// Constantes para definir las zonas del panel: 4 filas y 1 columna
const int rowSize = rect.h / 4;
// Constantes para definir las zonas del panel_: 4 filas y 1 columna
const int rowSize = rect_.h / 4;
const int textHeight = 7;
// Filas
@@ -408,63 +408,63 @@ void Scoreboard::recalculateAnchors()
const int col = panelWidth / 2;
// Slots de 4
slot4_1 = {col, row1};
slot4_2 = {col, row2};
slot4_3 = {col, row3};
slot4_4 = {col, row4};
slot4_1_ = {col, row1};
slot4_2_ = {col, row2};
slot4_3_ = {col, row3};
slot4_4_ = {col, row4};
// Primer cuadrado para poner el nombre de record
const int enterNameLenght = 8 * 7;
enterNamePos.x = (panelWidth - enterNameLenght) / 2;
enterNamePos.y = row4;
enter_name_pos_.x = (panelWidth - enterNameLenght) / 2;
enter_name_pos_.y = row4;
// Recoloca los sprites
if (powerMeterSprite)
if (power_meter_sprite_)
{
powerMeterSprite->setPosX(slot4_2.x - 20);
powerMeterSprite->setPosY(slot4_2.y);
power_meter_sprite_->setPosX(slot4_2_.x - 20);
power_meter_sprite_->setPosY(slot4_2_.y);
}
}
// Establece el modo del marcador
void Scoreboard::setMode(int index, ScoreboardMode mode)
{
panel[index].mode = mode;
panel_[index].mode = mode;
}
// Crea la textura de fondo
void Scoreboard::createBackgroundTexture()
{
// Elimina la textura en caso de existir
if (background)
if (background_)
{
SDL_DestroyTexture(background);
SDL_DestroyTexture(background_);
}
// Recrea la textura de fondo
background = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
SDL_SetTextureBlendMode(background, SDL_BLENDMODE_BLEND);
background_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect_.w, rect_.h);
SDL_SetTextureBlendMode(background_, SDL_BLENDMODE_BLEND);
}
// Crea las texturas de los paneles
void Scoreboard::createPanelTextures()
{
// Elimina las texturas en caso de existir
for (auto texture : panelTexture)
for (auto texture : panel_texture_)
{
if (texture != nullptr)
{
SDL_DestroyTexture(texture);
}
}
panelTexture.clear();
panel_texture_.clear();
// Crea las texturas para cada panel
// Crea las texturas para cada panel_
for (int i = 0; i < SCOREBOARD_MAX_PANELS; ++i)
{
SDL_Texture *tex = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, panel[i].pos.w, panel[i].pos.h);
SDL_Texture *tex = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, panel_[i].pos.w, panel_[i].pos.h);
SDL_SetTextureBlendMode(tex, SDL_BLENDMODE_BLEND);
panelTexture.push_back(tex);
panel_texture_.push_back(tex);
}
}
@@ -472,6 +472,6 @@ void Scoreboard::createPanelTextures()
void Scoreboard::renderSeparator()
{
// Dibuja la linea que separa el marcador de la zona de juego
SDL_SetRenderDrawColor(renderer, separator_color.r, separator_color.g, separator_color.b, 255);
SDL_RenderDrawLine(renderer, 0, 0, rect.w, 0);
SDL_SetRenderDrawColor(renderer_, separator_color.r, separator_color.g, separator_color.b, 255);
SDL_RenderDrawLine(renderer_, 0, 0, rect_.w, 0);
}