jaildesigner-jailgames/jaildoctors_dilemma
1
0
Fork 2
Code Issues 1 Pull Requests Projects Releases 20 Wiki Activity

canvi de pc

Browse Source
This commit is contained in:
Sergio
2025-02-27 07:37:39 +01:00
parent e6fd4225a2
commit c6474cb2da
26 changed files with 903 additions and 991 deletions
Download Patch File Download Diff File Expand all files Collapse all files

383
source/ending.cpp
View File

@@ -1,47 +1,46 @@
#include "ending.h"
#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
#include <SDL2/SDL_error.h> // for SDL_GetError
#include <SDL2/SDL_events.h> // for SDL_PollEvent, SDL_Event
#include <SDL2/SDL_pixels.h> // for SDL_PIXELFORMAT_RGBA8888
#include <SDL2/SDL_rect.h> // for SDL_Rect
#include <SDL2/SDL_timer.h> // for SDL_GetTicks
#include <algorithm> // for min
#include <iostream> // for basic_ostream, operator<<, cout, endl
#include "asset.h" // for Asset
#include "defines.h" // for GAMECANVAS_HEIGHT, GAMECANVAS_WIDTH
#include "global_events.h" // for check
#include "global_inputs.h" // for check
#include "input.h" // for Input
#include "jail_audio.h" // for JA_SetVolume, JA_PlayMusic, JA_StopM...
#include "options.h" // for Options, options, OptionsVideo, Sect...
#include "resource.h" // for Resource
#include "screen.h" // for Screen
#include "sprite.h" // for Sprite
#include "text.h" // for Text, TEXT_STROKE
#include "texture.h" // for Texture
#include "utils.h" // for Color, stringToColor, Palette
#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND
#include <SDL2/SDL_error.h> // for SDL_GetError
#include <SDL2/SDL_events.h> // for SDL_PollEvent, SDL_Event
#include <SDL2/SDL_pixels.h> // for SDL_PIXELFORMAT_RGBA8888
#include <SDL2/SDL_rect.h> // for SDL_Rect
#include <SDL2/SDL_timer.h> // for SDL_GetTicks
#include <algorithm> // for min
#include <iostream> // for basic_ostream, operator<<, cout, endl
#include "asset.h" // for Asset
#include "defines.h" // for GAMECANVAS_HEIGHT, GAMECANVAS_WIDTH
#include "global_events.h" // for check
#include "global_inputs.h" // for check
#include "input.h" // for Input
#include "jail_audio.h" // for JA_SetVolume, JA_PlayMusic, JA_StopM...
#include "options.h" // for Options, options, OptionsVideo, Sect...
#include "resource.h" // for Resource
#include "screen.h" // for Screen
#include "sprite.h" // for Sprite
#include "text.h" // for Text, TEXT_STROKE
#include "texture.h" // for Texture
#include "utils.h" // for Color, stringToColor, Palette
// Constructor
Ending::Ending()
: screen(Screen::get()),
renderer(Screen::get()->getRenderer()),
resource(Resource::get()),
asset(Asset::get()),
input(Input::get())
: screen_(Screen::get()),
renderer_(Screen::get()->getRenderer()),
resource_(Resource::get()),
asset_(Asset::get()),
input_(Input::get())
{
// Reserva memoria para los punteros a objetos
text = resource->getText("smb2");
music = resource->getMusic("ending1.ogg");
text_ = resource_->getText("smb2");
music = resource_->getMusic("ending1.ogg");
// Inicializa variables
counter = -1;
preCounter = 0;
coverCounter = 0;
counter_ = -1;
pre_counter_ = 0;
cover_counter_ = 0;
options.section.section = Section::ENDING;
options.section.subsection = Subsection::NONE;
ticks = 0;
ticksSpeed = 15;
scene = 0;
ticks_ = 0;
current_scene_ = 0;
// Inicializa los textos
iniTexts();
@@ -53,18 +52,18 @@ Ending::Ending()
iniScenes();
// Cambia el color del borde
screen->setBorderColor(stringToColor(options.video.palette, "black"));
screen_->setBorderColor(stringToColor(options.video.palette, "black"));
// Crea la textura para cubrir el rexto
coverTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT + 8);
if (coverTexture == nullptr)
cover_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT + 8);
if (cover_texture_ == nullptr)
{
if (options.console)
{
std::cout << "Error: canvasTexture could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
}
}
SDL_SetTextureBlendMode(coverTexture, SDL_BLENDMODE_BLEND);
SDL_SetTextureBlendMode(cover_texture_, SDL_BLENDMODE_BLEND);
// Rellena la textura para la cortinilla
fillCoverTexture();
@@ -74,17 +73,17 @@ Ending::Ending()
Ending::~Ending()
{
// Libera la memoria de los objetos
SDL_DestroyTexture(coverTexture);
SDL_DestroyTexture(cover_texture_);
}
// Actualiza el objeto
void Ending::update()
{
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
if (SDL_GetTicks() - ticks > ticksSpeed)
if (SDL_GetTicks() - ticks_ > GAME_SPEED)
{
// Actualiza el contador de ticks
ticks = SDL_GetTicks();
ticks_ = SDL_GetTicks();
// Comprueba las entradas
checkInput();
@@ -101,7 +100,7 @@ void Ending::update()
// Actualiza el volumen de la musica
updateMusicVolume();
screen->update();
screen_->update();
}
}
@@ -109,22 +108,22 @@ void Ending::update()
void Ending::render()
{
// Prepara para empezar a dibujar en la textura de juego
screen->start();
screen_->start();
// Limpia la pantalla
screen->clean(stringToColor(options.video.palette, "black"));
screen_->clean(stringToColor(options.video.palette, "black"));
// Dibuja las imagenes de la escena
spritePics[scene].sprite->render();
spritePics[scene].coverSprite->render();
sprite_pics_[current_scene_].sprite->render();
sprite_pics_[current_scene_].cover_sprite->render();
// Dibuja los textos de la escena
for (auto ti : scenes[scene].textIndex)
for (auto ti : scenes_[current_scene_].text_index)
{
if (counter > ti.trigger)
if (counter_ > ti.trigger)
{
spriteTexts[ti.index].sprite->render();
spriteTexts[ti.index].coverSprite->render();
sprite_texts_[ti.index].sprite->render();
sprite_texts_[ti.index].cover_sprite->render();
}
}
@@ -132,7 +131,7 @@ void Ending::render()
renderCoverTexture();
// Vuelca el contenido del renderizador en pantalla
screen->render();
screen_->render();
}
// Comprueba el manejador de eventos
@@ -155,7 +154,7 @@ void Ending::checkInput()
void Ending::iniTexts()
{
// Vector con los textos
std::vector<textAndPos_t> texts;
std::vector<TextAndPosition> texts;
// Escena #0
texts.push_back({"HE FINALLY MANAGED", 32});
@@ -187,66 +186,66 @@ void Ending::iniTexts()
texts.push_back({"WERE BORN...", 158});
// Crea los sprites
spriteTexts.clear();
sprite_texts_.clear();
for (auto t : texts)
{
endingTexture_t st;
const int width = text->lenght(t.caption, 1) + 2 + 2;
const int height = text->getCharacterSize() + 2 + 2;
EndingTexture st;
const int width = text_->lenght(t.caption, 1) + 2 + 2;
const int height = text_->getCharacterSize() + 2 + 2;
Color c = stringToColor(options.video.palette, "black");
// Crea la texture
st.texture = std::make_shared<Texture>(renderer);
st.texture = std::make_shared<Texture>(renderer_);
st.texture->createBlank(width, height);
st.texture->setAsRenderTarget(renderer);
st.texture->setAsRenderTarget(renderer_);
st.texture->setBlendMode(SDL_BLENDMODE_BLEND);
text->writeDX(TEXT_STROKE, 2, 2, t.caption, 1, c, 2, c);
text_->writeDX(TEXT_STROKE, 2, 2, t.caption, 1, c, 2, c);
// Crea el sprite
st.sprite = std::make_shared<Sprite>(st.texture, 0, 0, st.texture->getWidth(), st.texture->getHeight());
st.sprite->setPosition((GAMECANVAS_WIDTH - st.texture->getWidth()) / 2, t.pos);
// Crea la coverTexture
st.coverTexture = std::make_shared<Texture>(renderer);
st.coverTexture->createBlank(width, height + 8);
st.coverTexture->setAsRenderTarget(renderer);
st.coverTexture->setBlendMode(SDL_BLENDMODE_BLEND);
st.cover_texture = std::make_shared<Texture>(renderer_);
st.cover_texture->createBlank(width, height + 8);
st.cover_texture->setAsRenderTarget(renderer_);
st.cover_texture->setBlendMode(SDL_BLENDMODE_BLEND);
// Rellena la coverTexture con color transparente
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
SDL_RenderClear(renderer_);
// Los primeros 8 pixels crea una malla
c = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
for (int i = 0; i < width; i += 2)
{
SDL_RenderDrawPoint(renderer, i, 0);
SDL_RenderDrawPoint(renderer, i, 2);
SDL_RenderDrawPoint(renderer, i, 4);
SDL_RenderDrawPoint(renderer, i, 6);
SDL_RenderDrawPoint(renderer_, i, 0);
SDL_RenderDrawPoint(renderer_, i, 2);
SDL_RenderDrawPoint(renderer_, i, 4);
SDL_RenderDrawPoint(renderer_, i, 6);
SDL_RenderDrawPoint(renderer, i + 1, 5);
SDL_RenderDrawPoint(renderer, i + 1, 7);
SDL_RenderDrawPoint(renderer_, i + 1, 5);
SDL_RenderDrawPoint(renderer_, i + 1, 7);
}
// El resto se rellena de color sólido
SDL_Rect rect = {0, 8, width, height};
c = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
SDL_RenderFillRect(renderer, &rect);
SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
SDL_RenderFillRect(renderer_, &rect);
// Crea el sprite
st.coverSprite = std::make_shared<Sprite>(st.coverTexture, 0, 0, st.coverTexture->getWidth(), st.coverTexture->getHeight() - 8);
st.coverSprite->setPosition((GAMECANVAS_WIDTH - st.coverTexture->getWidth()) / 2, t.pos);
st.coverSprite->setClip(0, 8, -1, -1);
st.cover_sprite = std::make_shared<Sprite>(st.cover_texture, 0, 0, st.cover_texture->getWidth(), st.cover_texture->getHeight() - 8);
st.cover_sprite->setPosition((GAMECANVAS_WIDTH - st.cover_texture->getWidth()) / 2, t.pos);
st.cover_sprite->setClip(0, 8, -1, -1);
// Inicializa variables
st.clipDesp = 8;
st.clipHeight = height;
st.clip_desp = 8;
st.clip_height = height;
spriteTexts.push_back(st);
sprite_texts_.push_back(st);
}
}
@@ -254,7 +253,7 @@ void Ending::iniTexts()
void Ending::iniPics()
{
// Vector con las rutas y la posición
std::vector<textAndPos_t> pics;
std::vector<TextAndPosition> pics;
if (options.video.palette == Palette::ZXSPECTRUM)
{
@@ -274,14 +273,14 @@ void Ending::iniPics()
}
// Crea los sprites
spritePics.clear();
sprite_pics_.clear();
for (auto p : pics)
{
endingTexture_t sp;
EndingTexture sp;
// Crea la texture
sp.texture = resource->getTexture(p.caption);
sp.texture = resource_->getTexture(p.caption);
const int width = sp.texture->getWidth();
const int height = sp.texture->getHeight();
@@ -290,45 +289,45 @@ void Ending::iniPics()
sp.sprite->setPosition((GAMECANVAS_WIDTH - width) / 2, p.pos);
// Crea la coverTexture
sp.coverTexture = std::make_shared<Texture>(renderer);
sp.coverTexture->createBlank(width, height + 8);
sp.coverTexture->setAsRenderTarget(renderer);
sp.coverTexture->setBlendMode(SDL_BLENDMODE_BLEND);
sp.cover_texture = std::make_shared<Texture>(renderer_);
sp.cover_texture->createBlank(width, height + 8);
sp.cover_texture->setAsRenderTarget(renderer_);
sp.cover_texture->setBlendMode(SDL_BLENDMODE_BLEND);
// Rellena la coverTexture con color transparente
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
SDL_RenderClear(renderer_);
// Los primeros 8 pixels crea una malla
Color c = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
for (int i = 0; i < width; i += 2)
{
SDL_RenderDrawPoint(renderer, i, 0);
SDL_RenderDrawPoint(renderer, i, 2);
SDL_RenderDrawPoint(renderer, i, 4);
SDL_RenderDrawPoint(renderer, i, 6);
SDL_RenderDrawPoint(renderer_, i, 0);
SDL_RenderDrawPoint(renderer_, i, 2);
SDL_RenderDrawPoint(renderer_, i, 4);
SDL_RenderDrawPoint(renderer_, i, 6);
SDL_RenderDrawPoint(renderer, i + 1, 5);
SDL_RenderDrawPoint(renderer, i + 1, 7);
SDL_RenderDrawPoint(renderer_, i + 1, 5);
SDL_RenderDrawPoint(renderer_, i + 1, 7);
}
// El resto se rellena de color sólido
SDL_Rect rect = {0, 8, width, height};
c = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
SDL_RenderFillRect(renderer, &rect);
SDL_SetRenderDrawColor(renderer_, c.r, c.g, c.b, 0xFF);
SDL_RenderFillRect(renderer_, &rect);
// Crea el sprite
sp.coverSprite = std::make_shared<Sprite>(sp.coverTexture, 0, 0, sp.coverTexture->getWidth(), sp.coverTexture->getHeight() - 8);
sp.coverSprite->setPosition((GAMECANVAS_WIDTH - sp.coverTexture->getWidth()) / 2, p.pos);
sp.coverSprite->setClip(0, 8, -1, -1);
sp.cover_sprite = std::make_shared<Sprite>(sp.cover_texture, 0, 0, sp.cover_texture->getWidth(), sp.cover_texture->getHeight() - 8);
sp.cover_sprite->setPosition((GAMECANVAS_WIDTH - sp.cover_texture->getWidth()) / 2, p.pos);
sp.cover_sprite->setClip(0, 8, -1, -1);
// Inicializa variables
sp.clipDesp = 8;
sp.clipHeight = height;
sp.clip_desp = 8;
sp.clip_height = height;
spritePics.push_back(sp);
sprite_pics_.push_back(sp);
}
}
@@ -340,79 +339,79 @@ void Ending::iniScenes()
const int lapse = 80;
// Crea el contenedor
scene_t sc;
SceneData sc;
// Inicializa el vector
scenes.clear();
scenes_.clear();
// Crea la escena #0
sc.counterEnd = 1000;
sc.pictureIndex = 0;
sc.textIndex.clear();
sc.counter_end = 1000;
sc.picture_index = 0;
sc.text_index.clear();
trigger = 85 * 2;
trigger += lapse;
sc.textIndex.push_back({0, trigger});
sc.text_index.push_back({0, trigger});
trigger += lapse;
sc.textIndex.push_back({1, trigger});
sc.text_index.push_back({1, trigger});
trigger += lapse * 3;
sc.textIndex.push_back({2, trigger});
sc.text_index.push_back({2, trigger});
trigger += lapse;
sc.textIndex.push_back({3, trigger});
scenes.push_back(sc);
sc.text_index.push_back({3, trigger});
scenes_.push_back(sc);
// Crea la escena #1
sc.counterEnd = 1400;
sc.pictureIndex = 1;
sc.textIndex.clear();
sc.counter_end = 1400;
sc.picture_index = 1;
sc.text_index.clear();
trigger = 140 * 2;
trigger += lapse;
sc.textIndex.push_back({4, trigger});
sc.text_index.push_back({4, trigger});
trigger += lapse;
sc.textIndex.push_back({5, trigger});
sc.text_index.push_back({5, trigger});
trigger += lapse;
sc.textIndex.push_back({6, trigger});
sc.text_index.push_back({6, trigger});
trigger += lapse * 3;
sc.textIndex.push_back({7, trigger});
sc.text_index.push_back({7, trigger});
trigger += lapse;
sc.textIndex.push_back({8, trigger});
sc.text_index.push_back({8, trigger});
trigger += lapse * 3;
sc.textIndex.push_back({9, trigger});
scenes.push_back(sc);
sc.text_index.push_back({9, trigger});
scenes_.push_back(sc);
// Crea la escena #2
sc.counterEnd = 1000;
sc.pictureIndex = 2;
sc.textIndex.clear();
sc.counter_end = 1000;
sc.picture_index = 2;
sc.text_index.clear();
trigger = 148 / 2;
trigger += lapse;
sc.textIndex.push_back({10, trigger});
sc.text_index.push_back({10, trigger});
trigger += lapse;
sc.textIndex.push_back({11, trigger});
scenes.push_back(sc);
sc.text_index.push_back({11, trigger});
scenes_.push_back(sc);
// Crea la escena #3
sc.counterEnd = 800;
sc.pictureIndex = 3;
sc.textIndex.clear();
sc.counter_end = 800;
sc.picture_index = 3;
sc.text_index.clear();
trigger = 87 / 2;
trigger += lapse;
sc.textIndex.push_back({12, trigger});
sc.text_index.push_back({12, trigger});
trigger += lapse / 2;
sc.textIndex.push_back({13, trigger});
scenes.push_back(sc);
sc.text_index.push_back({13, trigger});
scenes_.push_back(sc);
// Crea la escena #4
sc.counterEnd = 1000;
sc.pictureIndex = 4;
sc.textIndex.clear();
sc.counter_end = 1000;
sc.picture_index = 4;
sc.text_index.clear();
trigger = 91 * 2;
trigger += lapse;
sc.textIndex.push_back({14, trigger});
sc.text_index.push_back({14, trigger});
trigger += lapse * 2;
sc.textIndex.push_back({15, trigger});
sc.text_index.push_back({15, trigger});
trigger += lapse * 3;
sc.textIndex.push_back({16, trigger});
scenes.push_back(sc);
sc.text_index.push_back({16, trigger});
scenes_.push_back(sc);
}
// Bucle principal
@@ -435,80 +434,80 @@ void Ending::run()
void Ending::updateCounters()
{
// Incrementa el contador
if (preCounter < 200)
if (pre_counter_ < 200)
{
preCounter++;
pre_counter_++;
}
else
{
counter++;
counter_++;
}
if (counter > scenes[scene].counterEnd - 100)
if (counter_ > scenes_[current_scene_].counter_end - 100)
{
coverCounter++;
cover_counter_++;
}
}
// Actualiza las cortinillas de los elementos
void Ending::updateSpriteCovers()
{ // Actualiza la cortinilla de los textos
if (counter % 4 == 0)
if (counter_ % 4 == 0)
{
for (auto ti : scenes[scene].textIndex)
for (auto ti : scenes_[current_scene_].text_index)
{
if (counter > ti.trigger)
if (counter_ > ti.trigger)
{
if (spriteTexts[ti.index].clipDesp > 0)
if (sprite_texts_[ti.index].clip_desp > 0)
{
spriteTexts[ti.index].clipDesp -= 2;
sprite_texts_[ti.index].clip_desp -= 2;
}
else if (spriteTexts[ti.index].clipHeight > 0)
else if (sprite_texts_[ti.index].clip_height > 0)
{
spriteTexts[ti.index].clipHeight -= 2;
spriteTexts[ti.index].coverSprite->setY(spriteTexts[ti.index].coverSprite->getY() + 2);
sprite_texts_[ti.index].clip_height -= 2;
sprite_texts_[ti.index].cover_sprite->setY(sprite_texts_[ti.index].cover_sprite->getY() + 2);
}
spriteTexts[ti.index].coverSprite->setClip(0, spriteTexts[ti.index].clipDesp, spriteTexts[ti.index].coverSprite->getWidth(), spriteTexts[ti.index].clipHeight);
sprite_texts_[ti.index].cover_sprite->setClip(0, sprite_texts_[ti.index].clip_desp, sprite_texts_[ti.index].cover_sprite->getWidth(), sprite_texts_[ti.index].clip_height);
}
}
}
// Actualiza la cortinilla de las imagenes
if (counter % 2 == 0)
if (counter_ % 2 == 0)
{
if (spritePics[scene].clipDesp > 0)
if (sprite_pics_[current_scene_].clip_desp > 0)
{
spritePics[scene].clipDesp -= 2;
sprite_pics_[current_scene_].clip_desp -= 2;
}
else if (spritePics[scene].clipHeight > 0)
else if (sprite_pics_[current_scene_].clip_height > 0)
{
spritePics[scene].clipHeight -= 2;
if (spritePics[scene].clipHeight < 0)
sprite_pics_[current_scene_].clip_height -= 2;
if (sprite_pics_[current_scene_].clip_height < 0)
{
spritePics[scene].clipHeight = 0;
sprite_pics_[current_scene_].clip_height = 0;
}
spritePics[scene].coverSprite->setY(spritePics[scene].coverSprite->getY() + 2);
sprite_pics_[current_scene_].cover_sprite->setY(sprite_pics_[current_scene_].cover_sprite->getY() + 2);
}
spritePics[scene].coverSprite->setClip(0, spritePics[scene].clipDesp, spritePics[scene].coverSprite->getWidth(), spritePics[scene].clipHeight);
sprite_pics_[current_scene_].cover_sprite->setClip(0, sprite_pics_[current_scene_].clip_desp, sprite_pics_[current_scene_].cover_sprite->getWidth(), sprite_pics_[current_scene_].clip_height);
}
}
// Comprueba si se ha de cambiar de escena
void Ending::checkChangeScene()
{
if (counter > scenes[scene].counterEnd)
if (counter_ > scenes_[current_scene_].counter_end)
{
scene++;
counter = 0;
coverCounter = 0;
if (scene == 5)
current_scene_++;
counter_ = 0;
cover_counter_ = 0;
if (current_scene_ == 5)
{
// Termina el bucle
options.section.section = Section::ENDING2;
// Mantiene los valores anteriores
scene = 4;
coverCounter = 100;
current_scene_ = 4;
cover_counter_ = 100;
}
}
}
@@ -517,49 +516,49 @@ void Ending::checkChangeScene()
void Ending::fillCoverTexture()
{
// Rellena la textura que cubre el texto con color transparente
SDL_SetRenderTarget(renderer, coverTexture);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_RenderClear(renderer);
SDL_SetRenderTarget(renderer_, cover_texture_);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 0);
SDL_RenderClear(renderer_);
// Los primeros 8 pixels crea una malla
const Color color = stringToColor(options.video.palette, "black");
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
for (int i = 0; i < 256; i += 2)
{
SDL_RenderDrawPoint(renderer, i + 0, GAMECANVAS_HEIGHT + 0);
SDL_RenderDrawPoint(renderer, i + 1, GAMECANVAS_HEIGHT + 1);
SDL_RenderDrawPoint(renderer, i + 0, GAMECANVAS_HEIGHT + 2);
SDL_RenderDrawPoint(renderer, i + 1, GAMECANVAS_HEIGHT + 3);
SDL_RenderDrawPoint(renderer_, i + 0, GAMECANVAS_HEIGHT + 0);
SDL_RenderDrawPoint(renderer_, i + 1, GAMECANVAS_HEIGHT + 1);
SDL_RenderDrawPoint(renderer_, i + 0, GAMECANVAS_HEIGHT + 2);
SDL_RenderDrawPoint(renderer_, i + 1, GAMECANVAS_HEIGHT + 3);
SDL_RenderDrawPoint(renderer, i, GAMECANVAS_HEIGHT + 4);
SDL_RenderDrawPoint(renderer, i, GAMECANVAS_HEIGHT + 6);
SDL_RenderDrawPoint(renderer_, i, GAMECANVAS_HEIGHT + 4);
SDL_RenderDrawPoint(renderer_, i, GAMECANVAS_HEIGHT + 6);
}
// El resto se rellena de color sólido
SDL_Rect rect = {0, 0, 256, GAMECANVAS_HEIGHT};
SDL_RenderFillRect(renderer, &rect);
SDL_RenderFillRect(renderer_, &rect);
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderTarget(renderer_, nullptr);
}
// Dibuja la cortinilla de cambio de escena
void Ending::renderCoverTexture()
{
if (coverCounter > 0)
if (cover_counter_ > 0)
{ // Dibuja la textura que cubre el texto
const int offset = std::min(coverCounter, 100);
SDL_Rect srcRect = {0, 200 - (coverCounter * 2), 256, offset * 2};
const int offset = std::min(cover_counter_, 100);
SDL_Rect srcRect = {0, 200 - (cover_counter_ * 2), 256, offset * 2};
SDL_Rect dstRect = {0, 0, 256, offset * 2};
SDL_RenderCopy(renderer, coverTexture, &srcRect, &dstRect);
SDL_RenderCopy(renderer_, cover_texture_, &srcRect, &dstRect);
}
}
// Actualiza el volumen de la musica
void Ending::updateMusicVolume()
{
if (scene == 4 && coverCounter > 0)
if (current_scene_ == 4 && cover_counter_ > 0)
{
const float step = (100.0f - coverCounter) / 100.0f;
const float step = (100.0f - cover_counter_) / 100.0f;
const int volume = 128 * step;
JA_SetVolume(volume);
}