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

268
source/screen.cpp
View File

@@ -22,105 +22,101 @@
#endif
// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
Screen *Screen::screen = nullptr;
Screen *Screen::screen_ = nullptr;
// [SINGLETON] Crearemos el objeto screen con esta función estática
void Screen::init(SDL_Window *window, SDL_Renderer *renderer)
{
Screen::screen = new Screen(window, renderer);
Screen::screen_ = new Screen(window, renderer);
}
// [SINGLETON] Destruiremos el objeto screen con esta función estática
void Screen::destroy()
{
delete Screen::screen;
delete Screen::screen_;
}
// [SINGLETON] Con este método obtenemos el objeto screen y podemos trabajar con él
Screen *Screen::get()
{
return Screen::screen;
return Screen::screen_;
}
// Constructor
Screen::Screen(SDL_Window *window, SDL_Renderer *renderer)
: window(window), renderer(renderer)
: window_(window), renderer_(renderer)
{
// Copia punteros
input = Input::get();
asset = Asset::get();
// Inicializa variables
srcrect = {0, 0, param.game.width, param.game.height};
dstrect = {0, 0, param.game.width, param.game.height};
borderColor = {0, 0, 0};
flashEffect.enabled = false;
flashEffect.counter = 0;
flashEffect.lenght = 0;
flashEffect.color = {0xFF, 0xFF, 0xFF};
shakeEffect.enabled = false;
shakeEffect.desp = 2;
shakeEffect.delay = 3;
shakeEffect.counter = 0;
shakeEffect.lenght = 8;
shakeEffect.remaining = 0;
shakeEffect.originalPos = 0;
shakeEffect.originalWidth = param.game.width;
attenuateEffect = false;
fpsTicks = 0;
fpsCounter = 0;
fps = 0;
src_rect_ = {0, 0, param.game.width, param.game.height};
dst_rect_ = {0, 0, param.game.width, param.game.height};
border_color_ = {0, 0, 0};
flash_effect_.enabled = false;
flash_effect_.counter = 0;
flash_effect_.lenght = 0;
flash_effect_.color = {0xFF, 0xFF, 0xFF};
shake_effect_.enabled = false;
shake_effect_.desp = 2;
shake_effect_.delay = 3;
shake_effect_.counter = 0;
shake_effect_.lenght = 8;
shake_effect_.remaining = 0;
shake_effect_.originalPos = 0;
shake_effect_.originalWidth = param.game.width;
attenuate_effect_ = false;
fps_ticks_ = 0;
fps_counter_ = 0;
fps_ = 0;
#ifdef DEBUG
showInfo = true;
show_info_ = true;
#else
showInfo = false;
show_info_ = false;
#endif
SDL_DisplayMode DM;
SDL_GetCurrentDisplayMode(0, &DM);
infoResolution = std::to_string(DM.w) + " X " + std::to_string(DM.h) + " AT " + std::to_string(DM.refresh_rate) + " HZ";
info_resolution_ = std::to_string(DM.w) + " X " + std::to_string(DM.h) + " AT " + std::to_string(DM.refresh_rate) + " HZ";
// Crea los objetos
notify = std::make_unique<Notify>(renderer, "", asset->get("8bithud.png"), asset->get("8bithud.txt"), asset->get("notify.wav"));
notify_ = std::make_unique<Notify>(renderer_, "", Asset::get()->get("8bithud.png"), Asset::get()->get("8bithud.txt"), Asset::get()->get("notify_.wav"));
// Define el color del borde para el modo de pantalla completa
borderColor = {0x00, 0x00, 0x00};
border_color_ = {0x00, 0x00, 0x00};
// Crea las textura donde se dibujan los graficos del juego
gameCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
shaderCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
game_canvas_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
shader_canvas_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
// Establece el modo de video
setVideoMode(options.video.mode);
// Muestra la ventana
SDL_ShowWindow(window);
SDL_ShowWindow(window_);
}
// Destructor
Screen::~Screen()
{
SDL_DestroyTexture(gameCanvas);
SDL_DestroyTexture(shaderCanvas);
SDL_DestroyTexture(game_canvas_);
SDL_DestroyTexture(shader_canvas_);
}
// Limpia la pantalla
void Screen::clean(Color color)
{
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, color.r, color.g, color.b, 0xFF);
SDL_RenderClear(renderer_);
}
// Prepara para empezar a dibujar en la textura de juego
void Screen::start()
{
SDL_SetRenderTarget(renderer, gameCanvas);
SDL_SetRenderTarget(renderer_, game_canvas_);
}
// Vuelca el contenido del renderizador en pantalla
void Screen::blit()
{
// Actualiza el contador de FPS
fpsCounter++;
fps_counter_++;
// Actualiza y dibuja el efecto de flash en la pantalla
doFlash();
@@ -135,51 +131,51 @@ void Screen::blit()
displayInfo();
// Muestra las notificaciones
notify->render();
notify_->render();
#ifdef NO_SHADERS
// Vuelve a dejar el renderizador en modo normal
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderTarget(renderer_, nullptr);
// Borra el contenido previo
SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, border_color_.r, border_color_.g, border_color_.b, 0xFF);
SDL_RenderClear(renderer_);
// Copia la textura de juego en el renderizador en la posición adecuada
if (shakeEffect.enabled)
SDL_RenderCopy(renderer, gameCanvas, nullptr, nullptr);
SDL_RenderCopy(renderer, gameCanvas, &srcrect, &dstrect);
if (shake_effect_.enabled)
SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
// Muestra por pantalla el renderizador
SDL_RenderPresent(renderer);
SDL_RenderPresent(renderer_);
#else
if (options.video.shaders)
{
SDL_SetRenderTarget(renderer, shaderCanvas);
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
SDL_RenderClear(renderer);
if (shakeEffect.enabled)
SDL_RenderCopy(renderer, gameCanvas, nullptr, nullptr);
SDL_RenderCopy(renderer, gameCanvas, &srcrect, &dstrect);
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderTarget(renderer_, shader_canvas_);
SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
SDL_RenderClear(renderer_);
if (shake_effect_.enabled)
SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
SDL_SetRenderTarget(renderer_, nullptr);
shader::render();
}
else
{
// Vuelve a dejar el renderizador en modo normal
SDL_SetRenderTarget(renderer, nullptr);
SDL_SetRenderTarget(renderer_, nullptr);
// Borra el render
SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
SDL_RenderClear(renderer_);
// Copia la textura de juego en el renderizador en la posición adecuada
if (shakeEffect.enabled)
SDL_RenderCopy(renderer, gameCanvas, nullptr, nullptr);
SDL_RenderCopy(renderer, gameCanvas, &srcrect, &dstrect);
if (shake_effect_.enabled)
SDL_RenderCopy(renderer_, game_canvas_, nullptr, nullptr);
SDL_RenderCopy(renderer_, game_canvas_, &src_rect_, &dst_rect_);
// Muestra por pantalla el renderizador
SDL_RenderPresent(renderer);
SDL_RenderPresent(renderer_);
}
#endif
}
@@ -197,7 +193,7 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
case ScreenVideoMode::WINDOW:
{
// Cambia a modo de ventana
SDL_SetWindowFullscreen(window, 0);
SDL_SetWindowFullscreen(window_, 0);
#ifdef ARCADE
// Oculta el puntero
@@ -207,8 +203,8 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
SDL_ShowCursor(SDL_ENABLE);
#endif
// Modifica el tamaño de la ventana
SDL_SetWindowSize(window, param.game.width * options.video.window.size, param.game.height * options.video.window.size);
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
SDL_SetWindowSize(window_, param.game.width * options.video.window.size, param.game.height * options.video.window.size);
SDL_SetWindowPosition(window_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
break;
}
@@ -217,7 +213,7 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
case ScreenVideoMode::FULLSCREEN:
{
// Aplica el modo de video
SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
SDL_SetWindowFullscreen(window_, SDL_WINDOW_FULLSCREEN_DESKTOP);
// Oculta el puntero
SDL_ShowCursor(SDL_DISABLE);
@@ -233,10 +229,10 @@ void Screen::setVideoMode(ScreenVideoMode videoMode)
if (options.video.shaders)
{
#ifndef NO_SHADERS
std::ifstream f(asset->get("crtpi.glsl").c_str());
std::ifstream f(Asset::get()->get("crtpi.glsl").c_str());
std::string source((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
shader::init(window, shaderCanvas, source.c_str());
shader::init(window_, shader_canvas_, source.c_str());
#endif
}
}
@@ -274,20 +270,20 @@ void Screen::incWindowSize()
// Cambia el color del borde
void Screen::setBorderColor(Color color)
{
borderColor = color;
border_color_ = color;
}
// Cambia el tipo de mezcla
void Screen::setBlendMode(SDL_BlendMode blendMode)
{
SDL_SetRenderDrawBlendMode(renderer, blendMode);
SDL_SetRenderDrawBlendMode(renderer_, blendMode);
}
// Actualiza la lógica de la clase
void Screen::update()
{
updateShake();
notify->update();
updateShakeEffect();
notify_->update();
updateFPS();
OnScreenHelp::get()->update();
}
@@ -297,7 +293,7 @@ void Screen::checkInput()
{
#ifndef ARCADE
// Comprueba el teclado para cambiar entre pantalla completa y ventana
if (input->checkInput(input_window_fullscreen, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_window_fullscreen, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
switchVideoMode();
const std::string mode = options.video.mode == ScreenVideoMode::WINDOW ? "Window" : "Fullscreen";
@@ -306,7 +302,7 @@ void Screen::checkInput()
}
// Comprueba el teclado para decrementar el tamaño de la ventana
if (input->checkInput(input_window_dec_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_window_dec_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
decWindowSize();
const std::string size = std::to_string(options.video.window.size);
@@ -315,7 +311,7 @@ void Screen::checkInput()
}
// Comprueba el teclado para incrementar el tamaño de la ventana
if (input->checkInput(input_window_inc_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_window_inc_size, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
incWindowSize();
const std::string size = std::to_string(options.video.window.size);
@@ -325,7 +321,7 @@ void Screen::checkInput()
#endif
// Comprueba el teclado para activar o desactivar los shaders
if (input->checkInput(input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
switchShaders();
return;
@@ -333,26 +329,26 @@ void Screen::checkInput()
#ifdef DEBUG
// Comprueba el teclado para mostrar la información de debug
if (input->checkInput(input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
if (Input::get()->checkInput(input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_KEYBOARD))
{
showInfo = !showInfo;
show_info_ = !show_info_;
return;
}
#endif
for (int i = 0; i < input->getNumControllers(); ++i)
for (int i = 0; i < Input::get()->getNumControllers(); ++i)
{
// Comprueba los mandos para activar o desactivar los shaders
if (input->checkModInput(input_service, input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
if (Input::get()->checkModInput(input_service, input_video_shaders, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
{
switchShaders();
return;
}
// Comprueba los mandos para mostrar la información de debug
if (input->checkModInput(input_service, input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
if (Input::get()->checkModInput(input_service, input_showinfo, INPUT_DO_NOT_ALLOW_REPEAT, INPUT_USE_GAMECONTROLLER, i))
{
showInfo = !showInfo;
show_info_ = !show_info_;
return;
}
}
@@ -362,43 +358,43 @@ void Screen::checkInput()
void Screen::shake()
{
// Si no hay un shake effect activo, se guarda una copia de los valores actuales antes de modificarlos
if (!shakeEffect.enabled)
if (!shake_effect_.enabled)
{
shakeEffect.enabled = true;
shakeEffect.originalPos = srcrect.x;
shakeEffect.originalWidth = srcrect.w;
srcrect.w -= shakeEffect.desp;
dstrect.w = srcrect.w;
shake_effect_.enabled = true;
shake_effect_.originalPos = src_rect_.x;
shake_effect_.originalWidth = src_rect_.w;
src_rect_.w -= shake_effect_.desp;
dst_rect_.w = src_rect_.w;
}
// Si ya hay un shake effect en marcha no se pilla el origen, solo se renuevan los contadores
shakeEffect.remaining = shakeEffect.lenght;
shakeEffect.counter = shakeEffect.delay;
shake_effect_.remaining = shake_effect_.lenght;
shake_effect_.counter = shake_effect_.delay;
}
// Actualiza la logica para agitar la pantalla
void Screen::updateShake()
void Screen::updateShakeEffect()
{
if (shakeEffect.enabled)
if (shake_effect_.enabled)
{
if (shakeEffect.counter > 0)
if (shake_effect_.counter > 0)
{
shakeEffect.counter--;
shake_effect_.counter--;
}
else
{
shakeEffect.counter = shakeEffect.delay;
const auto srcdesp = shakeEffect.remaining % 2 == 0 ? 0 : shakeEffect.desp;
const auto dstdesp = shakeEffect.remaining % 2 == 1 ? 0 : shakeEffect.desp;
srcrect.x = shakeEffect.originalPos + srcdesp;
dstrect.x = shakeEffect.originalPos + dstdesp;
shakeEffect.remaining--;
shakeEffect.enabled = shakeEffect.remaining == -1 ? false : true;
if (!shakeEffect.enabled)
shake_effect_.counter = shake_effect_.delay;
const auto srcdesp = shake_effect_.remaining % 2 == 0 ? 0 : shake_effect_.desp;
const auto dstdesp = shake_effect_.remaining % 2 == 1 ? 0 : shake_effect_.desp;
src_rect_.x = shake_effect_.originalPos + srcdesp;
dst_rect_.x = shake_effect_.originalPos + dstdesp;
shake_effect_.remaining--;
shake_effect_.enabled = shake_effect_.remaining == -1 ? false : true;
if (!shake_effect_.enabled)
{
srcrect.x = shakeEffect.originalPos;
srcrect.w = shakeEffect.originalWidth;
dstrect = srcrect;
src_rect_.x = shake_effect_.originalPos;
src_rect_.w = shake_effect_.originalWidth;
dst_rect_ = src_rect_;
}
}
}
@@ -407,39 +403,39 @@ void Screen::updateShake()
// Pone la pantalla de color
void Screen::flash(Color color, int lenght)
{
flashEffect.enabled = true;
flashEffect.counter = 0;
flashEffect.lenght = lenght;
flashEffect.color = color;
flash_effect_.enabled = true;
flash_effect_.counter = 0;
flash_effect_.lenght = lenght;
flash_effect_.color = color;
}
// Actualiza y dibuja el efecto de flash en la pantalla
void Screen::doFlash()
{
if (flashEffect.enabled)
if (flash_effect_.enabled)
{
// Dibuja el color del flash en la textura
SDL_Texture *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, gameCanvas);
SDL_SetRenderDrawColor(renderer, flashEffect.color.r, flashEffect.color.g, flashEffect.color.b, 0xFF);
SDL_RenderClear(renderer);
SDL_SetRenderTarget(renderer, temp);
SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, game_canvas_);
SDL_SetRenderDrawColor(renderer_, flash_effect_.color.r, flash_effect_.color.g, flash_effect_.color.b, 0xFF);
SDL_RenderClear(renderer_);
SDL_SetRenderTarget(renderer_, temp);
// Actualiza la lógica del efecto
flashEffect.counter < flashEffect.lenght ? flashEffect.counter++ : flashEffect.enabled = false;
flash_effect_.counter < flash_effect_.lenght ? flash_effect_.counter++ : flash_effect_.enabled = false;
}
}
// Atenua la pantalla
void Screen::doAttenuate()
{
if (attenuateEffect)
if (attenuate_effect_)
{
SDL_Texture *temp = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, gameCanvas);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 64);
SDL_RenderFillRect(renderer, nullptr);
SDL_SetRenderTarget(renderer, temp);
SDL_Texture *temp = SDL_GetRenderTarget(renderer_);
SDL_SetRenderTarget(renderer_, game_canvas_);
SDL_SetRenderDrawColor(renderer_, 0, 0, 0, 64);
SDL_RenderFillRect(renderer_, nullptr);
SDL_SetRenderTarget(renderer_, temp);
}
}
@@ -455,50 +451,50 @@ void Screen::switchShaders()
// Atenua la pantalla
void Screen::attenuate(bool value)
{
attenuateEffect = value;
attenuate_effect_ = value;
}
// Muestra una notificación de texto por pantalla;
void Screen::showNotification(std::string text1, std::string text2, int icon)
{
notify->showText(text1, text2, icon);
notify_->showText(text1, text2, icon);
}
// Obtiene el puntero al renderizador
SDL_Renderer *Screen::getRenderer()
{
return renderer;
return renderer_;
}
// Calcula los frames por segundo
void Screen::updateFPS()
{
if (SDL_GetTicks() - fpsTicks > 1000)
if (SDL_GetTicks() - fps_ticks_ > 1000)
{
fpsTicks = SDL_GetTicks();
fps = fpsCounter;
fpsCounter = 0;
fps_ticks_ = SDL_GetTicks();
fps_ = fps_counter_;
fps_counter_ = 0;
}
}
// Muestra información por pantalla
void Screen::displayInfo()
{
if (showInfo)
if (show_info_)
{
// FPS
const std::string fpstext = std::to_string(fps) + " FPS";
const std::string fpstext = std::to_string(fps_) + " FPS";
dbg_print(param.game.width - fpstext.length() * 8, 0, fpstext.c_str(), 255, 255, 0);
// Resolution
dbg_print(0, 0, infoResolution.c_str(), 255, 255, 0);
dbg_print(0, 0, info_resolution_.c_str(), 255, 255, 0);
dbg_print(0, 8, std::to_string(globalInputs::servicePressedCounter[0]).c_str(), 255, 255, 0);
}
}
// Indica si hay alguna notificación activa en pantalla
bool Screen::notificationsAreActive()
bool Screen::notificationsAreActive() const
{
return notify->active();
return notify_->active();
}