jailers/jaildoctors_dilemma
5
0
Fork 0
forked from jaildesigner-jailgames/jaildoctors_dilemma
Code Pull Requests Activity

Eliminado el fichero const.h

Browse Source
This commit is contained in:
Sergio
2022-08-29 20:57:28 +02:00
parent 75317a8b46
commit 0d27774c74
10 changed files with 289 additions and 408 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
source/const.h
View File

@@ -1,97 +0,0 @@
#pragma once
#include <SDL2/SDL.h>
#include <string>
#include "utils.h"
#ifndef CONST_H
#define CONST_H
// Textos
#define WINDOW_CAPTION "JailDoctor's Dilemma"
#define TEXT_COPYRIGHT "@2022 JailDesigner"
#define VERSION "0.1"
// Tamaño de bloque
#define BLOCK 8
#define HALF_BLOCK 4
// Tamaño de la pantalla real
#define SCREEN_WIDTH 256
#define SCREEN_HEIGHT 192
// Tamaño de la pantalla virtual
#define GAMECANVAS_WIDTH 256
#define GAMECANVAS_HEIGHT 192
// Tamaño de la pantalla que se muestra
const int VIEW_WIDTH = SCREEN_WIDTH * 3;
const int VIEW_HEIGHT = SCREEN_HEIGHT * 3;
// Zona de juego
const int PLAY_AREA_TOP = (0 * BLOCK);
const int PLAY_AREA_BOTTOM = (16 * BLOCK);
const int PLAY_AREA_LEFT = (0 * BLOCK);
const int PLAY_AREA_RIGHT = (32 * BLOCK);
const int PLAY_AREA_WIDTH = PLAY_AREA_RIGHT - PLAY_AREA_LEFT;
const int PLAY_AREA_HEIGHT = PLAY_AREA_BOTTOM - PLAY_AREA_TOP;
const int PLAY_AREA_CENTER_X = PLAY_AREA_LEFT + (PLAY_AREA_WIDTH / 2);
const int PLAY_AREA_CENTER_FIRST_QUARTER_X = (PLAY_AREA_WIDTH / 4);
const int PLAY_AREA_CENTER_THIRD_QUARTER_X = (PLAY_AREA_WIDTH / 4) * 3;
const int PLAY_AREA_CENTER_Y = PLAY_AREA_TOP + (PLAY_AREA_HEIGHT / 2);
const int PLAY_AREA_FIRST_QUARTER_Y = PLAY_AREA_HEIGHT / 4;
const int PLAY_AREA_THIRD_QUARTER_Y = (PLAY_AREA_HEIGHT / 4) * 3;
#define BORDER_TOP 0
#define BORDER_RIGHT 1
#define BORDER_BOTTOM 2
#define BORDER_LEFT 3
// Anclajes de pantalla
const int GAMECANVAS_CENTER_X = GAMECANVAS_WIDTH / 2;
const int GAMECANVAS_FIRST_QUARTER_X = GAMECANVAS_WIDTH / 4;
const int GAMECANVAS_THIRD_QUARTER_X = (GAMECANVAS_WIDTH / 4) * 3;
const int GAMECANVAS_CENTER_Y = GAMECANVAS_HEIGHT / 2;
const int GAMECANVAS_FIRST_QUARTER_Y = GAMECANVAS_HEIGHT / 4;
const int GAMECANVAS_THIRD_QUARTER_Y = (GAMECANVAS_HEIGHT / 4) * 3;
// Secciones del programa
#define SECTION_PROG_LOGO 0
#define SECTION_PROG_INTRO 1
#define SECTION_PROG_TITLE 2
#define SECTION_PROG_GAME 3
#define SECTION_PROG_QUIT 4
// Subsecciones
#define SECTION_GAME_PLAY 0
#define SECTION_GAME_PAUSE 1
#define SECTION_GAME_GAMEOVER 2
#define SECTION_TITLE_1 3
#define SECTION_TITLE_2 4
#define SECTION_TITLE_3 5
#define SECTION_TITLE_INSTRUCTIONS 6
// Estados de cada elemento que pertenece a un evento
#define EVENT_WAITING 1
#define EVENT_RUNNING 2
#define EVENT_COMPLETED 3
// Estados de entrada
#define INPUT_NULL 0
#define INPUT_FIRE_LEFT 7
#define INPUT_FIRE_UP 8
#define INPUT_FIRE_RIGHT 9
#define INPUT_PAUSE 10
// Zona muerta del mando analógico
#define JOYSTICK_DEAD_ZONE 8000
// Colores
const color_t bgColor = {0x27, 0x27, 0x36};
const color_t noColor = {0xFF, 0xFF, 0xFF};
const color_t shdwTxtColor = {0x43, 0x43, 0x4F};
// Tipo de filtro
#define FILTER_NEAREST 0
#define FILTER_LINEAL 1
#endif

287
source/director.cpp
View File

@@ -11,31 +11,29 @@ Director::Director(std::string path)
setExecutablePath(path); setExecutablePath(path);
// Crea el objeto que controla los ficheros de recursos // Crea el objeto que controla los ficheros de recursos
mAsset = new Asset(mExecutablePath); asset = new Asset(executablePath);
// Establece la lista de ficheros // Establece la lista de ficheros
setFileList(); setFileList();
// Si falta algún fichero no inicia el programa // Si falta algún fichero no inicia el programa
Uint8 section = SECTION_PROG_GAME; Uint8 section = SECTION_PROG_GAME;
if (!mAsset->check()) if (!asset->check())
section = SECTION_PROG_QUIT; section = SECTION_PROG_QUIT;
// Crea el puntero a la estructura y carga el fichero de configuración // Crea el puntero a la estructura y carga el fichero de configuración
mOptions = new options_t; options = new options_t;
if (!loadConfigFile()) options->fullScreenMode = 0;
{ options->windowSize = 2;
mOptions->fullScreenMode = 0; options->filter = FILTER_NEAREST;
mOptions->windowSize = 3; options->vSync = true;
mOptions->difficulty = DIFFICULTY_NORMAL; options->screenWidth = GAME_WIDTH * options->windowSize;
mOptions->input[0].deviceType = INPUT_USE_KEYBOARD; options->screenHeight = GAME_HEIGHT * options->windowSize;
mOptions->input[1].deviceType = INPUT_USE_GAMECONTROLLER; options->integerScale = true;
mOptions->filter = FILTER_NEAREST; options->keepAspect = true;
mOptions->vSync = true;
}
// Crea los objetos // Crea los objetos
mInput = new Input(mAsset->get("gamecontrollerdb.txt")); input = new Input(asset->get("gamecontrollerdb.txt"));
// Inicializa SDL // Inicializa SDL
initSDL(); initSDL();
@@ -44,8 +42,8 @@ Director::Director(std::string path)
initJailAudio(); initJailAudio();
// Aplica las opciones // Aplica las opciones
SDL_SetWindowFullscreen(mWindow, mOptions->fullScreenMode); SDL_SetWindowFullscreen(window, options->fullScreenMode);
SDL_SetWindowSize(mWindow, SCREEN_WIDTH * mOptions->windowSize, SCREEN_HEIGHT * mOptions->windowSize); SDL_SetWindowSize(window, SCREEN_WIDTH * options->windowSize, SCREEN_HEIGHT * options->windowSize);
// Inicializa el resto de variables // Inicializa el resto de variables
init(section); init(section);
@@ -53,22 +51,13 @@ Director::Director(std::string path)
Director::~Director() Director::~Director()
{ {
saveConfigFile(); delete options;
delete asset;
delete mInput; delete input;
mInput = nullptr; delete screen;
delete mOptions;
mOptions = nullptr;
delete mAsset;
mAsset = nullptr;
SDL_DestroyRenderer(mRenderer);
SDL_DestroyWindow(mWindow);
mRenderer = nullptr;
mWindow = nullptr;
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit(); SDL_Quit();
} }
@@ -76,30 +65,30 @@ Director::~Director()
void Director::init(Uint8 name) void Director::init(Uint8 name)
{ {
// Sección // Sección
mSection.name = name; section.name = name;
mSection.subsection = 0; section.subsection = 0;
// Controles // Controles
mInput->bindKey(INPUT_UP, SDL_SCANCODE_UP); input->bindKey(INPUT_UP, SDL_SCANCODE_UP);
mInput->bindKey(INPUT_DOWN, SDL_SCANCODE_DOWN); input->bindKey(INPUT_DOWN, SDL_SCANCODE_DOWN);
mInput->bindKey(INPUT_LEFT, SDL_SCANCODE_LEFT); input->bindKey(INPUT_LEFT, SDL_SCANCODE_LEFT);
mInput->bindKey(INPUT_RIGHT, SDL_SCANCODE_RIGHT); input->bindKey(INPUT_RIGHT, SDL_SCANCODE_RIGHT);
mInput->bindKey(INPUT_ACCEPT, SDL_SCANCODE_RETURN); input->bindKey(INPUT_ACCEPT, SDL_SCANCODE_RETURN);
mInput->bindKey(INPUT_CANCEL, SDL_SCANCODE_ESCAPE); input->bindKey(INPUT_CANCEL, SDL_SCANCODE_ESCAPE);
mInput->bindKey(INPUT_BUTTON_1, SDL_SCANCODE_SPACE); input->bindKey(INPUT_BUTTON_1, SDL_SCANCODE_SPACE);
mInput->bindKey(INPUT_BUTTON_2, SDL_SCANCODE_D); input->bindKey(INPUT_BUTTON_2, SDL_SCANCODE_D);
mInput->bindKey(INPUT_BUTTON_PAUSE, SDL_SCANCODE_ESCAPE); input->bindKey(INPUT_BUTTON_PAUSE, SDL_SCANCODE_ESCAPE);
mInput->bindKey(INPUT_BUTTON_ESCAPE, SDL_SCANCODE_ESCAPE); input->bindKey(INPUT_BUTTON_ESCAPE, SDL_SCANCODE_ESCAPE);
mInput->bindGameControllerButton(INPUT_UP, SDL_CONTROLLER_BUTTON_DPAD_UP); input->bindGameControllerButton(INPUT_UP, SDL_CONTROLLER_BUTTON_DPAD_UP);
mInput->bindGameControllerButton(INPUT_DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN); input->bindGameControllerButton(INPUT_DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN);
mInput->bindGameControllerButton(INPUT_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT); input->bindGameControllerButton(INPUT_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
mInput->bindGameControllerButton(INPUT_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT); input->bindGameControllerButton(INPUT_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
mInput->bindGameControllerButton(INPUT_ACCEPT, SDL_CONTROLLER_BUTTON_B); input->bindGameControllerButton(INPUT_ACCEPT, SDL_CONTROLLER_BUTTON_B);
mInput->bindGameControllerButton(INPUT_CANCEL, SDL_CONTROLLER_BUTTON_A); input->bindGameControllerButton(INPUT_CANCEL, SDL_CONTROLLER_BUTTON_A);
mInput->bindGameControllerButton(INPUT_BUTTON_1, SDL_CONTROLLER_BUTTON_B); input->bindGameControllerButton(INPUT_BUTTON_1, SDL_CONTROLLER_BUTTON_B);
mInput->bindGameControllerButton(INPUT_BUTTON_PAUSE, SDL_CONTROLLER_BUTTON_GUIDE); input->bindGameControllerButton(INPUT_BUTTON_PAUSE, SDL_CONTROLLER_BUTTON_GUIDE);
mInput->bindGameControllerButton(INPUT_BUTTON_ESCAPE, SDL_CONTROLLER_BUTTON_GUIDE); input->bindGameControllerButton(INPUT_BUTTON_ESCAPE, SDL_CONTROLLER_BUTTON_GUIDE);
} }
// Inicializa JailAudio // Inicializa JailAudio
@@ -127,14 +116,14 @@ bool Director::initSDL()
std::srand(static_cast<unsigned int>(SDL_GetTicks())); std::srand(static_cast<unsigned int>(SDL_GetTicks()));
// Establece el filtro de la textura a nearest // Establece el filtro de la textura a nearest
if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(mOptions->filter).c_str())) if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, std::to_string(options->filter).c_str()))
{ {
printf("Warning: Nearest texture filtering not enabled!\n"); printf("Warning: Nearest texture filtering not enabled!\n");
} }
// Crea la ventana // Crea la ventana
mWindow = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, VIEW_WIDTH, VIEW_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI); window = SDL_CreateWindow(WINDOW_CAPTION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, VIEW_WIDTH, VIEW_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI);
if (mWindow == NULL) if (window == NULL)
{ {
printf("Window could not be created!\nSDL Error: %s\n", SDL_GetError()); printf("Window could not be created!\nSDL Error: %s\n", SDL_GetError());
success = false; success = false;
@@ -142,12 +131,12 @@ bool Director::initSDL()
else else
{ {
// Crea un renderizador para la ventana. El vsync se activa en funcion de las opciones // Crea un renderizador para la ventana. El vsync se activa en funcion de las opciones
if (mOptions->vSync) if (options->vSync)
mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
else else
mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED); renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (mRenderer == NULL) if (renderer == NULL)
{ {
printf("Renderer could not be created!\nSDL Error: %s\n", SDL_GetError()); printf("Renderer could not be created!\nSDL Error: %s\n", SDL_GetError());
success = false; success = false;
@@ -155,13 +144,13 @@ bool Director::initSDL()
else else
{ {
// Inicializa el color de renderizado // Inicializa el color de renderizado
SDL_SetRenderDrawColor(mRenderer, 0x00, 0x00, 0x00, 0xFF); SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0xFF);
// Establece el tamaño del buffer de renderizado // Establece el tamaño del buffer de renderizado
SDL_RenderSetLogicalSize(mRenderer, SCREEN_WIDTH, SCREEN_HEIGHT); SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH, SCREEN_HEIGHT);
// Establece el modo de mezcla // Establece el modo de mezcla
SDL_SetRenderDrawBlendMode(mRenderer, SDL_BLENDMODE_BLEND); SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
} }
} }
} }
@@ -173,165 +162,55 @@ bool Director::initSDL()
// Crea el indice de ficheros // Crea el indice de ficheros
void Director::setFileList() void Director::setFileList()
{ {
mAsset->add("/media/font/smb2.png", font); asset->add("/media/font/smb2.png", font);
mAsset->add("/media/font/smb2.txt", font); asset->add("/media/font/smb2.txt", font);
mAsset->add("/media/font/debug.png", font); asset->add("/media/font/debug.png", font);
mAsset->add("/media/font/debug.txt", font); asset->add("/media/font/debug.txt", font);
mAsset->add("/data/gamecontrollerdb.txt", data); asset->add("/data/gamecontrollerdb.txt", data);
mAsset->add("/data/config.bin", data, false); asset->add("/data/room/01.room", room);
mAsset->add("/data/room/01.room", room); asset->add("/data/room/02.room", room);
mAsset->add("/data/room/02.room", room); asset->add("/data/room/03.room", room);
mAsset->add("/data/room/03.room", room); asset->add("/data/room/04.room", room);
mAsset->add("/data/room/04.room", room); asset->add("/data/room/05.room", room);
mAsset->add("/data/room/05.room", room); asset->add("/data/room/01.tmx", room);
mAsset->add("/data/room/01.tmx", room); asset->add("/data/room/02.tmx", room);
mAsset->add("/data/room/02.tmx", room); asset->add("/data/room/03.tmx", room);
mAsset->add("/data/room/03.tmx", room); asset->add("/data/room/04.tmx", room);
mAsset->add("/data/room/04.tmx", room); asset->add("/data/room/05.tmx", room);
mAsset->add("/data/room/05.tmx", room); asset->add("/media/tilesets/standard.png", bitmap);
mAsset->add("/media/tilesets/standard.png", bitmap); asset->add("/media/enemies/paco.png", bitmap);
mAsset->add("/media/enemies/paco.png", bitmap); asset->add("/media/enemies/paco.ani", data);
mAsset->add("/media/enemies/paco.ani", data); asset->add("/media/enemies/chip.png", bitmap);
mAsset->add("/media/enemies/chip.png", bitmap); asset->add("/media/enemies/chip.ani", data);
mAsset->add("/media/enemies/chip.ani", data); asset->add("/media/enemies/wave.png", bitmap);
mAsset->add("/media/enemies/wave.png", bitmap); asset->add("/media/enemies/wave.ani", data);
mAsset->add("/media/enemies/wave.ani", data); asset->add("/media/player/player01.png", bitmap);
mAsset->add("/media/player/player01.png", bitmap); asset->add("/media/player/player01.ani", data);
mAsset->add("/media/player/player01.ani", data); asset->add("/media/items/items.png", bitmap);
mAsset->add("/media/items/items.png", bitmap);
}
// Carga el fichero de configuración
bool Director::loadConfigFile()
{
// Pone unos valores por defecto
mOptions->fullScreenMode = 0;
mOptions->windowSize = 3;
mOptions->difficulty = DIFFICULTY_NORMAL;
mOptions->input[0].deviceType = INPUT_USE_KEYBOARD;
mOptions->input[1].deviceType = INPUT_USE_GAMECONTROLLER;
mOptions->filter = FILTER_NEAREST;
mOptions->vSync = true;
// Indicador de éxito en la carga
bool success = true;
const std::string p = mAsset->get("config.bin");
std::string filename = p.substr(p.find_last_of("\\/") + 1);
SDL_RWops *file = SDL_RWFromFile(p.c_str(), "r+b");
// El fichero no existe
if (file == NULL)
{
printf("Warning: Unable to open %s file\n", filename.c_str());
// Crea el fichero para escritura
file = SDL_RWFromFile(p.c_str(), "w+b");
if (file != NULL)
{
printf("New file (%s) created!\n", filename.c_str());
// Escribe los datos
SDL_RWwrite(file, &mOptions->fullScreenMode, sizeof(mOptions->fullScreenMode), 1);
SDL_RWwrite(file, &mOptions->windowSize, sizeof(mOptions->windowSize), 1);
SDL_RWwrite(file, &mOptions->language, sizeof(mOptions->language), 1);
SDL_RWwrite(file, &mOptions->difficulty, sizeof(mOptions->difficulty), 1);
SDL_RWwrite(file, &mOptions->input[0].deviceType, sizeof(mOptions->input[0].deviceType), 1);
SDL_RWwrite(file, &mOptions->input[1].deviceType, sizeof(mOptions->input[1].deviceType), 1);
SDL_RWwrite(file, &mOptions->filter, sizeof(mOptions->filter), 1);
SDL_RWwrite(file, &mOptions->vSync, sizeof(mOptions->vSync), 1);
// Cierra el fichero
SDL_RWclose(file);
}
else
{
printf("Error: Unable to create file %s\n", filename.c_str());
success = false;
}
}
// El fichero existe
else
{
// Carga los datos
printf("Reading file %s\n", filename.c_str());
SDL_RWread(file, &mOptions->fullScreenMode, sizeof(mOptions->fullScreenMode), 1);
SDL_RWread(file, &mOptions->windowSize, sizeof(mOptions->windowSize), 1);
SDL_RWread(file, &mOptions->language, sizeof(mOptions->language), 1);
SDL_RWread(file, &mOptions->difficulty, sizeof(mOptions->difficulty), 1);
SDL_RWread(file, &mOptions->input[0].deviceType, sizeof(mOptions->input[0].deviceType), 1);
SDL_RWread(file, &mOptions->input[1].deviceType, sizeof(mOptions->input[1].deviceType), 1);
SDL_RWread(file, &mOptions->filter, sizeof(mOptions->filter), 1);
SDL_RWread(file, &mOptions->vSync, sizeof(mOptions->vSync), 1);
// Normaliza los valores
if (!((mOptions->fullScreenMode == 0) ||
(mOptions->fullScreenMode == SDL_WINDOW_FULLSCREEN) ||
(mOptions->fullScreenMode == SDL_WINDOW_FULLSCREEN_DESKTOP)))
mOptions->fullScreenMode = 0;
if ((mOptions->windowSize < 1) || (mOptions->windowSize > 4))
mOptions->windowSize = 3;
// Cierra el fichero
SDL_RWclose(file);
}
return success;
}
// Guarda el fichero de configuración
bool Director::saveConfigFile()
{
bool success = true;
const std::string p = mAsset->get("config.bin");
std::string filename = p.substr(p.find_last_of("\\/") + 1);
SDL_RWops *file = SDL_RWFromFile(p.c_str(), "w+b");
if (file != NULL)
{
// Guarda los datos
SDL_RWwrite(file, &mOptions->fullScreenMode, sizeof(mOptions->fullScreenMode), 1);
SDL_RWwrite(file, &mOptions->windowSize, sizeof(mOptions->windowSize), 1);
SDL_RWwrite(file, &mOptions->language, sizeof(mOptions->language), 1);
SDL_RWwrite(file, &mOptions->difficulty, sizeof(mOptions->difficulty), 1);
SDL_RWwrite(file, &mOptions->input[0].deviceType, sizeof(mOptions->input[0].deviceType), 1);
SDL_RWwrite(file, &mOptions->input[1].deviceType, sizeof(mOptions->input[1].deviceType), 1);
SDL_RWwrite(file, &mOptions->filter, sizeof(mOptions->filter), 1);
SDL_RWwrite(file, &mOptions->vSync, sizeof(mOptions->vSync), 1);
printf("Writing file %s\n", filename.c_str());
// Cierra el fichero
SDL_RWclose(file);
}
else
{
printf("Error: Unable to save %s file! %s\n", filename.c_str(), SDL_GetError());
}
return success;
} }
// Establece el valor de la variable // Establece el valor de la variable
void Director::setExecutablePath(std::string path) void Director::setExecutablePath(std::string path)
{ {
mExecutablePath = path.substr(0, path.find_last_of("\\/")); executablePath = path.substr(0, path.find_last_of("\\/"));
} }
// Obtiene el valor de la variable // Obtiene el valor de la variable
Uint8 Director::getSubsection() Uint8 Director::getSubsection()
{ {
return mSection.subsection; return section.subsection;
} }
// Obtiene el valor de la variable // Obtiene el valor de la variable
Uint8 Director::getSection() Uint8 Director::getSection()
{ {
return mSection.name; return section.name;
} }
// Establece el valor de la variable // Establece el valor de la variable
void Director::setSection(section_t section) void Director::setSection(section_t section)
{ {
mSection = section; section = section;
} }
void Director::runLogo() void Director::runLogo()
@@ -348,9 +227,9 @@ void Director::runTitle()
void Director::runGame() void Director::runGame()
{ {
mGame = new Game(mWindow, mRenderer, mAsset, mInput); game = new Game(renderer, screen, asset, input);
setSection(mGame->run()); setSection(game->run());
delete mGame; delete game;
} }
void Director::run() void Director::run()

28
source/director.h
View File

@@ -14,23 +14,25 @@
#ifndef DIRECTOR_H #ifndef DIRECTOR_H
#define DIRECTOR_H #define DIRECTOR_H
#define MAX_FILE_LIST 100 #define WINDOW_CAPTION "JailDoctor's Dilemma"
#define GAME_WIDTH 320
#define GAME_HEIGHT 240
// Director // Director
class Director class Director
{ {
private: private:
SDL_Window *mWindow; // La ventana donde dibujamos SDL_Window *window; // La ventana donde dibujamos
SDL_Renderer *mRenderer; // El renderizador de la ventana SDL_Renderer *renderer; // El renderizador de la ventana
Screen *screen; // Objeto encargado de dibujar en pantalla
Input *input; // Objeto Input para gestionar las entradas
Game *game; // Objeto para la sección del juego
Asset *asset; // Objeto que gestiona todos los ficheros de recursos
Input *mInput; // Objeto Input para gestionar las entradas struct options_t *options; // Variable con todas las opciones del programa
Game *mGame; // Objeto para la sección del juego
Asset *mAsset; // Objeto que gestiona todos los ficheros de recursos
struct options_t *mOptions; // Variable con todas las opciones del programa std::string executablePath; // Path del ejecutable
section_t section; // Sección y subsección actual del programa;
std::string mExecutablePath; // Path del ejecutable
section_t mSection; // Sección y subsección actual del programa;
// Inicia las variables necesarias para arrancar el programa // Inicia las variables necesarias para arrancar el programa
void init(Uint8 name); void init(Uint8 name);
@@ -47,12 +49,6 @@ private:
// Comprueba que todos los ficheros existen // Comprueba que todos los ficheros existen
bool checkFileList(); bool checkFileList();
// Carga el fichero de configuración
bool loadConfigFile();
// Guarda el fichero de configuración
bool saveConfigFile();
// Establece el valor de la variable // Establece el valor de la variable
void setExecutablePath(std::string path); void setExecutablePath(std::string path);

4
source/game.cpp
View File

@@ -1,7 +1,7 @@
#include "game.h" #include "game.h"
// Constructor // Constructor
Game::Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Input *input) Game::Game(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input)
{ {
// Inicia variables // Inicia variables
currentRoom = "01.room"; currentRoom = "01.room";
@@ -11,10 +11,10 @@ Game::Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Input *inpu
// Copia los punteros // Copia los punteros
this->renderer = renderer; this->renderer = renderer;
this->asset = asset; this->asset = asset;
this->screen = screen;
this->input = input; this->input = input;
// Crea los objetos // Crea los objetos
screen = new Screen(window, renderer);
itemTracker = new ItemTracker(); itemTracker = new ItemTracker();
room = new Room(asset->get(currentRoom), renderer, asset, itemTracker); room = new Room(asset->get(currentRoom), renderer, asset, itemTracker);
player = new Player(spawnPoint, asset->get("player01.png"), asset->get("player01.ani"), renderer, asset, input, room); player = new Player(spawnPoint, asset->get("player01.png"), asset->get("player01.ani"), renderer, asset, input, room);

2
source/game.h
View File

@@ -69,7 +69,7 @@ private:
public: public:
// Constructor // Constructor
Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Input *input); Game(SDL_Renderer *renderer, Screen *screen, Asset *asset, Input *input);
// Destructor // Destructor
~Game(); ~Game();

118
source/screen.cpp
View File

@@ -1,63 +1,133 @@
#include "screen.h" #include "screen.h"
#include "const.h" #include "const.h"
#include <string>
#include <stdio.h>
// Constructor // Constructor
Screen::Screen(SDL_Window *window, SDL_Renderer *renderer) Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, options_t *options)
{ {
// Inicializa variables // Inicializa variables
mWindow = window; this->window = window;
mRenderer = renderer; this->renderer = renderer;
this->options = options;
mScreenWidth = SCREEN_WIDTH; gameCanvasWidth = SCREEN_WIDTH;
mScreenHeight = SCREEN_HEIGHT; gameCanvasHeight = SCREEN_HEIGHT;
mGameCanvasWidth = GAMECANVAS_WIDTH;
mGameCanvasHeight = GAMECANVAS_HEIGHT;
mGameCanvasPosX = (SCREEN_WIDTH - GAMECANVAS_WIDTH) / 2;
mGameCanvasPosY = (SCREEN_HEIGHT - GAMECANVAS_HEIGHT) / 2;
mBorderColor = {0x27, 0x27, 0x36}; // Establece el modo de video
setVideoMode(options->fullScreenMode);
// Define el color del borde para el modo de pantalla completa
borderColor = {0x27, 0x27, 0x36};
borderColor = {0x00, 0x00, 0x00};
// Crea la textura donde se dibujan los graficos del juego // Crea la textura donde se dibujan los graficos del juego
mGameCanvas = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT); gameCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, gameCanvasWidth, gameCanvasHeight);
if (mGameCanvas == NULL) if (gameCanvas == NULL)
printf("TitleSurface could not be created!\nSDL Error: %s\n", SDL_GetError()); printf("TitleSurface could not be created!\nSDL Error: %s\n", SDL_GetError());
} }
// Destructor // Destructor
Screen::~Screen() Screen::~Screen()
{ {
mRenderer = nullptr; renderer = nullptr;
} }
// Limpia la pantalla // Limpia la pantalla
void Screen::clean(color_t color) void Screen::clean(color_t color)
{ {
SDL_SetRenderDrawColor(mRenderer, color.r, color.g, color.b, 0xFF); SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
SDL_RenderClear(mRenderer); SDL_RenderClear(renderer);
} }
// Prepara para empezar a dibujar en la textura de juego // Prepara para empezar a dibujar en la textura de juego
void Screen::start() void Screen::start()
{ {
SDL_SetRenderTarget(mRenderer, mGameCanvas); SDL_SetRenderTarget(renderer, gameCanvas);
} }
// Vuelca el contenido del renderizador en pantalla // Vuelca el contenido del renderizador en pantalla
void Screen::blit() void Screen::blit()
{ {
// Vuelve a dejar el renderizador en modo normal // Vuelve a dejar el renderizador en modo normal
SDL_SetRenderTarget(mRenderer, NULL); SDL_SetRenderTarget(renderer, NULL);
// Borra el contenido previo // Borra el contenido previo
SDL_SetRenderDrawColor(mRenderer, mBorderColor.r, mBorderColor.g, mBorderColor.b, 0xFF); SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
SDL_RenderClear(mRenderer); SDL_RenderClear(renderer);
// Rectangulo de destino donde se dibujarà la textura con el juego
SDL_Rect dest = {mGameCanvasPosX, mGameCanvasPosY, mGameCanvasWidth, mGameCanvasHeight};
// Copia la textura de juego en el renderizador en la posición adecuada // Copia la textura de juego en el renderizador en la posición adecuada
SDL_RenderCopy(mRenderer, mGameCanvas, NULL, &dest); SDL_RenderCopy(renderer, gameCanvas, NULL, &dest);
// Muestra por pantalla el renderizador // Muestra por pantalla el renderizador
SDL_RenderPresent(mRenderer); SDL_RenderPresent(renderer);
}
// Establece el modo de video
void Screen::setVideoMode(int fullScreenMode)
{
// Aplica el modo de video
SDL_SetWindowFullscreen(window, fullScreenMode);
// Si está activo el modo ventana quita el borde
if (fullScreenMode == 0)
{
screenWidth = gameCanvasWidth;
screenHeight = gameCanvasHeight;
dest = {0, 0, gameCanvasWidth, gameCanvasHeight};
// Modifica el tamaño del renderizador y de la ventana
SDL_RenderSetLogicalSize(renderer, screenWidth, screenHeight);
SDL_SetWindowSize(window, screenWidth * options->windowSize, screenHeight * options->windowSize);
}
// Si está activo el modo de pantalla completa añade el borde
if (fullScreenMode == SDL_WINDOW_FULLSCREEN_DESKTOP)
{
// Obten el alto y el ancho de la ventana
SDL_GetWindowSize(window, &screenWidth, &screenHeight);
// Aplica el escalado al rectangulo donde se pinta la textura del juego
if (options->integerScale)
{
// Calcula el tamaño de la escala máxima
int scale = 0;
while (((gameCanvasWidth * (scale + 1)) <= screenWidth) && ((gameCanvasHeight * (scale + 1)) <= screenHeight))
{
scale++;
}
dest.w = gameCanvasWidth * scale;
dest.h = gameCanvasHeight * scale;
dest.x = (screenWidth - dest.w) / 2;
dest.y = (screenHeight - dest.h) / 2;
}
else if (options->keepAspect)
{
float ratio = (float)gameCanvasWidth / (float)gameCanvasHeight;
if ((screenWidth - gameCanvasWidth) >= (screenHeight - gameCanvasHeight))
{
dest.h = screenHeight;
dest.w = (int)((screenHeight * ratio) + 0.5f);
dest.x = (screenWidth - dest.w) / 2;
dest.y = (screenHeight - dest.h) / 2;
}
else
{
dest.w = screenWidth;
dest.h = (int)((screenWidth / ratio) + 0.5f);
dest.x = (screenWidth - dest.w) / 2;
dest.y = (screenHeight - dest.h) / 2;
}
}
else
{
dest.w = screenWidth;
dest.h = screenHeight;
dest.x = dest.y = 0;
}
// Modifica el tamaño del renderizador
SDL_RenderSetLogicalSize(renderer, screenWidth, screenHeight);
}
} }

29
source/screen.h
View File

@@ -1,4 +1,5 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "utils.h" #include "utils.h"
@@ -9,34 +10,36 @@
class Screen class Screen
{ {
private: private:
SDL_Window *mWindow; // Ventana de la aplicación SDL_Window *window; // Ventana de la aplicación
SDL_Renderer *mRenderer; // El renderizador de la ventana SDL_Renderer *renderer; // El renderizador de la ventana
SDL_Texture *mGameCanvas; // Textura para completar la ventana de juego hasta la pantalla completa SDL_Texture *gameCanvas; // Textura para completar la ventana de juego hasta la pantalla completa
options_t *options; // Variable con todas las opciones del programa
int mScreenWidth; // Ancho de la pantalla int screenWidth; // Ancho de la pantalla
int mScreenHeight; // Alto de la pantalla int screenHeight; // Alto de la pantalla
int mGameCanvasWidth; // Ancho de la textura donde se dibuja el juego int gameCanvasWidth; // Ancho de la textura donde se dibuja el juego
int mGameCanvasHeight; // Alto de la textura donde se dibuja el juego int gameCanvasHeight; // Alto de la textura donde se dibuja el juego
int mGameCanvasPosX; // Posicion en el eje X donde se dibujará la textura del juego dentro de la pantalla SDL_Rect dest; // Coordenadas donde se va a dibujar la textura del juego
int mGameCanvasPosY; // Posicion en el eje Y donde se dibujará la textura del juego dentro de la pantalla color_t borderColor; // Color del borde añadido a la textura de juego para rellenar la pantalla
color_t mBorderColor; // Color del borde añadido a la textura de juego para rellenar la pantalla
public: public:
// Constructor // Constructor
Screen(SDL_Window *windows, SDL_Renderer *renderer); Screen(SDL_Window *window, SDL_Renderer *renderer, options_t *options);
// Destructor // Destructor
~Screen(); ~Screen();
// Limpia la pantalla // Limpia la pantalla
void clean(color_t color); void clean(color_t color = {0x00, 0x00, 0x00});
// Prepara para empezar a dibujar en la textura de juego // Prepara para empezar a dibujar en la textura de juego
void start(); void start();
// Vuelca el contenido del renderizador en pantalla // Vuelca el contenido del renderizador en pantalla
void blit(); void blit();
// Establece el modo de video
void setVideoMode(int fullScreenMode);
}; };
#endif #endif

51
source/utils.cpp
View File

@@ -3,8 +3,8 @@
// Calcula el cuadrado de la distancia entre dos puntos // Calcula el cuadrado de la distancia entre dos puntos
double distanceSquared(int x1, int y1, int x2, int y2) double distanceSquared(int x1, int y1, int x2, int y2)
{ {
int deltaX = x2 - x1; const int deltaX = x2 - x1;
int deltaY = y2 - y1; const int deltaY = y2 - y1;
return deltaX * deltaX + deltaY * deltaY; return deltaX * deltaX + deltaY * deltaY;
} }
@@ -71,20 +71,20 @@ bool checkCollision(circle_t &a, SDL_Rect &b)
return false; return false;
} }
// Detector de colisiones entre un dos rectangulos // Detector de colisiones entre dos rectangulos
bool checkCollision(SDL_Rect &a, SDL_Rect &b) bool checkCollision(SDL_Rect &a, SDL_Rect &b)
{ {
// Calculate the sides of rect A // Calculate the sides of rect A
int leftA = a.x; const int leftA = a.x;
int rightA = a.x + a.w; const int rightA = a.x + a.w;
int topA = a.y; const int topA = a.y;
int bottomA = a.y + a.h; const int bottomA = a.y + a.h;
// Calculate the sides of rect B // Calculate the sides of rect B
int leftB = b.x; const int leftB = b.x;
int rightB = b.x + b.w; const int rightB = b.x + b.w;
int topB = b.y; const int topB = b.y;
int bottomB = b.y + b.h; const int bottomB = b.y + b.h;
// If any of the sides from A are outside of B // If any of the sides from A are outside of B
if (bottomA <= topB) if (bottomA <= topB)
@@ -111,6 +111,35 @@ bool checkCollision(SDL_Rect &a, SDL_Rect &b)
return true; return true;
} }
// Detector de colisiones entre un punto y u rectangulo
bool checkCollision(SDL_Point &p, SDL_Rect &r)
{
// Comprueba si el punto está fuera del rectangulo en el eje X
if (p.x < r.x)
{
return false;
}
if (p.x > r.x + r.w)
{
return false;
}
// Comprueba si el punto está fuera del rectangulo en el eje Y
if (p.y < r.y)
{
return false;
}
if (p.y > r.y + r.h)
{
return false;
}
// Si ha llegado hasta aquí, es que está dentro
return true;
}
// Carga un archivo de imagen en una textura // Carga un archivo de imagen en una textura
bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer) bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer)
{ {

53
source/utils.h
View File

@@ -1,4 +1,5 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "ltexture.h" #include "ltexture.h"
#include <string> #include <string>
@@ -6,9 +7,24 @@
#ifndef UTILS_H #ifndef UTILS_H
#define UTILS_H #define UTILS_H
#define DIFFICULTY_EASY 0 #define FILTER_NEAREST 0
#define DIFFICULTY_NORMAL 1 #define FILTER_LINEAL 1
#define DIFFICULTY_HARD 2
// Secciones del programa
#define SECTION_PROG_LOGO 0
#define SECTION_PROG_INTRO 1
#define SECTION_PROG_TITLE 2
#define SECTION_PROG_GAME 3
#define SECTION_PROG_QUIT 4
// Subsecciones
#define SUBSECTION_GAME_PLAY 0
#define SUBSECTION_GAME_PAUSE 1
#define SUBSECTION_GAME_GAMEOVER 2
#define SUBSECTION_TITLE_1 3
#define SUBSECTION_TITLE_2 4
#define SUBSECTION_TITLE_3 5
#define SUBSECTION_TITLE_INSTRUCTIONS 6
// Estructura para definir un circulo // Estructura para definir un circulo
struct circle_t struct circle_t
@@ -33,35 +49,17 @@ struct section_t
Uint8 subsection; Uint8 subsection;
}; };
// Estructura para mapear el teclado usado en la demo
struct demoKeys_t
{
Uint8 left;
Uint8 right;
Uint8 noInput;
Uint8 fire;
Uint8 fireLeft;
Uint8 fireRight;
};
// Estructura para albergar métodos de control
struct input_t
{
int id; // Identificador en el vector de mandos
std::string name; // Nombre del dispositivo
Uint8 deviceType; // Tipo de dispositivo (teclado o mando)
};
// Estructura con todas las opciones de configuración del programa // Estructura con todas las opciones de configuración del programa
struct options_t struct options_t
{ {
Uint8 difficulty; // Dificultad del juego
input_t input[2]; // Modo de control (teclado o mando)
Uint8 language; // Idioma usado en el juego
Uint32 fullScreenMode; // Contiene el valor del modo de pantalla completa Uint32 fullScreenMode; // Contiene el valor del modo de pantalla completa
Uint8 windowSize; // Contiene el valor del tamaño de la ventana int windowSize; // Contiene el valor por el que se multiplica el tamaño de la ventana
Uint32 filter; // Filtro usado para el escalado de la imagen Uint32 filter; // Filtro usado para el escalado de la imagen
bool vSync; // Indica si se quiere usar vsync o no bool vSync; // Indica si se quiere usar vsync o no
int screenWidth; // Ancho de la pantalla/ventana
int screenHeight; // Alto de la pantalla/ventana
bool integerScale; // Indica si el escalado de la imagen ha de ser entero en el modo a pantalla completa
bool keepAspect; // Indica si se ha de mantener la relación de aspecto al poner el modo a pantalla completa
}; };
// Calcula el cuadrado de la distancia entre dos puntos // Calcula el cuadrado de la distancia entre dos puntos
@@ -76,6 +74,9 @@ bool checkCollision(circle_t &a, SDL_Rect &b);
// Detector de colisiones entre un dos rectangulos // Detector de colisiones entre un dos rectangulos
bool checkCollision(SDL_Rect &a, SDL_Rect &b); bool checkCollision(SDL_Rect &a, SDL_Rect &b);
// Detector de colisiones entre un punto y u rectangulo
bool checkCollision(SDL_Point &p, SDL_Rect &r);
// Carga un archivo de imagen en una textura // Carga un archivo de imagen en una textura
bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer); bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer);