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

Reubicados los cpp de librerias comunes

Browse Source
This commit is contained in:
Sergio
2022-10-10 13:51:51 +02:00
parent 6f621987c5
commit 41d72d48d5
43 changed files with 1947 additions and 842 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@@ -3,7 +3,7 @@ executable = jaildoctors_dilemma
windows: windows:
@echo off @echo off
if not exist bin\ (mkdir bin) if not exist bin\ (mkdir bin)
g++ -std=c++11 -Wall -O2 source/*.cpp -lmingw32 -lSDL2main -lSDL2 -o bin/$(executable).exe g++ -std=c++11 -Wall -O2 source/*.cpp source/utils/*.cpp -lmingw32 -lSDL2main -lSDL2 -o bin/$(executable).exe
macos: macos:
mkdir -p bin mkdir -p bin
g++ source/*.cpp -std=c++11 -Wall -O2 -lSDL2 -o bin/$(executable)_macos g++ source/*.cpp -std=c++11 -Wall -O2 -lSDL2 -o bin/$(executable)_macos

2
source/const.h
View File

@@ -2,7 +2,7 @@
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include <string> #include <string>
#include "utils.h" #include "utils\utils.h"
#ifndef CONST_H #ifndef CONST_H
#define CONST_H #define CONST_H

12
source/credits.h
View File

@@ -2,12 +2,12 @@
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "const.h" #include "const.h"
#include "utils.h" #include "utils\asset.h"
#include "sprite.h" #include "utils\jail_audio.h"
#include "screen.h" #include "utils\screen.h"
#include "asset.h" #include "utils\sprite.h"
#include "text.h" #include "utils\text.h"
#include "jail_audio.h" #include "utils\utils.h"
#include <vector> #include <vector>
#ifndef CREDITS_H #ifndef CREDITS_H

3
source/director.cpp
View File

@@ -1,6 +1,5 @@
#include "utils.h"
#include "director.h" #include "director.h"
#include "utils\utils.h"
#include <iostream> #include <iostream>
#include <string> #include <string>

22
source/director.h
View File

@@ -1,19 +1,19 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "sprite.h" #include "const.h"
#include "movingsprite.h" #include "credits.h"
#include "text.h"
#include "jail_audio.h"
#include "utils.h"
#include "input.h"
#include "game.h" #include "game.h"
#include "intro.h"
#include "logo.h" #include "logo.h"
#include "title.h" #include "title.h"
#include "credits.h" #include "utils\asset.h"
#include "intro.h" #include "utils\debug.h"
#include "asset.h" #include "utils\input.h"
#include "debug.h" #include "utils\jail_audio.h"
#include "const.h" #include "utils\movingsprite.h"
#include "utils\sprite.h"
#include "utils\text.h"
#include "utils\utils.h"
#ifndef DIRECTOR_H #ifndef DIRECTOR_H
#define DIRECTOR_H #define DIRECTOR_H

6
source/enemy.h
View File

@@ -1,8 +1,8 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "utils.h" #include "utils\animatedsprite.h"
#include "asset.h" #include "utils\asset.h"
#include "animatedsprite.h" #include "utils\utils.h"
#include <string> #include <string>
#ifndef ENEMY_H #ifndef ENEMY_H

24
source/game.h
View File

@@ -1,22 +1,22 @@
#pragma once #pragma once
#include <SDL2/SDL.h>
#include "utils.h" #include <SDL2/SDL.h>
#include "const.h" #include "const.h"
#include "sprite.h"
#include "animatedsprite.h"
#include "text.h"
#include "input.h"
#include "screen.h"
#include "asset.h"
#include "room.h"
#include "item_tracker.h" #include "item_tracker.h"
#include "room_tracker.h"
#include "player.h" #include "player.h"
#include "jail_audio.h" #include "room_tracker.h"
#include "room.h"
#include "scoreboard.h" #include "scoreboard.h"
#include "debug.h"
#include "test.h" #include "test.h"
#include "utils\animatedsprite.h"
#include "utils\asset.h"
#include "utils\debug.h"
#include "utils\input.h"
#include "utils\jail_audio.h"
#include "utils\screen.h"
#include "utils\sprite.h"
#include "utils\text.h"
#include "utils\utils.h"
#ifndef GAME_H #ifndef GAME_H
#define GAME_H #define GAME_H

12
source/intro.h
View File

@@ -2,15 +2,15 @@
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "const.h" #include "const.h"
#include "utils.h" #include "utils\asset.h"
#include "sprite.h" #include "utils\jail_audio.h"
#include "screen.h" #include "utils\screen.h"
#include "asset.h" #include "utils\sprite.h"
#include "jail_audio.h" #include "utils\utils.h"
#include <vector> #include <vector>
#include <string> #include <string>
#include "text.h" #include "utils\text.h"
#ifndef INTRO_H #ifndef INTRO_H
#define INTRO_H #define INTRO_H

7
source/item.h
View File

@@ -1,8 +1,9 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "utils.h" #include "utils\asset.h"
#include "asset.h" #include "utils\sprite.h"
#include "sprite.h" #include "utils\utils.h"
#include <string> #include <string>
#ifndef ITEM_H #ifndef ITEM_H

2
source/item_tracker.h
View File

@@ -1,6 +1,6 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "utils.h" #include "utils\utils.h"
#include <string> #include <string>
#include <vector> #include <vector>

10
source/logo.h
View File

@@ -2,11 +2,11 @@
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "const.h" #include "const.h"
#include "utils.h" #include "utils\asset.h"
#include "sprite.h" #include "utils\jail_audio.h"
#include "screen.h" #include "utils\screen.h"
#include "asset.h" #include "utils\sprite.h"
#include "jail_audio.h" #include "utils\utils.h"
#include <vector> #include <vector>
#ifndef LOGO_H #ifndef LOGO_H

14
source/player.h
View File

@@ -1,13 +1,13 @@
#pragma once #pragma once
#include <SDL2/SDL.h>
#include "utils.h" #include <SDL2/SDL.h>
#include "asset.h"
#include "room.h"
#include "animatedsprite.h"
#include "input.h"
#include "const.h" #include "const.h"
#include "debug.h" #include "room.h"
#include "utils\animatedsprite.h"
#include "utils\asset.h"
#include "utils\debug.h"
#include "utils\input.h"
#include "utils\utils.h"
#include <string> #include <string>
#include <vector> #include <vector>

20
source/room.h
View File

@@ -1,16 +1,16 @@
#pragma once #pragma once
#include <SDL2/SDL.h>
#include "utils.h" #include <SDL2/SDL.h>
#include "asset.h"
#include "screen.h"
#include "enemy.h"
#include "item.h"
#include "sprite.h"
#include "item_tracker.h"
#include "const.h" #include "const.h"
#include "jail_audio.h" #include "enemy.h"
#include "debug.h" #include "item_tracker.h"
#include "item.h"
#include "utils\asset.h"
#include "utils\debug.h"
#include "utils\jail_audio.h"
#include "utils\screen.h"
#include "utils\sprite.h"
#include "utils\utils.h"
#include <string> #include <string>
#include <vector> #include <vector>

3
source/room_tracker.h
View File

@@ -1,6 +1,7 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "utils.h" #include "utils\utils.h"
#include <string> #include <string>
#include <vector> #include <vector>

8
source/scoreboard.h
View File

@@ -1,11 +1,11 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "utils.h"
#include "text.h"
#include "asset.h"
#include "animatedsprite.h"
#include "const.h" #include "const.h"
#include "utils\animatedsprite.h"
#include "utils\asset.h"
#include "utils\text.h"
#include "utils\utils.h"
#include <string> #include <string>
#ifndef SCOREBOARD_H #ifndef SCOREBOARD_H

12
source/test.h
View File

@@ -2,13 +2,13 @@
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "const.h" #include "const.h"
#include "utils.h" #include "utils\asset.h"
#include "screen.h" #include "utils\debug.h"
#include "asset.h" #include "utils\screen.h"
#include "text.h" #include "utils\text.h"
#include "debug.h" #include "utils\utils.h"
#include <vector>
#include <string> #include <string>
#include <vector>
#ifndef TEST_H #ifndef TEST_H
#define TEST_H #define TEST_H

12
source/title.h
View File

@@ -2,12 +2,12 @@
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "const.h" #include "const.h"
#include "utils.h" #include "utils\asset.h"
#include "sprite.h" #include "utils\jail_audio.h"
#include "screen.h" #include "utils\screen.h"
#include "asset.h" #include "utils\sprite.h"
#include "text.h" #include "utils\text.h"
#include "jail_audio.h" #include "utils\utils.h"
#include <vector> #include <vector>
#ifndef TITLE_H #ifndef TITLE_H

0
source/animatedsprite.cpp → source/utils/animatedsprite.cpp
View File

146
source/animatedsprite.h → source/utils/animatedsprite.h
View File

@@ -1,74 +1,74 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "movingsprite.h" #include "movingsprite.h"
#include <vector> #include <fstream>
#include <string> #include <sstream>
#include <sstream> #include <string>
#include <fstream> #include <vector>
#ifndef ANIMATEDSPRITE_H #ifndef ANIMATEDSPRITE_H
#define ANIMATEDSPRITE_H #define ANIMATEDSPRITE_H
// Clase AnimatedSprite // Clase AnimatedSprite
class AnimatedSprite : public MovingSprite class AnimatedSprite : public MovingSprite
{ {
private: private:
struct t_animation struct t_animation
{ {
std::string name; // Nombre de la animacion std::string name; // Nombre de la animacion
std::vector<SDL_Rect> frames; // Cada uno de los frames que componen la animación std::vector<SDL_Rect> frames; // Cada uno de los frames que componen la animación
int speed; // Velocidad de la animación int speed; // Velocidad de la animación
int loop; // Indica a que frame vuelve la animación al terminar. -1 para que no vuelva int loop; // Indica a que frame vuelve la animación al terminar. -1 para que no vuelva
bool completed; // Indica si ha finalizado la animación bool completed; // Indica si ha finalizado la animación
int currentFrame; // Frame actual int currentFrame; // Frame actual
int counter; // Contador para las animaciones int counter; // Contador para las animaciones
}; };
std::vector<t_animation> animation; // Vector con las diferentes animaciones std::vector<t_animation> animation; // Vector con las diferentes animaciones
int currentAnimation; // Animacion activa int currentAnimation; // Animacion activa
public: public:
// Constructor // Constructor
AnimatedSprite(LTexture *texture = nullptr, SDL_Renderer *renderer = nullptr, std::string file = ""); AnimatedSprite(LTexture *texture = nullptr, SDL_Renderer *renderer = nullptr, std::string file = "");
// Destructor // Destructor
~AnimatedSprite(); ~AnimatedSprite();
// Calcula el frame correspondiente a la animación actual // Calcula el frame correspondiente a la animación actual
void animate(); void animate();
// Establece el frame actual de la animación // Establece el frame actual de la animación
void setCurrentFrame(int num); void setCurrentFrame(int num);
// Establece el valor del contador // Establece el valor del contador
void setAnimationCounter(std::string name, int num); void setAnimationCounter(std::string name, int num);
// Establece la velocidad de una animación // Establece la velocidad de una animación
void setAnimationSpeed(std::string name, int speed); void setAnimationSpeed(std::string name, int speed);
// Establece el frame al que vuelve la animación al finalizar // Establece el frame al que vuelve la animación al finalizar
void setAnimationLoop(std::string name, int loop); void setAnimationLoop(std::string name, int loop);
// Establece el valor de la variable // Establece el valor de la variable
void setAnimationCompleted(std::string name, bool value); void setAnimationCompleted(std::string name, bool value);
// Comprueba si ha terminado la animación // Comprueba si ha terminado la animación
bool animationIsCompleted(); bool animationIsCompleted();
// Devuelve el rectangulo de una animación y frame concreto // Devuelve el rectangulo de una animación y frame concreto
SDL_Rect getAnimationClip(std::string name, Uint8 index); SDL_Rect getAnimationClip(std::string name, Uint8 index);
// Obtiene el indice de la animación a partir del nombre // Obtiene el indice de la animación a partir del nombre
int getIndex(std::string name); int getIndex(std::string name);
// Carga la animación desde un fichero // Carga la animación desde un fichero
bool load(std::string filePath); bool load(std::string filePath);
// Establece la animacion actual // Establece la animacion actual
void setCurrentAnimation(std::string name = "default"); void setCurrentAnimation(std::string name = "default");
// Actualiza las variables del objeto // Actualiza las variables del objeto
void update(); void update();
}; };
#endif #endif

0
source/asset.cpp → source/utils/asset.cpp
View File

0
source/asset.h → source/utils/asset.h
View File

0
source/debug.cpp → source/utils/debug.cpp
View File

8
source/debug.h → source/utils/debug.h
View File

@@ -1,13 +1,13 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "const.h" #include "../const.h"
#include "utils.h"
#include "screen.h"
#include "asset.h" #include "asset.h"
#include "screen.h"
#include "text.h" #include "text.h"
#include <vector> #include "utils.h"
#include <string> #include <string>
#include <vector>
#ifndef DEBUG_H #ifndef DEBUG_H
#define DEBUG_H #define DEBUG_H

0
source/input.cpp → source/utils/input.cpp
View File

180
source/input.h → source/utils/input.h
View File

@@ -1,90 +1,90 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include <string> #include <string>
#include <vector> #include <vector>
#ifndef INPUT_H #ifndef INPUT_H
#define INPUT_H #define INPUT_H
#define INPUT_NULL 0 #define INPUT_NULL 0
#define INPUT_UP 1 #define INPUT_UP 1
#define INPUT_DOWN 2 #define INPUT_DOWN 2
#define INPUT_LEFT 3 #define INPUT_LEFT 3
#define INPUT_RIGHT 4 #define INPUT_RIGHT 4
#define INPUT_ACCEPT 5 #define INPUT_ACCEPT 5
#define INPUT_CANCEL 6 #define INPUT_CANCEL 6
#define INPUT_BUTTON_1 7 #define INPUT_BUTTON_1 7
#define INPUT_BUTTON_2 8 #define INPUT_BUTTON_2 8
#define INPUT_BUTTON_3 9 #define INPUT_BUTTON_3 9
#define INPUT_BUTTON_4 10 #define INPUT_BUTTON_4 10
#define INPUT_BUTTON_5 11 #define INPUT_BUTTON_5 11
#define INPUT_BUTTON_6 12 #define INPUT_BUTTON_6 12
#define INPUT_BUTTON_7 13 #define INPUT_BUTTON_7 13
#define INPUT_BUTTON_8 14 #define INPUT_BUTTON_8 14
#define INPUT_BUTTON_PAUSE 15 #define INPUT_BUTTON_PAUSE 15
#define INPUT_BUTTON_ESCAPE 16 #define INPUT_BUTTON_ESCAPE 16
#define REPEAT_TRUE true #define REPEAT_TRUE true
#define REPEAT_FALSE false #define REPEAT_FALSE false
#define INPUT_USE_KEYBOARD 0 #define INPUT_USE_KEYBOARD 0
#define INPUT_USE_GAMECONTROLLER 1 #define INPUT_USE_GAMECONTROLLER 1
#define INPUT_USE_ANY 2 #define INPUT_USE_ANY 2
// Clase Input // Clase Input
class Input class Input
{ {
private: private:
struct keyBindings_t struct keyBindings_t
{ {
Uint8 scancode; // Scancode asociado Uint8 scancode; // Scancode asociado
bool active; // Indica si está activo bool active; // Indica si está activo
}; };
struct GameControllerBindings_t struct GameControllerBindings_t
{ {
SDL_GameControllerButton button; // GameControllerButton asociado SDL_GameControllerButton button; // GameControllerButton asociado
bool active; // Indica si está activo bool active; // Indica si está activo
}; };
keyBindings_t keyBindings[17]; // Vector con las teclas asociadas a los inputs predefinidos keyBindings_t keyBindings[17]; // Vector con las teclas asociadas a los inputs predefinidos
GameControllerBindings_t gameControllerBindings[17]; // Vector con las teclas asociadas a los inputs predefinidos GameControllerBindings_t gameControllerBindings[17]; // Vector con las teclas asociadas a los inputs predefinidos
std::vector<SDL_GameController *> connectedControllers; // Vector con todos los mandos conectados std::vector<SDL_GameController *> connectedControllers; // Vector con todos los mandos conectados
std::vector<std::string> controllerNames; // Vector con los nombres de los mandos std::vector<std::string> controllerNames; // Vector con los nombres de los mandos
int numGamepads; // Numero de mandos conectados int numGamepads; // Numero de mandos conectados
std::string dbPath; // Ruta al archivo gamecontrollerdb.txt std::string dbPath; // Ruta al archivo gamecontrollerdb.txt
// Comprueba si hay un mando conectado // Comprueba si hay un mando conectado
bool discoverGameController(); bool discoverGameController();
public: public:
// Constructor // Constructor
Input(std::string file); Input(std::string file);
// Destructor // Destructor
~Input(); ~Input();
// Asigna uno de los posibles inputs a una tecla del teclado // Asigna uno de los posibles inputs a una tecla del teclado
void bindKey(Uint8 input, SDL_Scancode code); void bindKey(Uint8 input, SDL_Scancode code);
// Asigna uno de los posibles inputs a un botón del mando // Asigna uno de los posibles inputs a un botón del mando
void bindGameControllerButton(Uint8 input, SDL_GameControllerButton button); void bindGameControllerButton(Uint8 input, SDL_GameControllerButton button);
// Comprueba si un input esta activo // Comprueba si un input esta activo
bool checkInput(Uint8 input, bool repeat, int device = INPUT_USE_ANY, int index = 0); bool checkInput(Uint8 input, bool repeat, int device = INPUT_USE_ANY, int index = 0);
// Comprueba si hay almenos un input activo // Comprueba si hay almenos un input activo
bool checkAnyInput(int device = INPUT_USE_ANY, int index = 0); bool checkAnyInput(int device = INPUT_USE_ANY, int index = 0);
// Comprueba si hay algun mando conectado // Comprueba si hay algun mando conectado
bool gameControllerFound(); bool gameControllerFound();
// Obten el numero de mandos conectados // Obten el numero de mandos conectados
int getNumControllers(); int getNumControllers();
// Obten el nombre de un mando de juego // Obten el nombre de un mando de juego
std::string getControllerName(int index); std::string getControllerName(int index);
}; };
#endif #endif

0
source/jail_audio.cpp → source/utils/jail_audio.cpp
View File

0
source/jail_audio.h → source/utils/jail_audio.h
View File

370
source/ltexture.cpp → source/utils/ltexture.cpp
View File

@@ -1,186 +1,186 @@
#include "ltexture.h" #include "ltexture.h"
#define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h" #include "stb_image.h"
// Constructor // Constructor
LTexture::LTexture(SDL_Renderer *renderer, std::string path) LTexture::LTexture(SDL_Renderer *renderer, std::string path)
{ {
// Copia punteros // Copia punteros
this->renderer = renderer; this->renderer = renderer;
this->path = path; this->path = path;
// Inicializa // Inicializa
texture = nullptr; texture = nullptr;
width = 0; width = 0;
height = 0; height = 0;
// Carga el fichero en la textura // Carga el fichero en la textura
if (path != "") if (path != "")
{ {
loadFromFile(path, renderer); loadFromFile(path, renderer);
} }
} }
// Destructor // Destructor
LTexture::~LTexture() LTexture::~LTexture()
{ {
// Libera memoria // Libera memoria
unload(); unload();
} }
// Carga una imagen desde un fichero // Carga una imagen desde un fichero
bool LTexture::loadFromFile(std::string path, SDL_Renderer *renderer) bool LTexture::loadFromFile(std::string path, SDL_Renderer *renderer)
{ {
int req_format = STBI_rgb_alpha; int req_format = STBI_rgb_alpha;
int width, height, orig_format; int width, height, orig_format;
unsigned char *data = stbi_load(path.c_str(), &width, &height, &orig_format, req_format); unsigned char *data = stbi_load(path.c_str(), &width, &height, &orig_format, req_format);
if (data == nullptr) if (data == nullptr)
{ {
SDL_Log("Loading image failed: %s", stbi_failure_reason()); SDL_Log("Loading image failed: %s", stbi_failure_reason());
exit(1); exit(1);
} }
int depth, pitch; int depth, pitch;
Uint32 pixel_format; Uint32 pixel_format;
if (req_format == STBI_rgb) if (req_format == STBI_rgb)
{ {
depth = 24; depth = 24;
pitch = 3 * width; // 3 bytes por pixel * pixels per linea pitch = 3 * width; // 3 bytes por pixel * pixels per linea
pixel_format = SDL_PIXELFORMAT_RGB24; pixel_format = SDL_PIXELFORMAT_RGB24;
} }
else else
{ // STBI_rgb_alpha (RGBA) { // STBI_rgb_alpha (RGBA)
depth = 32; depth = 32;
pitch = 4 * width; pitch = 4 * width;
pixel_format = SDL_PIXELFORMAT_RGBA32; pixel_format = SDL_PIXELFORMAT_RGBA32;
} }
// Limpia // Limpia
unload(); unload();
// La textura final // La textura final
SDL_Texture *newTexture = nullptr; SDL_Texture *newTexture = nullptr;
// Carga la imagen desde una ruta específica // Carga la imagen desde una ruta específica
SDL_Surface *loadedSurface = SDL_CreateRGBSurfaceWithFormatFrom((void *)data, width, height, depth, pitch, pixel_format); SDL_Surface *loadedSurface = SDL_CreateRGBSurfaceWithFormatFrom((void *)data, width, height, depth, pitch, pixel_format);
if (loadedSurface == nullptr) if (loadedSurface == nullptr)
{ {
printf("Unable to load image %s!\n", path.c_str()); printf("Unable to load image %s!\n", path.c_str());
} }
else else
{ {
// Crea la textura desde los pixels de la surface // Crea la textura desde los pixels de la surface
newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface); newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface);
if (newTexture == nullptr) if (newTexture == nullptr)
{ {
printf("Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError()); printf("Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError());
} }
else else
{ {
// Obtiene las dimensiones de la imagen // Obtiene las dimensiones de la imagen
this->width = loadedSurface->w; this->width = loadedSurface->w;
this->height = loadedSurface->h; this->height = loadedSurface->h;
} }
// Elimina la textura cargada // Elimina la textura cargada
SDL_FreeSurface(loadedSurface); SDL_FreeSurface(loadedSurface);
} }
// Return success // Return success
texture = newTexture; texture = newTexture;
return texture != nullptr; return texture != nullptr;
} }
// Crea una textura en blanco // Crea una textura en blanco
bool LTexture::createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess access) bool LTexture::createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess access)
{ {
// Crea una textura sin inicializar // Crea una textura sin inicializar
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, access, width, height); texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, access, width, height);
if (texture == nullptr) if (texture == nullptr)
{ {
printf("Unable to create blank texture! SDL Error: %s\n", SDL_GetError()); printf("Unable to create blank texture! SDL Error: %s\n", SDL_GetError());
} }
else else
{ {
this->width = width; this->width = width;
this->height = height; this->height = height;
} }
return texture != nullptr; return texture != nullptr;
} }
// Libera la memoria de la textura // Libera la memoria de la textura
void LTexture::unload() void LTexture::unload()
{ {
// Libera la textura si existe // Libera la textura si existe
if (texture != nullptr) if (texture != nullptr)
{ {
SDL_DestroyTexture(texture); SDL_DestroyTexture(texture);
texture = nullptr; texture = nullptr;
width = 0; width = 0;
height = 0; height = 0;
} }
} }
// Establece el color para la modulacion // Establece el color para la modulacion
void LTexture::setColor(Uint8 red, Uint8 green, Uint8 blue) void LTexture::setColor(Uint8 red, Uint8 green, Uint8 blue)
{ {
SDL_SetTextureColorMod(texture, red, green, blue); SDL_SetTextureColorMod(texture, red, green, blue);
} }
// Establece el blending // Establece el blending
void LTexture::setBlendMode(SDL_BlendMode blending) void LTexture::setBlendMode(SDL_BlendMode blending)
{ {
SDL_SetTextureBlendMode(texture, blending); SDL_SetTextureBlendMode(texture, blending);
} }
// Establece el alpha para la modulación // Establece el alpha para la modulación
void LTexture::setAlpha(Uint8 alpha) void LTexture::setAlpha(Uint8 alpha)
{ {
SDL_SetTextureAlphaMod(texture, alpha); SDL_SetTextureAlphaMod(texture, alpha);
} }
// Renderiza la textura en un punto específico // Renderiza la textura en un punto específico
void LTexture::render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip, float zoomW, float zoomH, double angle, SDL_Point *center, SDL_RendererFlip flip) void LTexture::render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip, float zoomW, float zoomH, double angle, SDL_Point *center, SDL_RendererFlip flip)
{ {
// Establece el destini de renderizado en la pantalla // Establece el destini de renderizado en la pantalla
SDL_Rect renderQuad = {x, y, width, height}; SDL_Rect renderQuad = {x, y, width, height};
// Obtiene las dimesiones del clip de renderizado // Obtiene las dimesiones del clip de renderizado
if (clip != nullptr) if (clip != nullptr)
{ {
renderQuad.w = clip->w; renderQuad.w = clip->w;
renderQuad.h = clip->h; renderQuad.h = clip->h;
} }
renderQuad.w = renderQuad.w * zoomW; renderQuad.w = renderQuad.w * zoomW;
renderQuad.h = renderQuad.h * zoomH; renderQuad.h = renderQuad.h * zoomH;
// Renderiza a pantalla // Renderiza a pantalla
SDL_RenderCopyEx(renderer, texture, clip, &renderQuad, angle, center, flip); SDL_RenderCopyEx(renderer, texture, clip, &renderQuad, angle, center, flip);
} }
// Establece la textura como objetivo de renderizado // Establece la textura como objetivo de renderizado
void LTexture::setAsRenderTarget(SDL_Renderer *renderer) void LTexture::setAsRenderTarget(SDL_Renderer *renderer)
{ {
SDL_SetRenderTarget(renderer, texture); SDL_SetRenderTarget(renderer, texture);
} }
// Obtiene el ancho de la imagen // Obtiene el ancho de la imagen
int LTexture::getWidth() int LTexture::getWidth()
{ {
return width; return width;
} }
// Obtiene el alto de la imagen // Obtiene el alto de la imagen
int LTexture::getHeight() int LTexture::getHeight()
{ {
return height; return height;
} }
// Recarga la textura // Recarga la textura
bool LTexture::reLoad() bool LTexture::reLoad()
{ {
return loadFromFile(path, renderer); return loadFromFile(path, renderer);
} }

122
source/ltexture.h → source/utils/ltexture.h
View File

@@ -1,61 +1,61 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
#ifndef LTEXTURE_H #ifndef LTEXTURE_H
#define LTEXTURE_H #define LTEXTURE_H
// Clase LTexture // Clase LTexture
class LTexture class LTexture
{ {
private: private:
SDL_Texture *texture; // La textura SDL_Texture *texture; // La textura
SDL_Renderer *renderer; // Renderizador donde dibujar la textura SDL_Renderer *renderer; // Renderizador donde dibujar la textura
int width; // Ancho de la imagen int width; // Ancho de la imagen
int height; // Alto de la imagen int height; // Alto de la imagen
std::string path; // Ruta de la imagen de la textura std::string path; // Ruta de la imagen de la textura
public: public:
// Constructor // Constructor
LTexture(SDL_Renderer *renderer, std::string path = ""); LTexture(SDL_Renderer *renderer, std::string path = "");
// Destructor // Destructor
~LTexture(); ~LTexture();
// Carga una imagen desde un fichero // Carga una imagen desde un fichero
bool loadFromFile(std::string path, SDL_Renderer *renderer); bool loadFromFile(std::string path, SDL_Renderer *renderer);
// Crea una textura en blanco // Crea una textura en blanco
bool createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING); bool createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
// Libera la memoria de la textura // Libera la memoria de la textura
void unload(); void unload();
// Establece el color para la modulacion // Establece el color para la modulacion
void setColor(Uint8 red, Uint8 green, Uint8 blue); void setColor(Uint8 red, Uint8 green, Uint8 blue);
// Establece el blending // Establece el blending
void setBlendMode(SDL_BlendMode blending); void setBlendMode(SDL_BlendMode blending);
// Establece el alpha para la modulación // Establece el alpha para la modulación
void setAlpha(Uint8 alpha); void setAlpha(Uint8 alpha);
// Renderiza la textura en un punto específico // Renderiza la textura en un punto específico
void render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip = nullptr, float zoomW = 1, float zoomH = 1, double angle = 0.0, SDL_Point *center = nullptr, SDL_RendererFlip flip = SDL_FLIP_NONE); void render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip = nullptr, float zoomW = 1, float zoomH = 1, double angle = 0.0, SDL_Point *center = nullptr, SDL_RendererFlip flip = SDL_FLIP_NONE);
// Establece la textura como objetivo de renderizado // Establece la textura como objetivo de renderizado
void setAsRenderTarget(SDL_Renderer *renderer); void setAsRenderTarget(SDL_Renderer *renderer);
// Obtiene el ancho de la imagen // Obtiene el ancho de la imagen
int getWidth(); int getWidth();
// Obtiene el alto de la imagen // Obtiene el alto de la imagen
int getHeight(); int getHeight();
// Recarga la textura // Recarga la textura
bool reLoad(); bool reLoad();
}; };
#endif #endif

890
source/utils/menu.cpp Normal file
View File

@@ -0,0 +1,890 @@
#include "../const.h"
#include "menu.h"
// Constructor
Menu::Menu(SDL_Renderer *renderer, Asset *asset, Input *input, std::string file)
{
this->renderer = renderer;
this->asset = asset;
this->input = input;
soundMove = nullptr;
soundAccept = nullptr;
soundCancel = nullptr;
init();
if (file != "")
{
load(file);
}
reorganize();
}
Menu::~Menu()
{
renderer = nullptr;
asset = nullptr;
input = nullptr;
if (soundMove)
{
JA_DeleteSound(soundMove);
}
if (soundAccept)
{
JA_DeleteSound(soundAccept);
}
if (soundCancel)
{
JA_DeleteSound(soundCancel);
}
if (text != nullptr)
{
delete text;
}
}
// Carga la configuración del menu desde un archivo de texto
bool Menu::load(std::string file_path)
{
// Indicador de éxito en la carga
bool success = true;
// Indica si se ha creado ya el objeto de texto
bool textAllocated = false;
std::string filename = file_path.substr(file_path.find_last_of("\\/") + 1);
std::string line;
std::ifstream file(file_path);
// El fichero se puede abrir
if (file.good())
{
// Procesa el fichero linea a linea
printf("Reading file %s\n", filename.c_str());
while (std::getline(file, line))
{
if (line == "[item]")
{
item_t item;
item.label = "";
item.hPaddingDown = 1;
item.selectable = true;
item.greyed = false;
item.linkedDown = false;
do
{
std::getline(file, line);
// Encuentra la posición del caracter '='
int pos = line.find("=");
// Procesa las dos subcadenas
if (!setItem(&item, line.substr(0, pos), line.substr(pos + 1, line.length())))
{
printf("Warning: file %s\n, unknown parameter \"%s\"\n", filename.c_str(), line.substr(0, pos).c_str());
success = false;
}
} while (line != "[/item]");
addItem(item.label, item.hPaddingDown, item.selectable, item.greyed, item.linkedDown);
}
// En caso contrario se parsea el fichero para buscar las variables y los valores
else
{
// Encuentra la posición del caracter '='
int pos = line.find("=");
// Procesa las dos subcadenas
if (!setVars(line.substr(0, pos), line.substr(pos + 1, line.length())))
{
printf("Warning: file %s, unknown parameter \"%s\"\n", filename.c_str(), line.substr(0, pos).c_str());
success = false;
}
// Crea el objeto text tan pronto como se pueda. Necesario para añadir items
if (font_png != "" && font_txt != "" && !textAllocated)
{
text = new Text(asset->get(font_png), asset->get(font_txt), renderer);
textAllocated = true;
}
}
}
// Cierra el fichero
printf("Closing file %s\n\n", filename.c_str());
file.close();
}
// El fichero no se puede abrir
else
{
printf("Warning: Unable to open %s file\n", filename.c_str());
success = false;
}
return success;
}
// Asigna variables a partir de dos cadenas
bool Menu::setItem(item_t *item, std::string var, std::string value)
{
// Indicador de éxito en la asignación
bool success = true;
if (var == "text")
{
item->label = value;
}
else if (var == "hPaddingDown")
{
item->hPaddingDown = std::stoi(value);
}
else if (var == "selectable")
{
item->selectable = value == "true" ? true : false;
}
else if (var == "greyed")
{
item->greyed = value == "true" ? true : false;
}
else if (var == "linkedDown")
{
item->linkedDown = value == "true" ? true : false;
}
else if ((var == "") || (var == "[/item]"))
{
}
else
{
success = false;
}
return success;
}
// Asigna variables a partir de dos cadenas
bool Menu::setVars(std::string var, std::string value)
{
// Indicador de éxito en la asignación
bool success = true;
if (var == "font_png")
{
font_png = value;
}
else if (var == "font_txt")
{
font_txt = value;
}
else if (var == "sound_cancel")
{
soundCancel = JA_LoadSound(asset->get(value).c_str());
}
else if (var == "sound_accept")
{
soundAccept = JA_LoadSound(asset->get(value).c_str());
}
else if (var == "sound_move")
{
soundMove = JA_LoadSound(asset->get(value).c_str());
}
else if (var == "name")
{
name = value;
}
else if (var == "x")
{
x = std::stoi(value);
}
else if (var == "centerX")
{
centerX = std::stoi(value);
}
else if (var == "centerY")
{
centerY = std::stoi(value);
}
else if (var == "y")
{
y = std::stoi(value);
}
else if (var == "backgroundType")
{
backgroundType = std::stoi(value);
}
else if (var == "backgroundColor")
{
// Se introducen los valores separados por comas en un vector
std::stringstream ss(value);
std::string tmp;
getline(ss, tmp, ',');
rectBG.color.r = std::stoi(tmp);
getline(ss, tmp, ',');
rectBG.color.g = std::stoi(tmp);
getline(ss, tmp, ',');
rectBG.color.b = std::stoi(tmp);
getline(ss, tmp, ',');
rectBG.a = std::stoi(tmp);
}
else if (var == "selector_color")
{
// Se introducen los valores separados por comas en un vector
std::stringstream ss(value);
std::string tmp;
getline(ss, tmp, ',');
selector.color.r = std::stoi(tmp);
getline(ss, tmp, ',');
selector.color.g = std::stoi(tmp);
getline(ss, tmp, ',');
selector.color.b = std::stoi(tmp);
getline(ss, tmp, ',');
selector.a = std::stoi(tmp);
}
else if (var == "selector_text_color")
{
// Se introducen los valores separados por comas en un vector
std::stringstream ss(value);
std::string tmp;
getline(ss, tmp, ',');
selector.itemColor.r = std::stoi(tmp);
getline(ss, tmp, ',');
selector.itemColor.g = std::stoi(tmp);
getline(ss, tmp, ',');
selector.itemColor.b = std::stoi(tmp);
}
else if (var == "areElementsCenteredOnX")
{
areElementsCenteredOnX = value == "true" ? true : false;
}
else if (var == "isCenteredOnX")
{
isCenteredOnX = value == "true" ? true : false;
}
else if (var == "isCenteredOnY")
{
isCenteredOnY = value == "true" ? true : false;
}
else if (var == "defaultActionWhenCancel")
{
defaultActionWhenCancel = std::stoi(value);
}
else if (var == "")
{
}
else
{
success = false;
}
return success;
}
// Inicializa las variables
void Menu::init()
{
// Inicia variables
name = "";
selector.index = 0;
itemSelected = MENU_NO_OPTION;
x = 0;
y = 0;
rectBG.rect = {0, 0, 0, 0};
rectBG.color = {0, 0, 0};
rectBG.a = 0;
backgroundType = MENU_BACKGROUND_SOLID;
isCenteredOnX = false;
isCenteredOnY = false;
areElementsCenteredOnX = false;
centerX = 0;
centerY = 0;
widestItem = 0;
colorGreyed = {128, 128, 128};
defaultActionWhenCancel = 0;
font_png = "";
font_txt = "";
// Selector
selector.originY = 0;
selector.targetY = 0;
selector.despY = 0;
selector.originH = 0;
selector.targetH = 0;
selector.incH = 0;
selector.y = 0.0f;
selector.h = 0.0f;
selector.numJumps = 8;
selector.moving = false;
selector.resizing = false;
selector.rect = {0, 0, 0, 0};
selector.color = {0, 0, 0};
selector.itemColor = {0, 0, 0};
selector.a = 255;
}
// Carga los ficheros de audio
void Menu::loadAudioFile(std::string file, int sound)
{
switch (sound)
{
case SOUND_ACCEPT:
soundAccept = JA_LoadSound(file.c_str());
break;
case SOUND_CANCEL:
soundCancel = JA_LoadSound(file.c_str());
break;
case SOUND_MOVE:
soundMove = JA_LoadSound(file.c_str());
break;
default:
break;
}
}
// Obtiene el nombre del menu
std::string Menu::getName()
{
return name;
}
// Obtiene el valor de la variable
int Menu::getItemSelected()
{
// Al llamar a esta funcion, se obtiene el valor y se borra
const int temp = itemSelected;
itemSelected = MENU_NO_OPTION;
return temp;
}
// Actualiza la posicion y el estado del selector
void Menu::updateSelector()
{
if (selector.moving)
{
// Calcula el desplazamiento en Y
selector.y += selector.despY;
if (selector.despY > 0) // Va hacia abajo
{
if (selector.y > selector.targetY) // Ha llegado al destino
{
selector.originY = selector.y = selector.targetY;
selector.moving = false;
}
}
if (selector.despY < 0) // Va hacia arriba
{
if (selector.y < selector.targetY) // Ha llegado al destino
{
selector.originY = selector.y = selector.targetY;
selector.moving = false;
}
}
selector.rect.y = int(selector.y);
}
else
{
selector.rect.y = int(selector.y);
}
if (selector.resizing)
{
// Calcula el incremento en H
selector.h += selector.incH;
if (selector.incH > 0) // Crece
{
if (selector.h > selector.targetH) // Ha llegado al destino
{
// selector.originH = selector.targetH = selector.rect.h = getSelectorHeight(selector.index);
selector.originH = selector.h = selector.targetH;
selector.resizing = false;
}
}
if (selector.incH < 0) // Decrece
{
if (selector.h < selector.targetH) // Ha llegado al destino
{
// selector.originH = selector.targetH = selector.rect.h = getSelectorHeight(selector.index);
selector.originH = selector.h = selector.targetH;
selector.resizing = false;
}
}
selector.rect.h = int(selector.h);
}
else
{
selector.rect.h = getSelectorHeight(selector.index);
}
}
// Coloca el selector en una posición específica
void Menu::setSelectorPos(int index)
{
if (index < (int)item.size())
{
selector.index = index;
selector.rect.y = selector.y = selector.originY = selector.targetY = item[selector.index].rect.y;
selector.rect.w = rectBG.rect.w;
selector.rect.x = rectBG.rect.x;
selector.originH = selector.targetH = selector.rect.h = getSelectorHeight(selector.index);
selector.moving = false;
selector.resizing = false;
}
}
// Obtiene la anchura del elemento más ancho del menu
int Menu::getWidestItem()
{
int result = 0;
// Obtenemos la anchura del item mas ancho
for (auto &i : item)
{
result = std::max(result, i.rect.w);
}
return result;
}
// Deja el menu apuntando al primer elemento
void Menu::reset()
{
itemSelected = MENU_NO_OPTION;
selector.index = 0;
selector.originY = selector.targetY = selector.y = item[0].rect.y;
selector.originH = selector.targetH = item[0].rect.h;
selector.moving = false;
selector.resizing = false;
}
// Actualiza el menu para recolocarlo correctamente y establecer el tamaño
void Menu::reorganize()
{
setRectSize();
if (isCenteredOnX)
{
centerMenuOnX(centerX);
}
if (isCenteredOnY)
{
centerMenuOnY(centerY);
}
if (areElementsCenteredOnX)
{
centerMenuElementsOnX();
}
}
// Deja el menu apuntando al siguiente elemento
bool Menu::increaseSelectorIndex()
{
// Obten las coordenadas del elemento actual
selector.y = selector.originY = item[selector.index].rect.y;
selector.h = selector.originH = getSelectorHeight(selector.index);
// Calcula cual es el siguiente elemento
++selector.index %= item.size();
while (!item[selector.index].selectable)
{
++selector.index %= item.size();
}
// Establece las coordenadas y altura de destino
selector.targetY = item[selector.index].rect.y;
selector.despY = (selector.targetY - selector.originY) / selector.numJumps;
selector.targetH = getSelectorHeight(selector.index);
selector.incH = (selector.targetH - selector.originH) / selector.numJumps;
selector.moving = true;
if (selector.incH != 0)
{
selector.resizing = true;
}
return true;
}
// Deja el menu apuntando al elemento anterior
bool Menu::decreaseSelectorIndex()
{
// Obten las coordenadas del elemento actual
selector.y = selector.originY = item[selector.index].rect.y;
selector.h = selector.originH = getSelectorHeight(selector.index);
// Calcula cual es el siguiente elemento
if (selector.index == 0)
{
selector.index = item.size();
}
else
{
selector.index--;
}
while (!item[selector.index].selectable)
{
if (selector.index == 0)
{
selector.index = item.size();
}
else
{
selector.index--;
}
}
// Establece las coordenadas y altura de destino
selector.targetY = item[selector.index].rect.y;
selector.despY = (selector.targetY - selector.originY) / selector.numJumps;
selector.targetH = getSelectorHeight(selector.index);
selector.incH = (selector.targetH - selector.originH) / selector.numJumps;
selector.moving = true;
if (selector.incH != 0)
{
selector.resizing = true;
}
return true;
}
// Actualiza la logica del menu
void Menu::update()
{
checkInput();
updateSelector();
}
// Pinta el menu en pantalla
void Menu::render()
{
// Rendereritza el fondo del menu
if (backgroundType == MENU_BACKGROUND_SOLID)
{
SDL_SetRenderDrawColor(renderer, rectBG.color.r, rectBG.color.g, rectBG.color.b, rectBG.a);
SDL_RenderFillRect(renderer, &rectBG.rect);
}
// Renderiza el rectangulo del selector
const SDL_Rect temp = {selector.rect.x, selector.rect.y - 1, selector.rect.w, selector.rect.h + 1};
// temp.y--;
// temp.h++;
SDL_SetRenderDrawColor(renderer, selector.color.r, selector.color.g, selector.color.b, selector.a);
SDL_RenderFillRect(renderer, &temp);
// Renderiza el borde del fondo
if (backgroundType == MENU_BACKGROUND_SOLID)
{
SDL_SetRenderDrawColor(renderer, rectBG.color.r, rectBG.color.g, rectBG.color.b, 255);
SDL_RenderDrawRect(renderer, &rectBG.rect);
}
// Renderiza el texto
for (int i = 0; i < (int)item.size(); ++i)
{
if (i == selector.index)
{
const color_t color = {selector.itemColor.r, selector.itemColor.g, selector.itemColor.b};
text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, color);
}
else if (item[i].selectable)
{
text->write(item[i].rect.x, item[i].rect.y, item[i].label);
}
else if (item[i].greyed)
{
text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, colorGreyed);
}
else
// No seleccionable
{
if ((item[i].linkedUp) && (i == selector.index + 1))
{
const color_t color = {selector.itemColor.r, selector.itemColor.g, selector.itemColor.b};
text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, color);
}
else // No enlazado con el de arriba
{
text->write(item[i].rect.x, item[i].rect.y, item[i].label);
}
}
}
}
// Establece el rectangulo de fondo del menu y el selector
void Menu::setRectSize()
{
rectBG.rect.w = findWidth() + text->getCharacterSize();
rectBG.rect.h = findHeight() + text->getCharacterSize();
// La posición X es la del menú menos medio caracter
rectBG.rect.x = x - (text->getCharacterSize() / 2);
// La posición Y es la del menu menos la altura de medio caracter
rectBG.rect.y = y - (text->getCharacterSize() / 2);
// Establecemos los valores del rectangulo del selector a partir de los valores del rectangulo de fondo
setSelectorPos(selector.index);
}
// Establece el color del rectangulo de fondo
void Menu::setBackgroundColor(color_t color, int alpha)
{
rectBG.color = color;
rectBG.a = alpha;
}
// Establece el color del rectangulo del selector
void Menu::setSelectorColor(color_t color, int alpha)
{
selector.color = color;
selector.a = alpha;
}
// Establece el color del texto del selector
void Menu::setSelectorTextColor(color_t color)
{
selector.itemColor = color;
}
// Centra el menu respecto un punto en el eje X
void Menu::centerMenuOnX(int value)
{
isCenteredOnX = true;
centerX = value;
// Establece la nueva posición centrada en funcion del elemento más ancho
x = (value) - (findWidth() / 2);
// Reposiciona los elementos del menu
for (auto &i : item)
{
i.rect.x = x;
}
// Recalcula el rectangulo de fondo
setRectSize();
}
// Centra el menu respecto un punto en el eje Y
void Menu::centerMenuOnY(int value)
{
isCenteredOnY = true;
centerY = value;
// Establece la nueva posición centrada en funcion del elemento más ancho
y = (value) - (findHeight() / 2);
// Reposiciona los elementos del menu
replaceElementsOnY();
// Recalcula el rectangulo de fondo
setRectSize();
}
// Centra los elementos del menu en el eje X
void Menu::centerMenuElementsOnX()
{
areElementsCenteredOnX = true;
for (auto &i : item)
{
i.rect.x = (centerX - (i.rect.w / 2));
}
}
// Añade un item al menu
void Menu::addItem(std::string text, int hPaddingDown, bool selectable, bool greyed, bool linkedDown)
{
item_t temp;
// Si es el primer item coge la posición en el eje Y del propio menu
if (item.size() == 0)
{
temp.rect.y = y;
}
else
// En caso contrario, coge la posición en el eje Y a partir del elemento anterior
{
temp.rect.y = item.back().rect.y + item.back().rect.h + item.back().hPaddingDown;
}
temp.rect.x = x;
temp.hPaddingDown = hPaddingDown;
temp.selectable = selectable;
temp.greyed = greyed;
temp.linkedDown = linkedDown;
item.push_back(temp);
setItemCaption(item.size() - 1, text);
if (item.size() > 0)
{
if (item[item.size() - 1].linkedDown)
{
item[item.size()].linkedUp = true;
}
}
centerX = x + (findWidth() / 2);
reorganize();
}
// Cambia el texto de un item
void Menu::setItemCaption(int index, std::string text)
{
item[index].label = text;
item[index].rect.w = this->text->lenght(item[index].label);
item[index].rect.h = this->text->getCharacterSize();
reorganize();
const std::string texto = item[index].label + ":" + std::to_string(item[index].rect.w);
printf("Adding menu item -> %s\n", texto.c_str());
}
// Establece el indice del itemm que se usará por defecto al cancelar el menu
void Menu::setDefaultActionWhenCancel(int item)
{
defaultActionWhenCancel = item;
}
// Gestiona la entrada de teclado y mando durante el menu
void Menu::checkInput()
{
if (input->checkInput(INPUT_UP, REPEAT_FALSE))
{
if (decreaseSelectorIndex())
{
if (soundMove)
{
JA_PlaySound(soundMove);
}
}
}
if (input->checkInput(INPUT_DOWN, REPEAT_FALSE))
{
if (increaseSelectorIndex())
{
if (soundMove)
{
JA_PlaySound(soundMove);
}
}
}
if (input->checkInput(INPUT_ACCEPT, REPEAT_FALSE))
{
itemSelected = selector.index;
if (soundAccept)
{
JA_PlaySound(soundAccept);
}
}
if (input->checkInput(INPUT_CANCEL, REPEAT_FALSE))
{
itemSelected = defaultActionWhenCancel;
if (soundCancel)
{
JA_PlaySound(soundCancel);
}
}
}
// Calcula el ancho del menu
int Menu::findWidth()
{
return getWidestItem();
}
// Calcula el alto del menu
int Menu::findHeight()
{
int height = 0;
// Obtenemos la altura de la suma de alturas de los items
for (auto &i : item)
{
height += i.rect.h + i.hPaddingDown;
}
return height - item.back().hPaddingDown;
}
// Recoloca los elementos del menu en el eje Y
void Menu::replaceElementsOnY()
{
item[0].rect.y = y;
for (int i = 1; i < (int)item.size(); i++)
{
item[i].rect.y = item[i - 1].rect.y + item[i - 1].rect.h + item[i - 1].hPaddingDown;
}
}
// Establece el estado seleccionable de un item
void Menu::setSelectable(int index, bool value)
{
item[index].selectable = value;
}
// Establece el estado agrisado de un item
void Menu::setGreyed(int index, bool value)
{
item[index].greyed = value;
}
// Establece el estado de enlace de un item
void Menu::setLinkedDown(int index, bool value)
{
item[index].linkedDown = value;
}
// Calcula la altura del selector
int Menu::getSelectorHeight(int value)
{
if (item[value].linkedDown)
{
return item[value].rect.h + item[value].hPaddingDown + item[value + 1].rect.h;
}
else
{
return item[value].rect.h;
}
}

214
source/utils/menu.h Normal file
View File

@@ -0,0 +1,214 @@
#pragma once
#include <SDL2/SDL.h>
#include "asset.h"
#include "input.h"
#include "jail_audio.h"
#include "sprite.h"
#include "text.h"
#include "utils.h"
#include <fstream>
#include <sstream>
#include <vector>
#ifndef MENU_H
#define MENU_H
// Tipos de fondos para el menu
#define MENU_BACKGROUND_TRANSPARENT 0
#define MENU_BACKGROUND_SOLID 1
// Tipos de archivos de audio
#define SOUND_ACCEPT 0
#define SOUND_MOVE 1
#define SOUND_CANCEL 2
// Opciones de menu
#define MENU_NO_OPTION -1
// Clase Menu
class Menu
{
private:
struct rectangle_t
{
SDL_Rect rect; // Rectangulo
color_t color; // Color
int a; // Transparencia
};
struct item_t
{
std::string label; // Texto
SDL_Rect rect; // Rectangulo que delimita el elemento
int hPaddingDown; // Espaciado bajo el elemento
bool selectable; // Indica si se puede seleccionar
bool greyed; // Indica si ha de aparecer con otro color mas oscuro
bool linkedDown; // Indica si el elemento actual y el siguiente se tratan como uno solo. Afecta al selector
bool linkedUp; // Indica si el elemento actual y el anterior se tratan como uno solo. Afecta al selector
};
struct selector_t
{
float originY; // Coordenada de origen
float targetY; // Coordenada de destino
float despY; // Cantidad de pixeles que se desplaza el selector en cada salto: (target - origin) / numJumps
bool moving; // Indica si el selector está avanzando hacia el destino
float originH; // Altura de origen
float targetH; // Altura de destino
float incH; // Cantidad de pixels que debe incrementar o decrementar el selector en cada salto
bool resizing; // Indica si el selector está cambiando de tamaño
float y; // Coordenada actual, usado para el desplazamiento
float h; // Altura actual, usado para el cambio de tamaño
int numJumps; // Numero de pasos preestablecido para llegar al destino
int index; // Elemento del menu que tiene el foco
SDL_Rect rect; // Rectangulo del selector
color_t color; // Color del selector
color_t itemColor; // Color del item
int a; // Cantidad de transparencia para el rectangulo del selector
};
std::string name; // Nombre del menu
int x; // Posición en el eje X de la primera letra del primer elemento
int y; // Posición en el eje Y de la primera letra del primer elemento
int h; // Altura del menu
int w; // Anchura del menu
int itemSelected; // Índice del item del menu que ha sido seleccionado
int defaultActionWhenCancel; // Indice del item del menu que se selecciona cuando se cancela el menu
int backgroundType; // Tipo de fondo para el menu
int centerX; // Centro del menu en el eje X
int centerY; // Centro del menu en el eje Y
bool isCenteredOnX; // Variable para saber si el menu debe estar centrado respecto a un punto en el eje X
bool isCenteredOnY; // Variable para saber si el menu debe estar centrado respecto a un punto en el eje Y
bool areElementsCenteredOnX; // Variable para saber si los elementos van centrados en el eje X
int widestItem; // Anchura del elemento más ancho
JA_Sound soundAccept; // Sonido al aceptar o elegir una opción del menu
JA_Sound soundCancel; // Sonido al cancelar el menu
JA_Sound soundMove; // Sonido al mover el selector
SDL_Renderer *renderer; // Puntero al renderizador de la ventana
Text *text; // Texto para poder escribir los items del menu
Input *input; // Gestor de eventos de entrada de teclado o gamepad
Asset *asset; // Objeto para gestionar los ficheros de recursos
color_t colorGreyed; // Color para los elementos agrisados
rectangle_t rectBG; // Rectangulo de fondo del menu
std::vector<item_t> item; // Estructura para cada elemento del menu
selector_t selector; // Variables para pintar el selector del menu
std::string font_png;
std::string font_txt;
// Carga la configuración del menu desde un archivo de texto
bool load(std::string file_path);
// Asigna variables a partir de dos cadenas
bool setVars(std::string var, std::string value);
// Asigna variables a partir de dos cadenas
bool setItem(item_t *item, std::string var, std::string value);
// Inicializa las variables
void init();
// Establece el rectangulo de fondo del menu
void setRectSize();
// Actualiza el menu para recolocarlo correctamente y establecer el tamaño
void reorganize();
// Deja el menu apuntando al siguiente elemento
bool increaseSelectorIndex();
// Deja el menu apuntando al elemento anterior
bool decreaseSelectorIndex();
// Actualiza la posicion y el estado del selector
void updateSelector();
// Obtiene la anchura del elemento más ancho del menu
int getWidestItem();
// Gestiona la entrada de teclado y mando durante el menu
void checkMenuInput(Menu *menu);
// Calcula el ancho del menu
int findWidth();
// Calcula el alto del menu
int findHeight();
// Recoloca los elementos del menu en el eje Y
void replaceElementsOnY();
// Calcula la altura del selector
int getSelectorHeight(int value);
public:
// Constructor
Menu(SDL_Renderer *renderer, Asset *asset, Input *input, std::string file="");
// Destructor
~Menu();
// Carga los ficheros de audio
void loadAudioFile(std::string file, int sound);
// Obtiene el nombre del menu
std::string getName();
// Obtiene el valor de la variable
int getItemSelected();
// Deja el menu apuntando al primer elemento
void reset();
// Gestiona la entrada de teclado y mando durante el menu
void checkInput();
// Actualiza la logica del menu
void update();
// Pinta el menu en pantalla
void render();
// Establece el color del rectangulo de fondo
void setBackgroundColor(color_t color, int alpha);
// Establece el color del rectangulo del selector
void setSelectorColor(color_t color, int alpha);
// Establece el color del texto del selector
void setSelectorTextColor(color_t color);
// Centra el menu respecto a un punto en el eje X
void centerMenuOnX(int value);
// Centra el menu respecto a un punto en el eje Y
void centerMenuOnY(int value);
// Centra los elementos del menu en el eje X
void centerMenuElementsOnX();
// Añade un item al menu
void addItem(std::string text, int hPaddingDown = 1, bool selectable = true, bool greyed = false, bool linkedDown = false);
// Cambia el texto de un item
void setItemCaption(int index, std::string text);
// Establece el indice del item que se usará por defecto al cancelar el menu
void setDefaultActionWhenCancel(int item);
// Coloca el selector en una posición específica
void setSelectorPos(int index);
// Establece el estado seleccionable de un item
void setSelectable(int index, bool value);
// Establece el estado agrisado de un item
void setGreyed(int index, bool value);
// Establece el estado de enlace de un item
void setLinkedDown(int index, bool value);
// hacer procedimientos para establecer el titulo, la x, la y, la tipografia y el tipo de fondo
};
#endif

0
source/movingsprite.cpp → source/utils/movingsprite.cpp
View File

346
source/movingsprite.h → source/utils/movingsprite.h
View File

@@ -1,173 +1,173 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "sprite.h" #include "sprite.h"
#ifndef MOVINGSPRITE_H #ifndef MOVINGSPRITE_H
#define MOVINGSPRITE_H #define MOVINGSPRITE_H
// Clase MovingSprite. Añade posicion y velocidad en punto flotante // Clase MovingSprite. Añade posicion y velocidad en punto flotante
class MovingSprite : public Sprite class MovingSprite : public Sprite
{ {
protected: protected:
float x; // Posición en el eje X float x; // Posición en el eje X
float y; // Posición en el eje Y float y; // Posición en el eje Y
float xPrev; // Posición anterior en el eje X float xPrev; // Posición anterior en el eje X
float yPrev; // Posición anterior en el eje Y float yPrev; // Posición anterior en el eje Y
float vx; // Velocidad en el eje X. Cantidad de pixeles a desplazarse float vx; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
float vy; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse float vy; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
float ax; // Aceleración en el eje X. Variación de la velocidad float ax; // Aceleración en el eje X. Variación de la velocidad
float ay; // Aceleración en el eje Y. Variación de la velocidad float ay; // Aceleración en el eje Y. Variación de la velocidad
float zoomW; // Zoom aplicado a la anchura float zoomW; // Zoom aplicado a la anchura
float zoomH; // Zoom aplicado a la altura float zoomH; // Zoom aplicado a la altura
double angle; // Angulo para dibujarlo double angle; // Angulo para dibujarlo
bool rotateEnabled; // Indica si ha de rotar bool rotateEnabled; // Indica si ha de rotar
int rotateSpeed; // Velocidad de giro int rotateSpeed; // Velocidad de giro
double rotateAmount; // Cantidad de grados a girar en cada iteración double rotateAmount; // Cantidad de grados a girar en cada iteración
int counter; // Contador interno int counter; // Contador interno
SDL_Point center; // Centro de rotación SDL_Point center; // Centro de rotación
SDL_RendererFlip currentFlip; // Indica como se voltea el sprite SDL_RendererFlip currentFlip; // Indica como se voltea el sprite
public: public:
// Constructor // Constructor
MovingSprite(float x = 0, float y = 0, int w = 0, int h = 0, float velx = 0, float vely = 0, float accelx = 0, float accely = 0, LTexture *texture = nullptr, SDL_Renderer *renderer = nullptr); MovingSprite(float x = 0, float y = 0, int w = 0, int h = 0, float velx = 0, float vely = 0, float accelx = 0, float accely = 0, LTexture *texture = nullptr, SDL_Renderer *renderer = nullptr);
// Destructor // Destructor
~MovingSprite(); ~MovingSprite();
// Mueve el sprite // Mueve el sprite
void move(); void move();
// Rota el sprite // Rota el sprite
void rotate(); void rotate();
// Actualiza las variables internas del objeto // Actualiza las variables internas del objeto
void update(); void update();
// Reinicia todas las variables // Reinicia todas las variables
void clear(); void clear();
// Muestra el sprite por pantalla // Muestra el sprite por pantalla
void render(); void render();
// Obten el valor de la variable // Obten el valor de la variable
float getPosX(); float getPosX();
// Obten el valor de la variable // Obten el valor de la variable
float getPosY(); float getPosY();
// Obten el valor de la variable // Obten el valor de la variable
float getVelX(); float getVelX();
// Obten el valor de la variable // Obten el valor de la variable
float getVelY(); float getVelY();
// Obten el valor de la variable // Obten el valor de la variable
float getAccelX(); float getAccelX();
// Obten el valor de la variable // Obten el valor de la variable
float getAccelY(); float getAccelY();
// Obten el valor de la variable // Obten el valor de la variable
float getZoomW(); float getZoomW();
// Obten el valor de la variable // Obten el valor de la variable
float getZoomH(); float getZoomH();
// Obten el valor de la variable // Obten el valor de la variable
double getAngle(); double getAngle();
// Obtiene el valor de la variable // Obtiene el valor de la variable
bool getRotate(); bool getRotate();
// Obtiene el valor de la variable // Obtiene el valor de la variable
Uint16 getRotateSpeed(); Uint16 getRotateSpeed();
// Establece la posición del objeto // Establece la posición del objeto
void setPos(SDL_Rect rect); void setPos(SDL_Rect rect);
// Establece el valor de la variable // Establece el valor de la variable
void setPosX(float value); void setPosX(float value);
// Establece el valor de la variable // Establece el valor de la variable
void setPosY(float value); void setPosY(float value);
// Establece el valor de la variable // Establece el valor de la variable
void setVelX(float value); void setVelX(float value);
// Establece el valor de la variable // Establece el valor de la variable
void setVelY(float value); void setVelY(float value);
// Establece el valor de la variable // Establece el valor de la variable
void setAccelX(float value); void setAccelX(float value);
// Establece el valor de la variable // Establece el valor de la variable
void setAccelY(float value); void setAccelY(float value);
// Establece el valor de la variable // Establece el valor de la variable
void setZoomW(float value); void setZoomW(float value);
// Establece el valor de la variable // Establece el valor de la variable
void setZoomH(float value); void setZoomH(float value);
// Establece el valor de la variable // Establece el valor de la variable
void setAngle(double vaue); void setAngle(double vaue);
// Incrementa el valor de la variable // Incrementa el valor de la variable
void incAngle(double value); void incAngle(double value);
// Decrementa el valor de la variable // Decrementa el valor de la variable
void decAngle(double value); void decAngle(double value);
// Establece el valor de la variable // Establece el valor de la variable
void setRotate(bool value); void setRotate(bool value);
// Establece el valor de la variable // Establece el valor de la variable
void setRotateSpeed(int value); void setRotateSpeed(int value);
// Establece el valor de la variable // Establece el valor de la variable
void setRotateAmount(double value); void setRotateAmount(double value);
// Quita el efecto de rotación y deja el sprite en su angulo inicial. // Quita el efecto de rotación y deja el sprite en su angulo inicial.
void disableRotate(); void disableRotate();
// Cambia el sentido de la rotación // Cambia el sentido de la rotación
void switchRotate(); void switchRotate();
// Establece el valor de la variable // Establece el valor de la variable
void setFlip(SDL_RendererFlip flip); void setFlip(SDL_RendererFlip flip);
// Gira el sprite horizontalmente // Gira el sprite horizontalmente
void flip(); void flip();
// Obtiene el valor de la variable // Obtiene el valor de la variable
SDL_RendererFlip getFlip(); SDL_RendererFlip getFlip();
// Devuelve el rectangulo donde está el sprite // Devuelve el rectangulo donde está el sprite
SDL_Rect getRect(); SDL_Rect getRect();
// Establece los valores de posición y tamaño del sprite // Establece los valores de posición y tamaño del sprite
void setRect(SDL_Rect rect); void setRect(SDL_Rect rect);
// Deshace el último movimiento // Deshace el último movimiento
void undoMove(); void undoMove();
// Deshace el último movimiento en el eje X // Deshace el último movimiento en el eje X
void undoMoveX(); void undoMoveX();
// Deshace el último movimiento en el eje Y // Deshace el último movimiento en el eje Y
void undoMoveY(); void undoMoveY();
// Pone a cero las velocidades de desplacamiento // Pone a cero las velocidades de desplacamiento
void clearVel(); void clearVel();
// Devuelve el incremento en el eje X en pixels // Devuelve el incremento en el eje X en pixels
int getIncX(); int getIncX();
}; };
#endif #endif

0
source/screen.cpp → source/utils/screen.cpp
View File

0
source/screen.h → source/utils/screen.h
View File

0
source/sprite.cpp → source/utils/sprite.cpp
View File

198
source/sprite.h → source/utils/sprite.h
View File

@@ -1,99 +1,99 @@
#pragma once #pragma once
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include "ltexture.h" #include "ltexture.h"
#ifndef SPRITE_H #ifndef SPRITE_H
#define SPRITE_H #define SPRITE_H
// Clase sprite // Clase sprite
class Sprite class Sprite
{ {
protected: protected:
int x; // Posición en el eje X donde dibujar el sprite int x; // Posición en el eje X donde dibujar el sprite
int y; // Posición en el eje Y donde dibujar el sprite int y; // Posición en el eje Y donde dibujar el sprite
int w; // Ancho del sprite int w; // Ancho del sprite
int h; // Alto del sprite int h; // Alto del sprite
SDL_Renderer *renderer; // Puntero al renderizador de la ventana SDL_Renderer *renderer; // Puntero al renderizador de la ventana
LTexture *texture; // Textura donde estan todos los dibujos del sprite LTexture *texture; // Textura donde estan todos los dibujos del sprite
SDL_Rect spriteClip; // Rectangulo de origen de la textura que se dibujará en pantalla SDL_Rect spriteClip; // Rectangulo de origen de la textura que se dibujará en pantalla
bool enabled; // Indica si el sprite esta habilitado bool enabled; // Indica si el sprite esta habilitado
public: public:
// Constructor // Constructor
Sprite(int x = 0, int y = 0, int w = 0, int h = 0, LTexture *texture = nullptr, SDL_Renderer *renderer = nullptr); Sprite(int x = 0, int y = 0, int w = 0, int h = 0, LTexture *texture = nullptr, SDL_Renderer *renderer = nullptr);
Sprite(SDL_Rect rect, LTexture *texture, SDL_Renderer *renderer); Sprite(SDL_Rect rect, LTexture *texture, SDL_Renderer *renderer);
// Destructor // Destructor
~Sprite(); ~Sprite();
// Muestra el sprite por pantalla // Muestra el sprite por pantalla
void render(); void render();
// Obten el valor de la variable // Obten el valor de la variable
int getPosX(); int getPosX();
// Obten el valor de la variable // Obten el valor de la variable
int getPosY(); int getPosY();
// Obten el valor de la variable // Obten el valor de la variable
int getWidth(); int getWidth();
// Obten el valor de la variable // Obten el valor de la variable
int getHeight(); int getHeight();
// Establece la posición del objeto // Establece la posición del objeto
void setPos(SDL_Rect rect); void setPos(SDL_Rect rect);
// Establece el valor de la variable // Establece el valor de la variable
void setPosX(int x); void setPosX(int x);
// Establece el valor de la variable // Establece el valor de la variable
void setPosY(int y); void setPosY(int y);
// Incrementa el valor de la variable // Incrementa el valor de la variable
void incPosX(int value); void incPosX(int value);
// Incrementa el valor de la variable // Incrementa el valor de la variable
void incPosY(int value); void incPosY(int value);
// Establece el valor de la variable // Establece el valor de la variable
void setWidth(int w); void setWidth(int w);
// Establece el valor de la variable // Establece el valor de la variable
void setHeight(int h); void setHeight(int h);
// Obten el valor de la variable // Obten el valor de la variable
SDL_Rect getSpriteClip(); SDL_Rect getSpriteClip();
// Establece el valor de la variable // Establece el valor de la variable
void setSpriteClip(SDL_Rect rect); void setSpriteClip(SDL_Rect rect);
// Establece el valor de la variable // Establece el valor de la variable
void setSpriteClip(int x, int y, int w, int h); void setSpriteClip(int x, int y, int w, int h);
// Obten el valor de la variable // Obten el valor de la variable
LTexture *getTexture(); LTexture *getTexture();
// Establece el valor de la variable // Establece el valor de la variable
void setTexture(LTexture *texture); void setTexture(LTexture *texture);
// Establece el valor de la variable // Establece el valor de la variable
void setRenderer(SDL_Renderer *renderer); void setRenderer(SDL_Renderer *renderer);
// Establece el valor de la variable // Establece el valor de la variable
void setEnabled(bool value); void setEnabled(bool value);
// Comprueba si el objeto está habilitado // Comprueba si el objeto está habilitado
bool isEnabled(); bool isEnabled();
// Devuelve el rectangulo donde está el sprite // Devuelve el rectangulo donde está el sprite
SDL_Rect getRect(); SDL_Rect getRect();
// Establece los valores de posición y tamaño del sprite // Establece los valores de posición y tamaño del sprite
void setRect(SDL_Rect rect); void setRect(SDL_Rect rect);
}; };
#endif #endif

0
source/stb_image.h → source/utils/stb_image.h
View File

0
source/stb_vorbis.c → source/utils/stb_vorbis.c
View File

1
source/text.cpp → source/utils/text.cpp
View File

@@ -1,4 +1,3 @@
#include "text.h" #include "text.h"
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>

143
source/text.h → source/utils/text.h
View File

@@ -1,71 +1,72 @@
#pragma once #pragma once
#include "sprite.h" #include <SDL2/SDL.h>
#include "utils.h" #include "sprite.h"
#include "utils.h"
#ifndef TEXT_H
#define TEXT_H #ifndef TEXT_H
#define TEXT_H
#define TXT_COLOR 1
#define TXT_SHADOW 2 #define TXT_COLOR 1
#define TXT_CENTER 4 #define TXT_SHADOW 2
#define TXT_STROKE 8 #define TXT_CENTER 4
#define TXT_STROKE 8
// Clase texto. Pinta texto en pantalla a partir de un bitmap
class Text // Clase texto. Pinta texto en pantalla a partir de un bitmap
{ class Text
private: {
Sprite *sprite; // Objeto con los graficos para el texto private:
Sprite *sprite; // Objeto con los graficos para el texto
struct Offset
{ struct Offset
int x; {
int y; int x;
int w; int y;
}; int w;
Offset offset[128]; // Vector con las posiciones y ancho de cada letra };
Offset offset[128]; // Vector con las posiciones y ancho de cada letra
int boxWidth; // Anchura de la caja de cada caracter en el png
int boxHeight; // Altura de la caja de cada caracter en el png int boxWidth; // Anchura de la caja de cada caracter en el png
std::string file; // Fichero con los descriptores de la fuente int boxHeight; // Altura de la caja de cada caracter en el png
LTexture *texture; // Textura con los bitmaps del texto std::string file; // Fichero con los descriptores de la fuente
LTexture *texture; // Textura con los bitmaps del texto
// Inicializador
void init(); // Inicializador
void init();
// Inicializa el vector de offsets desde un fichero
void initOffsetFromFile(); // Inicializa el vector de offsets desde un fichero
void initOffsetFromFile();
public:
// Constructor public:
Text(std::string bitmapFile, std::string textFile, SDL_Renderer *renderer); // Constructor
Text(std::string bitmapFile, std::string textFile, SDL_Renderer *renderer);
// Destructor
~Text(); // Destructor
~Text();
// Escribe el texto en pantalla
void write(int x, int y, std::string text, int kerning = 1, int lenght = -1); // Escribe el texto en pantalla
void write(int x, int y, std::string text, int kerning = 1, int lenght = -1);
// Escribe el texto con colores
void writeColored(int x, int y, std::string text, color_t color, int kerning = 1, int lenght = -1); // Escribe el texto con colores
void writeColored(int x, int y, std::string text, color_t color, int kerning = 1, int lenght = -1);
// Escribe el texto con sombra
void writeShadowed(int x, int y, std::string text, color_t color, Uint8 shadowDistance = 1, int kerning = 1, int lenght = -1); // Escribe el texto con sombra
void writeShadowed(int x, int y, std::string text, color_t color, Uint8 shadowDistance = 1, int kerning = 1, int lenght = -1);
// Escribe el texto centrado en un punto x
void writeCentered(int x, int y, std::string text, int kerning = 1, int lenght = -1); // Escribe el texto centrado en un punto x
void writeCentered(int x, int y, std::string text, int kerning = 1, int lenght = -1);
// Escribe texto con extras
void writeDX(Uint8 flags, int x, int y, std::string text, int kerning = 1, color_t textColor = {255, 255, 255}, Uint8 shadowDistance = 1, color_t shadowColor = {0, 0, 0}, int lenght = -1); // Escribe texto con extras
void writeDX(Uint8 flags, int x, int y, std::string text, int kerning = 1, color_t textColor = {255, 255, 255}, Uint8 shadowDistance = 1, color_t shadowColor = {0, 0, 0}, int lenght = -1);
// Obtiene la longitud en pixels de una cadena
int lenght(std::string text, int kerning = 1); // Obtiene la longitud en pixels de una cadena
int lenght(std::string text, int kerning = 1);
// Devuelve el valor de la variable
int getCharacterSize(); // Devuelve el valor de la variable
int getCharacterSize();
// Recarga la textura
void reLoadTexture(); // Recarga la textura
}; void reLoadTexture();
};
#endif
#endif

0
source/utils.cpp → source/utils/utils.cpp
View File

0
source/utils.h → source/utils/utils.h
View File