forked from jaildesigner-jailgames/jaildoctors_dilemma
556 lines
18 KiB
C++
556 lines
18 KiB
C++
#include "ending.h"
|
|
|
|
// Constructor
|
|
Ending::Ending(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options)
|
|
{
|
|
// Copia los punteros
|
|
this->renderer = renderer;
|
|
this->screen = screen;
|
|
this->resource = resource;
|
|
this->asset = asset;
|
|
this->options = options;
|
|
|
|
// Reserva memoria para los punteros a objetos
|
|
eventHandler = new SDL_Event();
|
|
text = new Text(resource->getOffset("smb2.txt"), resource->getTexture("smb2.png"), renderer);
|
|
texture = resource->getTexture("ending1.png");
|
|
sprite = new Sprite({0, 0, texture->getWidth(), texture->getHeight()}, texture, renderer);
|
|
|
|
// Inicializa variables
|
|
counter = 0;
|
|
counterEnabled = true;
|
|
subCounter = 0;
|
|
section.name = SECTION_PROG_ENDING;
|
|
section.subsection = 0;
|
|
ticks = 0;
|
|
ticksSpeed = 15;
|
|
scene = -1;
|
|
sceneLenght.insert(sceneLenght.end(), {0, 100, 100, 100});
|
|
pause = false;
|
|
|
|
// Inicializa los textos
|
|
iniTexts();
|
|
|
|
// Cambia el color del borde
|
|
screen->setBorderColor(stringToColor(options->palette, "black"));
|
|
|
|
// Crea la textura para el texto que se escribe en pantalla
|
|
canvasTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
|
|
if (canvasTexture == nullptr)
|
|
{
|
|
if (options->console)
|
|
{
|
|
std::cout << "Error: canvasTexture could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
|
|
}
|
|
}
|
|
SDL_SetTextureBlendMode(canvasTexture, SDL_BLENDMODE_BLEND);
|
|
|
|
// 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)
|
|
{
|
|
if (options->console)
|
|
{
|
|
std::cout << "Error: canvasTexture could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
|
|
}
|
|
}
|
|
SDL_SetTextureBlendMode(coverTexture, SDL_BLENDMODE_BLEND);
|
|
|
|
// Rellena la textura segun la escena
|
|
fillTexture();
|
|
}
|
|
|
|
// Destructor
|
|
Ending::~Ending()
|
|
{
|
|
// Libera la memoria de los objetos
|
|
delete eventHandler;
|
|
delete text;
|
|
delete sprite;
|
|
SDL_DestroyTexture(canvasTexture);
|
|
SDL_DestroyTexture(coverTexture);
|
|
|
|
for (auto st : spriteTexts)
|
|
{
|
|
delete st.coverTexture;
|
|
delete st.sprite;
|
|
delete st.texture;
|
|
}
|
|
spriteTexts.clear();
|
|
}
|
|
|
|
// Actualiza el objeto
|
|
void Ending::update()
|
|
{
|
|
// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
|
|
if (SDL_GetTicks() - ticks > ticksSpeed)
|
|
{
|
|
// Actualiza el contador de ticks
|
|
ticks = SDL_GetTicks();
|
|
|
|
// Comprueba el manejador de eventos
|
|
checkEventHandler();
|
|
|
|
if (pause)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Actualiza el contador
|
|
updateCounter();
|
|
}
|
|
}
|
|
|
|
// Dibuja el final en pantalla
|
|
void Ending::render()
|
|
{
|
|
// Prepara para empezar a dibujar en la textura de juego
|
|
screen->start();
|
|
|
|
// Limpia la pantalla
|
|
screen->clean(stringToColor(options->palette, "green"));
|
|
|
|
// Dibuja la canvasTexture
|
|
// SDL_RenderCopy(renderer, canvasTexture, nullptr, nullptr);
|
|
|
|
// Dibuja la coverTexture
|
|
// renderCoverTexture();
|
|
|
|
if (scene == 0)
|
|
{
|
|
spriteTexts.at(0).sprite->render();
|
|
spriteTexts.at(1).sprite->render();
|
|
spriteTexts.at(2).sprite->render();
|
|
spriteTexts.at(3).sprite->render();
|
|
|
|
spriteTexts.at(0).coverSprite->render();
|
|
spriteTexts.at(1).coverSprite->render();
|
|
spriteTexts.at(2).coverSprite->render();
|
|
spriteTexts.at(3).coverSprite->render();
|
|
}
|
|
|
|
// Vuelca el contenido del renderizador en pantalla
|
|
screen->blit();
|
|
}
|
|
|
|
// Comprueba el manejador de eventos
|
|
void Ending::checkEventHandler()
|
|
{
|
|
// Comprueba los eventos que hay en la cola
|
|
while (SDL_PollEvent(eventHandler) != 0)
|
|
{
|
|
// Evento de salida de la aplicación
|
|
if (eventHandler->type == SDL_QUIT)
|
|
{
|
|
section.name = SECTION_PROG_QUIT;
|
|
break;
|
|
}
|
|
|
|
// Comprueba las teclas que se han pulsado
|
|
if ((eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONDOWN))
|
|
{
|
|
switch (eventHandler->key.keysym.scancode)
|
|
{
|
|
case SDL_SCANCODE_ESCAPE:
|
|
// section.name = SECTION_PROG_QUIT;
|
|
break;
|
|
|
|
case SDL_SCANCODE_P:
|
|
pause = !pause;
|
|
break;
|
|
|
|
case SDL_SCANCODE_B:
|
|
screen->switchBorder();
|
|
resource->reLoadTextures();
|
|
break;
|
|
|
|
case SDL_SCANCODE_F:
|
|
screen->switchVideoMode();
|
|
resource->reLoadTextures();
|
|
break;
|
|
|
|
case SDL_SCANCODE_F1:
|
|
screen->setWindowSize(1);
|
|
resource->reLoadTextures();
|
|
break;
|
|
|
|
case SDL_SCANCODE_F2:
|
|
screen->setWindowSize(2);
|
|
resource->reLoadTextures();
|
|
break;
|
|
|
|
case SDL_SCANCODE_F3:
|
|
screen->setWindowSize(3);
|
|
resource->reLoadTextures();
|
|
break;
|
|
|
|
case SDL_SCANCODE_F4:
|
|
screen->setWindowSize(4);
|
|
resource->reLoadTextures();
|
|
break;
|
|
|
|
case SDL_SCANCODE_F5:
|
|
// switchPalette();
|
|
break;
|
|
|
|
case SDL_SCANCODE_RIGHT:
|
|
++scene %= 5;
|
|
fillTexture();
|
|
break;
|
|
|
|
case SDL_SCANCODE_LEFT:
|
|
--scene %= 5;
|
|
fillTexture();
|
|
break;
|
|
|
|
default:
|
|
// section.name = SECTION_PROG_TITLE;
|
|
// section.subsection = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Inicializa los textos
|
|
void Ending::iniTexts()
|
|
{
|
|
// Reinicia el vector
|
|
texts.clear();
|
|
|
|
// Escena #0
|
|
texts.push_back({"HE FINALLY MANAGED", 32});
|
|
texts.push_back({"TO GET TO THE JAIL", 43});
|
|
texts.push_back({"WITH ALL HIS PROJECTS", 141});
|
|
texts.push_back({"READY TO BE RELEASED", 152});
|
|
|
|
// Escena #1
|
|
texts.push_back({"ALL THE JAILERS WERE THERE", 1});
|
|
texts.push_back({"WAITING FOR THE JAILGAMES", 11});
|
|
texts.push_back({"TO BE RELEASED", 21});
|
|
|
|
texts.push_back({"THERE WERE EVEN BARRULLS AND", 161});
|
|
texts.push_back({"BEGINNERS AMONG THE CROWD", 171});
|
|
|
|
texts.push_back({"BRY WAS CRYING...", 181});
|
|
|
|
// Escena #2
|
|
texts.push_back({"BUT SUDDENLY SOMETHING", 19});
|
|
texts.push_back({"CAUGHT HIS ATTENTION", 31});
|
|
|
|
// Escena #3
|
|
texts.push_back({"A PILE OF JUNK!", 36});
|
|
texts.push_back({"FULL OF NON WORKING THINGS!!", 49});
|
|
|
|
// Escena #4
|
|
texts.push_back({"AND THEN,", 26});
|
|
texts.push_back({"FOURTY NEW PROJECTS", 36});
|
|
texts.push_back({"WERE BORN...", 158});
|
|
|
|
// Crea los sprites
|
|
for (auto st : spriteTexts)
|
|
{
|
|
delete st.sprite;
|
|
delete st.texture;
|
|
}
|
|
spriteTexts.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;
|
|
color_t c = stringToColor(options->palette, "black");
|
|
|
|
// Crea la texture
|
|
st.texture = new Texture(renderer);
|
|
st.texture->createBlank(renderer, width, height, SDL_TEXTUREACCESS_TARGET);
|
|
st.texture->setAsRenderTarget(renderer);
|
|
st.texture->setBlendMode(SDL_BLENDMODE_BLEND);
|
|
text->writeDX(TXT_STROKE, 2, 2, t.caption, 1, c, 2, c);
|
|
|
|
// Crea el sprite
|
|
st.sprite = new Sprite({0, 0, st.texture->getWidth(), st.texture->getHeight()}, st.texture, renderer);
|
|
st.sprite->setPos({(GAMECANVAS_WIDTH - st.texture->getWidth()) / 2, t.pos});
|
|
|
|
// Crea la coverTexture
|
|
st.coverTexture = new Texture(renderer);
|
|
st.coverTexture->createBlank(renderer, width, height + 8, SDL_TEXTUREACCESS_TARGET);
|
|
st.coverTexture->setAsRenderTarget(renderer);
|
|
st.coverTexture->setBlendMode(SDL_BLENDMODE_BLEND);
|
|
|
|
// Rellena la coverTexture con color transparente
|
|
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
|
|
SDL_RenderClear(renderer);
|
|
|
|
// Los primeros 8 pixels crea una malla
|
|
c = stringToColor(options->palette, "red");
|
|
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 + 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->palette, "cyan");
|
|
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
|
|
SDL_RenderFillRect(renderer, &rect);
|
|
|
|
// Crea el sprite
|
|
st.coverSprite = new Sprite({0, 0, st.coverTexture->getWidth(), st.coverTexture->getHeight() - 8}, st.coverTexture, renderer);
|
|
st.coverSprite->setPos({(GAMECANVAS_WIDTH - st.coverTexture->getWidth()) / 2, t.pos});
|
|
st.coverSprite->setSpriteClip(0, 8, -1, -1);
|
|
|
|
spriteTexts.push_back(st);
|
|
}
|
|
}
|
|
|
|
// Rellena la textura segun la escena
|
|
void Ending::fillTexture()
|
|
{
|
|
// Inicializa los textos
|
|
iniTexts();
|
|
|
|
// Rellena la canvasTexture de color
|
|
SDL_SetRenderTarget(renderer, canvasTexture);
|
|
color_t c = stringToColor(options->palette, "green");
|
|
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
|
|
SDL_RenderClear(renderer);
|
|
|
|
const int size = text->getCharacterSize();
|
|
|
|
if (scene == 0)
|
|
{ // Compone la escena #0
|
|
|
|
// Dibuja el sprite
|
|
texture = resource->getTexture("ending1.png");
|
|
sprite->setTexture(texture);
|
|
sprite->setSpriteClip({0, 0, texture->getWidth(), texture->getHeight()});
|
|
const int x = (PLAY_AREA_WIDTH - texture->getWidth()) / 2;
|
|
sprite->setRect({x, 48, texture->getWidth(), texture->getHeight()});
|
|
sprite->render();
|
|
|
|
// Dos lineas de texto
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 34, texts.at(0), 1, c, 2, c);
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 45, texts.at(1), 1, c, 2, c);
|
|
spriteTexts.at(0).sprite->render();
|
|
spriteTexts.at(1).sprite->render();
|
|
|
|
// Dos lineas más de texto
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 143, texts.at(2), 1, c, 2, c);
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 154, texts.at(3), 1, c, 2, c);
|
|
spriteTexts.at(2).sprite->render();
|
|
spriteTexts.at(3).sprite->render();
|
|
}
|
|
|
|
else if (scene == 1)
|
|
{ // Compone la escena #1
|
|
|
|
// Dibuja el sprite
|
|
texture = resource->getTexture("ending2.png");
|
|
sprite->setTexture(texture);
|
|
sprite->setSpriteClip({0, 0, texture->getWidth(), texture->getHeight()});
|
|
const int x = (GAMECANVAS_WIDTH - texture->getWidth()) / 2;
|
|
const int y = (GAMECANVAS_HEIGHT - texture->getHeight()) / 2;
|
|
sprite->setRect({x, y, texture->getWidth(), texture->getHeight()});
|
|
sprite->render();
|
|
|
|
// Tres lineas de texto
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 3, texts.at(4), 1, c, 2, c);
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 13, texts.at(5), 1, c, 2, c);
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 23, texts.at(6), 1, c, 2, c);
|
|
spriteTexts.at(4).sprite->render();
|
|
spriteTexts.at(5).sprite->render();
|
|
spriteTexts.at(6).sprite->render();
|
|
|
|
// Dos lineas más de texto
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 163, texts.at(7), 1, c, 2, c);
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 173, texts.at(8), 1, c, 2, c);
|
|
spriteTexts.at(7).sprite->render();
|
|
spriteTexts.at(8).sprite->render();
|
|
|
|
// Una linea mas
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 183, texts.at(9), 1, c, 2, c);
|
|
spriteTexts.at(9).sprite->render();
|
|
}
|
|
|
|
else if (scene == 2)
|
|
{ // Compone la escena #2
|
|
|
|
// Dibuja el sprite
|
|
texture = resource->getTexture("ending3.png");
|
|
sprite->setTexture(texture);
|
|
sprite->setSpriteClip({0, 0, texture->getWidth(), texture->getHeight()});
|
|
const int x = (GAMECANVAS_WIDTH - texture->getWidth()) / 2;
|
|
sprite->setRect({x, 29, texture->getWidth(), texture->getHeight()});
|
|
sprite->render();
|
|
|
|
// Dos lineas de texto
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 21, texts.at(10), 1, c, 2, c);
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 33, texts.at(11), 1, c, 2, c);
|
|
spriteTexts.at(10).sprite->render();
|
|
spriteTexts.at(11).sprite->render();
|
|
}
|
|
|
|
else if (scene == 3)
|
|
{ // Compone la escena #3
|
|
|
|
// Dibuja el sprite
|
|
texture = resource->getTexture("ending4.png");
|
|
sprite->setTexture(texture);
|
|
sprite->setSpriteClip({0, 0, texture->getWidth(), texture->getHeight()});
|
|
const int x = (GAMECANVAS_WIDTH - texture->getWidth()) / 2;
|
|
sprite->setRect({x, 63, texture->getWidth(), texture->getHeight()});
|
|
sprite->render();
|
|
|
|
// Dos lineas de texto
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 38, texts.at(12), 1, c, 2, c);
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 51, texts.at(13), 1, c, 2, c);
|
|
spriteTexts.at(12).sprite->render();
|
|
spriteTexts.at(13).sprite->render();
|
|
}
|
|
|
|
else if (scene == 4)
|
|
{ // Compone la escena #4
|
|
|
|
// Dibuja el sprite
|
|
texture = resource->getTexture("ending5.png");
|
|
sprite->setTexture(texture);
|
|
sprite->setSpriteClip({0, 0, texture->getWidth(), texture->getHeight()});
|
|
const int x = (GAMECANVAS_WIDTH - texture->getWidth()) / 2;
|
|
sprite->setRect({x, 53, texture->getWidth(), texture->getHeight()});
|
|
sprite->render();
|
|
|
|
// Dos lineas de texto
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 28, texts.at(14), 1, c, 2, c);
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 38, texts.at(15), 1, c, 2, c);
|
|
spriteTexts.at(14).sprite->render();
|
|
spriteTexts.at(15).sprite->render();
|
|
|
|
// Una linea mas
|
|
// text->writeDX(TXT_CENTER | TXT_STROKE, PLAY_AREA_CENTER_X, 160, texts.at(16), 1, c, 2, c);
|
|
spriteTexts.at(16).sprite->render();
|
|
}
|
|
|
|
else if (scene == -1)
|
|
{ // Compone la escena # -1
|
|
|
|
text->write(0, 182, "SCENE -1");
|
|
spriteTexts.at(0).sprite->render();
|
|
}
|
|
|
|
SDL_SetRenderTarget(renderer, nullptr);
|
|
|
|
// Rellena la coverTexture con color transparente
|
|
SDL_SetRenderTarget(renderer, coverTexture);
|
|
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0x00);
|
|
SDL_RenderClear(renderer);
|
|
|
|
// Los primeros 8 pixels crea una malla
|
|
c = stringToColor(options->palette, "red");
|
|
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
|
|
for (int i = 0; i < 256; 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 + 1, 5);
|
|
SDL_RenderDrawPoint(renderer, i + 1, 7);
|
|
}
|
|
|
|
// El resto se rellena de color sólido
|
|
SDL_Rect rect = {0, 8, 256, 192};
|
|
c = stringToColor(options->palette, "cyan");
|
|
SDL_SetRenderDrawColor(renderer, c.r, c.g, c.b, 0xFF);
|
|
SDL_RenderFillRect(renderer, &rect);
|
|
|
|
SDL_SetRenderTarget(renderer, nullptr);
|
|
}
|
|
|
|
// Bucle principal
|
|
section_t Ending::run()
|
|
{
|
|
while (section.name == SECTION_PROG_ENDING)
|
|
{
|
|
update();
|
|
render();
|
|
}
|
|
|
|
return section;
|
|
}
|
|
|
|
// Actualiza el contador
|
|
void Ending::updateCounter()
|
|
{
|
|
if (scene == -1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Incrementa el contador
|
|
if (counterEnabled)
|
|
{
|
|
counter++;
|
|
|
|
{
|
|
/*for (auto st : spriteTexts)
|
|
{
|
|
const int height = st.sprite->getHeight() + 8;
|
|
const int width = st.sprite->getWidth();
|
|
const int offset = std::min(counter / 8, height / 2);
|
|
SDL_Rect srcRect = {0, 0, width, height - (offset * 2)};
|
|
SDL_Rect dstRect = {0, (offset * 2) - 8, width, height - (offset * 2)};
|
|
st.texture->setAsRenderTarget(renderer);
|
|
SDL_RenderCopy(renderer, st.coverTexture->getSDLTexture(), &srcRect, &dstRect);
|
|
}*/
|
|
}
|
|
}
|
|
else
|
|
{
|
|
subCounter++;
|
|
if (subCounter == 100)
|
|
{
|
|
counterEnabled = true;
|
|
subCounter = 0;
|
|
}
|
|
}
|
|
|
|
// Comprueba si ha terminado la sección
|
|
if (counter > 600)
|
|
{
|
|
scene++;
|
|
fillTexture();
|
|
counter = 0;
|
|
if (scene == 5)
|
|
{
|
|
section.name = SECTION_PROG_QUIT;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Dibuja la coverTexture
|
|
void Ending::renderCoverTexture()
|
|
{
|
|
if (scene == -1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (counter < 1150)
|
|
{
|
|
// Dibuja la textura que cubre el texto
|
|
const int offset = std::min(counter / 2, 200 / 2);
|
|
SDL_Rect srcRect = {0, 0, 256, 200 - (offset * 2)};
|
|
SDL_Rect dstRect = {0, (offset * 2) - 8, 256, 200 - (offset * 2)};
|
|
SDL_RenderCopy(renderer, coverTexture, &srcRect, &dstRect);
|
|
}
|
|
} |