- Modificada la carpeta de guardar datos al estandar de jailgames

- Cambiados los textos de los creditos/instrucciones para la versión de consola

Makefile

@@ -2,7 +2,7 @@ executable = jaildoctors_dilemma
 source = source/*.cpp source/common/*.cpp
 appName = JailDoctor's Dilemma
 releaseFolder = jdd_release
-version = v1.06.2
+version = v1.08
 
 # Release names
 windowsRelease = $(executable)-$(version)-win32-x64.zip

README.md

@@ -1,4 +1,4 @@
-# JailDoctor's Dilemma (v1.06.2)
+# JailDoctor's Dilemma (v1.08)
 
 JailDoc es un Jailer. A los Jailers les gusta empezar proyectos. A nadie le gusta terminarlos. Los Jailers viven en la Jail. A la Jail va uno a empezar proyectos. A la Jail va uno a enseñar sus proyectos. A la Jail va uno a aprender como empezar nuevos proyectos. A la Jail va uno a ayudar a sus compañeros a que empiecen nuevos proyectos.
 

data/enemies/paco.ani

@@ -3,7 +3,7 @@ frameHeight=16
 
 [animation]
 name=default
-speed=8
+speed=4
 loop=0
-frames=0,1,2,3
+frames=0,1,2,3,4,5,6,7
 [/animation]

data/room/01.tmx

@@ -3,9 +3,9 @@
  <tileset firstgid="1" source="standard.tsx"/>
  <layer id="1" name="Capa de patrones 1" width="32" height="16">
   <data encoding="csv">
-164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,
-164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,43,43,43,43,43,43,43,43,43,43,43,43,43,43,164,
-164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,
+192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,
+168,166,185,167,166,185,166,166,168,166,166,167,166,166,185,166,166,43,43,43,43,43,43,43,43,43,43,43,43,43,43,166,
+211,181,211,213,211,181,211,212,213,211,181,211,211,212,211,213,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,
 164,43,43,43,43,43,43,43,43,43,43,43,43,43,43,164,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,
 43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,
 43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,43,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,34,

data/room/02.room

@@ -1,6 +1,6 @@
 name=ROAD TO THE JAIL
 bgColor=black
-border=cyan
+border=blue
 tileMapFile=02.tmx
 tileSetFile=standard.png
 roomUp=0

data/room/02.tmx

@@ -3,22 +3,22 @@
  <tileset firstgid="1" source="standard.tsx"/>
  <layer id="1" name="Capa de patrones 1" width="32" height="16">
   <data encoding="csv">
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,43,43,43,43,
-43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,25,25,25,
-43,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,
+192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,43,43,43,43,43,
+43,166,166,167,168,166,185,167,166,185,166,166,168,166,166,167,166,166,185,166,166,166,185,167,166,166,166,185,25,25,25,25,
+43,43,211,212,212,211,181,211,213,211,181,211,212,213,211,181,211,211,211,211,212,213,211,181,211,213,181,211,135,0,0,0,
 43,43,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,
 43,43,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,25,25,25,
 34,34,304,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,25,25,
 34,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,303,25,25,
 34,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,25,
-34,34,0,413,413,413,413,0,0,0,0,413,413,413,413,413,0,0,0,0,413,413,413,413,413,413,413,0,0,0,25,25,
+34,34,0,413,413,413,413,0,0,0,0,413,304,413,413,413,0,0,0,0,413,304,413,413,413,413,304,0,0,0,25,25,
 34,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,25,
-34,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,387,25,25,
+34,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,411,25,25,
 34,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,25,
-34,34,389,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,387,25,25,
+34,34,413,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,411,25,25,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,513,189,190,537,0,0,0,0,
-34,34,189,190,189,190,189,190,189,190,189,190,189,190,189,190,189,190,189,191,0,0,189,190,189,190,189,190,189,190,25,25
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,524,189,191,548,0,0,0,0,
+34,34,189,190,189,190,189,190,189,190,189,190,189,190,189,190,189,190,189,191,0,0,189,190,189,190,189,190,189,191,25,25
 </data>
  </layer>
 </map>

data/room/05.room

@@ -11,8 +11,8 @@ itemColor1=bright_green
 itemColor2=green
 
 [enemy]
-tileSetFile=diskette.png
-animation=diskette.ani
+tileSetFile=floppy.png
+animation=floppy.ani
 width=16
 height=16
 x=15

data/room/05.tmx

@@ -10,7 +10,7 @@
 134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,117,
 25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,117,
 25,0,0,0,0,0,0,0,0,0,0,417,417,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,
-25,0,0,556,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,25,25,0,0,0,0,0,0,0,0,0,387,25,
+25,0,0,556,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,25,25,0,0,0,0,0,0,0,0,0,0,25,
 25,25,25,25,25,25,0,0,0,417,417,0,0,0,0,0,0,0,305,31,0,0,0,0,0,0,0,0,0,0,0,305,
 0,0,0,0,305,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,417,417,0,0,0,0,0,0,
 0,0,0,0,0,0,0,417,417,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,

data/room/12.room

@@ -11,8 +11,8 @@ itemColor1=red
 itemColor2=magenta
 
 [enemy]
-tileSetFile=diskette.png
-animation=diskette.ani
+tileSetFile=floppy.png
+animation=floppy.ani
 width=16
 height=16
 x=9
@@ -27,8 +27,8 @@ color=green
 [/enemy]
 
 [enemy]
-tileSetFile=diskette.png
-animation=diskette.ani
+tileSetFile=floppy.png
+animation=floppy.ani
 width=16
 height=16
 x=1

data/room/17.room

@@ -11,8 +11,8 @@ itemColor1=yellow
 itemColor2=red
 
 [enemy]
-tileSetFile=diskette.png
-animation=diskette.ani
+tileSetFile=floppy.png
+animation=floppy.ani
 width=16
 height=16
 x=5
@@ -27,8 +27,8 @@ color=green
 [/enemy]
 
 [enemy]
-tileSetFile=diskette.png
-animation=diskette.ani
+tileSetFile=floppy.png
+animation=floppy.ani
 width=16
 height=16
 x=12

data/room/18.tmx

@@ -3,16 +3,16 @@
  <tileset firstgid="1" source="standard.tsx"/>
  <layer id="1" name="Capa de patrones 1" width="32" height="16">
   <data encoding="csv">
-5,5,5,5,5,5,5,5,5,5,5,0,0,0,506,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-5,5,5,5,5,5,5,5,0,0,0,0,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,5,
+5,5,5,5,5,5,5,5,0,0,0,0,0,0,506,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+5,5,5,5,5,5,5,0,0,0,0,0,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,5,
 5,5,5,5,5,5,5,0,0,0,0,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
 5,5,5,5,5,5,5,0,0,0,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
 5,5,5,5,5,5,5,0,0,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
-0,0,0,0,0,0,134,0,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
-0,0,0,0,0,0,134,0,415,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
+5,5,5,5,173,0,134,0,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
+557,557,557,557,557,557,134,0,415,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
 5,5,5,5,5,5,5,415,415,415,530,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
-5,5,5,5,5,5,5,0,0,0,0,530,0,0,0,0,0,0,449,449,449,449,449,449,449,449,449,449,449,449,449,5,
-5,5,5,5,5,5,5,0,0,0,0,0,530,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
+5,5,5,5,5,5,0,0,0,0,0,530,0,0,0,0,0,0,449,449,449,449,449,449,449,449,449,449,449,449,449,5,
+5,5,5,5,5,0,0,0,0,0,0,0,530,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
 0,0,0,0,0,0,0,0,0,0,0,0,0,530,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,517,367,5,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,367,367,367,367,429,429,0,429,429,367,367,367,367,367,367,367,367,5,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,343,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,5,

data/room/19.tmx

@@ -4,15 +4,15 @@
  <layer id="1" name="Capa de patrones 1" width="32" height="16">
   <data encoding="csv">
 349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,349,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,38,38,38,38,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,241,241,0,0,0,0,0,0,241,241,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,38,38,241,241,0,0,0,0,0,0,0,0,0,0,0,0,241,241,38,38,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,188,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,188,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,188,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,188,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,38,38,38,38,0,0,0,0,0,0,0,0,0,0,0,0,0,188,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,188,
+0,0,0,0,0,0,0,0,0,0,0,241,241,0,0,0,0,0,0,241,241,0,0,0,0,0,0,0,0,0,0,188,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,188,
+0,0,0,0,0,0,38,38,241,241,0,0,0,0,0,0,0,0,0,0,0,0,241,241,38,38,0,0,0,0,0,188,
 0,0,0,0,0,38,38,0,0,0,0,241,241,0,0,0,0,0,0,241,241,0,0,0,0,38,38,0,0,0,0,0,
 0,0,0,0,38,38,0,0,0,0,0,0,0,0,241,241,241,241,0,0,0,0,0,0,0,0,38,38,0,0,0,0,
 0,0,0,0,38,0,0,0,0,0,0,241,241,0,0,0,0,0,0,241,241,0,0,0,0,0,0,38,0,0,0,0,

data/room/27.room

@@ -9,8 +9,8 @@ roomLeft=26.room
 roomRight=0
 
 #[enemy]
-#tileSetFile=diskette.png
-#animation=diskette.ani
+#tileSetFile=floppy.png
+#animation=floppy.ani
 #width=16
 #height=16
 #x=2

data/room/28.tmx

@@ -3,17 +3,17 @@
  <tileset firstgid="1" source="standard.tsx"/>
  <layer id="1" name="Capa de patrones 1" width="32" height="16">
   <data encoding="csv">
-90,89,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,89,90,41,235,235,0,0,235,235,41,89,90,89,
-89,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,89,90,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,89,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,235,0,0,0,0,0,0,
+90,89,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,89,94,41,235,235,0,0,235,235,41,89,90,89,
+89,94,215,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,214,215,0,0,0,0,0,0,0,0,214,89,90,
+214,215,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,214,89,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,235,0,0,0,0,0,214,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,0,0,0,0,235,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 89,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,0,0,0,0,0,0,0,0,0,
-94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,0,0,0,0,0,
+94,215,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,0,0,0,0,0,
 89,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,415,415,415,415,415,415,
+94,215,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,415,415,415,415,415,415,
 89,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,0,0,0,0,0,0,0,0,0,0,
 90,89,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 89,90,89,94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

data/room/34.room

@@ -11,8 +11,8 @@ itemColor1=green
 itemColor2=red
 
 [enemy]
-tileSetFile=diskette.png
-animation=diskette.ani
+tileSetFile=floppy.png
+animation=floppy.ani
 width=16
 height=16
 x=20

data/room/36.room

@@ -1,4 +1,4 @@
-name=STATIC
+name=BE CAREFUL WITH THE FUSE
 bgColor=black
 border=bright_cyan
 tileMapFile=36.tmx

data/room/42.room

@@ -1,6 +1,6 @@
 name=P.A.C.O. ON THE GO
 bgColor=black
-border=black
+border=blue
 tileMapFile=42.tmx
 tileSetFile=standard.png
 roomUp=0
@@ -23,7 +23,7 @@ x1=10
 y1=2
 x2=10
 y2=11
-color=green
+color=magenta
 [/enemy]
 
 [enemy]

data/room/42.tmx

@@ -11,8 +11,8 @@
 36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,415,421,62,
 36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,421,0,0,0,0,0,0,0,0,
 36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,415,415,421,415,0,0,0,0,0,0,0,0,0,0,0,
-36,0,0,0,0,0,0,0,305,0,0,0,0,305,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-36,0,0,0,305,0,0,0,0,0,0,0,0,0,0,0,0,421,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+36,0,0,0,0,0,0,0,306,0,0,0,0,306,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+36,0,0,0,306,0,0,0,0,0,0,0,0,0,0,0,0,421,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 36,0,415,421,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,415,415,0,0,421,415,0,0,0,0,0,0,
 36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

data/room/46.room

@@ -11,6 +11,22 @@ itemColor1=red
 itemColor2=magenta
 autoSurface=left
 
+[enemy]
+tileSetFile=batman_fire.png
+animation=batman_fire.ani
+width=16
+height=16
+x=10
+y=13
+vx=1.3
+vy=0
+x1=0
+y1=13
+x2=29
+y2=13
+color=cyan
+flip=true
+[/enemy]
 
 [enemy]
 tileSetFile=heavy.png

data/room/50.room

@@ -9,8 +9,8 @@ roomLeft=0
 roomRight=49.room
 
 [enemy]
-tileSetFile=diskette.png
-animation=diskette.ani
+tileSetFile=floppy.png
+animation=floppy.ani
 width=16
 height=16
 x=7
@@ -25,8 +25,8 @@ color=magenta
 [/enemy]
 
 [enemy]
-tileSetFile=diskette.png
-animation=diskette.ani
+tileSetFile=floppy.png
+animation=floppy.ani
 width=16
 height=16
 x=20

data/room/50.tmx

@@ -4,7 +4,7 @@
  <layer id="1" name="Capa de patrones 1" width="32" height="16">
   <data encoding="csv">
 42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42,
-42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42,
+42,42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42,42,
 42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42,
 42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42,
 42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

data/room/53.room

@@ -1,4 +1,4 @@
-name=P.A.C.O WORKSHOP
+name=P.A.C.O. WORKSHOP
 bgColor=black
 border=yellow
 tileMapFile=53.tmx

release/Info.plist

@@ -23,11 +23,11 @@
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.0.6.2</string>
+	<string>1.0.8</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>
-	<string>1.0.6.2</string>
+	<string>1.0.8</string>
 	<key>CSResourcesFileMapped</key>
 	<true/>
 	<key>LSMinimumSystemVersion</key>

source/cheevos.cpp

@@ -1,13 +1,242 @@
 #include "cheevos.h"
+#include <iostream>
 
 // Constructor
-Cheevos::Cheevos(options_t *options)
+Cheevos::Cheevos(Screen *screen, options_t *options, std::string file)
 {
+    // Copia la dirección de los objetos
     this->options = options;
+    this->screen = screen;
+    this->file = file;
+
+    // Inicializa los logros
+    init();
+
+    // Inicializa variables
+    enabled = true;
+
+    // Carga el estado de los logros desde un fichero
+    loadFromFile();
 }
 
 // Destructor
 Cheevos::~Cheevos()
 {
+    // Guarda el estado de los logros en un fichero
+    saveToFile();
 
+    cheevos.clear();
+}
+
+// Inicializa los logros
+void Cheevos::init()
+{
+    cheevos_t c;
+    c.completed = false;
+    c.valid = true;
+    c.icon = 2;
+
+    c.id = 1;
+    c.caption = "SHINY THINGS";
+    c.description = "Get 25\% of the items";
+    cheevos.push_back(c);
+
+    c.id = 2;
+    c.caption = "HALF THE WORK";
+    c.description = "Get 50\% of the items";
+    cheevos.push_back(c);
+
+    c.id = 3;
+    c.caption = "GETTING THERE";
+    c.description = "Get 75\% of the items";
+    cheevos.push_back(c);
+
+    c.id = 4;
+    c.caption = "THE COLLECTOR";
+    c.description = "Get 100\% of the items";
+    cheevos.push_back(c);
+
+    c.id = 5;
+    c.caption = "WANDERING AROUND";
+    c.description = "Visit 20 rooms";
+    cheevos.push_back(c);
+
+    c.id = 6;
+    c.caption = "I GOT LOST";
+    c.description = "Visit 40 rooms";
+    cheevos.push_back(c);
+
+    c.id = 7;
+    c.caption = "I LIKE TO EXPLORE";
+    c.description = "Visit all rooms";
+    cheevos.push_back(c);
+
+    c.id = 8;
+    c.caption = "FINISH THE GAME";
+    c.description = "Complete the game";
+    cheevos.push_back(c);
+
+    c.id = 9;
+    c.caption = "I WAS SUCKED BY A HOLE";
+    c.description = "Complete the game without entering the jail";
+    cheevos.push_back(c);
+
+    c.id = 10;
+    c.caption = "MY LITTLE PROJECTS";
+    c.description = "Complete the game with all items";
+    cheevos.push_back(c);
+
+    c.id = 11;
+    c.caption = "I LIKE MY MULTICOLOURED FRIENDS";
+    c.description = "Complete the game without dying";
+    cheevos.push_back(c);
+
+    c.id = 12;
+    c.caption = "SHIT PROJECTS DONE FAST";
+    c.description = "Complete the game in under 30 minutes";
+    cheevos.push_back(c);
+}
+
+// Busca un logro por id y devuelve el indice
+int Cheevos::find(int id)
+{
+    for (int i = 0; i < (int)cheevos.size(); ++i)
+    {
+        if (cheevos[i].id == id)
+        {
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+// Desbloquea un logro
+void Cheevos::unlock(int id)
+{
+    const int index = find(id);
+
+    if (index == -1)
+    {
+        return;
+    }
+
+    if (!cheevos[index].valid)
+    {
+        return;
+    }
+
+    if (cheevos[index].completed)
+    {
+        return;
+    }
+
+    if (!enabled)
+    {
+        return;
+    }
+
+    cheevos[index].completed = true;
+    screen->showNotification("ACHIEVEMENT UNLOCKED!", cheevos[index].caption, cheevos[index].icon);
+}
+
+// Invalida un logro
+void Cheevos::invalidate(int id)
+{
+    const int index = find(id);
+    if (index == -1)
+    {
+        return;
+    }
+    cheevos[index].valid = false;
+}
+
+// Habilita o deshabilita los logros
+void Cheevos::enable(bool value)
+{
+    enabled = value;
+}
+
+// Carga el estado de los logros desde un fichero
+void Cheevos::loadFromFile()
+{
+    // Open file for reading in binary
+    SDL_RWops *file = SDL_RWFromFile(this->file.c_str(), "r+b");
+
+    // El fichero no existe
+    if (file == NULL)
+    {
+        if (options->console)
+        {
+            std::cout << "Warning: Unable to open file! SDL Error: " << SDL_GetError() << std::endl;
+        }
+
+        // Crea el fichero en modo escritura
+        file = SDL_RWFromFile(this->file.c_str(), "w+b");
+
+        if (file != NULL)
+        {
+            if (options->console)
+            {
+                std::cout << "New file created!" << std::endl;
+            }
+
+            // Guarda la información
+            for (int i = 0; i < (int)cheevos.size(); ++i)
+            {
+                SDL_RWwrite(file, &cheevos[i].completed, sizeof(bool), 1);
+            }
+
+            // Cierra el fichero
+            SDL_RWclose(file);
+        }
+        else
+        {
+            if (options->console)
+            {
+                std::cout << "Error: Unable to create file! SDL Error: " << SDL_GetError() << std::endl;
+            }
+        }
+    }
+    // El fichero existe
+    else
+    {
+        // Carga los datos
+        if (options->console)
+        {
+            std::cout << "Reading file...!" << std::endl;
+        }
+        for (int i = 0; i < (int)cheevos.size(); ++i)
+        {
+            SDL_RWread(file, &cheevos[i].completed, sizeof(bool), 1);
+        }
+
+        // Cierra el fichero
+        SDL_RWclose(file);
+    }
+}
+
+// Guarda el estado de los logros en un fichero
+void Cheevos::saveToFile()
+{
+    // Abre el fichero en modo escritura
+    SDL_RWops *file = SDL_RWFromFile(this->file.c_str(), "w+b");
+    if (file != NULL)
+    {
+        // Guarda la información
+        for (int i = 0; i < (int)cheevos.size(); ++i)
+        {
+            SDL_RWwrite(file, &cheevos[i].completed, sizeof(bool), 1);
+        }
+
+        // Cierra el fichero
+        SDL_RWclose(file);
+    }
+    else
+    {
+        if (options->console)
+        {
+            std::cout << "Error: Unable to save file! " << SDL_GetError() << std::endl;
+        }
+    }
 }

source/cheevos.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <SDL2/SDL.h>
+#include "common/screen.h"
 #include "common/utils.h"
 #include <string>
 #include <vector>
@@ -7,21 +8,55 @@
 #ifndef CHEEVOS_H
 #define CHEEVOS_H
 
+struct cheevos_t
+{
+	int id;					 // Identificador del logro
+	std::string caption;	 // Texto con el nombre del logro
+	std::string description; // Texto que describe el logro
+	int icon;				 // Indice del icono a utilizar en la notificación
+	bool completed;			 // Indica si se ha obtenido el logro
+	bool valid;				 // Indica si se puede obtener el logro
+};
+
 class Cheevos
 {
 private:
 	// Punteros y objetos
-	options_t *options;
+	Screen *screen;		// Objeto encargado de dibujar en pantalla
+	options_t *options; // Puntero a las opciones del juego
 
 	// Variables
+	std::vector<cheevos_t> cheevos; // Listado de logros
+	bool enabled;					// Indica si los logros se pueden obtener
+	std::string file;				// Fichero done leer/almacenar el estado de los logros
 
+	// Inicializa los logros
+	void init();
+
+	// Busca un logro por id y devuelve el indice
+	int find(int id);
+
+	// Carga el estado de los logros desde un fichero
+	void loadFromFile();
+
+	// Guarda el estado de los logros en un fichero
+	void saveToFile();
 
 public:
 	// Constructor
-	Cheevos(options_t *options);
+	Cheevos(Screen *screen, options_t *options, std::string file);
 
 	// Destructor
 	~Cheevos();
+
+	// Desbloquea un logro
+	void unlock(int id);
+
+	// Invalida un logro
+	void invalidate(int id);
+
+	// Habilita o deshabilita los logros
+	void enable(bool value);
 };
 
 #endif

source/common/animatedsprite.cpp

@@ -222,121 +222,121 @@ int AnimatedSprite::getIndex(std::string name)
 // Calcula el frame correspondiente a la animación
 void AnimatedSprite::animate()
 {
-	if (!enabled || animation.at(currentAnimation).speed == 0)
+	if (!enabled || animation[currentAnimation].speed == 0)
 	{
 		return;
 	}
 
 	// Calcula el frame actual a partir del contador
-	animation.at(currentAnimation).currentFrame = animation.at(currentAnimation).counter / animation.at(currentAnimation).speed;
+	animation[currentAnimation].currentFrame = animation[currentAnimation].counter / animation[currentAnimation].speed;
 
 	// Si alcanza el final de la animación, reinicia el contador de la animación
 	// en función de la variable loop y coloca el nuevo frame
-	if (animation.at(currentAnimation).currentFrame >= (int)animation.at(currentAnimation).frames.size())
+	if (animation[currentAnimation].currentFrame >= (int)animation[currentAnimation].frames.size())
 	{
-		if (animation.at(currentAnimation).loop == -1)
+		if (animation[currentAnimation].loop == -1)
 		{ // Si no hay loop, deja el último frame
-			animation.at(currentAnimation).currentFrame = animation.at(currentAnimation).frames.size();
-			animation.at(currentAnimation).completed = true;
+			animation[currentAnimation].currentFrame = animation[currentAnimation].frames.size();
+			animation[currentAnimation].completed = true;
 		}
 		else
 		{ // Si hay loop, vuelve al frame indicado
-			animation.at(currentAnimation).counter = 0;
-			animation.at(currentAnimation).currentFrame = animation.at(currentAnimation).loop;
+			animation[currentAnimation].counter = 0;
+			animation[currentAnimation].currentFrame = animation[currentAnimation].loop;
 		}
 	}
 	// En caso contrario
 	else
 	{
 		// Escoge el frame correspondiente de la animación
-		setSpriteClip(animation.at(currentAnimation).frames.at(animation.at(currentAnimation).currentFrame));
+		setSpriteClip(animation[currentAnimation].frames[animation[currentAnimation].currentFrame]);
 
 		// Incrementa el contador de la animacion
-		animation.at(currentAnimation).counter++;
+		animation[currentAnimation].counter++;
 	}
 }
 
 // Obtiene el numero de frames de la animación actual
 int AnimatedSprite::getNumFrames()
 {
-	return (int)animation.at(currentAnimation).frames.size();
+	return (int)animation[currentAnimation].frames.size();
 }
 
 // Establece el frame actual de la animación
 void AnimatedSprite::setCurrentFrame(int num)
 {
 	// Descarta valores fuera de rango
-	if (num >= (int)animation.at(currentAnimation).frames.size())
+	if (num >= (int)animation[currentAnimation].frames.size())
 	{
 		num = 0;
 	}
 
 	// Cambia el valor de la variable
-	animation.at(currentAnimation).currentFrame = num;
-	animation.at(currentAnimation).counter = 0;
+	animation[currentAnimation].currentFrame = num;
+	animation[currentAnimation].counter = 0;
 
 	// Escoge el frame correspondiente de la animación
-	setSpriteClip(animation.at(currentAnimation).frames.at(animation.at(currentAnimation).currentFrame));
+	setSpriteClip(animation[currentAnimation].frames[animation[currentAnimation].currentFrame]);
 }
 
 // Establece el valor del contador
 void AnimatedSprite::setAnimationCounter(std::string name, int num)
 {
-	animation.at(getIndex(name)).counter = num;
+	animation[getIndex(name)].counter = num;
 }
 
 // Establece la velocidad de una animación
 void AnimatedSprite::setAnimationSpeed(std::string name, int speed)
 {
-	animation.at(getIndex(name)).counter = speed;
+	animation[getIndex(name)].counter = speed;
 }
 
 // Establece la velocidad de una animación
 void AnimatedSprite::setAnimationSpeed(int index, int speed)
 {
-	animation.at(index).counter = speed;
+	animation[index].counter = speed;
 }
 
 // Establece si la animación se reproduce en bucle
 void AnimatedSprite::setAnimationLoop(std::string name, int loop)
 {
-	animation.at(getIndex(name)).loop = loop;
+	animation[getIndex(name)].loop = loop;
 }
 
 // Establece si la animación se reproduce en bucle
 void AnimatedSprite::setAnimationLoop(int index, int loop)
 {
-	animation.at(index).loop = loop;
+	animation[index].loop = loop;
 }
 
 // Establece el valor de la variable
 void AnimatedSprite::setAnimationCompleted(std::string name, bool value)
 {
-	animation.at(getIndex(name)).completed = value;
+	animation[getIndex(name)].completed = value;
 }
 
 // OLD - Establece el valor de la variable
 void AnimatedSprite::setAnimationCompleted(int index, bool value)
 {
-	animation.at(index).completed = value;
+	animation[index].completed = value;
 }
 
 // Comprueba si ha terminado la animación
 bool AnimatedSprite::animationIsCompleted()
 {
-	return animation.at(currentAnimation).completed;
+	return animation[currentAnimation].completed;
 }
 
 // Devuelve el rectangulo de una animación y frame concreto
 SDL_Rect AnimatedSprite::getAnimationClip(std::string name, Uint8 index)
 {
-	return animation.at(getIndex(name)).frames.at(index);
+	return animation[getIndex(name)].frames[index];
 }
 
 // Devuelve el rectangulo de una animación y frame concreto
 SDL_Rect AnimatedSprite::getAnimationClip(int indexA, Uint8 indexF)
 {
-	return animation.at(indexA).frames.at(indexF);
+	return animation[indexA].frames[indexF];
 }
 
 // Carga la animación desde un vector
@@ -484,9 +484,9 @@ void AnimatedSprite::setCurrentAnimation(std::string name)
 	if (currentAnimation != newAnimation)
 	{
 		currentAnimation = newAnimation;
-		animation.at(currentAnimation).currentFrame = 0;
-		animation.at(currentAnimation).counter = 0;
-		animation.at(currentAnimation).completed = false;
+		animation[currentAnimation].currentFrame = 0;
+		animation[currentAnimation].counter = 0;
+		animation[currentAnimation].completed = false;
 	}
 }
 
@@ -497,9 +497,9 @@ void AnimatedSprite::setCurrentAnimation(int index)
 	if (currentAnimation != newAnimation)
 	{
 		currentAnimation = newAnimation;
-		animation.at(currentAnimation).currentFrame = 0;
-		animation.at(currentAnimation).counter = 0;
-		animation.at(currentAnimation).completed = false;
+		animation[currentAnimation].currentFrame = 0;
+		animation[currentAnimation].counter = 0;
+		animation[currentAnimation].completed = false;
 	}
 }
 
@@ -513,7 +513,7 @@ void AnimatedSprite::update()
 // Establece el rectangulo para un frame de una animación
 void AnimatedSprite::setAnimationFrames(Uint8 index_animation, Uint8 index_frame, int x, int y, int w, int h)
 {
-	animation.at(index_animation).frames.push_back({x, y, w, h});
+	animation[index_animation].frames.push_back({x, y, w, h});
 }
 
 // OLD - Establece el contador para todas las animaciones
@@ -528,7 +528,7 @@ void AnimatedSprite::setAnimationCounter(int value)
 // Reinicia la animación
 void AnimatedSprite::resetAnimation()
 {
-	animation.at(currentAnimation).currentFrame = 0;
-	animation.at(currentAnimation).counter = 0;
-	animation.at(currentAnimation).completed = false;
+	animation[currentAnimation].currentFrame = 0;
+	animation[currentAnimation].counter = 0;
+	animation[currentAnimation].completed = false;
 }

source/common/input.cpp

@@ -11,12 +11,12 @@ Input::Input(std::string file)
 	keyBindings_t kb;
 	kb.scancode = 0;
 	kb.active = false;
-	keyBindings.resize(17, kb);
+	keyBindings.resize(input_number_of_inputs, kb);
 
 	GameControllerBindings_t gcb;
 	gcb.button = SDL_CONTROLLER_BUTTON_INVALID;
 	gcb.active = false;
-	gameControllerBindings.resize(17, gcb);
+	gameControllerBindings.resize(input_number_of_inputs, gcb);
 
 	verbose = true;
 	enabled = true;
@@ -34,13 +34,13 @@ void Input::update()
 // Asigna inputs a teclas
 void Input::bindKey(Uint8 input, SDL_Scancode code)
 {
-	keyBindings.at(input).scancode = code;
+	keyBindings[input].scancode = code;
 }
 
 // Asigna inputs a botones del mando
 void Input::bindGameControllerButton(Uint8 input, SDL_GameControllerButton button)
 {
-	gameControllerBindings.at(input).button = button;
+	gameControllerBindings[input].button = button;
 }
 
 // Comprueba si un input esta activo
@@ -65,7 +65,7 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 
 		if (repeat)
 		{
-			if (keyStates[keyBindings.at(input).scancode] != 0)
+			if (keyStates[keyBindings[input].scancode] != 0)
 			{
 				successKeyboard = true;
 			}
@@ -76,11 +76,11 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 		}
 		else
 		{
-			if (!keyBindings.at(input).active)
+			if (!keyBindings[input].active)
 			{
-				if (keyStates[keyBindings.at(input).scancode] != 0)
+				if (keyStates[keyBindings[input].scancode] != 0)
 				{
-					keyBindings.at(input).active = true;
+					keyBindings[input].active = true;
 					successKeyboard = true;
 				}
 				else
@@ -90,9 +90,9 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 			}
 			else
 			{
-				if (keyStates[keyBindings.at(input).scancode] == 0)
+				if (keyStates[keyBindings[input].scancode] == 0)
 				{
-					keyBindings.at(input).active = false;
+					keyBindings[input].active = false;
 					successKeyboard = false;
 				}
 				else
@@ -108,7 +108,7 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 		{
 			if (repeat)
 			{
-				if (SDL_GameControllerGetButton(connectedControllers.at(index), gameControllerBindings.at(input).button) != 0)
+				if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[input].button) != 0)
 				{
 					successGameController = true;
 				}
@@ -119,11 +119,11 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 			}
 			else
 			{
-				if (!gameControllerBindings.at(input).active)
+				if (!gameControllerBindings[input].active)
 				{
-					if (SDL_GameControllerGetButton(connectedControllers.at(index), gameControllerBindings.at(input).button) != 0)
+					if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[input].button) != 0)
 					{
-						gameControllerBindings.at(input).active = true;
+						gameControllerBindings[input].active = true;
 						successGameController = true;
 					}
 					else
@@ -133,9 +133,9 @@ bool Input::checkInput(Uint8 input, bool repeat, int device, int index)
 				}
 				else
 				{
-					if (SDL_GameControllerGetButton(connectedControllers.at(index), gameControllerBindings.at(input).button) == 0)
+					if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[input].button) == 0)
 					{
-						gameControllerBindings.at(input).active = false;
+						gameControllerBindings[input].active = false;
 						successGameController = false;
 					}
 					else
@@ -163,7 +163,7 @@ bool Input::checkAnyInput(int device, int index)
 
 		for (int i = 0; i < (int)keyBindings.size(); ++i)
 		{
-			if (mKeystates[keyBindings.at(i).scancode] != 0)
+			if (mKeystates[keyBindings[i].scancode] != 0)
 			{
 				return true;
 			}
@@ -176,7 +176,7 @@ bool Input::checkAnyInput(int device, int index)
 		{
 			for (int i = 0; i < (int)gameControllerBindings.size(); ++i)
 			{
-				if (SDL_GameControllerGetButton(connectedControllers.at(index), gameControllerBindings.at(i).button) != 0)
+				if (SDL_GameControllerGetButton(connectedControllers[index], gameControllerBindings[i].button) != 0)
 				{
 					return true;
 				}
@@ -277,7 +277,7 @@ std::string Input::getControllerName(int index)
 {
 	if (numGamepads > 0)
 	{
-		return controllerNames.at(index);
+		return controllerNames[index];
 	}
 	else
 	{

source/common/input.h

@@ -7,23 +7,31 @@
 #ifndef INPUT_H
 #define INPUT_H
 
-#define INPUT_NULL 0
-#define INPUT_UP 1
-#define INPUT_DOWN 2
-#define INPUT_LEFT 3
-#define INPUT_RIGHT 4
-#define INPUT_ACCEPT 5
-#define INPUT_CANCEL 6
-#define INPUT_BUTTON_1 7
-#define INPUT_BUTTON_2 8
-#define INPUT_BUTTON_3 9
-#define INPUT_BUTTON_4 10
-#define INPUT_BUTTON_5 11
-#define INPUT_BUTTON_6 12
-#define INPUT_BUTTON_7 13
-#define INPUT_BUTTON_8 14
-#define INPUT_BUTTON_PAUSE 15
-#define INPUT_BUTTON_ESCAPE 16
+enum inputs_e
+{
+	// Inputs obligatorios
+	input_null,
+	input_up,
+	input_down,
+	input_left,
+	input_right,
+	input_pause,
+	input_exit,
+	input_accept,
+	input_cancel,
+
+	// Inputs personalizados
+	input_jump,
+	input_window_fullscreen,
+	input_window_inc_size,
+	input_window_dec_size,
+	input_toggle_border,
+	input_switch_music,
+	input_swap_palette,
+
+	// Input obligatorio
+	input_number_of_inputs
+};
 
 #define REPEAT_TRUE true
 #define REPEAT_FALSE false
@@ -81,7 +89,7 @@ public:
 	void bindGameControllerButton(Uint8 input, SDL_GameControllerButton button);
 
 	// 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 = true, int device = INPUT_USE_ANY, int index = 0);
 
 	// Comprueba si hay almenos un input activo
 	bool checkAnyInput(int device = INPUT_USE_ANY, int index = 0);

source/common/jail_audio.cpp

@@ -1,3 +1,4 @@
+#ifndef JA_USESDLMIXER
 #include "jail_audio.h"
 #include "stb_vorbis.c"
 #include <SDL2/SDL.h>
@@ -11,7 +12,7 @@ struct JA_Sound_t {
 };
 
 struct JA_Channel_t {
-    JA_Sound            sound;
+    JA_Sound_t          *sound;
     int                 pos {0};
     int                 times {0};
     JA_Channel_state    state { JA_CHANNEL_FREE };
@@ -25,7 +26,7 @@ struct JA_Music_t {
     JA_Music_state  state {JA_MUSIC_INVALID};
 };
 
-JA_Music        current_music{NULL};
+JA_Music_t      *current_music{NULL};
 JA_Channel_t    channels[JA_MAX_SIMULTANEOUS_CHANNELS];
 
 int             JA_freq {48000};
@@ -86,7 +87,7 @@ void JA_Quit() {
     sdlAudioDevice = 0;
 }
 
-JA_Music JA_LoadMusic(const char* filename) {
+JA_Music_t *JA_LoadMusic(const char* filename) {
     int chan, samplerate;
 
     // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
@@ -98,7 +99,7 @@ JA_Music JA_LoadMusic(const char* filename) {
     if (fread(buffer, fsize, 1, f)!=1) return NULL;
     fclose(f);
 
-    JA_Music music = new JA_Music_t();
+    JA_Music_t *music = new JA_Music_t();
 
     music->samples = stb_vorbis_decode_memory(buffer, fsize, &chan, &samplerate, &music->output);
     free(buffer);
@@ -121,7 +122,7 @@ JA_Music JA_LoadMusic(const char* filename) {
     return music;
 }
 
-void JA_PlayMusic(JA_Music music, const int loop) {
+void JA_PlayMusic(JA_Music_t *music, const int loop) {
     if (current_music != NULL) {
         current_music->pos = 0;
         current_music->state = JA_MUSIC_STOPPED;
@@ -153,21 +154,21 @@ JA_Music_state JA_GetMusicState() {
     return current_music->state;
 }
 
-void JA_DeleteMusic(JA_Music music) {
+void JA_DeleteMusic(JA_Music_t *music) {
     if (current_music == music) current_music = NULL;
     free(music->output);
     delete music;
 }
 
-JA_Sound JA_NewSound(Uint8* buffer, Uint32 length) {
-    JA_Sound sound = new JA_Sound_t();
+JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
+    JA_Sound_t *sound = new JA_Sound_t();
     sound->buffer = buffer;
     sound->length = length;
     return sound;
 }
 
-JA_Sound JA_LoadSound(const char* filename) {
-    JA_Sound sound = new JA_Sound_t();
+JA_Sound_t *JA_LoadSound(const char* filename) {
+    JA_Sound_t *sound = new JA_Sound_t();
     SDL_AudioSpec wavSpec;
     SDL_LoadWAV(filename, &wavSpec, &sound->buffer, &sound->length);
 
@@ -184,7 +185,7 @@ JA_Sound JA_LoadSound(const char* filename) {
     return sound;
 }
 
-int JA_PlaySound(JA_Sound sound, const int loop) {
+int JA_PlaySound(JA_Sound_t *sound, const int loop) {
     int channel = 0;
     while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
     if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) channel = 0;
@@ -196,7 +197,7 @@ int JA_PlaySound(JA_Sound sound, const int loop) {
     return channel;
 }
 
-void JA_DeleteSound(JA_Sound sound) {
+void JA_DeleteSound(JA_Sound_t *sound) {
     for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
         if (channels[i].sound == sound) JA_StopChannel(i);
     }
@@ -246,4 +247,5 @@ JA_Channel_state JA_GetChannelState(const int channel) {
 int JA_SetVolume(int volume) {
     JA_volume = volume > 128 ? 128 : volume < 0 ? 0 : volume;
     return JA_volume;
-}
+}
+#endif

source/common/jail_audio.h

@@ -4,27 +4,27 @@
 enum JA_Channel_state { JA_CHANNEL_INVALID, JA_CHANNEL_FREE, JA_CHANNEL_PLAYING, JA_CHANNEL_PAUSED };
 enum JA_Music_state { JA_MUSIC_INVALID, JA_MUSIC_PLAYING, JA_MUSIC_PAUSED, JA_MUSIC_STOPPED };
 
-typedef struct JA_Sound_t *JA_Sound;
-typedef struct JA_Music_t *JA_Music;
+struct JA_Sound_t;
+struct JA_Music_t;
 
 void JA_Init(const int freq, const SDL_AudioFormat format, const int channels);
 void JA_Quit();
 
-JA_Music JA_LoadMusic(const char* filename);
-void JA_PlayMusic(JA_Music music, const int loop = -1);
+JA_Music_t *JA_LoadMusic(const char* filename);
+void JA_PlayMusic(JA_Music_t *music, const int loop = -1);
 void JA_PauseMusic();
 void JA_ResumeMusic();
 void JA_StopMusic();
 JA_Music_state JA_GetMusicState();
-void JA_DeleteMusic(JA_Music music);
+void JA_DeleteMusic(JA_Music_t *music);
 
-JA_Sound JA_NewSound(Uint8* buffer, Uint32 length);
-JA_Sound JA_LoadSound(const char* filename);
-int JA_PlaySound(JA_Sound sound, const int loop = 0);
+JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length);
+JA_Sound_t *JA_LoadSound(const char* filename);
+int JA_PlaySound(JA_Sound_t *sound, const int loop = 0);
 void JA_PauseChannel(const int channel);
 void JA_ResumeChannel(const int channel);
 void JA_StopChannel(const int channel);
 JA_Channel_state JA_GetChannelState(const int channel);
-void JA_DeleteSound(JA_Sound sound);
+void JA_DeleteSound(JA_Sound_t *sound);
 
 int JA_SetVolume(int volume);

source/common/jail_audio_sdlmixer.cpp

@@ -0,0 +1,101 @@
+#ifdef JA_USESDLMIXER
+#include "jail_audio.h"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_mixer.h>
+#include <stdio.h>
+
+struct JA_Sound_t {}; // Dummy structs
+struct JA_Music_t {};
+
+int             JA_freq {48000};
+SDL_AudioFormat JA_format {AUDIO_S16};
+Uint8           JA_channels {2};
+
+void JA_Init(const int freq, const SDL_AudioFormat format, const int channels) {
+    JA_freq = freq;
+    JA_format = format;
+    JA_channels = channels;
+    Mix_OpenAudio(JA_freq, JA_format, JA_channels, 1024);
+}
+
+void JA_Quit() {
+    Mix_CloseAudio();
+}
+
+JA_Music_t *JA_LoadMusic(const char* filename) {
+    return (JA_Music_t*)Mix_LoadMUS(filename);
+}
+
+void JA_PlayMusic(JA_Music_t *music, const int loop) {
+    Mix_PlayMusic((Mix_Music*)music, loop);
+}
+
+void JA_PauseMusic() {
+    Mix_PauseMusic();
+}
+
+void JA_ResumeMusic() {
+    Mix_ResumeMusic();
+}
+
+void JA_StopMusic() {
+    Mix_HaltMusic();
+}
+
+JA_Music_state JA_GetMusicState() {
+    if (Mix_PausedMusic()) {
+        return JA_MUSIC_PAUSED;
+    } else if (Mix_PlayingMusic()) {
+        return JA_MUSIC_PLAYING;
+    } else {
+        return JA_MUSIC_STOPPED;
+    }
+}
+
+void JA_DeleteMusic(JA_Music_t *music) {
+    Mix_FreeMusic((Mix_Music*)music);
+}
+
+JA_Sound_t *JA_NewSound(Uint8* buffer, Uint32 length) {
+    return NULL;
+}
+
+JA_Sound_t *JA_LoadSound(const char* filename) {
+    JA_Sound_t *sound = (JA_Sound_t*)Mix_LoadWAV(filename);
+    return sound;
+}
+
+int JA_PlaySound(JA_Sound_t *sound, const int loop) {
+    return Mix_PlayChannel(-1, (Mix_Chunk*)sound, loop);
+}
+
+void JA_DeleteSound(JA_Sound_t *sound) {
+    Mix_FreeChunk((Mix_Chunk*)sound);
+}
+
+void JA_PauseChannel(const int channel) {
+    Mix_Pause(channel);
+}
+
+void JA_ResumeChannel(const int channel) {
+    Mix_Resume(channel);
+}
+
+void JA_StopChannel(const int channel) {
+    Mix_HaltChannel(channel);
+}
+
+JA_Channel_state JA_GetChannelState(const int channel) {
+    if (Mix_Paused(channel)) {
+        return JA_CHANNEL_PAUSED;
+    } else if (Mix_Playing(channel)) {
+        return JA_CHANNEL_PLAYING;
+    } else {
+        return JA_CHANNEL_FREE;
+    }
+}
+
+int JA_SetVolume(int volume) {
+    return Mix_Volume(-1, volume);
+}
+#endif

source/common/menu.cpp

@@ -458,7 +458,7 @@ void Menu::setSelectorPos(int index)
 	if (index < (int)item.size())
 	{
 		selector.index = index;
-		selector.rect.y = selector.y = selector.originY = selector.targetY = item.at(selector.index).rect.y;
+		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);
@@ -486,13 +486,13 @@ void Menu::reset()
 {
 	itemSelected = MENU_NO_OPTION;
 	selector.index = 0;
-	selector.originY = selector.targetY = selector.y = item.at(0).rect.y;
-	selector.originH = selector.targetH = item.at(0).rect.h;
+	selector.originY = selector.targetY = selector.y = item[0].rect.y;
+	selector.originH = selector.targetH = item[0].rect.h;
 	selector.moving = false;
 	selector.resizing = false;
 
 	// Si el primer elemento no es seleccionable, incrementa el selector
-	if (!item.at(selector.index).selectable)
+	if (!item[selector.index].selectable)
 	{
 		increaseSelectorIndex();
 		setSelectorPos(selector.index);
@@ -524,18 +524,18 @@ void Menu::reorganize()
 bool Menu::increaseSelectorIndex()
 {
 	// Obten las coordenadas del elemento actual
-	selector.y = selector.originY = item.at(selector.index).rect.y;
+	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.at(selector.index).selectable)
+	while (!item[selector.index].selectable)
 	{
 		++selector.index %= item.size();
 	}
 
 	// Establece las coordenadas y altura de destino
-	selector.targetY = item.at(selector.index).rect.y;
+	selector.targetY = item[selector.index].rect.y;
 	selector.despY = (selector.targetY - selector.originY) / selector.numJumps;
 
 	selector.targetH = getSelectorHeight(selector.index);
@@ -554,7 +554,7 @@ bool Menu::increaseSelectorIndex()
 bool Menu::decreaseSelectorIndex()
 {
 	// Obten las coordenadas del elemento actual
-	selector.y = selector.originY = item.at(selector.index).rect.y;
+	selector.y = selector.originY = item[selector.index].rect.y;
 	selector.h = selector.originH = getSelectorHeight(selector.index);
 
 	// Calcula cual es el siguiente elemento
@@ -567,7 +567,7 @@ bool Menu::decreaseSelectorIndex()
 		selector.index--;
 	}
 
-	while (!item.at(selector.index).selectable)
+	while (!item[selector.index].selectable)
 	{
 		if (selector.index == 0)
 		{
@@ -580,7 +580,7 @@ bool Menu::decreaseSelectorIndex()
 	}
 
 	// Establece las coordenadas y altura de destino
-	selector.targetY = item.at(selector.index).rect.y;
+	selector.targetY = item[selector.index].rect.y;
 	selector.despY = (selector.targetY - selector.originY) / selector.numJumps;
 
 	selector.targetH = getSelectorHeight(selector.index);
@@ -630,29 +630,29 @@ void Menu::render()
 		if (i == selector.index)
 		{
 			const color_t color = {selector.itemColor.r, selector.itemColor.g, selector.itemColor.b};
-			text->writeColored(item.at(i).rect.x, item.at(i).rect.y, item.at(i).label, color);
+			text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, color);
 		}
 
-		else if (item.at(i).selectable)
+		else if (item[i].selectable)
 		{
-			text->write(item.at(i).rect.x, item.at(i).rect.y, item.at(i).label);
+			text->write(item[i].rect.x, item[i].rect.y, item[i].label);
 		}
 
-		else if (item.at(i).greyed)
+		else if (item[i].greyed)
 		{
-			text->writeColored(item.at(i).rect.x, item.at(i).rect.y, item.at(i).label, colorGreyed);
+			text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, colorGreyed);
 		}
 
 		else
 		{ // No seleccionable
-			if ((item.at(i).linkedUp) && (i == selector.index + 1))
+			if ((item[i].linkedUp) && (i == selector.index + 1))
 			{
 				const color_t color = {selector.itemColor.r, selector.itemColor.g, selector.itemColor.b};
-				text->writeColored(item.at(i).rect.x, item.at(i).rect.y, item.at(i).label, color);
+				text->writeColored(item[i].rect.x, item[i].rect.y, item[i].label, color);
 			}
 			else // No enlazado con el de arriba
 			{
-				text->write(item.at(i).rect.x, item.at(i).rect.y, item.at(i).label);
+				text->write(item[i].rect.x, item[i].rect.y, item[i].label);
 			}
 		}
 	}
@@ -822,7 +822,7 @@ void Menu::addItem(std::string text, int hPaddingDown, bool selectable, bool gre
 
 	if (item.size() > 1)
 	{
-		if (item.at(item.size() - 2).linkedDown)
+		if (item[item.size() - 2].linkedDown)
 		{
 			item.back().linkedUp = true;
 		}
@@ -835,9 +835,9 @@ void Menu::addItem(std::string text, int hPaddingDown, bool selectable, bool gre
 // Cambia el texto de un item
 void Menu::setItemCaption(int index, std::string text)
 {
-	item.at(index).label = text;
-	item.at(index).rect.w = this->text->lenght(item.at(index).label);
-	item.at(index).rect.h = this->text->getCharacterSize();
+	item[index].label = text;
+	item[index].rect.w = this->text->lenght(item[index].label);
+	item[index].rect.h = this->text->getCharacterSize();
 	reorganize();
 }
 
@@ -850,7 +850,7 @@ void Menu::setDefaultActionWhenCancel(int item)
 // Gestiona la entrada de teclado y mando durante el menu
 void Menu::checkInput()
 {
-	if (input->checkInput(INPUT_UP, REPEAT_FALSE))
+	if (input->checkInput(input_up, REPEAT_FALSE))
 	{
 		if (decreaseSelectorIndex())
 		{
@@ -861,7 +861,7 @@ void Menu::checkInput()
 		}
 	}
 
-	if (input->checkInput(INPUT_DOWN, REPEAT_FALSE))
+	if (input->checkInput(input_down, REPEAT_FALSE))
 	{
 		if (increaseSelectorIndex())
 		{
@@ -872,7 +872,7 @@ void Menu::checkInput()
 		}
 	}
 
-	if (input->checkInput(INPUT_ACCEPT, REPEAT_FALSE))
+	if (input->checkInput(input_accept, REPEAT_FALSE))
 	{
 		itemSelected = selector.index;
 		if (soundAccept)
@@ -881,7 +881,7 @@ void Menu::checkInput()
 		}
 	}
 
-	if (input->checkInput(INPUT_CANCEL, REPEAT_FALSE))
+	if (input->checkInput(input_cancel, REPEAT_FALSE))
 	{
 		itemSelected = defaultActionWhenCancel;
 		if (soundCancel)
@@ -914,42 +914,42 @@ int Menu::findHeight()
 // Recoloca los elementos del menu en el eje Y
 void Menu::replaceElementsOnY()
 {
-	item.at(0).rect.y = y;
+	item[0].rect.y = y;
 
 	for (int i = 1; i < (int)item.size(); i++)
 	{
-		item.at(i).rect.y = item.at(i - 1).rect.y + item.at(i - 1).rect.h + item.at(i - 1).hPaddingDown;
+		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.at(index).selectable = value;
+	item[index].selectable = value;
 }
 
 // Establece el estado agrisado de un item
 void Menu::setGreyed(int index, bool value)
 {
-	item.at(index).greyed = value;
+	item[index].greyed = value;
 }
 
 // Establece el estado de enlace de un item
 void Menu::setLinkedDown(int index, bool value)
 {
-	item.at(index).linkedDown = value;
+	item[index].linkedDown = value;
 }
 
 // Calcula la altura del selector
 int Menu::getSelectorHeight(int value)
 {
-	if (item.at(value).linkedDown)
+	if (item[value].linkedDown)
 	{
-		return item.at(value).rect.h + item.at(value).hPaddingDown + item.at(value + 1).rect.h;
+		return item[value].rect.h + item[value].hPaddingDown + item[value + 1].rect.h;
 	}
 	else
 	{
-		return item.at(value).rect.h;
+		return item[value].rect.h;
 	}
 }
 

source/common/menu.h

@@ -91,9 +91,9 @@ private:
 	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
+	JA_Sound_t* soundAccept;		 // Sonido al aceptar o elegir una opción del menu
+	JA_Sound_t* soundCancel;		 // Sonido al cancelar el menu
+	JA_Sound_t* soundMove;			 // Sonido al mover el selector
 	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

source/common/notify.cpp

@@ -4,7 +4,7 @@
 #include <iostream>
 
 // Constructor
-Notify::Notify(SDL_Renderer *renderer, std::string bitmapFile, std::string textFile, std::string soundFile, options_t *options)
+Notify::Notify(SDL_Renderer *renderer, std::string iconFile, std::string bitmapFile, std::string textFile, std::string soundFile, options_t *options)
 {
     // Inicializa variables
     this->renderer = renderer;
@@ -13,8 +13,9 @@ Notify::Notify(SDL_Renderer *renderer, std::string bitmapFile, std::string textF
     waitTime = 300;
 
     // Crea objetos
-    texture = new Texture(renderer, bitmapFile);
-    text = new Text(textFile, texture, renderer);
+    iconTexture = new Texture(renderer, iconFile);
+    textTexture = new Texture(renderer, bitmapFile);
+    text = new Text(textFile, textTexture, renderer);
     sound = JA_LoadSound(soundFile.c_str());
 }
 
@@ -22,7 +23,8 @@ Notify::Notify(SDL_Renderer *renderer, std::string bitmapFile, std::string textF
 Notify::~Notify()
 {
     // Libera la memoria de los objetos
-    delete texture;
+    delete textTexture;
+    delete iconTexture;
     delete text;
     JA_DeleteSound(sound);
 
@@ -38,7 +40,7 @@ void Notify::render()
 {
     for (int i = (int)notifications.size() - 1; i >= 0; --i)
     {
-        notifications.at(i).sprite->render();
+        notifications[i].sprite->render();
     }
 }
 
@@ -47,63 +49,63 @@ void Notify::update()
 {
     for (int i = 0; i < (int)notifications.size(); ++i)
     {
-        notifications.at(i).counter++;
+        notifications[i].counter++;
 
         // Comprueba los estados
-        if (notifications.at(i).state == ns_rising)
+        if (notifications[i].state == ns_rising)
         {
-            const float step = ((float)notifications.at(i).counter / notifications.at(i).travelDist);
+            const float step = ((float)notifications[i].counter / notifications[i].travelDist);
             const int alpha = 255 * step;
 
             if (options->notifications.posV == pos_top)
             {
-                notifications.at(i).rect.y++;
+                notifications[i].rect.y++;
             }
             else
             {
-                notifications.at(i).rect.y--;
+                notifications[i].rect.y--;
             }
-            notifications.at(i).texture->setAlpha(alpha);
+            notifications[i].texture->setAlpha(alpha);
 
-            if (notifications.at(i).rect.y == notifications.at(i).y)
+            if (notifications[i].rect.y == notifications[i].y)
             {
-                notifications.at(i).state = ns_stay;
-                notifications.at(i).texture->setAlpha(255);
-                notifications.at(i).counter = 0;
+                notifications[i].state = ns_stay;
+                notifications[i].texture->setAlpha(255);
+                notifications[i].counter = 0;
             }
         }
 
-        else if (notifications.at(i).state == ns_stay)
+        else if (notifications[i].state == ns_stay)
         {
-            if (notifications.at(i).counter == waitTime)
+            if (notifications[i].counter == waitTime)
             {
-                notifications.at(i).state = ns_vanishing;
-                notifications.at(i).counter = 0;
+                notifications[i].state = ns_vanishing;
+                notifications[i].counter = 0;
             }
         }
-        else if (notifications.at(i).state == ns_vanishing)
+        else if (notifications[i].state == ns_vanishing)
         {
 
-            const float step = (notifications.at(i).counter / (float)notifications.at(i).travelDist);
+            const float step = (notifications[i].counter / (float)notifications[i].travelDist);
             const int alpha = 255 * (1 - step);
 
             if (options->notifications.posV == pos_top)
             {
-                notifications.at(i).rect.y--;
+                notifications[i].rect.y--;
             }
             else
             {
-                notifications.at(i).rect.y++;
+                notifications[i].rect.y++;
             }
-            notifications.at(i).texture->setAlpha(alpha);
+            notifications[i].texture->setAlpha(alpha);
 
-            if (notifications.at(i).rect.y == notifications.at(i).y - notifications.at(i).travelDist)
+            if (notifications[i].rect.y == notifications[i].y - notifications[i].travelDist)
             {
-                notifications.at(i).state = ns_finished;
+                notifications[i].state = ns_finished;
             }
         }
 
-        notifications.at(i).sprite->setRect(notifications.at(i).rect);
+        notifications[i].sprite->setRect(notifications[i].rect);
     }
 
     clearFinishedNotifications();
@@ -114,22 +116,25 @@ void Notify::clearFinishedNotifications()
 {
     for (int i = (int)notifications.size() - 1; i >= 0; --i)
     {
-        if (notifications.at(i).state == ns_finished)
+        if (notifications[i].state == ns_finished)
         {
-            delete notifications.at(i).sprite;
-            delete notifications.at(i).texture;
+            delete notifications[i].sprite;
+            delete notifications[i].texture;
             notifications.erase(notifications.begin() + i);
         }
     }
 }
 
 // Muestra una notificación de texto por pantalla;
-void Notify::showText(std::string text)
+void Notify::showText(std::string text1, std::string text2, int icon)
 {
     // Inicializa variables
-    const int width = this->text->lenght(text) + (this->text->getCharacterSize() * 2);
-    const int height = this->text->getCharacterSize() * 2;
-    const int padding = (this->text->getCharacterSize() / 2);
+    const int iconSize = 16;
+    const int padding = text->getCharacterSize();
+    const int iconSpace = icon >= 0 ? iconSize + padding : 0;
+    const std::string txt = text1.length() > text2.length() ? text1 : text2;
+    const int width = text->lenght(txt) + (padding * 2) + iconSpace;
+    const int height = (text->getCharacterSize() * 2) + (padding * 2);
 
     // Posición horizontal
     int despH = 0;
@@ -178,7 +183,8 @@ void Notify::showText(std::string text)
     n.travelDist = travelDist;
     n.counter = 0;
     n.state = ns_rising;
-    n.text = text;
+    n.text1 = text1;
+    n.text2 = text2;
     if (options->notifications.posV == pos_top)
     {
         n.rect = {despH, offset - travelDist, width, height};
@@ -191,14 +197,52 @@ void Notify::showText(std::string text)
     // Crea la textura
     n.texture = new Texture(renderer);
     n.texture->createBlank(renderer, width, height, SDL_TEXTUREACCESS_TARGET);
-    n.texture->setAsRenderTarget(renderer);
-    SDL_SetRenderDrawColor(renderer, bgColor.r, bgColor.g, bgColor.b, 255);
-    SDL_RenderClear(renderer);
     n.texture->setBlendMode(SDL_BLENDMODE_BLEND);
-    this->text->writeDX(TXT_CENTER | TXT_STROKE, width / 2, padding, text, 1, {255, 255, 255}, 1, {0, 0, 0});
+
+    // Prepara para dibujar en la textura
+    n.texture->setAsRenderTarget(renderer);
+
+    // Dibuja el fondo de la notificación
+    SDL_SetRenderDrawColor(renderer, bgColor.r, bgColor.g, bgColor.b, 255);
+    SDL_Rect rect;
+    rect = {4, 0, width - (4 * 2), height};
+    SDL_RenderFillRect(renderer, &rect);
+
+    rect = {4 / 2, 1, width - 4, height - 2};
+    SDL_RenderFillRect(renderer, &rect);
+
+    rect = {1, 4 / 2, width - 2, height - 4};
+    SDL_RenderFillRect(renderer, &rect);
+
+    rect = {0, 4, width, height - (4 * 2)};
+    SDL_RenderFillRect(renderer, &rect);
+
+    // Dibuja el icono de la notificación
+    if (icon >= 0)
+    {
+        Sprite *sp = new Sprite({0, 0, iconSize, iconSize}, iconTexture, renderer);
+        sp->setPos({padding, padding, iconSize, iconSize});
+        sp->setSpriteClip({iconSize * (icon % 10), iconSize * (icon / 10), iconSize, iconSize});
+        sp->render();
+        delete sp;
+    }
+
+    // Escribe el texto de la notificación
+    color_t color = {255, 255, 255};
+    if (text2 != "")
+    { // Dos lineas de texto
+        text->writeColored(padding + iconSpace, padding, text1, color);
+        text->writeColored(padding + iconSpace, padding + text->getCharacterSize() + 1, text2, color);
+    }
+    else
+    { // Una linea de texto
+        text->writeColored(padding + iconSpace, (height / 2) - (text->getCharacterSize() / 2), text1, color);
+    }
+
+    // Deja de dibujar en la textura
     SDL_SetRenderTarget(renderer, nullptr);
 
-    // Crea el sprite
+    // Crea el sprite de la notificación
     n.sprite = new Sprite(n.rect, n.texture, renderer);
 
     // Añade la notificación a la lista

source/common/notify.h

@@ -36,7 +36,8 @@ private:
 
 	struct notification_t
 	{
-		std::string text;
+		std::string text1;
+		std::string text2;
 		int counter;
 		notification_state_e state;
 		notification_position_e position;
@@ -49,7 +50,8 @@ private:
 
 	// Objetos y punteros
 	SDL_Renderer *renderer; // El renderizador de la ventana
-	Texture *texture;		// Textura para la fuente de las notificaciones
+	Texture *textTexture;	// Textura para la fuente de las notificaciones
+	Texture *iconTexture;	// Textura para los iconos de las notificaciones
 	Text *text;				// Objeto para dibujar texto
 	options_t *options;		// Variable con todas las opciones del programa
 
@@ -57,7 +59,7 @@ private:
 	color_t bgColor;						   // Color de fondo de las notificaciones
 	int waitTime;							   // Tiempo que se ve la notificación
 	std::vector<notification_t> notifications; // La lista de notificaciones activas
-	JA_Sound sound;							   // Sonido a reproducir cuando suena la notificación
+	JA_Sound_t *sound;						   // Sonido a reproducir cuando suena la notificación
 
 	// Elimina las notificaciones finalizadas
 	void clearFinishedNotifications();
@@ -70,13 +72,13 @@ public:
 	void update();
 
 	// Constructor
-	Notify(SDL_Renderer *renderer, std::string bitmapFile, std::string textFile, std::string soundFile, options_t *options);
+	Notify(SDL_Renderer *renderer, std::string iconFile, std::string bitmapFile, std::string textFile, std::string soundFile, options_t *options);
 
 	// Destructor
 	~Notify();
 
 	// Muestra una notificación de texto por pantalla;
-	void showText(std::string text);
+	void showText(std::string text1 = "", std::string text2 = "", int icon = -1);
 
 	// Indica si hay notificaciones activas
 	bool active();

source/common/screen.cpp

@@ -12,7 +12,7 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, options
     this->asset = asset;
 
     // Crea los objetos
-    notify = new Notify(renderer, asset->get("smb2.png"), asset->get("smb2.txt"), asset->get("notify.wav"), options);
+    notify = new Notify(renderer, asset->get("notify.png"), asset->get("smb2.png"), asset->get("smb2.txt"), asset->get("notify.wav"), options);
 
     gameCanvasWidth = options->gameWidth;
     gameCanvasHeight = options->gameHeight;
@@ -48,6 +48,7 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, options
 Screen::~Screen()
 {
     delete notify;
+    SDL_DestroyTexture(gameCanvas);
 }
 
 // Limpia la pantalla
@@ -86,15 +87,18 @@ void Screen::blit()
 // Establece el modo de video
 void Screen::setVideoMode(int videoMode)
 {
-    // Muestra el puntero
-    SDL_ShowCursor(SDL_ENABLE);
-
     // Aplica el modo de video
     SDL_SetWindowFullscreen(window, videoMode);
 
     // Si está activo el modo ventana quita el borde
     if (videoMode == 0)
     {
+        // Muestra el puntero
+        SDL_ShowCursor(SDL_ENABLE);
+
+        // Esconde la ventana
+        //SDL_HideWindow(window);
+
         if (options->borderEnabled)
         {
             windowWidth = gameCanvasWidth + borderWidth;
@@ -109,9 +113,12 @@ void Screen::setVideoMode(int videoMode)
             dest = {0, 0, gameCanvasWidth, gameCanvasHeight};
         }
 
-        // Modifica el tamaño del renderizador y de la ventana
-        SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
+        // Modifica el tamaño de la ventana
         SDL_SetWindowSize(window, windowWidth * options->windowSize, windowHeight * options->windowSize);
+        SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+
+        // Muestra la ventana
+        //SDL_ShowWindow(window);
     }
 
     // Si está activo el modo de pantalla completa añade el borde
@@ -162,11 +169,11 @@ void Screen::setVideoMode(int videoMode)
             dest.h = windowHeight;
             dest.x = dest.y = 0;
         }
-
-        // Modifica el tamaño del renderizador
-        SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
     }
 
+    // Modifica el tamaño del renderizador
+    SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
+
     // Actualiza las opciones
     options->videoMode = videoMode;
     options->screen.windowWidth = windowWidth;
@@ -190,6 +197,22 @@ void Screen::setWindowSize(int size)
     setVideoMode(0);
 }
 
+// Reduce el tamaño de la ventana
+void Screen::decWindowSize()
+{
+    --options->windowSize;
+    options->windowSize = std::max(options->windowSize, 1);
+    setVideoMode(0);
+}
+
+// Aumenta el tamaño de la ventana
+void Screen::incWindowSize()
+{
+    ++options->windowSize;
+    options->windowSize = std::min(options->windowSize, 4);
+    setVideoMode(0);
+}
+
 // Cambia el color del borde
 void Screen::setBorderColor(color_t color)
 {
@@ -344,7 +367,7 @@ void Screen::renderSpectrumFade()
     const float step = (float)spectrumFadeCounter / (float)spectrumFadeLenght;
     const int max = spectrumColor.size() - 1;
     const int index = max + (0 - max) * step;
-    const color_t c = spectrumColor.at(index);
+    const color_t c = spectrumColor[index];
     SDL_SetTextureColorMod(gameCanvas, c.r, c.g, c.b);
 }
 
@@ -370,9 +393,9 @@ void Screen::updateNotifier()
 }
 
 // Muestra una notificación de texto por pantalla;
-void Screen::showNotification(std::string text)
+void Screen::showNotification(std::string text1, std::string text2, int icon)
 {
-    notify->showText(text);
+    notify->showText(text1, text2, icon);
 }
 
 // Dibuja las notificaciones

source/common/screen.h

@@ -4,6 +4,7 @@
 #include "asset.h"
 #include "notify.h"
 #include "utils.h"
+#include "../const.h"
 #include <vector>
 
 #ifndef SCREEN_H
@@ -94,6 +95,12 @@ public:
 	// Cambia el tamaño de la ventana
 	void setWindowSize(int size);
 
+	// Reduce el tamaño de la ventana
+	void decWindowSize();
+
+	// Aumenta el tamaño de la ventana
+	void incWindowSize();
+
 	// Cambia el color del borde
 	void setBorderColor(color_t color);
 
@@ -132,7 +139,7 @@ public:
 	void updateNotifier();
 
 	// Muestra una notificación de texto por pantalla;
-	void showNotification(std::string text);
+	void showNotification(std::string text1 = "", std::string text2 = "", int icon = -1);
 };
 
 #endif

source/common/sprite.cpp

@@ -27,12 +27,12 @@ Sprite::Sprite(int x, int y, int w, int h, Texture *texture, SDL_Renderer *rende
 Sprite::Sprite(SDL_Rect rect, Texture *texture, SDL_Renderer *renderer)
 {
 	// Establece la posición X,Y del sprite
-	x = rect.x;
-	y = rect.y;
+	this->x = rect.x;
+	this->y = rect.y;
 
 	// Establece el alto y el ancho del sprite
-	w = rect.w;
-	h = rect.h;
+	this->w = rect.w;
+	this->h = rect.h;
 
 	// Establece el puntero al renderizador de la ventana
 	this->renderer = renderer;

source/common/texture.cpp

@@ -103,6 +103,7 @@ bool Texture::loadFromFile(std::string path, SDL_Renderer *renderer, bool verbos
 	}
 
 	// Return success
+	stbi_image_free(data);
 	texture = newTexture;
 	return texture != nullptr;
 }

source/common/utils.h

@@ -101,6 +101,7 @@ struct cheat_t
 struct online_t
 {
 	bool enabled;		  // Indica si se quiere usar el modo online o no
+	bool sessionEnabled;  // Indica ya se ha hecho login
 	std::string server;	  // Servidor para los servicios online
 	int port;			  // Puerto del servidor
 	std::string gameID;	  // Identificador del juego para los servicios online

source/credits.cpp

@@ -2,14 +2,16 @@
 #include <iostream>
 
 // Constructor
-Credits::Credits(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options)
+Credits::Credits(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section)
 {
 	// Copia la dirección de los objetos
-	this->resource = resource;
 	this->renderer = renderer;
 	this->screen = screen;
+	this->resource = resource;
 	this->asset = asset;
+	this->input = input;
 	this->options = options;
+	this->section = section;
 
 	// Reserva memoria para los punteros
 	eventHandler = new SDL_Event();
@@ -20,8 +22,8 @@ Credits::Credits(SDL_Renderer *renderer, Screen *screen, Resource *resource, Ass
 	counter = 0;
 	counterEnabled = true;
 	subCounter = 0;
-	section.name = SECTION_PROG_CREDITS;
-	section.subsection = 0;
+	section->name = SECTION_PROG_CREDITS;
+	section->subsection = 0;
 	ticks = 0;
 	ticksSpeed = 15;
 	sprite->setRect({194, 174, 8, 8});
@@ -74,59 +76,50 @@ void Credits::checkEventHandler()
 		// Evento de salida de la aplicación
 		if (eventHandler->type == SDL_QUIT)
 		{
-			section.name = SECTION_PROG_QUIT;
+			section->name = SECTION_PROG_QUIT;
 			break;
 		}
+	}
+}
 
-		// Comprueba las teclas que se han pulsado
-		if ((eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONDOWN))
-		{
-			switch (eventHandler->key.keysym.scancode)
-			{
-			case SDL_SCANCODE_ESCAPE:
-				section.name = SECTION_PROG_QUIT;
-				break;
+// Comprueba las entradas
+void Credits::checkInput()
+{
 
-			case SDL_SCANCODE_B:
-				screen->switchBorder();
-				resource->reLoadTextures();
-				break;
+	if (input->checkInput(input_exit, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_QUIT;
+	}
 
-			case SDL_SCANCODE_F:
-				screen->switchVideoMode();
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_toggle_border, REPEAT_FALSE))
+	{
+		screen->switchBorder();
+	}
 
-			case SDL_SCANCODE_F1:
-				screen->setWindowSize(1);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_fullscreen, REPEAT_FALSE))
+	{
+		screen->switchVideoMode();
+	}
 
-			case SDL_SCANCODE_F2:
-				screen->setWindowSize(2);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_dec_size, REPEAT_FALSE))
+	{
+		screen->decWindowSize();
+	}
 
-			case SDL_SCANCODE_F3:
-				screen->setWindowSize(3);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_inc_size, REPEAT_FALSE))
+	{
+		screen->incWindowSize();
+	}
 
-			case SDL_SCANCODE_F4:
-				screen->setWindowSize(4);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_swap_palette, REPEAT_FALSE))
+	{
+		switchPalette();
+	}
 
-			case SDL_SCANCODE_F5:
-				switchPalette();
-				break;
-
-			default:
-				section.name = SECTION_PROG_TITLE;
-				section.subsection = 0;
-				break;
-			}
-		}
+	else if (input->checkInput(input_pause, REPEAT_FALSE) || input->checkInput(input_accept, REPEAT_FALSE) || input->checkInput(input_jump, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_TITLE;
+		section->subsection = 0;
 	}
 }
 
@@ -147,6 +140,7 @@ void Credits::iniTexts()
 		keys = "A,D AND W";
 	}
 
+#ifndef GAME_CONSOLE
 	texts.clear();
 	texts.push_back({"", stringToColor(options->palette, "white")});
 	texts.push_back({"INSTRUCTIONS:", stringToColor(options->palette, "yellow")});
@@ -160,11 +154,11 @@ void Credits::iniTexts()
 	texts.push_back({"KEYS:", stringToColor(options->palette, "yellow")});
 	texts.push_back({"", stringToColor(options->palette, "white")});
 	texts.push_back({keys + " TO MOVE AND JUMP", stringToColor(options->palette, "white")});
-	texts.push_back({"M TO TURN ON/OFF THE MUSIC", stringToColor(options->palette, "white")});
-	texts.push_back({"H TO HOLD/PAUSE THE GAME", stringToColor(options->palette, "white")});
-	texts.push_back({"F1-F4 TO CHANGE WINDOWS SIZE", stringToColor(options->palette, "white")});
-	texts.push_back({"F TO SWITCH TO FULLSCREEN", stringToColor(options->palette, "white")});
-	texts.push_back({"B TO SWITCH THE BORDER SCREEN", stringToColor(options->palette, "white")});
+	texts.push_back({"M TO SWITCH THE MUSIC", stringToColor(options->palette, "white")});
+	texts.push_back({"H TO PAUSE THE GAME", stringToColor(options->palette, "white")});
+	texts.push_back({"F1-F2 TO CHANGE WINDOWS SIZE", stringToColor(options->palette, "white")});
+	texts.push_back({"F3 TO SWITCH TO FULLSCREEN", stringToColor(options->palette, "white")});
+	texts.push_back({"B TO TOOGLE THE BORDER SCREEN", stringToColor(options->palette, "white")});
 	texts.push_back({"", stringToColor(options->palette, "white")});
 	texts.push_back({"", stringToColor(options->palette, "white")});
 
@@ -175,6 +169,36 @@ void Credits::iniTexts()
 
 	texts.push_back({"I LOVE JAILGAMES! ", stringToColor(options->palette, "white")});
 	texts.push_back({"", stringToColor(options->palette, "white")});
+#else
+	texts.clear();
+	texts.push_back({"", stringToColor(options->palette, "white")});
+	texts.push_back({"INSTRUCTIONS:", stringToColor(options->palette, "yellow")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+	texts.push_back({"HELP JAILDOC TO GET BACK ALL", stringToColor(options->palette, "white")});
+	texts.push_back({"HIS PROJECTS AND GO TO THE", stringToColor(options->palette, "white")});
+	texts.push_back({"JAIL TO FINISH THEM", stringToColor(options->palette, "white")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+
+	texts.push_back({"KEYS:", stringToColor(options->palette, "yellow")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+	texts.push_back({"B TO JUMP", stringToColor(options->palette, "white")});
+	texts.push_back({"R TO SWITCH THE MUSIC", stringToColor(options->palette, "white")});
+	texts.push_back({"L TO SWAP THE COLOR PALETTE", stringToColor(options->palette, "white")});
+	texts.push_back({"START TO PAUSE", stringToColor(options->palette, "white")});
+	texts.push_back({"SELECT TO EXIT", stringToColor(options->palette, "white")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+
+	texts.push_back({"A GAME BY JAILDESIGNER", stringToColor(options->palette, "yellow")});
+	texts.push_back({"MADE ON SUMMER/FALL 2022", stringToColor(options->palette, "yellow")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+
+	texts.push_back({"I LOVE JAILGAMES! ", stringToColor(options->palette, "white")});
+	texts.push_back({"", stringToColor(options->palette, "white")});
+#endif
 }
 
 // Escribe el texto en la textura
@@ -200,7 +224,7 @@ void Credits::fillTexture()
 	}
 
 	// Escribe el corazón
-	const int textLenght = text->lenght(texts.at(22).label, 1) - text->lenght(" ", 1); // Se resta el ultimo caracter que es un espacio
+	const int textLenght = text->lenght(texts[22].label, 1) - text->lenght(" ", 1); // Se resta el ultimo caracter que es un espacio
 	const int posX = ((PLAY_AREA_WIDTH - textLenght) / 2) + textLenght;
 	text->writeColored(posX, 176, "}", stringToColor(options->palette, "bright_red"));
 
@@ -259,21 +283,24 @@ void Credits::updateCounter()
 	// Comprueba si ha terminado la sección
 	if (counter > 1200)
 	{
-		section.name = SECTION_PROG_DEMO;
+		section->name = SECTION_PROG_DEMO;
 	}
 }
 
 // Actualiza las variables
 void Credits::update()
 {
+	// Comprueba el manejador de eventos
+	checkEventHandler();
+
 	// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
 	if (SDL_GetTicks() - ticks > ticksSpeed)
 	{
 		// Actualiza el contador de ticks
 		ticks = SDL_GetTicks();
 
-		// Comprueba el manejador de eventos
-		checkEventHandler();
+		// Comprueba las entradas
+		checkInput();
 
 		// Actualiza el contador
 		updateCounter();
@@ -318,15 +345,13 @@ void Credits::render()
 }
 
 // Bucle para el logo del juego
-section_t Credits::run()
+void Credits::run()
 {
-	while (section.name == SECTION_PROG_CREDITS)
+	while (section->name == SECTION_PROG_CREDITS)
 	{
 		update();
 		render();
 	}
-
-	return section;
 }
 
 // Cambia la paleta

source/credits.h

@@ -3,6 +3,7 @@
 #include <SDL2/SDL.h>
 #include "common/animatedsprite.h"
 #include "common/asset.h"
+#include "common/input.h"
 #include "common/jail_audio.h"
 #include "common/resource.h"
 #include "common/screen.h"
@@ -30,18 +31,19 @@ private:
 	Screen *screen;			   // Objeto encargado de dibujar en pantalla
 	Resource *resource;		   // Objeto con los recursos
 	Asset *asset;			   // Objeto con los ficheros de recursos
+	Input *input;			   // Objeto pata gestionar la entrada
 	SDL_Event *eventHandler;   // Manejador de eventos
 	Text *text;				   // Objeto para escribir texto en pantalla
 	SDL_Texture *textTexture;  // Textura para dibujar el texto
 	SDL_Texture *coverTexture; // Textura para cubrir el texto
 	AnimatedSprite *sprite;	   // Sprite para el brillo del corazón
 	options_t *options;		   // Puntero a las opciones del juego
+	section_t *section;		   // Estado del bucle principal para saber si continua o se sale
 
 	// Variables
 	int counter;				   // Contador
 	bool counterEnabled;		   // Indica si esta activo el contador
 	int subCounter;				   // Contador secundario
-	section_t section;			   // Estado del bucle principal para saber si continua o se sale
 	Uint32 ticks;				   // Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticksSpeed;			   // Velocidad a la que se repiten los bucles del programa
 	std::vector<captions_t> texts; // Vector con los textos
@@ -55,6 +57,9 @@ private:
 	// Comprueba el manejador de eventos
 	void checkEventHandler();
 
+	// Comprueba las entradas
+	void checkInput();
+
 	// Actualiza el contador
 	void updateCounter();
 
@@ -69,13 +74,13 @@ private:
 
 public:
 	// Constructor
-	Credits(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options);
+	Credits(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section);
 
 	// Destructor
 	~Credits();
 
 	// Bucle principal
-	section_t run();
+	void run();
 };
 
 #endif

source/demo.cpp

@@ -1,7 +1,7 @@
 #include "demo.h"
 
 // Constructor
-Demo::Demo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options, Debug *debug)
+Demo::Demo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section, Debug *debug)
 {
 	// Inicia algunas variables
 	board.iniClock = SDL_GetTicks();
@@ -15,15 +15,17 @@ Demo::Demo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *as
 	rooms.push_back("44.room");
 
 	roomIndex = 0;
-	currentRoom = rooms.at(roomIndex);
+	currentRoom = rooms[roomIndex];
 
 	// Copia los punteros
-	this->resource = resource;
 	this->renderer = renderer;
-	this->asset = asset;
 	this->screen = screen;
-	this->debug = debug;
+	this->resource = resource;
+	this->asset = asset;
+	this->input = input;
 	this->options = options;
+	this->section = section;
+	this->debug = debug;
 
 	// Crea los objetos
 	itemTracker = new ItemTracker();
@@ -40,12 +42,12 @@ Demo::Demo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *as
 	board.lives = 9;
 	board.items = 0;
 	board.rooms = 1;
-	board.jailEnabled = options->cheat.jailEnabled;
+	board.jailEnabled = false;
 	board.music = true;
 	setScoreBoardColor();
 
-	section.name = SECTION_PROG_DEMO;
-	section.subsection = 0;
+	section->name = SECTION_PROG_DEMO;
+	section->subsection = 0;
 }
 
 Demo::~Demo()
@@ -67,86 +69,82 @@ void Demo::checkEventHandler()
 		// Evento de salida de la aplicación
 		if (eventHandler->type == SDL_QUIT)
 		{
-			section.name = SECTION_PROG_QUIT;
+			section->name = SECTION_PROG_QUIT;
 			screen->setBorderColor(stringToColor(options->palette, "black"));
 			break;
 		}
-
-		// Comprueba las teclas que se han pulsado
-		if ((eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONDOWN))
-		{
-			switch (eventHandler->key.keysym.scancode)
-			{
-			case SDL_SCANCODE_ESCAPE:
-				section.name = SECTION_PROG_QUIT;
-				break;
-
-			case SDL_SCANCODE_B:
-				screen->switchBorder();
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F:
-				screen->switchVideoMode();
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F1:
-				screen->setWindowSize(1);
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F2:
-				screen->setWindowSize(2);
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F3:
-				screen->setWindowSize(3);
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F4:
-				screen->setWindowSize(4);
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F5:
-				switchPalette();
-				break;
-
-			default:
-				section.name = SECTION_PROG_TITLE;
-				section.subsection = 0;
-				break;
-			}
-		}
 	}
 }
 
-// Bucle para el juego
-section_t Demo::run()
+// Comprueba las entradas
+void Demo::checkInput()
 {
-	while (section.name == SECTION_PROG_DEMO)
+
+	if (input->checkInput(input_exit, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_QUIT;
+	}
+
+	else if (input->checkInput(input_toggle_border, REPEAT_FALSE))
+	{
+		screen->switchBorder();
+		reLoadTextures();
+	}
+
+	else if (input->checkInput(input_window_fullscreen, REPEAT_FALSE))
+	{
+		screen->switchVideoMode();
+		reLoadTextures();
+	}
+
+	else if (input->checkInput(input_window_dec_size, REPEAT_FALSE))
+	{
+		screen->decWindowSize();
+		reLoadTextures();
+	}
+
+	else if (input->checkInput(input_window_inc_size, REPEAT_FALSE))
+	{
+		screen->incWindowSize();
+		reLoadTextures();
+	}
+
+	else if (input->checkInput(input_swap_palette, REPEAT_FALSE))
+	{
+		switchPalette();
+	}
+
+	else if (input->checkInput(input_pause, REPEAT_FALSE) || input->checkInput(input_accept, REPEAT_FALSE) || input->checkInput(input_jump, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_TITLE;
+		section->subsection = 0;
+	}
+}
+
+// Bucle para el juego
+void Demo::run()
+{
+	while (section->name == SECTION_PROG_DEMO)
 	{
 		update();
 		render();
 	}
-
-	return section;
 }
 
 // Actualiza el juego, las variables, comprueba la entrada, etc.
 void Demo::update()
 {
+	// Comprueba los eventos de la cola
+	checkEventHandler();
+
 	// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
 	if (SDL_GetTicks() - ticks > ticksSpeed)
 	{
 		// Actualiza el contador de ticks
 		ticks = SDL_GetTicks();
 
-		// Comprueba los eventos de la cola
-		checkEventHandler();
+		// Comprueba las entradas
+		checkInput();
 
 		// Actualiza los objetos
 		room->update();
@@ -164,8 +162,8 @@ void Demo::render()
 {
 	// Prepara para dibujar el frame
 	screen->start();
-	screen->clean(room->getBGColor());
 
+	// Dibuja los elementos del juego en orden
 	room->renderMap();
 	room->renderEnemies();
 	room->renderItems();
@@ -255,12 +253,12 @@ void Demo::checkRoomChange()
 		roomIndex++;
 		if (roomIndex == (int)rooms.size())
 		{
-			section.name = SECTION_PROG_LOGO;
-			section.subsection = SUBSECTION_LOGO_TO_TITLE;
+			section->name = SECTION_PROG_LOGO;
+			section->subsection = SUBSECTION_LOGO_TO_TITLE;
 		}
 		else
 		{
-			changeRoom(rooms.at(roomIndex));
+			changeRoom(rooms[roomIndex]);
 		}
 	}
 }

source/demo.h

@@ -3,6 +3,7 @@
 #include <SDL2/SDL.h>
 #include "common/animatedsprite.h"
 #include "common/asset.h"
+#include "common/input.h"
 #include "common/debug.h"
 #include "common/input.h"
 #include "common/resource.h"
@@ -29,16 +30,17 @@ private:
 	Room *room;				  // Objeto encargado de gestionar cada habitación del juego
 	Resource *resource;		  // Objeto con los recursos
 	Asset *asset;			  // Objeto con la ruta a todos los ficheros de recursos
+	Input *input;			  // Objeto pata gestionar la entrada
 	Text *text;				  // Objeto para los textos del juego
 	ScoreBoard *scoreboard;	  // Objeto encargado de gestionar el marcador
 	ItemTracker *itemTracker; // Lleva el control de los objetos recogidos
 	Debug *debug;			  // Objeto para gestionar la información de debug
 	options_t *options;		  // Puntero a las opciones del juego
+	section_t *section;		  // Seccion actual dentro del juego
 
 	// Variables
 	Uint32 ticks;					// Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticksSpeed;				// Velocidad a la que se repiten los bucles del programa
-	section_t section;				// Seccion actual dentro del juego
 	std::string currentRoom;		// Fichero de la habitación actual
 	board_t board;					// Estructura con los datos del marcador
 	int counter;					// Contador para el modo demo
@@ -55,6 +57,9 @@ private:
 	// Comprueba los eventos de la cola
 	void checkEventHandler();
 
+	// Comprueba las entradas
+	void checkInput();
+
 	// Escribe el nombre de la pantalla
 	void renderRoomName();
 
@@ -75,13 +80,13 @@ private:
 
 public:
 	// Constructor
-	Demo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options, Debug *debug);
+	Demo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section, Debug *debug);
 
 	// Destructor
 	~Demo();
 
 	// Bucle para el juego
-	section_t run();
+	void run();
 };
 
 #endif

source/director.cpp

@@ -14,11 +14,12 @@
 // Constructor
 Director::Director(int argc, char *argv[])
 {
-	section.name = SECTION_PROG_LOGO;
-	section.subsection = SUBSECTION_LOGO_TO_INTRO;
+	section = new section_t();
+	section->name = SECTION_PROG_LOGO;
+	section->subsection = SUBSECTION_LOGO_TO_INTRO;
 
 #ifdef DEBUG
-	section.name = SECTION_PROG_GAME;
+	section->name = SECTION_PROG_GAME;
 #endif
 
 	// Crea e inicializa las opciones del programa
@@ -28,7 +29,12 @@ Director::Director(int argc, char *argv[])
 	checkProgramArguments(argc, argv);
 
 	// Crea la carpeta del sistema donde guardar datos
-	createSystemFolder();
+	createSystemFolder("jailgames");
+#ifndef DEBUG
+	createSystemFolder("jailgames/jaildoctors_dilemma");
+#else
+	createSystemFolder("jailgames/jaildoctors_dilemma_debug");
+#endif
 
 	// Crea el objeto que controla los ficheros de recursos
 	asset = new Asset(executablePath);
@@ -65,6 +71,7 @@ Director::~Director()
 	saveConfig();
 
 	// Libera la memoria
+	delete section;
 	delete options;
 	delete asset;
 	delete input;
@@ -129,6 +136,10 @@ void Director::initOptions()
 	options->borderHeight = 24;
 	options->palette = p_zxspectrum;
 
+#ifdef GAME_CONSOLE
+	options->windowSize = 2;
+#endif
+
 	// Estos valores no se guardan en el fichero de configuraci´ón
 	options->console = false;
 	options->cheat.infiniteLives = false;
@@ -140,6 +151,7 @@ void Director::initOptions()
 
 	// Opciones online
 	options->online.enabled = true;
+	options->online.sessionEnabled = false;
 	options->online.server = "jaildoctor.duckdns.org";
 	options->online.port = 9911;
 #ifdef DEBUG
@@ -153,7 +165,7 @@ void Director::initOptions()
 	options->notifications.posV = pos_top;
 	options->notifications.posH = pos_left;
 	options->notifications.sound = true;
-	options->notifications.color = {64, 64, 64};
+	options->notifications.color = {48, 48, 48};
 }
 
 // Comprueba los parametros del programa
@@ -403,24 +415,18 @@ bool Director::saveConfig()
 }
 
 // Crea la carpeta del sistema donde guardar datos
-void Director::createSystemFolder()
+void Director::createSystemFolder(std::string folder)
 {
-#ifdef DEBUG
-	const std::string folderName = "jaildoctors_dilemma_debug";
-#else
-	const std::string folderName = "jaildoctors_dilemma";
-#endif
-
 #ifdef _WIN32
-	systemFolder = std::string(getenv("APPDATA")) + "/" + folderName;
+	systemFolder = std::string(getenv("APPDATA")) + "/" + folder;
 #elif __APPLE__
 	struct passwd *pw = getpwuid(getuid());
 	const char *homedir = pw->pw_dir;
-	systemFolder = std::string(homedir) + "/Library/Application Support/" + folderName;
+	systemFolder = std::string(homedir) + "/Library/Application Support" + "/" + folder;
 #elif __linux__
 	struct passwd *pw = getpwuid(getuid());
 	const char *homedir = pw->pw_dir;
-	systemFolder = std::string(homedir) + "/." + folderName;
+	systemFolder = std::string(homedir) + "/." + folder;
 #endif
 
 	struct stat st = {0};
@@ -458,14 +464,14 @@ void Director::createSystemFolder()
 }
 
 // Carga los recursos
-void Director::loadResources(section_t section)
+void Director::loadResources(section_t *section)
 {
 	if (options->console)
 	{
 		std::cout << "** LOAD RESOURCES" << std::endl;
 	}
 
-	if (section.name == SECTION_PROG_LOGO)
+	if (section->name == SECTION_PROG_LOGO)
 	{
 		std::vector<std::string> textureList;
 		textureList.push_back("jailgames.png");
@@ -474,7 +480,7 @@ void Director::loadResources(section_t section)
 		resource->loadTextures(textureList);
 	}
 
-	else if (section.name == SECTION_PROG_INTRO)
+	else if (section->name == SECTION_PROG_INTRO)
 	{
 		std::vector<std::string> textureList;
 		textureList.push_back("loading_screen_bn.png");
@@ -485,7 +491,7 @@ void Director::loadResources(section_t section)
 		resource->loadTextures(textureList);
 	}
 
-	else if (section.name == SECTION_PROG_TITLE)
+	else if (section->name == SECTION_PROG_TITLE)
 	{
 		std::vector<std::string> textureList;
 		textureList.push_back("loading_screen_color.png");
@@ -501,7 +507,7 @@ void Director::loadResources(section_t section)
 		resource->loadOffsets(offsetsList);
 	}
 
-	else if (section.name == SECTION_PROG_CREDITS)
+	else if (section->name == SECTION_PROG_CREDITS)
 	{
 		// Texturas
 		std::vector<std::string> textureList;
@@ -523,7 +529,7 @@ void Director::loadResources(section_t section)
 		resource->loadOffsets(offsetsList);
 	}
 
-	else if (section.name == SECTION_PROG_ENDING)
+	else if (section->name == SECTION_PROG_ENDING)
 	{
 		// Texturas
 		std::vector<std::string> textureList;
@@ -548,7 +554,7 @@ void Director::loadResources(section_t section)
 		resource->loadOffsets(offsetsList);
 	}
 
-	else if (section.name == SECTION_PROG_ENDING2)
+	else if (section->name == SECTION_PROG_ENDING2)
 	{
 		// Texturas
 		std::vector<std::string> textureList;
@@ -581,7 +587,7 @@ void Director::loadResources(section_t section)
 		textureList.push_back("demon.png");
 		textureList.push_back("heavy.png");
 		textureList.push_back("dimallas.png");
-		textureList.push_back("diskette.png");
+		textureList.push_back("floppy.png");
 		textureList.push_back("dong.png");
 		textureList.push_back("guitar.png");
 		textureList.push_back("jailbattle_alien.png");
@@ -644,7 +650,7 @@ void Director::loadResources(section_t section)
 		animationList.push_back("demon.ani");
 		animationList.push_back("heavy.ani");
 		animationList.push_back("dimallas.ani");
-		animationList.push_back("diskette.ani");
+		animationList.push_back("floppy.ani");
 		animationList.push_back("dong.ani");
 		animationList.push_back("guitar.ani");
 		animationList.push_back("jailbattle_alien.ani");
@@ -686,7 +692,7 @@ void Director::loadResources(section_t section)
 		resource->loadOffsets(offsetsList);
 	}
 
-	else if (section.name == SECTION_PROG_GAME_OVER)
+	else if (section->name == SECTION_PROG_GAME_OVER)
 	{
 		// Texturas
 		std::vector<std::string> textureList;
@@ -710,7 +716,7 @@ void Director::loadResources(section_t section)
 		resource->loadOffsets(offsetsList);
 	}
 
-	else if (section.name == SECTION_PROG_GAME || section.name == SECTION_PROG_DEMO)
+	else if (section->name == SECTION_PROG_GAME || section->name == SECTION_PROG_DEMO)
 	{
 		// Texturas
 		std::vector<std::string> textureList;
@@ -755,7 +761,7 @@ void Director::loadResources(section_t section)
 		textureList.push_back("crosshair.png");
 		textureList.push_back("demon.png");
 		textureList.push_back("dimallas.png");
-		textureList.push_back("diskette.png");
+		textureList.push_back("floppy.png");
 		textureList.push_back("dong.png");
 		textureList.push_back("guitar.png");
 		textureList.push_back("heavy.png");
@@ -836,7 +842,7 @@ void Director::loadResources(section_t section)
 		animationList.push_back("crosshair.ani");
 		animationList.push_back("demon.ani");
 		animationList.push_back("dimallas.ani");
-		animationList.push_back("diskette.ani");
+		animationList.push_back("floppy.ani");
 		animationList.push_back("dong.ani");
 		animationList.push_back("guitar.ani");
 		animationList.push_back("heavy.ani");
@@ -1202,43 +1208,56 @@ void Director::initInput()
 	// Busca si hay un mando conectado
 	input->discoverGameController();
 
-	// Asigna inputs a teclas
+	// Teclado - Movimiento
 	if (options->keys == ctrl_cursor)
 	{
-		input->bindKey(INPUT_UP, SDL_SCANCODE_UP);
-		input->bindKey(INPUT_LEFT, SDL_SCANCODE_LEFT);
-		input->bindKey(INPUT_RIGHT, SDL_SCANCODE_RIGHT);
+		input->bindKey(input_jump, SDL_SCANCODE_UP);
+		input->bindKey(input_left, SDL_SCANCODE_LEFT);
+		input->bindKey(input_right, SDL_SCANCODE_RIGHT);
 	}
 	else if (options->keys == ctrl_opqa)
 	{
-		input->bindKey(INPUT_UP, SDL_SCANCODE_Q);
-		input->bindKey(INPUT_LEFT, SDL_SCANCODE_O);
-		input->bindKey(INPUT_RIGHT, SDL_SCANCODE_P);
+		input->bindKey(input_jump, SDL_SCANCODE_Q);
+		input->bindKey(input_left, SDL_SCANCODE_O);
+		input->bindKey(input_right, SDL_SCANCODE_P);
 	}
 	else if (options->keys == ctrl_wasd)
 	{
-		input->bindKey(INPUT_UP, SDL_SCANCODE_W);
-		input->bindKey(INPUT_LEFT, SDL_SCANCODE_A);
-		input->bindKey(INPUT_RIGHT, SDL_SCANCODE_D);
+		input->bindKey(input_jump, SDL_SCANCODE_W);
+		input->bindKey(input_left, SDL_SCANCODE_A);
+		input->bindKey(input_right, SDL_SCANCODE_D);
 	}
 
-	input->bindKey(INPUT_DOWN, SDL_SCANCODE_DOWN);
-	input->bindKey(INPUT_ACCEPT, SDL_SCANCODE_RETURN);
-	input->bindKey(INPUT_CANCEL, SDL_SCANCODE_ESCAPE);
-	input->bindKey(INPUT_BUTTON_1, SDL_SCANCODE_SPACE);
-	input->bindKey(INPUT_BUTTON_2, SDL_SCANCODE_D);
-	input->bindKey(INPUT_BUTTON_PAUSE, SDL_SCANCODE_ESCAPE);
-	input->bindKey(INPUT_BUTTON_ESCAPE, SDL_SCANCODE_ESCAPE);
+	// Teclado - Otros
+	input->bindKey(input_accept, SDL_SCANCODE_RETURN);
+	input->bindKey(input_cancel, SDL_SCANCODE_ESCAPE);
+	input->bindKey(input_pause, SDL_SCANCODE_H);
+	input->bindKey(input_exit, SDL_SCANCODE_ESCAPE);
+	input->bindKey(input_window_dec_size, SDL_SCANCODE_F1);
+	input->bindKey(input_window_inc_size, SDL_SCANCODE_F2);
+	input->bindKey(input_window_fullscreen, SDL_SCANCODE_F3);
+	input->bindKey(input_swap_palette, SDL_SCANCODE_F5);
+	input->bindKey(input_switch_music, SDL_SCANCODE_M);
+	input->bindKey(input_toggle_border, SDL_SCANCODE_B);
 
-	input->bindGameControllerButton(INPUT_UP, SDL_CONTROLLER_BUTTON_DPAD_UP);
-	input->bindGameControllerButton(INPUT_DOWN, SDL_CONTROLLER_BUTTON_DPAD_DOWN);
-	input->bindGameControllerButton(INPUT_LEFT, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
-	input->bindGameControllerButton(INPUT_RIGHT, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
-	input->bindGameControllerButton(INPUT_ACCEPT, SDL_CONTROLLER_BUTTON_B);
-	input->bindGameControllerButton(INPUT_CANCEL, SDL_CONTROLLER_BUTTON_A);
-	input->bindGameControllerButton(INPUT_BUTTON_1, SDL_CONTROLLER_BUTTON_B);
-	input->bindGameControllerButton(INPUT_BUTTON_PAUSE, SDL_CONTROLLER_BUTTON_GUIDE);
-	input->bindGameControllerButton(INPUT_BUTTON_ESCAPE, SDL_CONTROLLER_BUTTON_GUIDE);
+	// Mando - Movimiento
+	input->bindGameControllerButton(input_jump, SDL_CONTROLLER_BUTTON_B);
+	input->bindGameControllerButton(input_left, SDL_CONTROLLER_BUTTON_DPAD_LEFT);
+	input->bindGameControllerButton(input_right, SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
+
+	// Mando - Otros
+	input->bindGameControllerButton(input_accept, SDL_CONTROLLER_BUTTON_B);
+	input->bindGameControllerButton(input_cancel, SDL_CONTROLLER_BUTTON_A);
+#ifdef GAME_CONSOLE
+	input->bindGameControllerButton(input_pause, SDL_CONTROLLER_BUTTON_BACK);
+	input->bindGameControllerButton(input_exit, SDL_CONTROLLER_BUTTON_START);
+#else
+	input->bindGameControllerButton(input_pause, SDL_CONTROLLER_BUTTON_START);
+	input->bindGameControllerButton(input_exit, SDL_CONTROLLER_BUTTON_BACK);
+#endif
+	input->bindGameControllerButton(input_swap_palette, SDL_CONTROLLER_BUTTON_LEFTSHOULDER);
+	input->bindGameControllerButton(input_switch_music, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
+	input->bindGameControllerButton(input_toggle_border, SDL_CONTROLLER_BUTTON_X);
 }
 
 // Inicializa JailAudio
@@ -1357,6 +1376,10 @@ bool Director::setFileList()
 	asset->add(systemFolder + "/config.txt", t_data, false, true);
 	asset->add(systemFolder + "/stats_buffer.csv", t_data, false, true);
 	asset->add(systemFolder + "/stats.csv", t_data, false, true);
+	asset->add(systemFolder + "/cheevos.bin", t_data, false, true);
+
+	// Notificaciones
+	asset->add(prefix + "/data/notifications/notify.png", t_bitmap);
 
 	// Habitaciones
 	asset->add(prefix + "/data/room/01.room", t_room);
@@ -1533,8 +1556,8 @@ bool Director::setFileList()
 	asset->add(prefix + "/data/enemies/demon.png", t_bitmap);
 	asset->add(prefix + "/data/enemies/dimallas.ani", t_data);
 	asset->add(prefix + "/data/enemies/dimallas.png", t_bitmap);
-	asset->add(prefix + "/data/enemies/diskette.ani", t_data);
-	asset->add(prefix + "/data/enemies/diskette.png", t_bitmap);
+	asset->add(prefix + "/data/enemies/floppy.ani", t_data);
+	asset->add(prefix + "/data/enemies/floppy.png", t_bitmap);
 	asset->add(prefix + "/data/enemies/dong.ani", t_data);
 	asset->add(prefix + "/data/enemies/dong.png", t_bitmap);
 	asset->add(prefix + "/data/enemies/guitar.ani", t_data);
@@ -1681,24 +1704,6 @@ bool Director::setFileList()
 	return asset->check();
 }
 
-// Obtiene el valor de la variable
-Uint8 Director::getSubsection()
-{
-	return section.subsection;
-}
-
-// Obtiene el valor de la variable
-Uint8 Director::getSection()
-{
-	return section.name;
-}
-
-// Establece el valor de la variable
-void Director::setSection(section_t section)
-{
-	this->section = section;
-}
-
 // Ejecuta la seccion de juego con el logo
 void Director::runLogo()
 {
@@ -1707,8 +1712,8 @@ void Director::runLogo()
 		std::cout << "\n* SECTION: LOGO" << std::endl;
 	}
 	loadResources(section);
-	logo = new Logo(renderer, screen, resource, asset, options, section.subsection);
-	setSection(logo->run());
+	logo = new Logo(renderer, screen, resource, asset, input, options, section);
+	logo->run();
 	delete logo;
 	resource->free();
 }
@@ -1721,8 +1726,8 @@ void Director::runIntro()
 		std::cout << "\n* SECTION: INTRO" << std::endl;
 	}
 	loadResources(section);
-	intro = new Intro(renderer, screen, resource, asset, options);
-	setSection(intro->run());
+	intro = new Intro(renderer, screen, resource, asset, input, options, section);
+	intro->run();
 	delete intro;
 	resource->free();
 }
@@ -1739,8 +1744,8 @@ void Director::runTitle()
 		JA_PlayMusic(music);
 	}
 	loadResources(section);
-	title = new Title(renderer, screen, resource, asset, options);
-	setSection(title->run());
+	title = new Title(renderer, screen, resource, asset, input, options, section);
+	title->run();
 	delete title;
 	resource->free();
 }
@@ -1753,8 +1758,8 @@ void Director::runCredits()
 		std::cout << "\n* SECTION: CREDITS" << std::endl;
 	}
 	loadResources(section);
-	credits = new Credits(renderer, screen, resource, asset, options);
-	setSection(credits->run());
+	credits = new Credits(renderer, screen, resource, asset, input, options, section);
+	credits->run();
 	delete credits;
 	resource->free();
 }
@@ -1767,8 +1772,8 @@ void Director::runDemo()
 		std::cout << "\n* SECTION: DEMO" << std::endl;
 	}
 	loadResources(section);
-	demo = new Demo(renderer, screen, resource, asset, options, debug);
-	setSection(demo->run());
+	demo = new Demo(renderer, screen, resource, asset, input, options, section, debug);
+	demo->run();
 	delete demo;
 	resource->free();
 }
@@ -1782,7 +1787,7 @@ void Director::runEnterID()
 	}
 	// loadResources(section);
 	enterID = new EnterID(renderer, screen, asset, options, section);
-	setSection(enterID->run());
+	enterID->run();
 	delete enterID;
 	resource->free();
 }
@@ -1795,8 +1800,8 @@ void Director::runEnding()
 		std::cout << "\n* SECTION: ENDING" << std::endl;
 	}
 	loadResources(section);
-	ending = new Ending(renderer, screen, resource, asset, options);
-	setSection(ending->run());
+	ending = new Ending(renderer, screen, resource, asset, input, options, section);
+	ending->run();
 	delete ending;
 	resource->free();
 }
@@ -1809,8 +1814,8 @@ void Director::runEnding2()
 		std::cout << "\n* SECTION: ENDING2" << std::endl;
 	}
 	loadResources(section);
-	ending2 = new Ending2(renderer, screen, resource, asset, options);
-	setSection(ending2->run());
+	ending2 = new Ending2(renderer, screen, resource, asset, input, options, section);
+	ending2->run();
 	delete ending2;
 	resource->free();
 }
@@ -1823,8 +1828,8 @@ void Director::runGameOver()
 		std::cout << "\n* SECTION: GAME OVER" << std::endl;
 	}
 	loadResources(section);
-	gameOver = new GameOver(renderer, screen, resource, asset, options);
-	setSection(gameOver->run());
+	gameOver = new GameOver(renderer, screen, resource, asset, input, options, section);
+	gameOver->run();
 	delete gameOver;
 	resource->free();
 }
@@ -1838,8 +1843,8 @@ void Director::runGame()
 	}
 	JA_StopMusic();
 	loadResources(section);
-	game = new Game(renderer, screen, resource, asset, options, input, debug);
-	setSection(game->run());
+	game = new Game(renderer, screen, resource, asset, options, input, section, debug);
+	game->run();
 	delete game;
 	resource->free();
 }
@@ -1847,9 +1852,9 @@ void Director::runGame()
 void Director::run()
 {
 	// Bucle principal
-	while (getSection() != SECTION_PROG_QUIT)
+	while (section->name != SECTION_PROG_QUIT)
 	{
-		switch (getSection())
+		switch (section->name)
 		{
 		case SECTION_PROG_LOGO:
 			runLogo();

source/director.h

@@ -46,10 +46,10 @@ private:
 	GameOver *gameOver;		   // Objeto para gestionar el final de la partida
 	Debug *debug;			   // Objeto para getsionar la información de debug
 	struct options_t *options; // Variable con todas las opciones del programa
+	section_t *section;		   // Sección y subsección actual del programa;
 
 	// Variables
-	section_t section;			// Sección y subsección actual del programa;
-	JA_Music music;				// Musica del titulo
+	JA_Music_t *music;			// Musica del titulo
 	std::string executablePath; // Path del ejecutable
 	std::string systemFolder;	// Carpeta del sistema donde guardar datos
 
@@ -69,10 +69,10 @@ private:
 	bool saveConfig();
 
 	// Crea la carpeta del sistema donde guardar datos
-	void createSystemFolder();
+	void createSystemFolder(std::string folder);
 
 	// Carga los recursos
-	void loadResources(section_t section);
+	void loadResources(section_t *section);
 
 	// Asigna variables a partir de dos cadenas
 	bool setOptions(options_t *options, std::string var, std::string value);
@@ -89,15 +89,6 @@ private:
 	// Crea el indice de ficheros
 	bool setFileList();
 
-	// Obtiene el valor de la variable
-	Uint8 getSubsection();
-
-	// Obtiene el valor de la variable
-	Uint8 getSection();
-
-	// Establece el valor de la variable
-	void setSection(section_t section);
-
 	// Ejecuta la seccion de juego con el logo
 	void runLogo();
 

source/ending.cpp

@@ -1,14 +1,16 @@
 #include "ending.h"
 
 // Constructor
-Ending::Ending(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options)
+Ending::Ending(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section)
 {
     // Copia los punteros
     this->renderer = renderer;
     this->screen = screen;
     this->resource = resource;
     this->asset = asset;
+    this->input = input;
     this->options = options;
+    this->section = section;
 
     // Reserva memoria para los punteros a objetos
     eventHandler = new SDL_Event();
@@ -19,8 +21,8 @@ Ending::Ending(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset
     counter = -1;
     preCounter = 0;
     coverCounter = 0;
-    section.name = SECTION_PROG_ENDING;
-    section.subsection = 0;
+    section->name = SECTION_PROG_ENDING;
+    section->subsection = 0;
     ticks = 0;
     ticksSpeed = 15;
     scene = 0;
@@ -83,14 +85,17 @@ Ending::~Ending()
 // Actualiza el objeto
 void Ending::update()
 {
+    // Comprueba el manejador de eventos
+    checkEventHandler();
+
     // Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
     if (SDL_GetTicks() - ticks > ticksSpeed)
     {
         // Actualiza el contador de ticks
         ticks = SDL_GetTicks();
 
-        // Comprueba el manejador de eventos
-        checkEventHandler();
+        // Comprueba las entradas
+        checkInput();
 
         // Actualiza el contador
         updateCounters();
@@ -119,16 +124,16 @@ void Ending::render()
     screen->clean(stringToColor(options->palette, "black"));
 
     // Dibuja las imagenes de la escena
-    spritePics.at(scene).sprite->render();
-    spritePics.at(scene).coverSprite->render();
+    spritePics[scene].sprite->render();
+    spritePics[scene].coverSprite->render();
 
     // Dibuja los textos de la escena
-    for (auto ti : scenes.at(scene).textIndex)
+    for (auto ti : scenes[scene].textIndex)
     {
         if (counter > ti.trigger)
         {
-            spriteTexts.at(ti.index).sprite->render();
-            spriteTexts.at(ti.index).coverSprite->render();
+            spriteTexts[ti.index].sprite->render();
+            spriteTexts[ti.index].coverSprite->render();
         }
     }
 
@@ -150,57 +155,45 @@ void Ending::checkEventHandler()
         // Evento de salida de la aplicación
         if (eventHandler->type == SDL_QUIT)
         {
-            section.name = SECTION_PROG_QUIT;
+            section->name = SECTION_PROG_QUIT;
             break;
         }
+    }
+}
 
-        // Comprueba las teclas que se han pulsado
-        if ((eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONDOWN))
-        {
-            switch (eventHandler->key.keysym.scancode)
-            {
-            case SDL_SCANCODE_ESCAPE:
-                section.name = SECTION_PROG_QUIT;
-                break;
+// Comprueba las entradas
+void Ending::checkInput()
+{
 
-            case SDL_SCANCODE_B:
-                screen->switchBorder();
-                resource->reLoadTextures();
-                break;
+    if (input->checkInput(input_exit, REPEAT_FALSE))
+    {
+        section->name = SECTION_PROG_LOGO;
+        section->subsection = SUBSECTION_LOGO_TO_INTRO;
+    }
 
-            case SDL_SCANCODE_F:
-                screen->switchVideoMode();
-                resource->reLoadTextures();
-                break;
+    else if (input->checkInput(input_toggle_border, REPEAT_FALSE))
+    {
+        screen->switchBorder();
+    }
 
-            case SDL_SCANCODE_F1:
-                screen->setWindowSize(1);
-                resource->reLoadTextures();
-                break;
+    else if (input->checkInput(input_window_fullscreen, REPEAT_FALSE))
+    {
+        screen->switchVideoMode();
+    }
 
-            case SDL_SCANCODE_F2:
-                screen->setWindowSize(2);
-                resource->reLoadTextures();
-                break;
+    else if (input->checkInput(input_window_dec_size, REPEAT_FALSE))
+    {
+        screen->decWindowSize();
+    }
 
-            case SDL_SCANCODE_F3:
-                screen->setWindowSize(3);
-                resource->reLoadTextures();
-                break;
+    else if (input->checkInput(input_window_inc_size, REPEAT_FALSE))
+    {
+        screen->incWindowSize();
+    }
 
-            case SDL_SCANCODE_F4:
-                screen->setWindowSize(4);
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F5:
-                switchPalette();
-                break;
-
-            default:
-                break;
-            }
-        }
+    else if (input->checkInput(input_swap_palette, REPEAT_FALSE))
+    {
+        switchPalette();
     }
 }
 
@@ -482,11 +475,11 @@ void Ending::iniScenes()
 }
 
 // Bucle principal
-section_t Ending::run()
+void Ending::run()
 {
     JA_PlayMusic(music);
 
-    while (section.name == SECTION_PROG_ENDING)
+    while (section->name == SECTION_PROG_ENDING)
     {
         update();
         render();
@@ -494,8 +487,6 @@ section_t Ending::run()
 
     JA_StopMusic();
     JA_SetVolume(128);
-
-    return section;
 }
 
 // Actualiza los contadores
@@ -511,7 +502,7 @@ void Ending::updateCounters()
         counter++;
     }
 
-    if (counter > scenes.at(scene).counterEnd - 100)
+    if (counter > scenes[scene].counterEnd - 100)
     {
         coverCounter++;
     }
@@ -522,20 +513,20 @@ void Ending::updateSpriteCovers()
 { // Actualiza la cortinilla de los textos
     if (counter % 4 == 0)
     {
-        for (auto ti : scenes.at(scene).textIndex)
+        for (auto ti : scenes[scene].textIndex)
         {
             if (counter > ti.trigger)
             {
-                if (spriteTexts.at(ti.index).clipDesp > 0)
+                if (spriteTexts[ti.index].clipDesp > 0)
                 {
-                    spriteTexts.at(ti.index).clipDesp -= 2;
+                    spriteTexts[ti.index].clipDesp -= 2;
                 }
-                else if (spriteTexts.at(ti.index).clipHeight > 0)
+                else if (spriteTexts[ti.index].clipHeight > 0)
                 {
-                    spriteTexts.at(ti.index).clipHeight -= 2;
-                    spriteTexts.at(ti.index).coverSprite->setPosY(spriteTexts.at(ti.index).coverSprite->getPosY() + 2);
+                    spriteTexts[ti.index].clipHeight -= 2;
+                    spriteTexts[ti.index].coverSprite->setPosY(spriteTexts[ti.index].coverSprite->getPosY() + 2);
                 }
-                spriteTexts.at(ti.index).coverSprite->setSpriteClip(0, spriteTexts.at(ti.index).clipDesp, spriteTexts.at(ti.index).coverSprite->getWidth(), spriteTexts.at(ti.index).clipHeight);
+                spriteTexts[ti.index].coverSprite->setSpriteClip(0, spriteTexts[ti.index].clipDesp, spriteTexts[ti.index].coverSprite->getWidth(), spriteTexts[ti.index].clipHeight);
             }
         }
     }
@@ -543,27 +534,27 @@ void Ending::updateSpriteCovers()
     // Actualiza la cortinilla de las imagenes
     if (counter % 2 == 0)
     {
-        if (spritePics.at(scene).clipDesp > 0)
+        if (spritePics[scene].clipDesp > 0)
         {
-            spritePics.at(scene).clipDesp -= 2;
+            spritePics[scene].clipDesp -= 2;
         }
-        else if (spritePics.at(scene).clipHeight > 0)
+        else if (spritePics[scene].clipHeight > 0)
         {
-            spritePics.at(scene).clipHeight -= 2;
-            if (spritePics.at(scene).clipHeight < 0)
+            spritePics[scene].clipHeight -= 2;
+            if (spritePics[scene].clipHeight < 0)
             {
-                spritePics.at(scene).clipHeight = 0;
+                spritePics[scene].clipHeight = 0;
             }
-            spritePics.at(scene).coverSprite->setPosY(spritePics.at(scene).coverSprite->getPosY() + 2);
+            spritePics[scene].coverSprite->setPosY(spritePics[scene].coverSprite->getPosY() + 2);
         }
-        spritePics.at(scene).coverSprite->setSpriteClip(0, spritePics.at(scene).clipDesp, spritePics.at(scene).coverSprite->getWidth(), spritePics.at(scene).clipHeight);
+        spritePics[scene].coverSprite->setSpriteClip(0, spritePics[scene].clipDesp, spritePics[scene].coverSprite->getWidth(), spritePics[scene].clipHeight);
     }
 }
 
 // Comprueba si se ha de cambiar de escena
 void Ending::checkChangeScene()
 {
-    if (counter > scenes.at(scene).counterEnd)
+    if (counter > scenes[scene].counterEnd)
     {
         scene++;
         counter = 0;
@@ -571,7 +562,7 @@ void Ending::checkChangeScene()
         if (scene == 5)
         {
             // Termina el bucle
-            section.name = SECTION_PROG_ENDING2;
+            section->name = SECTION_PROG_ENDING2;
 
             // Mantiene los valores anteriores
             scene = 4;
@@ -639,20 +630,20 @@ void Ending::switchPalette()
     {
         options->palette = p_zxarne;
 
-        spritePics.at(0).sprite->setTexture(resource->getTexture("ending1_zxarne.png"));
-        spritePics.at(1).sprite->setTexture(resource->getTexture("ending2_zxarne.png"));
-        spritePics.at(2).sprite->setTexture(resource->getTexture("ending3_zxarne.png"));
-        spritePics.at(3).sprite->setTexture(resource->getTexture("ending4_zxarne.png"));
-        spritePics.at(4).sprite->setTexture(resource->getTexture("ending5_zxarne.png"));
+        spritePics[0].sprite->setTexture(resource->getTexture("ending1_zxarne.png"));
+        spritePics[1].sprite->setTexture(resource->getTexture("ending2_zxarne.png"));
+        spritePics[2].sprite->setTexture(resource->getTexture("ending3_zxarne.png"));
+        spritePics[3].sprite->setTexture(resource->getTexture("ending4_zxarne.png"));
+        spritePics[4].sprite->setTexture(resource->getTexture("ending5_zxarne.png"));
     }
     else
     {
         options->palette = p_zxspectrum;
 
-        spritePics.at(0).sprite->setTexture(resource->getTexture("ending1.png"));
-        spritePics.at(1).sprite->setTexture(resource->getTexture("ending2.png"));
-        spritePics.at(2).sprite->setTexture(resource->getTexture("ending3.png"));
-        spritePics.at(3).sprite->setTexture(resource->getTexture("ending4.png"));
-        spritePics.at(4).sprite->setTexture(resource->getTexture("ending5.png"));
+        spritePics[0].sprite->setTexture(resource->getTexture("ending1.png"));
+        spritePics[1].sprite->setTexture(resource->getTexture("ending2.png"));
+        spritePics[2].sprite->setTexture(resource->getTexture("ending3.png"));
+        spritePics[3].sprite->setTexture(resource->getTexture("ending4.png"));
+        spritePics[4].sprite->setTexture(resource->getTexture("ending5.png"));
     }
 }

source/ending.h

@@ -1,6 +1,7 @@
 #pragma once
 #include <SDL2/SDL.h>
 #include "common/asset.h"
+#include "common/input.h"
 #include "common/jail_audio.h"
 #include "common/resource.h"
 #include "common/screen.h"
@@ -54,23 +55,24 @@ private:
 	Screen *screen;			   // Objeto encargado de dibujar en pantalla
 	Resource *resource;		   // Objeto con los recursos
 	Asset *asset;			   // Objeto con los ficheros de recursos
+	Input *input;			   // Objeto pata gestionar la entrada
 	options_t *options;		   // Puntero a las opciones del juego
 	SDL_Event *eventHandler;   // Manejador de eventos
 	Text *text;				   // Objeto para escribir texto en pantalla
 	SDL_Texture *coverTexture; // Textura para cubrir el texto
+	section_t *section;		   // Estado del bucle principal para saber si continua o se sale
 
 	// Variables
 	int counter;							  // Contador
 	int preCounter;							  // Contador previo
 	int coverCounter;						  // Contador para la cortinilla
-	section_t section;						  // Estado del bucle principal para saber si continua o se sale
 	Uint32 ticks;							  // Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticksSpeed;						  // Velocidad a la que se repiten los bucles del programa
 	std::vector<endingTexture_t> spriteTexts; // Vector con los sprites de texto con su cortinilla
 	std::vector<endingTexture_t> spritePics;  // Vector con los sprites de texto con su cortinilla
 	int scene;								  // Escena actual
 	std::vector<scene_t> scenes;			  // Vector con los textos e imagenes de cada escena
-	JA_Music music;							  // Musica que suena durante el final
+	JA_Music_t *music;						  // Musica que suena durante el final
 
 	// Actualiza el objeto
 	void update();
@@ -81,6 +83,9 @@ private:
 	// Comprueba el manejador de eventos
 	void checkEventHandler();
 
+	// Comprueba las entradas
+	void checkInput();
+
 	// Inicializa los textos
 	void iniTexts();
 
@@ -113,13 +118,13 @@ private:
 
 public:
 	// Constructor
-	Ending(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options);
+	Ending(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section);
 
 	// Destructor
 	~Ending();
 
 	// Bucle principal
-	section_t run();
+	void run();
 };
 
 #endif

source/ending2.cpp

@@ -2,14 +2,16 @@
 #include <algorithm>
 
 // Constructor
-Ending2::Ending2(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options)
+Ending2::Ending2(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section)
 {
     // Copia los punteros
     this->renderer = renderer;
     this->screen = screen;
     this->resource = resource;
     this->asset = asset;
+    this->input = input;
     this->options = options;
+    this->section = section;
 
     // Reserva memoria para los punteros a objetos
     eventHandler = new SDL_Event();
@@ -21,8 +23,8 @@ Ending2::Ending2(SDL_Renderer *renderer, Screen *screen, Resource *resource, Ass
     preCounter = 0;
     postCounter = 0;
     postCounterEnabled = false;
-    section.name = SECTION_PROG_ENDING2;
-    section.subsection = 0;
+    section->name = SECTION_PROG_ENDING2;
+    section->subsection = 0;
     ticks = 0;
     ticksSpeed = 15;
     distSpriteText = 8;
@@ -73,14 +75,17 @@ Ending2::~Ending2()
 // Actualiza el objeto
 void Ending2::update()
 {
+    // Comprueba el manejador de eventos
+    checkEventHandler();
+
     // Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
     if (SDL_GetTicks() - ticks > ticksSpeed)
     {
         // Actualiza el contador de ticks
         ticks = SDL_GetTicks();
 
-        // Comprueba el manejador de eventos
-        checkEventHandler();
+        // Comprueba las entradas
+        checkInput();
 
         // Actualiza los contadores
         updateCounters();
@@ -184,66 +189,54 @@ void Ending2::checkEventHandler()
         // Evento de salida de la aplicación
         if (eventHandler->type == SDL_QUIT)
         {
-            section.name = SECTION_PROG_QUIT;
+            section->name = SECTION_PROG_QUIT;
             break;
         }
-
-        // Comprueba las teclas que se han pulsado
-        if ((eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONDOWN))
-        {
-            switch (eventHandler->key.keysym.scancode)
-            {
-            case SDL_SCANCODE_ESCAPE:
-                section.name = SECTION_PROG_QUIT;
-                break;
-
-            case SDL_SCANCODE_B:
-                screen->switchBorder();
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F:
-                screen->switchVideoMode();
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F1:
-                screen->setWindowSize(1);
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F2:
-                screen->setWindowSize(2);
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F3:
-                screen->setWindowSize(3);
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F4:
-                screen->setWindowSize(4);
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F5:
-                switchPalette();
-                break;
-
-            default:
-                break;
-            }
-        }
+    }
+}
+
+// Comprueba las entradas
+void Ending2::checkInput()
+{
+
+    if (input->checkInput(input_exit, REPEAT_FALSE))
+    {
+        section->name = SECTION_PROG_LOGO;
+        section->subsection = SUBSECTION_LOGO_TO_INTRO;
+    }
+
+    else if (input->checkInput(input_toggle_border, REPEAT_FALSE))
+    {
+        screen->switchBorder();
+    }
+
+    else if (input->checkInput(input_window_fullscreen, REPEAT_FALSE))
+    {
+        screen->switchVideoMode();
+    }
+
+    else if (input->checkInput(input_window_dec_size, REPEAT_FALSE))
+    {
+        screen->decWindowSize();
+    }
+
+    else if (input->checkInput(input_window_inc_size, REPEAT_FALSE))
+    {
+        screen->incWindowSize();
+    }
+
+    else if (input->checkInput(input_swap_palette, REPEAT_FALSE))
+    {
+        switchPalette();
     }
 }
 
 // Bucle principal
-section_t Ending2::run()
+void Ending2::run()
 {
     JA_PlayMusic(music);
 
-    while (section.name == SECTION_PROG_ENDING2)
+    while (section->name == SECTION_PROG_ENDING2)
     {
         update();
         render();
@@ -251,8 +244,6 @@ section_t Ending2::run()
 
     JA_StopMusic();
     JA_SetVolume(128);
-
-    return section;
 }
 
 // Actualiza los contadores
@@ -275,8 +266,8 @@ void Ending2::updateCounters()
 
     if (postCounter > 600)
     {
-        section.name = SECTION_PROG_LOGO;
-        section.subsection = SUBSECTION_LOGO_TO_INTRO;
+        section->name = SECTION_PROG_LOGO;
+        section->subsection = SUBSECTION_LOGO_TO_INTRO;
     }
 }
 
@@ -288,7 +279,7 @@ void Ending2::iniSpriteList()
 
     // Añade los valores
     spriteList.push_back("bin");
-    spriteList.push_back("diskette");
+    spriteList.push_back("floppy");
     spriteList.push_back("bird");
     spriteList.push_back("chip");
     spriteList.push_back("jeannine");
@@ -469,13 +460,13 @@ void Ending2::placeSprites()
     {
         const int x = i % 2 == 0 ? firstCol : secondCol;
         const int y = (i / 1) * (maxSpriteHeight + distSpriteText + text->getCharacterSize() + distSpriteSprite) + GAMECANVAS_HEIGHT + 40;
-        const int w = sprites.at(i)->getAnimationClip(0, 0).w;
-        const int h = sprites.at(i)->getAnimationClip(0, 0).h;
+        const int w = sprites[i]->getAnimationClip(0, 0).w;
+        const int h = sprites[i]->getAnimationClip(0, 0).h;
         const int dx = -(w / 2);
         const int dy = i % 1 == 0 ? maxSpriteHeight - h : (int)(maxSpriteHeight * 1.5f) - h;
 
-        sprites.at(i)->setRect({x + dx, y + dy, w, h});
-        sprites.at(i)->setVelY(despSpeed);
+        sprites[i]->setRect({x + dx, y + dy, w, h});
+        sprites[i]->setVelY(despSpeed);
     }
 
     // Recoloca el último sprite, que es el del jugador
@@ -497,14 +488,14 @@ void Ending2::createSpriteTexts()
     for (int i = 0; i < (int)spriteList.size(); ++i)
     {
         // Calcula constantes
-        std::string txt = spriteList.at(i);
+        std::string txt = spriteList[i];
         std::replace(txt.begin(), txt.end(), '_', ' ');
         txt = txt == "player" ? "JAILDOCTOR" : txt; // Reemplaza el texto
         const int w = text->lenght(txt, 1);
         const int h = text->getCharacterSize();
         const int x = i % 2 == 0 ? firstCol : secondCol;
         const int dx = -(w / 2);
-        const int y = sprites.at(i)->getPosY() + sprites.at(i)->getHeight() + distSpriteText;
+        const int y = sprites[i]->getPosY() + sprites[i]->getHeight() + distSpriteText;
 
         // Cambia la posición del último sprite
         const int X = (i == (int)spriteList.size() - 1) ? GAMECANVAS_CENTER_X - (w / 2) : x + dx;
@@ -536,7 +527,7 @@ void Ending2::createTexts()
     for (int i = 0; i < (int)list.size(); ++i)
     {
         // Calcula constantes
-        const int w = text->lenght(list.at(i), 1);
+        const int w = text->lenght(list[i], 1);
         const int h = text->getCharacterSize();
         const int x = GAMECANVAS_CENTER_X;
         const int dx = -(w / 2);
@@ -547,7 +538,7 @@ void Ending2::createTexts()
         texture->createBlank(renderer, w, h, SDL_TEXTUREACCESS_TARGET);
         texture->setAsRenderTarget(renderer);
         texture->setBlendMode(SDL_BLENDMODE_BLEND);
-        text->write(0, 0, list.at(i));
+        text->write(0, 0, list[i]);
 
         // Crea el sprite
         MovingSprite *sprite = new MovingSprite(x + dx, y, w, h, 0.0f, despSpeed, 0.0f, 0.0f, texture, renderer);
@@ -565,7 +556,7 @@ void Ending2::createTexts()
     for (int i = 0; i < (int)list.size(); ++i)
     {
         // Calcula constantes
-        const int w = text->lenght(list.at(i), 1);
+        const int w = text->lenght(list[i], 1);
         const int h = text->getCharacterSize();
         const int x = GAMECANVAS_CENTER_X;
         const int dx = -(w / 2);
@@ -576,7 +567,7 @@ void Ending2::createTexts()
         texture->createBlank(renderer, w, h, SDL_TEXTUREACCESS_TARGET);
         texture->setAsRenderTarget(renderer);
         texture->setBlendMode(SDL_BLENDMODE_BLEND);
-        text->write(0, 0, list.at(i));
+        text->write(0, 0, list[i]);
 
         // Crea el sprite
         MovingSprite *sprite = new MovingSprite(x + dx, y, w, h, 0.0f, despSpeed, 0.0f, 0.0f, texture, renderer);
@@ -624,7 +615,7 @@ void Ending2::updateFinalFade()
 
     for (auto t : texts)
     {
-        t->getTexture()->setColor(colors.at(index).r, colors.at(index).g, colors.at(index).b);
+        t->getTexture()->setColor(colors[index].r, colors[index].g, colors[index].b);
     }
 }
 

source/ending2.h

@@ -2,6 +2,7 @@
 #include <SDL2/SDL.h>
 #include "common/animatedsprite.h"
 #include "common/asset.h"
+#include "common/input.h"
 #include "common/jail_audio.h"
 #include "common/resource.h"
 #include "common/screen.h"
@@ -25,21 +26,22 @@ private:
 	Screen *screen;							 // Objeto encargado de dibujar en pantalla
 	SDL_Event *eventHandler;				 // Manejador de eventos
 	SDL_Renderer *renderer;					 // El renderizador de la ventana
+	Input *input;							 // Objeto pata gestionar la entrada
 	Text *text;								 // Objeto para escribir texto en pantalla
 	options_t *options;						 // Puntero a las opciones del juego
 	std::vector<AnimatedSprite *> sprites;	 // Vector con todos los sprites a dibujar
 	std::vector<MovingSprite *> spriteTexts; // Vector con los sprites de texto de los sprites
 	std::vector<MovingSprite *> texts;		 // Vector con los sprites de texto
+	section_t *section;						 // Estado del bucle principal para saber si continua o se sale
 
 	// Variables
 	bool counterEnabled;				 // Indica si está el contador habilitado
 	int preCounter;						 // Contador previo
 	int postCounter;					 // Contador posterior
 	bool postCounterEnabled;			 // Indica si está habilitado el contador
-	section_t section;					 // Estado del bucle principal para saber si continua o se sale
 	Uint32 ticks;						 // Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticksSpeed;					 // Velocidad a la que se repiten los bucles del programa
-	JA_Music music;						 // Musica que suena durante el final
+	JA_Music_t *music;					 // Musica que suena durante el final
 	std::vector<std::string> spriteList; // Lista con todos los sprites a dibujar
 	std::vector<color_t> colors;		 // Vector con los colores para el fade
 	int maxSpriteWidth;					 // El valor de ancho del sprite mas ancho
@@ -59,6 +61,9 @@ private:
 	// Comprueba el manejador de eventos
 	void checkEventHandler();
 
+	// Comprueba las entradas
+	void checkInput();
+
 	// Actualiza los contadores
 	void updateCounters();
 
@@ -115,13 +120,13 @@ private:
 
 public:
 	// Constructor
-	Ending2(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options);
+	Ending2(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section);
 
 	// Destructor
 	~Ending2();
 
 	// Bucle principal
-	section_t run();
+	void run();
 };
 
 #endif

source/enter_id.cpp

@@ -5,13 +5,14 @@
 #include <iostream>
 
 // Constructor
-EnterID::EnterID(SDL_Renderer *renderer, Screen *screen, Asset *asset, options_t *options, section_t section)
+EnterID::EnterID(SDL_Renderer *renderer, Screen *screen, Asset *asset, options_t *options, section_t *section)
 {
     // Copia la dirección de los objetos
     this->renderer = renderer;
     this->screen = screen;
     this->asset = asset;
     this->options = options;
+    this->section = section;
 
     // Reserva memoria para los punteros
     eventHandler = new SDL_Event();
@@ -36,11 +37,10 @@ EnterID::EnterID(SDL_Renderer *renderer, Screen *screen, Asset *asset, options_t
     pos = 0;
     name[pos] = 0;
     maxLenght = 15;
-    this->section.subsection = section.subsection;
 
     if (options->online.enabled && options->online.jailerID == "")
     {
-        this->section.name = SECTION_PROG_ENTER_ID;
+        this->section->name = SECTION_PROG_ENTER_ID;
     }
     else
     {
@@ -60,18 +60,16 @@ EnterID::~EnterID()
 }
 
 // Bucle para el logo del juego
-section_t EnterID::run()
+void EnterID::run()
 {
     // Detiene la música
     JA_StopMusic();
 
-    while (section.name == SECTION_PROG_ENTER_ID)
+    while (section->name == SECTION_PROG_ENTER_ID)
     {
         update();
         render();
     }
-
-    return section;
 }
 
 // Comprueba el manejador de eventos
@@ -83,7 +81,7 @@ void EnterID::checkEventHandler()
         // Evento de salida de la aplicación
         if (eventHandler->type == SDL_QUIT)
         {
-            section.name = SECTION_PROG_QUIT;
+            section->name = SECTION_PROG_QUIT;
             break;
         }
 
@@ -138,7 +136,7 @@ void EnterID::checkEventHandler()
 
             else if (eventHandler->key.keysym.scancode == SDL_SCANCODE_ESCAPE)
             {
-                section.name = SECTION_PROG_QUIT;
+                section->name = SECTION_PROG_QUIT;
                 break;
             }
 
@@ -281,6 +279,11 @@ void EnterID::switchPalette()
 // Inicializa los servicios online
 void EnterID::initOnline()
 {
+    if (options->online.sessionEnabled)
+    { // Si ya ha iniciado la sesión, que no continue
+        return;
+    }
+
     if (options->online.jailerID == "")
     { // Jailer ID no definido
 
@@ -289,11 +292,15 @@ void EnterID::initOnline()
     else
     { // Jailer ID iniciado
 
-        options->online.enabled = true;
+        options->online.enabled = options->online.sessionEnabled = true;
         jscore::init(options->online.server, options->online.port);
 
-        const std::string caption = options->online.jailerID + " IS LOGGED IN";
-        screen->showNotification(caption);
+#ifdef DEBUG
+        const std::string caption = "IS LOGGED IN (DEBUG)";
+#else
+        const std::string caption = "IS LOGGED IN";
+#endif
+        screen->showNotification(options->online.jailerID, caption, 12);
         if (options->console)
         {
             std::cout << caption << std::endl;
@@ -305,6 +312,6 @@ void EnterID::initOnline()
 void EnterID::endSection()
 {
     initOnline();
-    section.name = (section.subsection == SUBSECTION_LOGO_TO_INTRO) ? SECTION_PROG_INTRO : SECTION_PROG_TITLE;
-    section.subsection = 0;
+    section->name = (section->subsection == SUBSECTION_LOGO_TO_INTRO) ? SECTION_PROG_INTRO : SECTION_PROG_TITLE;
+    section->subsection = 0;
 }

source/enter_id.h

@@ -29,10 +29,10 @@ private:
 	SDL_Texture *textTexture; // Textura para dibujar el texto
 	Text *text;				  // Objeto para escribir texto en pantalla
 	Texture *texture;		  // Textura para la fuente para el texto
+	section_t *section;		  // Estado del bucle principal para saber si continua o se sale
 
 	// Variables
 	int counter;				   // Contador
-	section_t section;			   // Estado del bucle principal para saber si continua o se sale
 	Uint32 ticks;				   // Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticksSpeed;			   // Velocidad a la que se repiten los bucles del programa
 	std::vector<captions_t> texts; // Vector con los textos
@@ -68,13 +68,13 @@ private:
 
 public:
 	// Constructor
-	EnterID(SDL_Renderer *renderer, Screen *screen, Asset *asset, options_t *options, section_t section);
+	EnterID(SDL_Renderer *renderer, Screen *screen, Asset *asset, options_t *options, section_t *section);
 
 	// Destructor
 	~EnterID();
 
 	// Bucle principal
-	section_t run();
+	void run();
 };
 
 #endif

source/game.cpp

@@ -2,15 +2,8 @@
 #include <iostream>
 
 // Constructor
-Game::Game(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options, Input *input, Debug *debug)
+Game::Game(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options, Input *input, section_t *section, Debug *debug)
 {
-	// Inicia algunas variables
-	board.iniClock = SDL_GetTicks();
-	currentRoom = "03.room";
-	const int x = 25;
-	const int y = 13;
-	spawnPoint = {x * 8, y * 8, 0, 0, 0, s_standing, SDL_FLIP_HORIZONTAL};
-
 	// Copia los punteros
 	this->resource = resource;
 	this->renderer = renderer;
@@ -19,15 +12,25 @@ Game::Game(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *as
 	this->input = input;
 	this->debug = debug;
 	this->options = options;
+	this->section = section;
 
+	// Inicia algunas variables
+	board.iniClock = SDL_GetTicks();
 #ifdef DEBUG
-	currentRoom = "01.room";
-	const int x1 = 25;
-	const int y1 = 13;
-	spawnPoint = {x1 * 8, y1 * 8, 0, 0, 0, s_standing, SDL_FLIP_HORIZONTAL};
+	currentRoom = "03.room";
+	const int x = 25;
+	const int y = 13;
+	spawnPoint = {x * 8, y * 8, 0, 0, 0, s_standing, SDL_FLIP_HORIZONTAL};
+	debug->setEnabled(false);
+#else
+	currentRoom = "03.room";
+	const int x = 25;
+	const int y = 13;
+	spawnPoint = {x * 8, y * 8, 0, 0, 0, s_standing, SDL_FLIP_HORIZONTAL};
 #endif
 
 	// Crea los objetos
+	cheevos = new Cheevos(screen, options, asset->get("cheevos.bin"));
 	scoreboard = new ScoreBoard(renderer, resource, asset, options, &board);
 	itemTracker = new ItemTracker();
 	roomTracker = new RoomTracker();
@@ -42,6 +45,25 @@ Game::Game(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *as
 	deathSound = JA_LoadSound(asset->get("death.wav").c_str());
 	stats = new Stats(asset->get("stats.csv"), asset->get("stats_buffer.csv"), options);
 
+	// Crea la textura para poner el nombre de la habitación
+	roomNameTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, text->getCharacterSize() * 2);
+	if (roomNameTexture == nullptr)
+	{
+		if (options->console)
+		{
+			std::cout << "Error: roomNameTexture could not be created!\nSDL Error: " << SDL_GetError() << std::endl;
+		}
+	}
+
+	// Establece el blend mode de la textura
+	SDL_SetTextureBlendMode(roomNameTexture, SDL_BLENDMODE_BLEND);
+
+	// Establece el destino de la textura
+	roomNameRect = {0, PLAY_AREA_HEIGHT, GAMECANVAS_WIDTH, text->getCharacterSize() * 2};
+
+	// Pone el nombre de la habitación en la textura
+	fillRoomNameTexture();
+
 	// Inicializa el resto de variables
 	ticks = 0;
 	ticksSpeed = 15;
@@ -61,14 +83,17 @@ Game::Game(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *as
 	totalItems = getTotalItems();
 	initStats();
 	stats->addVisit(room->getName());
+	const bool cheats = options->cheat.infiniteLives || options->cheat.invincible || options->cheat.jailEnabled;
+	cheevos->enable(!cheats); // Deshabilita los logros si hay trucos activados
 
-	section.name = SECTION_PROG_GAME;
-	section.subsection = 0;
+	section->name = SECTION_PROG_GAME;
+	section->subsection = 0;
 }
 
 Game::~Game()
 {
 	// Libera la memoria de los objetos
+	delete cheevos;
 	delete scoreboard;
 	delete itemTracker;
 	delete roomTracker;
@@ -78,6 +103,8 @@ Game::~Game()
 	delete text;
 	delete stats;
 
+	SDL_DestroyTexture(roomNameTexture);
+
 	JA_DeleteMusic(music);
 	JA_DeleteSound(deathSound);
 }
@@ -91,7 +118,7 @@ void Game::checkEventHandler()
 		// Evento de salida de la aplicación
 		if (eventHandler->type == SDL_QUIT)
 		{
-			section.name = SECTION_PROG_QUIT;
+			section->name = SECTION_PROG_QUIT;
 			screen->setBorderColor(stringToColor(options->palette, "black"));
 			break;
 		}
@@ -101,13 +128,10 @@ void Game::checkEventHandler()
 			reLoadTextures();
 		}
 
-		if ((eventHandler->type == SDL_KEYDOWN) and (eventHandler->key.repeat == 0))
+		if (eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0)
 		{
 			switch (eventHandler->key.keysym.scancode)
 			{
-			case SDL_SCANCODE_ESCAPE:
-				section.name = SECTION_PROG_TITLE;
-				break;
 #ifdef DEBUG
 			case SDL_SCANCODE_G:
 				debug->switchEnabled();
@@ -137,53 +161,21 @@ void Game::checkEventHandler()
 				break;
 
 			case SDL_SCANCODE_F6:
-				screen->showNotification("MAMA MIRA! SIN MANOS!");
+				screen->showNotification("ACHIEVEMENT UNLOCKED!", "I LIKE MY MULTICOLOURED FRIENDS", 2);
+				break;
+
+			case SDL_SCANCODE_F7:
+				screen->showNotification("ACHIEVEMENT UNLOCKED!", "I LIKE MY MULTICOLOURED FRIENDS", 3);
+				break;
+
+			case SDL_SCANCODE_F8:
+				screen->showNotification("JAILDESIGNER IS LOGGED IN", "", 4);
+				break;
+
+			case SDL_SCANCODE_F9:
+				screen->showNotification("JAILDESIGNER IS LOGGED IN", "", 5);
 				break;
 #endif
-
-			case SDL_SCANCODE_M:
-				board.music = !board.music;
-				board.music ? JA_ResumeMusic() : JA_PauseMusic();
-				break;
-
-			case SDL_SCANCODE_H:
-				switchPause();
-				break;
-
-			case SDL_SCANCODE_B:
-				screen->switchBorder();
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F:
-				screen->switchVideoMode();
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F1:
-				screen->setWindowSize(1);
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F2:
-				screen->setWindowSize(2);
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F3:
-				screen->setWindowSize(3);
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F4:
-				screen->setWindowSize(4);
-				reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F5:
-				switchPalette();
-				break;
-
 			default:
 				break;
 			}
@@ -191,8 +183,57 @@ void Game::checkEventHandler()
 	}
 }
 
+// Comprueba el teclado
+void Game::checkInput()
+{
+	if (input->checkInput(input_exit, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_TITLE;
+	}
+
+	else if (input->checkInput(input_switch_music, REPEAT_FALSE))
+	{
+		board.music = !board.music;
+		board.music ? JA_ResumeMusic() : JA_PauseMusic();
+	}
+
+	else if (input->checkInput(input_pause, REPEAT_FALSE))
+	{
+		switchPause();
+	}
+
+	else if (input->checkInput(input_toggle_border, REPEAT_FALSE))
+	{
+		screen->switchBorder();
+		reLoadTextures();
+	}
+
+	else if (input->checkInput(input_window_fullscreen, REPEAT_FALSE))
+	{
+		screen->switchVideoMode();
+		reLoadTextures();
+	}
+
+	else if (input->checkInput(input_window_dec_size, REPEAT_FALSE))
+	{
+		screen->decWindowSize();
+		reLoadTextures();
+	}
+
+	else if (input->checkInput(input_window_inc_size, REPEAT_FALSE))
+	{
+		screen->incWindowSize();
+		reLoadTextures();
+	}
+
+	else if (input->checkInput(input_swap_palette, REPEAT_FALSE))
+	{
+		switchPalette();
+	}
+}
+
 // Bucle para el juego
-section_t Game::run()
+void Game::run()
 {
 	JA_PlayMusic(music);
 	if (!board.music)
@@ -200,28 +241,29 @@ section_t Game::run()
 		JA_PauseMusic();
 	}
 
-	while (section.name == SECTION_PROG_GAME)
+	while (section->name == SECTION_PROG_GAME)
 	{
 		update();
 		render();
 	}
 
 	JA_StopMusic();
-
-	return section;
 }
 
 // Actualiza el juego, las variables, comprueba la entrada, etc.
 void Game::update()
 {
+	// Comprueba los eventos de la cola
+	checkEventHandler();
+
 	// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
 	if (SDL_GetTicks() - ticks > ticksSpeed)
 	{
 		// Actualiza el contador de ticks
 		ticks = SDL_GetTicks();
 
-		// Comprueba los eventos de la cola
-		checkEventHandler();
+		// Comprueba el teclado
+		checkInput();
 
 #ifdef DEBUG
 		debug->clear();
@@ -237,6 +279,7 @@ void Game::update()
 		checkGameOver();
 		checkEndGame();
 		checkRestoringJail();
+		checkSomeCheevos();
 		scoreboard->update();
 		input->update();
 
@@ -256,8 +299,8 @@ void Game::render()
 {
 	// Prepara para dibujar el frame
 	screen->start();
-	screen->clean(room->getBGColor());
 
+	// Dibuja los elementos del juego en orden
 	room->renderMap();
 	room->renderEnemies();
 	room->renderItems();
@@ -317,13 +360,8 @@ void Game::renderDebugInfo()
 // Escribe el nombre de la pantalla
 void Game::renderRoomName()
 {
-	// Texto en el centro de la pantalla
-	SDL_Rect rect = {0, 16 * BLOCK, PLAY_AREA_WIDTH, BLOCK * 2};
-	color_t color = stringToColor(options->palette, "white");
-	SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
-	SDL_RenderFillRect(renderer, &rect);
-
-	text->writeDX(TXT_CENTER | TXT_COLOR, GAMECANVAS_CENTER_X, 16 * 8 + 4, room->getName(), 1, room->getBGColor());
+	// Dibuja la textura con el nombre de la habitación
+	SDL_RenderCopy(renderer, roomNameTexture, nullptr, &roomNameRect);
 }
 
 // Cambia de habitación
@@ -345,6 +383,9 @@ bool Game::changeRoom(std::string file)
 		// Crea un objeto habitación nuevo a partir del fichero
 		room = new Room(resource->getRoom(file), renderer, screen, asset, options, itemTracker, &board.items, board.jailEnabled, debug);
 
+		// Pone el nombre de la habitación en la textura
+		fillRoomNameTexture();
+
 		// Pone el color del marcador en función del color del borde de la habitación
 		setScoreBoardColor();
 
@@ -413,7 +454,7 @@ void Game::checkGameOver()
 {
 	if (board.lives < 0 && blackScreenCounter > 17)
 	{
-		section.name = SECTION_PROG_GAME_OVER;
+		section->name = SECTION_PROG_GAME_OVER;
 	}
 }
 
@@ -434,6 +475,9 @@ void Game::killPlayer()
 	// Actualiza las estadisticas
 	stats->addDeath(room->getName());
 
+	// Invalida el logro de pasarse el juego sin morir
+	cheevos->invalidate(11);
+
 	// Destruye la habitacion y el jugador
 	delete room;
 	delete this->player;
@@ -539,24 +583,21 @@ void Game::setScoreBoardColor()
 // Comprueba si ha finalizado el juego
 bool Game::checkEndGame()
 {
-	const bool isOnTheRoom = room->getName() == "THE JAIL";			 // Estar en la habitación que toca
-	const bool haveTheItems = board.items >= int(totalItems * 0.9f); // Con mas del 90% de los items recogidos
-	const bool isOnTheDoor = player->getRect().x <= 128;			 // Y en la ubicación que toca (En la puerta)
+	const bool isOnTheRoom = room->getName() == "THE JAIL";										   // Estar en la habitación que toca
+	const bool haveTheItems = board.items >= int(totalItems * 0.9f) || options->cheat.jailEnabled; // Con mas del 90% de los items recogidos
+	const bool isOnTheDoor = player->getRect().x <= 128;										   // Y en la ubicación que toca (En la puerta)
 
 	if (haveTheItems)
 	{
 		board.jailEnabled = true;
 	}
 
-	if (isOnTheRoom && haveTheItems && isOnTheDoor)
+	if (haveTheItems && isOnTheRoom && isOnTheDoor)
 	{
-		section.name = SECTION_PROG_ENDING;
-		return true;
-	}
+		// Comprueba los logros de completar el juego
+		checkEndGameCheevos();
 
-	if (options->cheat.jailEnabled && isOnTheRoom && isOnTheDoor)
-	{
-		section.name = SECTION_PROG_ENDING;
+		section->name = SECTION_PROG_ENDING;
 		return true;
 	}
 
@@ -616,12 +657,25 @@ void Game::checkRestoringJail()
 	}
 
 	static int counter = 0;
-	counter++;
+
+	if (!paused)
+	{
+		counter++;
+	}
+
+	// Incrementa el numero de vidas
 	if (counter == 100)
 	{
 		counter = 0;
 		board.lives++;
 		JA_PlaySound(deathSound);
+
+		// Invalida el logro de completar el juego sin entrar a la jail
+		const bool haveTheItems = board.items >= int(totalItems * 0.9f);
+		if (!haveTheItems)
+		{
+			cheevos->invalidate(9);
+		}
 	}
 }
 
@@ -637,4 +691,92 @@ void Game::initStats()
 	}
 
 	stats->init();
+}
+
+// Crea la textura con el nombre de la habitación
+void Game::fillRoomNameTexture()
+{
+	// Pone la textura como destino de renderizado
+	SDL_SetRenderTarget(renderer, roomNameTexture);
+
+	// Rellena la textura de color
+	const color_t color = stringToColor(options->palette, "white");
+	SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
+	SDL_RenderClear(renderer);
+
+	// Escribe el texto en la textura
+	text->writeDX(TXT_CENTER | TXT_COLOR, GAMECANVAS_CENTER_X, text->getCharacterSize() / 2, room->getName(), 1, room->getBGColor());
+
+	// Deja el renderizador por defecto
+	SDL_SetRenderTarget(renderer, nullptr);
+}
+
+// Comprueba algunos logros
+void Game::checkSomeCheevos()
+{
+	// Logros sobre la cantidad de items
+	if (board.items == totalItems)
+	{
+		cheevos->unlock(4);
+		cheevos->unlock(3);
+		cheevos->unlock(2);
+		cheevos->unlock(1);
+	}
+	else if (board.items >= totalItems * 0.75f)
+	{
+		cheevos->unlock(3);
+		cheevos->unlock(2);
+		cheevos->unlock(1);
+	}
+	else if (board.items >= totalItems * 0.5f)
+	{
+		cheevos->unlock(2);
+		cheevos->unlock(1);
+	}
+	else if (board.items >= totalItems * 0.25f)
+	{
+		cheevos->unlock(1);
+	}
+
+	// Logros sobre las habitaciones visitadas
+	if (board.rooms >= 60)
+	{
+		cheevos->unlock(7);
+		cheevos->unlock(6);
+		cheevos->unlock(5);
+	}
+	else if (board.rooms >= 40)
+	{
+		cheevos->unlock(6);
+		cheevos->unlock(5);
+	}
+	else if (board.rooms >= 20)
+	{
+		cheevos->unlock(5);
+	}
+}
+
+// Comprueba los logros de completar el juego
+void Game::checkEndGameCheevos()
+{
+	// "Complete the game"
+	cheevos->unlock(8);
+
+	// "Complete the game without entering the jail"
+	cheevos->unlock(9);
+
+	// "Complete the game with all items"
+	if (board.items == totalItems)
+	{
+		cheevos->unlock(10);
+	}
+
+	// "Complete the game without dying"
+	cheevos->unlock(11);
+
+	// "Complete the game in under 30 minutes"
+	if (scoreboard->getMinutes() < 30)
+	{
+		cheevos->unlock(12);
+	}
 }

source/game.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <SDL2/SDL.h>
+#include "cheevos.h"
 #include "common/animatedsprite.h"
 #include "common/asset.h"
 #include "common/debug.h"
@@ -26,35 +27,38 @@ class Game
 {
 private:
 	// Objetos y punteros
-	SDL_Renderer *renderer;	  // El renderizador de la ventana
-	SDL_Event *eventHandler;  // Manejador de eventos
-	Screen *screen;			  // Objeto encargado de manejar el renderizador
-	Room *room;				  // Objeto encargado de gestionar cada habitación del juego
-	Player *player;			  // Objeto con el jugador
-	ItemTracker *itemTracker; // Lleva el control de los objetos recogidos
-	RoomTracker *roomTracker; // Lleva el control de las habitaciones visitadas
-	Asset *asset;			  // Objeto con la ruta a todos los ficheros de recursos
-	Input *input;			  // Objeto pata gestionar la entrada
-	Text *text;				  // Objeto para los textos del juego
-	ScoreBoard *scoreboard;	  // Objeto encargado de gestionar el marcador
-	Resource *resource;		  // Objeto con los recursos
-	Debug *debug;			  // Objeto para gestionar la información de debug
-	options_t *options;		  // Puntero a las opciones del juego
-	Stats *stats;			  // Objeto encargado de gestionar las estadísticas
+	SDL_Renderer *renderer;		  // El renderizador de la ventana
+	SDL_Event *eventHandler;	  // Manejador de eventos
+	Screen *screen;				  // Objeto encargado de manejar el renderizador
+	Room *room;					  // Objeto encargado de gestionar cada habitación del juego
+	Player *player;				  // Objeto con el jugador
+	ItemTracker *itemTracker;	  // Lleva el control de los objetos recogidos
+	RoomTracker *roomTracker;	  // Lleva el control de las habitaciones visitadas
+	Asset *asset;				  // Objeto con la ruta a todos los ficheros de recursos
+	Input *input;				  // Objeto pata gestionar la entrada
+	Text *text;					  // Objeto para los textos del juego
+	ScoreBoard *scoreboard;		  // Objeto encargado de gestionar el marcador
+	Cheevos *cheevos;			  // Objeto encargado de gestionar los logros del juego
+	Resource *resource;			  // Objeto con los recursos
+	Debug *debug;				  // Objeto para gestionar la información de debug
+	options_t *options;			  // Puntero a las opciones del juego
+	Stats *stats;				  // Objeto encargado de gestionar las estadísticas
+	SDL_Texture *roomNameTexture; // Textura para escribir el nombre de la habitación
+	section_t *section;			  // Seccion actual dentro del juego
 
 	// Variables
-	JA_Music music;			  // Musica que suena durante el juego
+	JA_Music_t *music;		  // Musica que suena durante el juego
 	Uint32 ticks;			  // Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticksSpeed;		  // Velocidad a la que se repiten los bucles del programa
-	section_t section;		  // Seccion actual dentro del juego
 	std::string currentRoom;  // Fichero de la habitación actual
 	playerSpawn_t spawnPoint; // Lugar de la habitación donde aparece el jugador
-	JA_Sound deathSound;	  // Sonido a reproducir cuando muere el jugador
+	JA_Sound_t *deathSound;	  // Sonido a reproducir cuando muere el jugador
 	board_t board;			  // Estructura con los datos del marcador
 	bool paused;			  // Indica si el juego se encuentra en pausa
 	bool blackScreen;		  // Indica si la pantalla está en negro. Se utiliza para la muerte del jugador
 	int blackScreenCounter;	  // Contador para temporizar la pantalla en negro
 	int totalItems;			  // Cantidad total de items que hay en el mapeado del juego
+	SDL_Rect roomNameRect;	  // Rectangulo donde pintar la textura con el nombre de la habitación
 
 	// Actualiza el juego, las variables, comprueba la entrada, etc.
 	void update();
@@ -79,6 +83,9 @@ private:
 	// Cambia de habitación
 	bool changeRoom(std::string file);
 
+	// Comprueba el teclado
+	void checkInput();
+
 	// Comprueba si el jugador esta en el borde de la pantalla y actua
 	void checkPlayerOnBorder();
 
@@ -133,15 +140,24 @@ private:
 	// Inicializa el diccionario de las estadísticas
 	void initStats();
 
+	// Pone el nombre de la habitación en la textura
+	void fillRoomNameTexture();
+
+	// Comprueba algunos logros
+	void checkSomeCheevos();
+
+	// Comprueba los logros de completar el juego
+	void checkEndGameCheevos();
+
 public:
 	// Constructor
-	Game(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options, Input *input, Debug *debug);
+	Game(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options, Input *input, section_t *section, Debug *debug);
 
 	// Destructor
 	~Game();
 
 	// Bucle para el juego
-	section_t run();
+	void run();
 };
 
 #endif

source/game_over.cpp

@@ -1,14 +1,16 @@
 #include "game_over.h"
 
 // Constructor
-GameOver::GameOver(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options)
+GameOver::GameOver(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section)
 {
     // Copia los punteros
     this->renderer = renderer;
     this->screen = screen;
     this->resource = resource;
     this->asset = asset;
+    this->input = input;
     this->options = options;
+    this->section = section;
 
     // Reserva memoria para los punteros a objetos
     eventHandler = new SDL_Event();
@@ -20,8 +22,8 @@ GameOver::GameOver(SDL_Renderer *renderer, Screen *screen, Resource *resource, A
     // Inicializa variables
     preCounter = 0;
     counter = 0;
-    section.name = SECTION_PROG_GAME_OVER;
-    section.subsection = 0;
+    section->name = SECTION_PROG_GAME_OVER;
+    section->subsection = 0;
     ticks = 0;
     ticksSpeed = 15;
     endSection = 400;
@@ -55,14 +57,17 @@ GameOver::~GameOver()
 // Actualiza el objeto
 void GameOver::update()
 {
+    // Comprueba el manejador de eventos
+    checkEventHandler();
+
     // Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
     if (SDL_GetTicks() - ticks > ticksSpeed)
     {
         // Actualiza el contador de ticks
         ticks = SDL_GetTicks();
 
-        // Comprueba el manejador de eventos
-        checkEventHandler();
+        // Comprueba las entradas
+        checkInput();
 
         // Actualiza el color usado para renderizar los textos e imagenes
         updateColor();
@@ -83,7 +88,7 @@ void GameOver::update()
 void GameOver::render()
 {
     const int y = 32;
-    
+
     // Prepara para empezar a dibujar en la textura de juego
     screen->start();
 
@@ -121,71 +126,56 @@ void GameOver::checkEventHandler()
         // Evento de salida de la aplicación
         if (eventHandler->type == SDL_QUIT)
         {
-            section.name = SECTION_PROG_QUIT;
-            section.subsection = 0;
+            section->name = SECTION_PROG_QUIT;
+            section->subsection = 0;
             break;
         }
-
-        // Comprueba las teclas que se han pulsado
-        if ((eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONDOWN))
-        {
-            switch (eventHandler->key.keysym.scancode)
-            {
-            case SDL_SCANCODE_ESCAPE:
-                section.name = SECTION_PROG_QUIT;
-                break;
-
-            case SDL_SCANCODE_B:
-                screen->switchBorder();
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F:
-                screen->switchVideoMode();
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F1:
-                screen->setWindowSize(1);
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F2:
-                screen->setWindowSize(2);
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F3:
-                screen->setWindowSize(3);
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F4:
-                screen->setWindowSize(4);
-                resource->reLoadTextures();
-                break;
-
-            case SDL_SCANCODE_F5:
-                switchPalette();
-                break;
-
-            default:
-                break;
-            }
-        }
     }
 }
 
-// Bucle principal
-section_t GameOver::run()
+// Comprueba las entradas
+void GameOver::checkInput()
 {
-    while (section.name == SECTION_PROG_GAME_OVER)
+
+    if (input->checkInput(input_exit, REPEAT_FALSE))
+    {
+        section->name = SECTION_PROG_QUIT;
+    }
+
+    else if (input->checkInput(input_toggle_border, REPEAT_FALSE))
+    {
+        screen->switchBorder();
+    }
+
+    else if (input->checkInput(input_window_fullscreen, REPEAT_FALSE))
+    {
+        screen->switchVideoMode();
+    }
+
+    else if (input->checkInput(input_window_dec_size, REPEAT_FALSE))
+    {
+        screen->decWindowSize();
+    }
+
+    else if (input->checkInput(input_window_inc_size, REPEAT_FALSE))
+    {
+        screen->incWindowSize();
+    }
+
+    else if (input->checkInput(input_swap_palette, REPEAT_FALSE))
+    {
+        switchPalette();
+    }
+}
+
+// Bucle principal
+void GameOver::run()
+{
+    while (section->name == SECTION_PROG_GAME_OVER)
     {
         update();
         render();
     }
-
-    return section;
 }
 
 // Actualiza el color usado para renderizar los textos e imagenes
@@ -195,16 +185,15 @@ void GameOver::updateColor()
 
     if (counter < half)
     {
-        // const float step = std::min(std::max(counter, iniFade) - iniFade, fadeLenght) / (float)fadeLenght;
         const float step = std::min(counter, fadeLenght) / (float)fadeLenght;
         const int index = (colors.size() - 1) - int((colors.size() - 1) * step);
-        color = colors.at(index);
+        color = colors[index];
     }
     else
     {
         const float step = std::min(std::max(counter, iniFade) - iniFade, fadeLenght) / (float)fadeLenght;
         const int index = (colors.size() - 1) * step;
-        color = colors.at(index);
+        color = colors[index];
     }
 }
 
@@ -240,8 +229,8 @@ void GameOver::updateCounters()
     // Comprueba si ha terminado la sección
     else if (counter == endSection)
     {
-        section.name = SECTION_PROG_LOGO;
-        section.subsection = SUBSECTION_LOGO_TO_TITLE;
+        section->name = SECTION_PROG_LOGO;
+        section->subsection = SUBSECTION_LOGO_TO_TITLE;
     }
 }
 

source/game_over.h

@@ -2,6 +2,7 @@
 #include <SDL2/SDL.h>
 #include "common/animatedsprite.h"
 #include "common/asset.h"
+#include "common/input.h"
 #include "common/jail_audio.h"
 #include "common/resource.h"
 #include "common/screen.h"
@@ -23,16 +24,17 @@ private:
 	Screen *screen;				  // Objeto encargado de dibujar en pantalla
 	Resource *resource;			  // Objeto con los recursos
 	Asset *asset;				  // Objeto con los ficheros de recursos
+	Input *input;				  // Objeto pata gestionar la entrada
 	options_t *options;			  // Puntero a las opciones del juego
 	SDL_Event *eventHandler;	  // Manejador de eventos
 	Text *text;					  // Objeto para escribir texto en pantalla
 	AnimatedSprite *playerSprite; // Sprite con el jugador
 	AnimatedSprite *tvSprite;	  // Sprite con el televisor
+	section_t *section;			  // Estado del bucle principal para saber si continua o se sale
 
 	// Variables
 	int preCounter;				 // Contador previo
 	int counter;				 // Contador
-	section_t section;			 // Estado del bucle principal para saber si continua o se sale
 	Uint32 ticks;				 // Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticksSpeed;			 // Velocidad a la que se repiten los bucles del programa
 	std::vector<color_t> colors; // Vector con los colores para el fade
@@ -40,7 +42,7 @@ private:
 	int endSection;				 // Contador: cuando acaba la sección
 	int iniFade;				 // Contador: cuando emiepza el fade
 	int fadeLenght;				 // Contador: duración del fade
-	JA_Music music;				 // Musica que suena durante el juego
+	JA_Music_t *music;			 // Musica que suena durante el juego
 
 	// Actualiza el objeto
 	void update();
@@ -51,6 +53,9 @@ private:
 	// Comprueba el manejador de eventos
 	void checkEventHandler();
 
+	// Comprueba las entradas
+	void checkInput();
+
 	// Actualiza el color usado para renderizar los textos e imagenes
 	void updateColor();
 
@@ -65,13 +70,13 @@ private:
 
 public:
 	// Constructor
-	GameOver(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options);
+	GameOver(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section);
 
 	// Destructor
 	~GameOver();
 
 	// Bucle principal
-	section_t run();
+	void run();
 };
 
 #endif

source/intro.cpp

@@ -1,14 +1,16 @@
 #include "intro.h"
 
 // Constructor
-Intro::Intro(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options)
+Intro::Intro(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section)
 {
 	// Copia la dirección de los objetos
 	this->resource = resource;
 	this->renderer = renderer;
 	this->screen = screen;
 	this->asset = asset;
+	this->input = input;
 	this->options = options;
+	this->section = section;
 
 	// Reserva memoria para los punteros
 	eventHandler = new SDL_Event();
@@ -31,21 +33,13 @@ Intro::Intro(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *
 	// Inicializa variables
 	preCounter = 0;
 	counter = 0;
-	section.name = SECTION_PROG_INTRO;
-	section.subsection = 0;
+	section->name = SECTION_PROG_INTRO;
+	section->subsection = 0;
 	ticks = 0;
 	ticksSpeed = 15;
 	loadCounter = 0;
-	lineCounter = 0;
 	loadingFirstPart = true;
-
-	// Ls lineas que tapan la primera textura
-	for (int i = 0; i < 192; ++i)
-	{
-		lines[i].x1 = 0;
-		lines[i].x2 = 257;
-		lines[i].y = i;
-	}
+	loadRect = {0, 0, 51, 1};
 
 	// Establece el orden de las lineas para imitar el direccionamiento de memoria del spectrum
 	for (int i = 0; i < 192; ++i)
@@ -90,89 +84,79 @@ void Intro::checkEventHandler()
 		// Evento de salida de la aplicación
 		if (eventHandler->type == SDL_QUIT)
 		{
-			section.name = SECTION_PROG_QUIT;
+			section->name = SECTION_PROG_QUIT;
 			break;
 		}
+	}
+}
 
-		// Comprueba las teclas que se han pulsado
-		if ((eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONDOWN))
-		{
-			switch (eventHandler->key.keysym.scancode)
-			{
-			case SDL_SCANCODE_ESCAPE:
-				section.name = SECTION_PROG_QUIT;
-				break;
+// Comprueba las entradas
+void Intro::checkInput()
+{
 
-			case SDL_SCANCODE_B:
-				screen->switchBorder();
-				resource->reLoadTextures();
-				break;
+	if (input->checkInput(input_exit, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_QUIT;
+	}
 
-			case SDL_SCANCODE_F:
-				screen->switchVideoMode();
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_toggle_border, REPEAT_FALSE))
+	{
+		screen->switchBorder();
+	}
 
-			case SDL_SCANCODE_F1:
-				screen->setWindowSize(1);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_fullscreen, REPEAT_FALSE))
+	{
+		screen->switchVideoMode();
+	}
 
-			case SDL_SCANCODE_F2:
-				screen->setWindowSize(2);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_dec_size, REPEAT_FALSE))
+	{
+		screen->decWindowSize();
+	}
 
-			case SDL_SCANCODE_F3:
-				screen->setWindowSize(3);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_inc_size, REPEAT_FALSE))
+	{
+		screen->incWindowSize();
+	}
 
-			case SDL_SCANCODE_F4:
-				screen->setWindowSize(4);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_swap_palette, REPEAT_FALSE))
+	{
+		switchPalette();
+	}
 
-			case SDL_SCANCODE_F5:
-				switchPalette();
-				break;
-
-			default:
-				section.name = SECTION_PROG_TITLE;
-				section.subsection = 0;
-				break;
-			}
-		}
+	else if (input->checkInput(input_pause, REPEAT_FALSE) || input->checkInput(input_accept, REPEAT_FALSE) || input->checkInput(input_jump, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_TITLE;
+		section->subsection = 0;
 	}
 }
 
 // Gestiona el contador de carga
 void Intro::updateLoad()
 {
-	// Primera parte de la carga, la parte en blanco ynegro
+	// Primera parte de la carga, la parte en blanco y negro
 	if (loadingFirstPart)
 	{
 		// Cada 5 pasos el loadCounter se incrementa en uno
 		const int numSteps = 5;
+		const int step = 51;
 		loadCounter = counter / numSteps;
 
 		if (loadCounter < 192)
 		{
-			const int step = 256 / numSteps;
-			lines[lineIndex[loadCounter]].x1 = step * (counter % numSteps);
-
-			// Elimina por completo la linea anterior
-			if (loadCounter > 0)
-			{
-				lines[lineIndex[loadCounter - 1]].x1 = 256;
-			}
+			loadRect.x = step * (counter % numSteps);
+			loadRect.y = lineIndex[loadCounter];
+			sprite1->setSpriteClip(loadRect);
+			sprite1->setRect(loadRect);
 		}
-
 		// Una vez actualizadas las 192 lineas, pasa a la segunda fase de la carga
 		else if (loadCounter == 192)
 		{
 			loadingFirstPart = false;
 			loadCounter = 0;
+			loadRect = {0, 0, 16, 8};
+			sprite2->setRect(loadRect);
+			sprite2->setSpriteClip(loadRect);
 			JA_PlayMusic(loadingSound3);
 		}
 	}
@@ -180,70 +164,52 @@ void Intro::updateLoad()
 	else
 	{
 		loadCounter += 2;
-		loadCounter = std::min(loadCounter, 768);
+		loadRect.x = (loadCounter * 8) % 256;
+		loadRect.y = (loadCounter / 32) * 8;
+		sprite2->setSpriteClip(loadRect);
+		sprite2->setRect(loadRect);
+
+		// Comprueba si ha terminado la intro
+		if (loadCounter >= 768)
+		{
+			section->name = SECTION_PROG_TITLE;
+			section->subsection = 0;
+			JA_StopMusic();
+		}
 	}
 }
 
 // Gestiona el contador interno
 void Intro::updateCounter()
 {
-	if (preCounter >= 50)
-	{ // Si el contador previo ha llegado a 50, empieza a contar el contador normal
-		if (counter == 0)
-		{
-			JA_PlayMusic(loadingSound2);
-		}
-		counter++;
-	}
-	else
-	{ // Actualiza el precontador
-		preCounter++;
+	(preCounter >= 50) ? counter++ : preCounter++;
+
+	if (counter == 1)
+	{
+		JA_PlayMusic(loadingSound2);
 	}
 }
 
 // Dibuja la pantalla de carga
 void Intro::renderLoad()
 {
-	// Carga 1 - Blanco y negro
-	if (loadingFirstPart)
-	{
-		// Dibuja la textura de pantalla de carga en blanco y negro en pantalla
-		sprite1->render();
-
-		// Dibuja las 192 lineas negras sobre la textura
-		SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
-		for (int i = 0; i < 192; ++i)
-		{
-			SDL_RenderDrawLine(renderer, lines[i].x1, lines[i].y, lines[i].x2, lines[i].y);
-		}
-	}
-	else
-	// Carga 2 - Color
-	{
-		sprite1->render();
-		SDL_Rect rect = {0, 0, 8, 8};
-		for (int i = 0; i < loadCounter; ++i)
-		{
-			rect.x = (i * 8) % 256;
-			rect.y = (i / 32) * 8;
-			sprite2->setRect(rect);
-			sprite2->setSpriteClip(rect);
-			sprite2->render();
-		}
-	}
+	loadingFirstPart ? sprite1->render() : sprite2->render();
 }
 
 // Actualiza las variables
 void Intro::update()
 {
+	// Comprueba el manejador de eventos
+	checkEventHandler();
+
 	// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
 	if (SDL_GetTicks() - ticks > ticksSpeed)
 	{
 		// Actualiza el contador de ticks
 		ticks = SDL_GetTicks();
 
-		// Comprueba el manejador de eventos
-		checkEventHandler();
+		// Comprueba las entradas
+		checkInput();
 
 		// Gestiona el contador interno
 		updateCounter();
@@ -253,14 +219,6 @@ void Intro::update()
 
 		// Actualiza las notificaciones
 		screen->updateNotifier();
-
-		// Comprueba si ha terminado la intro
-		if (loadCounter >= 768)
-		{
-			section.name = SECTION_PROG_TITLE;
-			section.subsection = 0;
-			JA_StopMusic();
-		}
 	}
 }
 
@@ -270,9 +228,6 @@ void Intro::render()
 	// Prepara para empezar a dibujar en la textura de juego
 	screen->start();
 
-	// Limpia la pantalla
-	screen->clean();
-
 	// Dibuja la pantalla de carga
 	renderLoad();
 
@@ -281,20 +236,19 @@ void Intro::render()
 }
 
 // Bucle para el logo del juego
-section_t Intro::run()
+void Intro::run()
 {
 	// Inicia el sonido de carga
 	JA_SetVolume(64);
 	JA_PlayMusic(loadingSound1);
 
-	while (section.name == SECTION_PROG_INTRO)
+	while (section->name == SECTION_PROG_INTRO)
 	{
 		update();
 		render();
 	}
 
 	JA_SetVolume(128);
-	return section;
 }
 
 // Cambia la paleta
@@ -312,4 +266,45 @@ void Intro::switchPalette()
 		sprite1->setTexture(resource->getTexture("loading_screen_bn.png"));
 		sprite2->setTexture(resource->getTexture("loading_screen_color.png"));
 	}
+
+	recreateLoadingScreen();
+}
+
+// Reconstruye la pantalla de carga
+void Intro::recreateLoadingScreen()
+{
+	// Prepara para empezar a dibujar en la textura de juego
+	screen->start();
+
+	// Primera parte de la carga, la parte en blanco y negro
+	if (loadingFirstPart)
+	{
+		const int numSteps = 5;
+		const int step = 51;
+
+		for (int i = 0; i <= counter; i++)
+		{
+			loadCounter = i / numSteps;
+			loadRect.x = step * (i % numSteps);
+			loadRect.y = lineIndex[loadCounter];
+			sprite1->setSpriteClip(loadRect);
+			sprite1->setRect(loadRect);
+			sprite1->render();
+		}
+	}
+	// Segunda parte de la carga, la parte de los bloques en color
+	else
+	{
+		for (int i = 0; i <= loadCounter; i++)
+		{
+			loadRect.x = (i * 8) % 256;
+			loadRect.y = (i / 32) * 8;
+			sprite2->setSpriteClip(loadRect);
+			sprite2->setRect(loadRect);
+			sprite2->render();
+		}
+	}
+
+	// Vuelca el contenido del renderizador en pantalla
+	screen->blit();
 }

source/intro.h

@@ -2,6 +2,7 @@
 
 #include <SDL2/SDL.h>
 #include "common/asset.h"
+#include "common/input.h"
 #include "common/jail_audio.h"
 #include "common/resource.h"
 #include "common/screen.h"
@@ -24,27 +25,27 @@ private:
 	Screen *screen;					// Objeto encargado de dibujar en pantalla
 	Resource *resource;				// Objeto con los recursos
 	Asset *asset;					// Objeto con los ficheros de recursos
+	Input *input;					// Objeto pata gestionar la entrada
 	Texture *loadingScreenTexture1; // Textura con la pantalla de carga en blanco y negro
 	Texture *loadingScreenTexture2; // Textura con la pantalla de carga en color
 	SDL_Event *eventHandler;		// Manejador de eventos
 	Sprite *sprite1;				// Sprite para manejar la textura loadingScreenTexture1
 	Sprite *sprite2;				// Sprite para manejar la textura loadingScreenTexture2
 	options_t *options;				// Puntero a las opciones del juego
+	section_t *section;				// Estado del bucle principal para saber si continua o se sale
 
 	// Variables
-	int preCounter;			// Contador previo para realizar una pausa inicial
-	int counter;			// Contador
-	section_t section;		// Estado del bucle principal para saber si continua o se sale
-	Uint32 ticks;			// Contador de ticks para ajustar la velocidad del programa
-	Uint32 ticksSpeed;		// Velocidad a la que se repiten los bucles del programa
-	int loadCounter;		// Contador para controlar las cargas
-	int lineCounter;		// Contador para dibujar las lineas de carga
-	bool loadingFirstPart;	// Para saber en que parte de la carga se encuentra
-	JA_Music loadingSound1; // Sonidos para imitar la carga tipo spectrum
-	JA_Music loadingSound2; // Sonidos para imitar la carga tipo spectrum
-	JA_Music loadingSound3; // Sonidos para imitar la carga tipo spectrum
-	h_line_t lines[192];	// Las 192 lineas que forman la pantalla de carga
-	int lineIndex[192];		// El orden en el que se procesan las 192 lineas de la pantalla de carga
+	int preCounter;			   // Contador previo para realizar una pausa inicial
+	int counter;			   // Contador
+	Uint32 ticks;			   // Contador de ticks para ajustar la velocidad del programa
+	Uint32 ticksSpeed;		   // Velocidad a la que se repiten los bucles del programa
+	int loadCounter;		   // Contador para controlar las cargas
+	bool loadingFirstPart;	   // Para saber en que parte de la carga se encuentra
+	JA_Music_t *loadingSound1; // Sonidos para imitar la carga tipo spectrum
+	JA_Music_t *loadingSound2; // Sonidos para imitar la carga tipo spectrum
+	JA_Music_t *loadingSound3; // Sonidos para imitar la carga tipo spectrum
+	int lineIndex[192];		   // El orden en el que se procesan las 192 lineas de la pantalla de carga
+	SDL_Rect loadRect;		   // Rectangulo para dibujar la pantalla de carga
 
 	// Actualiza las variables
 	void update();
@@ -55,6 +56,9 @@ private:
 	// Comprueba el manejador de eventos
 	void checkEventHandler();
 
+	// Comprueba las entradas
+	void checkInput();
+
 	// Gestiona el contador interno
 	void updateCounter();
 
@@ -67,15 +71,18 @@ private:
 	// Cambia la paleta
 	void switchPalette();
 
+	// Reconstruye la pantalla de carga
+	void recreateLoadingScreen();
+
 public:
 	// Constructor
-	Intro(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options);
+	Intro(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section);
 
 	// Destructor
 	~Intro();
 
 	// Bucle principal
-	section_t run();
+	void run();
 };
 
 #endif

source/item.cpp

@@ -36,7 +36,7 @@ Item::~Item()
 void Item::render()
 {
     const int index = (counter / colorChangeSpeed) % color.size();
-    sprite->getTexture()->setColor(color.at(index).r, color.at(index).g, color.at(index).b);
+    sprite->getTexture()->setColor(color[index].r, color[index].g, color[index].b);
     sprite->render();
     sprite->getTexture()->setColor(255, 255, 255);
 }

source/logo.cpp

@@ -2,14 +2,16 @@
 #include <iostream>
 
 // Constructor
-Logo::Logo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options, int subsection)
+Logo::Logo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section)
 {
 	// Copia la dirección de los objetos
 	this->resource = resource;
 	this->renderer = renderer;
 	this->screen = screen;
 	this->asset = asset;
+	this->input = input;
 	this->options = options;
+	this->section = section;
 
 	// Reserva memoria para los punteros
 	eventHandler = new SDL_Event();
@@ -26,19 +28,18 @@ Logo::Logo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *as
 		sprite.back()->setSpriteClip(0, i, texture->getWidth(), 1);
 		if (i % 2 == 0)
 		{
-			sprite.at(i)->setPosX(256 + (i * 3));
+			sprite[i]->setPosX(256 + (i * 3));
 		}
 		else
 		{
-			sprite.at(i)->setPosX(-181 - (i * 3));
+			sprite[i]->setPosX(-181 - (i * 3));
 		}
-		sprite.at(i)->setPosY(83 + i);
+		sprite[i]->setPosY(83 + i);
 	}
 
 	// Inicializa variables
 	counter = 0;
-	section.name = SECTION_PROG_LOGO;
-	section.subsection = subsection;
+	section->name = SECTION_PROG_LOGO;
 	ticks = 0;
 	ticksSpeed = 15;
 	initFade = 300;
@@ -77,59 +78,50 @@ void Logo::checkEventHandler()
 		// Evento de salida de la aplicación
 		if (eventHandler->type == SDL_QUIT)
 		{
-			section.name = SECTION_PROG_QUIT;
+			section->name = SECTION_PROG_QUIT;
 			break;
 		}
+	}
+}
 
-		// Comprueba las teclas que se han pulsado
-		if ((eventHandler->type == SDL_KEYUP && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONUP))
-		{
-			switch (eventHandler->key.keysym.scancode)
-			{
-			case SDL_SCANCODE_ESCAPE:
-				section.name = SECTION_PROG_QUIT;
-				break;
+// Comprueba las entradas
+void Logo::checkInput()
+{
 
-			case SDL_SCANCODE_B:
-				screen->switchBorder();
-				resource->reLoadTextures();
-				break;
+	if (input->checkInput(input_exit, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_TITLE;
+	}
 
-			case SDL_SCANCODE_F:
-				screen->switchVideoMode();
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_toggle_border, REPEAT_FALSE))
+	{
+		screen->switchBorder();
+	}
 
-			case SDL_SCANCODE_F1:
-				screen->setWindowSize(1);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_fullscreen, REPEAT_FALSE))
+	{
+		screen->switchVideoMode();
+	}
 
-			case SDL_SCANCODE_F2:
-				screen->setWindowSize(2);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_dec_size, REPEAT_FALSE))
+	{
+		screen->decWindowSize();
+	}
 
-			case SDL_SCANCODE_F3:
-				screen->setWindowSize(3);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_inc_size, REPEAT_FALSE))
+	{
+		screen->incWindowSize();
+	}
 
-			case SDL_SCANCODE_F4:
-				screen->setWindowSize(4);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_swap_palette, REPEAT_FALSE))
+	{
+		switchPalette();
+	}
 
-			case SDL_SCANCODE_F5:
-				switchPalette();
-				break;
-
-			default:
-				section.subsection = SUBSECTION_LOGO_TO_TITLE;
-				endSection();
-				break;
-			}
-		}
+	else if (input->checkInput(input_pause, REPEAT_FALSE) || input->checkInput(input_accept, REPEAT_FALSE) || input->checkInput(input_jump, REPEAT_FALSE))
+	{
+		section->subsection = SUBSECTION_LOGO_TO_TITLE;
+		endSection();
 	}
 }
 
@@ -142,22 +134,22 @@ void Logo::updateJAILGAMES()
 		{
 			const int speed = 8;
 			const int dest = 37;
-			if (sprite.at(i)->getPosX() != 37)
+			if (sprite[i]->getPosX() != 37)
 			{
 				if (i % 2 == 0)
 				{
-					sprite.at(i)->incPosX(-speed);
-					if (sprite.at(i)->getPosX() < dest)
+					sprite[i]->incPosX(-speed);
+					if (sprite[i]->getPosX() < dest)
 					{
-						sprite.at(i)->setPosX(dest);
+						sprite[i]->setPosX(dest);
 					}
 				}
 				else
 				{
-					sprite.at(i)->incPosX(speed);
-					if (sprite.at(i)->getPosX() > dest)
+					sprite[i]->incPosX(speed);
+					if (sprite[i]->getPosX() > dest)
 					{
-						sprite.at(i)->setPosX(dest);
+						sprite[i]->setPosX(dest);
 					}
 				}
 			}
@@ -173,72 +165,84 @@ void Logo::updateTextureColors()
 
 	if (counter == ini + inc * 0)
 	{
-		texture2->setColor(color.at(0).r, color.at(0).g, color.at(0).b);
+		texture2->setColor(color[0].r, color[0].g, color[0].b);
 	}
+
 	else if (counter == ini + inc * 1)
 	{
-		texture2->setColor(color.at(1).r, color.at(1).g, color.at(1).b);
+		texture2->setColor(color[1].r, color[1].g, color[1].b);
 	}
+
 	else if (counter == ini + inc * 2)
 	{
-		texture2->setColor(color.at(2).r, color.at(2).g, color.at(2).b);
+		texture2->setColor(color[2].r, color[2].g, color[2].b);
 	}
+
 	else if (counter == ini + inc * 3)
 	{
-		texture2->setColor(color.at(3).r, color.at(3).g, color.at(3).b);
+		texture2->setColor(color[3].r, color[3].g, color[3].b);
 	}
+
 	else if (counter == ini + inc * 4)
 	{
-		texture2->setColor(color.at(4).r, color.at(4).g, color.at(4).b);
+		texture2->setColor(color[4].r, color[4].g, color[4].b);
 	}
+
 	else if (counter == ini + inc * 5)
 	{
-		texture2->setColor(color.at(5).r, color.at(5).g, color.at(5).b);
+		texture2->setColor(color[5].r, color[5].g, color[5].b);
 	}
+
 	else if (counter == ini + inc * 6)
 	{
-		texture2->setColor(color.at(6).r, color.at(6).g, color.at(6).b);
+		texture2->setColor(color[6].r, color[6].g, color[6].b);
 	}
 
 	else if (counter == ini + inc * 7)
 	{
-		texture2->setColor(color.at(7).r, color.at(7).g, color.at(7).b);
+		texture2->setColor(color[7].r, color[7].g, color[7].b);
 	}
 
 	else if (counter == initFade + inc * 0)
 	{
-		texture->setColor(color.at(6).r, color.at(6).g, color.at(6).b);
-		texture2->setColor(color.at(6).r, color.at(6).g, color.at(6).b);
+		texture->setColor(color[6].r, color[6].g, color[6].b);
+		texture2->setColor(color[6].r, color[6].g, color[6].b);
 	}
+
 	else if (counter == initFade + inc * 1)
 	{
-		texture->setColor(color.at(5).r, color.at(5).g, color.at(5).b);
-		texture2->setColor(color.at(5).r, color.at(5).g, color.at(5).b);
+		texture->setColor(color[5].r, color[5].g, color[5].b);
+		texture2->setColor(color[5].r, color[5].g, color[5].b);
 	}
+
 	else if (counter == initFade + inc * 2)
 	{
-		texture->setColor(color.at(4).r, color.at(4).g, color.at(4).b);
-		texture2->setColor(color.at(4).r, color.at(4).g, color.at(4).b);
+		texture->setColor(color[4].r, color[4].g, color[4].b);
+		texture2->setColor(color[4].r, color[4].g, color[4].b);
 	}
+
 	else if (counter == initFade + inc * 3)
 	{
-		texture->setColor(color.at(3).r, color.at(3).g, color.at(3).b);
-		texture2->setColor(color.at(3).r, color.at(3).g, color.at(3).b);
+		texture->setColor(color[3].r, color[3].g, color[3].b);
+		texture2->setColor(color[3].r, color[3].g, color[3].b);
 	}
+
 	else if (counter == initFade + inc * 4)
 	{
-		texture->setColor(color.at(2).r, color.at(2).g, color.at(2).b);
-		texture2->setColor(color.at(2).r, color.at(2).g, color.at(2).b);
+		texture->setColor(color[2].r, color[2].g, color[2].b);
+		texture2->setColor(color[2].r, color[2].g, color[2].b);
 	}
+
 	else if (counter == initFade + inc * 5)
 	{
-		texture->setColor(color.at(1).r, color.at(1).g, color.at(1).b);
-		texture2->setColor(color.at(1).r, color.at(1).g, color.at(1).b);
+		texture->setColor(color[1].r, color[1].g, color[1].b);
+		texture2->setColor(color[1].r, color[1].g, color[1].b);
 	}
+
 	else if (counter == initFade + inc * 6)
 	{
-		texture->setColor(color.at(0).r, color.at(0).g, color.at(0).b);
-		texture2->setColor(color.at(0).r, color.at(0).g, color.at(0).b);
+		texture->setColor(color[0].r, color[0].g, color[0].b);
+		texture2->setColor(color[0].r, color[0].g, color[0].b);
 	}
 }
 
@@ -254,6 +258,9 @@ void Logo::update()
 		// Comprueba el manejador de eventos
 		checkEventHandler();
 
+		// Comprueba las entradas
+		checkInput();
+
 		// Incrementa el contador
 		counter++;
 
@@ -295,18 +302,16 @@ void Logo::render()
 }
 
 // Bucle para el logo del juego
-section_t Logo::run()
+void Logo::run()
 {
 	// Detiene la música
 	JA_StopMusic();
 
-	while (section.name == SECTION_PROG_LOGO)
+	while (section->name == SECTION_PROG_LOGO)
 	{
 		update();
 		render();
 	}
-
-	return section;
 }
 
 // Cambia la paleta
@@ -318,5 +323,5 @@ void Logo::switchPalette()
 // Termina la sección
 void Logo::endSection()
 {
-	section.name = SECTION_PROG_ENTER_ID;
+	section->name = SECTION_PROG_ENTER_ID;
 }

source/logo.h

@@ -2,6 +2,7 @@
 
 #include <SDL2/SDL.h>
 #include "common/asset.h"
+#include "common/input.h"
 #include "common/jail_audio.h"
 #include "common/resource.h"
 #include "common/screen.h"
@@ -21,17 +22,18 @@ private:
 	Screen *screen;				  // Objeto encargado de dibujar en pantalla
 	Resource *resource;			  // Objeto con los recursos
 	Asset *asset;				  // Objeto con los ficheros de recursos
+	Input *input;				  // Objeto pata gestionar la entrada
 	Texture *texture;			  // Textura con los graficos "JAILGAMES"
 	Texture *texture2;			  // Textura con los graficos "Since 1998"
 	SDL_Event *eventHandler;	  // Manejador de eventos
 	std::vector<Sprite *> sprite; // Vector con los sprites de cada linea que forman el bitmap JAILGAMES
 	Sprite *sprite2;			  // Sprite para manejar la textura2
 	options_t *options;			  // Puntero a las opciones del juego
+	section_t *section;			  // Estado del bucle principal para saber si continua o se sale
 
 	// Variables
 	std::vector<color_t> color; // Vector con los colores para el fade
 	int counter;				// Contador
-	section_t section;			// Estado del bucle principal para saber si continua o se sale
 	Uint32 ticks;				// Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticksSpeed;			// Velocidad a la que se repiten los bucles del programa
 	int initFade;				// Tiempo del contador cuando inicia el fade a negro
@@ -47,6 +49,9 @@ private:
 	// Comprueba el manejador de eventos
 	void checkEventHandler();
 
+	// Comprueba las entradas
+	void checkInput();
+
 	// Gestiona el logo de JAILGAME
 	void updateJAILGAMES();
 
@@ -61,13 +66,13 @@ private:
 
 public:
 	// Constructor
-	Logo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options, int subsection);
+	Logo(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section);
 
 	// Destructor
 	~Logo();
 
 	// Bucle principal
-	section_t run();
+	void run();
 };
 
 #endif

source/player.cpp

@@ -181,13 +181,13 @@ void Player::checkInput()
 
     if (!autoMovement)
     { // Comprueba las entradas de desplazamiento lateral solo en el caso de no estar enganchado a una superficie automatica
-        if (input->checkInput(INPUT_LEFT, REPEAT_TRUE))
+        if (input->checkInput(input_left))
         {
             vx = -0.6f;
             sprite->setFlipH(true);
         }
 
-        else if (input->checkInput(INPUT_RIGHT, REPEAT_TRUE))
+        else if (input->checkInput(input_right))
         {
             vx = 0.6f;
             sprite->setFlipH(false);
@@ -216,7 +216,7 @@ void Player::checkInput()
         }
     }
 
-    if (input->checkInput(INPUT_UP, REPEAT_TRUE))
+    if (input->checkInput(input_jump))
     {
         // Solo puede saltar si ademas de estar (state == s_standing)
         // Esta sobre el suelo, rampa o suelo que se mueve

source/player.h

@@ -81,8 +81,8 @@ public:
 	SDL_Rect lastPosition;				   // Contiene la ultima posición del jugador, por si hay que deshacer algun movimiento
 	int jumpIni;						   // Valor del eje Y en el que se inicia el salto
 	float maxVY;						   // Velocidad máxima que puede alcanzar al desplazarse en vertical
-	std::vector<JA_Sound> jumpSound;	   // Vecor con todos los sonidos del salto
-	std::vector<JA_Sound> fallSound;	   // Vecor con todos los sonidos de la caída
+	std::vector<JA_Sound_t*> jumpSound;	   // Vecor con todos los sonidos del salto
+	std::vector<JA_Sound_t*> fallSound;	   // Vecor con todos los sonidos de la caída
 	int jumpCounter;					   // Cuenta el tiempo de salto
 	int fallCounter;					   // Cuenta el tiempo de caida
 	bool alive;							   // Indica si el jugador esta vivo o no

source/room.cpp

@@ -473,7 +473,7 @@ Room::Room(room_t *room, SDL_Renderer *renderer, Screen *screen, Asset *asset, o
     setAnimatedTiles();
 
     // Crea la textura para el mapa de tiles de la habitación
-    mapTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, GAMECANVAS_WIDTH, GAMECANVAS_HEIGHT);
+    mapTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT);
     if (mapTexture == nullptr)
     {
         if (options->console)
@@ -534,8 +534,9 @@ color_t Room::getBorderColor()
 // Crea la textura con el mapeado de la habitación
 void Room::fillMapTexture()
 {
+    const color_t color = stringToColor(options->palette, bgColor);
     SDL_SetRenderTarget(renderer, mapTexture);
-    SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0x00, 0x00);
+    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
     SDL_RenderClear(renderer);
 
     // Los tileSetFiles son de 20x20 tiles. El primer tile es el 0. Cuentan hacia la derecha y hacia abajo
@@ -548,13 +549,13 @@ void Room::fillMapTexture()
             // Al cargar el mapa en memoria, se resta uno, por tanto los tiles vacios son -1
             // Tampoco hay que dibujar los tiles animados que estan en la fila 19 (indices)
             const int index = (y * mapWidth) + x;
-            const bool a = (tileMap.at(index) >= 18 * tileSetWidth) && (tileMap.at(index) < 19 * tileSetWidth);
-            const bool b = tileMap.at(index) > -1;
+            const bool a = (tileMap[index] >= 18 * tileSetWidth) && (tileMap[index] < 19 * tileSetWidth);
+            const bool b = tileMap[index] > -1;
 
             if (b && !a)
             {
-                clip.x = (tileMap.at(index) % tileSetWidth) * tileSize;
-                clip.y = (tileMap.at(index) / tileSetWidth) * tileSize;
+                clip.x = (tileMap[index] % tileSetWidth) * tileSize;
+                clip.y = (tileMap[index] / tileSetWidth) * tileSize;
                 texture->render(renderer, x * tileSize, y * tileSize, &clip);
 
 #ifdef DEBUG
@@ -664,7 +665,8 @@ void Room::fillMapTexture()
 void Room::renderMap()
 {
     // Dibuja la textura con el mapa en pantalla
-    SDL_RenderCopy(renderer, mapTexture, nullptr, nullptr);
+    SDL_Rect dest = {0, 0, PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT};
+    SDL_RenderCopy(renderer, mapTexture, nullptr, &dest);
 
 // Dibuja los tiles animados
 #ifdef DEBUG
@@ -763,37 +765,37 @@ tile_e Room::getTile(int index)
     if (onRange)
     {
         // Las filas 0-8 son de tiles t_wall
-        if ((tileMap.at(index) >= 0) && (tileMap.at(index) < 9 * tileSetWidth))
+        if ((tileMap[index] >= 0) && (tileMap[index] < 9 * tileSetWidth))
         {
             return t_wall;
         }
 
         // Las filas 9-17 son de tiles t_passable
-        else if ((tileMap.at(index) >= 9 * tileSetWidth) && (tileMap.at(index) < 18 * tileSetWidth))
+        else if ((tileMap[index] >= 9 * tileSetWidth) && (tileMap[index] < 18 * tileSetWidth))
         {
             return t_passable;
         }
 
         // Las filas 18-20 es de tiles t_animated
-        else if ((tileMap.at(index) >= 18 * tileSetWidth) && (tileMap.at(index) < 21 * tileSetWidth))
+        else if ((tileMap[index] >= 18 * tileSetWidth) && (tileMap[index] < 21 * tileSetWidth))
         {
             return t_animated;
         }
 
         // La fila 21 es de tiles t_slope_r
-        else if ((tileMap.at(index) >= 21 * tileSetWidth) && (tileMap.at(index) < 22 * tileSetWidth))
+        else if ((tileMap[index] >= 21 * tileSetWidth) && (tileMap[index] < 22 * tileSetWidth))
         {
             return t_slope_r;
         }
 
         // La fila 22 es de tiles t_slope_l
-        else if ((tileMap.at(index) >= 22 * tileSetWidth) && (tileMap.at(index) < 23 * tileSetWidth))
+        else if ((tileMap[index] >= 22 * tileSetWidth) && (tileMap[index] < 23 * tileSetWidth))
         {
             return t_slope_l;
         }
 
         // La fila 23 es de tiles t_kill
-        else if ((tileMap.at(index) >= 23 * tileSetWidth) && (tileMap.at(index) < 24 * tileSetWidth))
+        else if ((tileMap[index] >= 23 * tileSetWidth) && (tileMap[index] < 24 * tileSetWidth))
         {
             return t_kill;
         }
@@ -820,10 +822,10 @@ bool Room::itemCollision(SDL_Rect &rect)
 {
     for (int i = 0; i < (int)items.size(); ++i)
     {
-        if (checkCollision(rect, items.at(i)->getCollider()))
+        if (checkCollision(rect, items[i]->getCollider()))
         {
-            itemTracker->addItem(name, items.at(i)->getPos());
-            delete items.at(i);
+            itemTracker->addItem(name, items[i]->getPos());
+            delete items[i];
             items.erase(items.begin() + i);
             JA_PlaySound(itemSound);
             *itemsPicked = *itemsPicked + 1;
@@ -955,14 +957,14 @@ void Room::setBottomSurfaces()
         do
         {
             h_line_t line;
-            line.x1 = (tile.at(i) % mapWidth) * tileSize;
-            line.y = ((tile.at(i) / mapWidth) * tileSize) + tileSize - 1;
+            line.x1 = (tile[i] % mapWidth) * tileSize;
+            line.y = ((tile[i] / mapWidth) * tileSize) + tileSize - 1;
             lastOne = i;
             i++;
 
             if (i <= (int)tile.size() - 1)
             {
-                while (tile.at(i) == tile.at(i - 1) + 1)
+                while (tile[i] == tile[i - 1] + 1)
                 {
                     lastOne = i;
                     if (i == (int)tile.size() - 1)
@@ -973,11 +975,11 @@ void Room::setBottomSurfaces()
                 }
             }
 
-            line.x2 = ((tile.at(lastOne) % mapWidth) * tileSize) + tileSize - 1;
+            line.x2 = ((tile[lastOne] % mapWidth) * tileSize) + tileSize - 1;
             bottomSurfaces.push_back(line);
             if (i <= (int)tile.size() - 1)
             {
-                if (tile.at(i) == -1)
+                if (tile[i] == -1)
                 { // Si el siguiente elemento es un separador, hay que saltarlo
                     i++;
                 }
@@ -1018,14 +1020,14 @@ void Room::setTopSurfaces()
         do
         {
             h_line_t line;
-            line.x1 = (tile.at(i) % mapWidth) * tileSize;
-            line.y = (tile.at(i) / mapWidth) * tileSize;
+            line.x1 = (tile[i] % mapWidth) * tileSize;
+            line.y = (tile[i] / mapWidth) * tileSize;
             lastOne = i;
             i++;
 
             if (i <= (int)tile.size() - 1)
             {
-                while (tile.at(i) == tile.at(i - 1) + 1)
+                while (tile[i] == tile[i - 1] + 1)
                 {
                     lastOne = i;
                     if (i == (int)tile.size() - 1)
@@ -1036,11 +1038,11 @@ void Room::setTopSurfaces()
                 }
             }
 
-            line.x2 = ((tile.at(lastOne) % mapWidth) * tileSize) + tileSize - 1;
+            line.x2 = ((tile[lastOne] % mapWidth) * tileSize) + tileSize - 1;
             topSurfaces.push_back(line);
             if (i <= (int)tile.size() - 1)
             {
-                if (tile.at(i) == -1)
+                if (tile[i] == -1)
                 { // Si el siguiente elemento es un separador, hay que saltarlo
                     i++;
                 }
@@ -1080,9 +1082,9 @@ void Room::setLeftSurfaces()
         do
         {
             v_line_t line;
-            line.x = (tile.at(i) % mapWidth) * tileSize;
-            line.y1 = ((tile.at(i) / mapWidth) * tileSize);
-            while (tile.at(i) + mapWidth == tile.at(i + 1))
+            line.x = (tile[i] % mapWidth) * tileSize;
+            line.y1 = ((tile[i] / mapWidth) * tileSize);
+            while (tile[i] + mapWidth == tile[i + 1])
             {
                 if (i == (int)tile.size() - 1)
                 {
@@ -1090,7 +1092,7 @@ void Room::setLeftSurfaces()
                 }
                 i++;
             }
-            line.y2 = ((tile.at(i) / mapWidth) * tileSize) + tileSize - 1;
+            line.y2 = ((tile[i] / mapWidth) * tileSize) + tileSize - 1;
             leftSurfaces.push_back(line);
             i++;
         } while (i < (int)tile.size() - 1);
@@ -1128,9 +1130,9 @@ void Room::setRightSurfaces()
         do
         {
             v_line_t line;
-            line.x = ((tile.at(i) % mapWidth) * tileSize) + tileSize - 1;
-            line.y1 = ((tile.at(i) / mapWidth) * tileSize);
-            while (tile.at(i) + mapWidth == tile.at(i + 1))
+            line.x = ((tile[i] % mapWidth) * tileSize) + tileSize - 1;
+            line.y1 = ((tile[i] / mapWidth) * tileSize);
+            while (tile[i] + mapWidth == tile[i + 1])
             {
                 if (i == (int)tile.size() - 1)
                 {
@@ -1138,7 +1140,7 @@ void Room::setRightSurfaces()
                 }
                 i++;
             }
-            line.y2 = ((tile.at(i) / mapWidth) * tileSize) + tileSize - 1;
+            line.y2 = ((tile[i] / mapWidth) * tileSize) + tileSize - 1;
             rightSurfaces.push_back(line);
             i++;
         } while (i < (int)tile.size() - 1);
@@ -1165,14 +1167,14 @@ void Room::setLeftSlopes()
     while (found.size() > 0)
     {
         d_line_t line;
-        line.x1 = (found.at(0) % mapWidth) * tileSize;
-        line.y1 = (found.at(0) / mapWidth) * tileSize;
-        int lookingFor = found.at(0) + mapWidth + 1;
-        int lastOneFound = found.at(0);
+        line.x1 = (found[0] % mapWidth) * tileSize;
+        line.y1 = (found[0] / mapWidth) * tileSize;
+        int lookingFor = found[0] + mapWidth + 1;
+        int lastOneFound = found[0];
         found.erase(found.begin());
         for (int i = 0; i < (int)found.size(); ++i)
         {
-            if (found.at(i) == lookingFor)
+            if (found[i] == lookingFor)
             {
                 lastOneFound = lookingFor;
                 lookingFor += mapWidth + 1;
@@ -1206,14 +1208,14 @@ void Room::setRightSlopes()
     while (found.size() > 0)
     {
         d_line_t line;
-        line.x1 = ((found.at(0) % mapWidth) * tileSize) + tileSize - 1;
-        line.y1 = (found.at(0) / mapWidth) * tileSize;
-        int lookingFor = found.at(0) + mapWidth - 1;
-        int lastOneFound = found.at(0);
+        line.x1 = ((found[0] % mapWidth) * tileSize) + tileSize - 1;
+        line.y1 = (found[0] / mapWidth) * tileSize;
+        int lookingFor = found[0] + mapWidth - 1;
+        int lastOneFound = found[0];
         found.erase(found.begin());
         for (int i = 0; i < (int)found.size(); ++i)
         {
-            if (found.at(i) == lookingFor)
+            if (found[i] == lookingFor)
             {
                 lastOneFound = lookingFor;
                 lookingFor += mapWidth - 1;
@@ -1256,14 +1258,14 @@ void Room::setAutoSurfaces()
         do
         {
             h_line_t line;
-            line.x1 = (tile.at(i) % mapWidth) * tileSize;
-            line.y = (tile.at(i) / mapWidth) * tileSize;
+            line.x1 = (tile[i] % mapWidth) * tileSize;
+            line.y = (tile[i] / mapWidth) * tileSize;
             lastOne = i;
             i++;
 
             if (i <= (int)tile.size() - 1)
             {
-                while (tile.at(i) == tile.at(i - 1) + 1)
+                while (tile[i] == tile[i - 1] + 1)
                 {
                     lastOne = i;
                     if (i == (int)tile.size() - 1)
@@ -1274,11 +1276,11 @@ void Room::setAutoSurfaces()
                 }
             }
 
-            line.x2 = ((tile.at(lastOne) % mapWidth) * tileSize) + tileSize - 1;
+            line.x2 = ((tile[lastOne] % mapWidth) * tileSize) + tileSize - 1;
             autoSurfaces.push_back(line);
             if (i <= (int)tile.size() - 1)
             {
-                if (tile.at(i) == -1)
+                if (tile[i] == -1)
                 { // Si el siguiente elemento es un separador, hay que saltarlo
                     i++;
                 }
@@ -1299,9 +1301,9 @@ void Room::setAnimatedTiles()
             const int x = (i % mapWidth) * tileSize;
             const int y = (i / mapWidth) * tileSize;
 
-            // TileMap.at(i) es el tile a poner
-            const int xc = (tileMap.at(i) % tileSetWidth) * tileSize;
-            const int yc = (tileMap.at(i) / tileSetWidth) * tileSize;
+            // TileMap[i] es el tile a poner
+            const int xc = (tileMap[i] % tileSetWidth) * tileSize;
+            const int yc = (tileMap[i] / tileSetWidth) * tileSize;
 
             aTile_t at;
             at.sprite = new Sprite(x, y, 8, 8, texture, renderer);
@@ -1522,9 +1524,6 @@ void Room::openTheJail()
 {
     if (name == "THE JAIL")
     {
-        // Cambia el color de fondo
-        bgColor = "red";
-
         // Elimina el último enemigo (Bry debe ser el ultimo enemigo definido en el fichero)
         delete enemies.back();
         enemies.pop_back();
@@ -1532,7 +1531,7 @@ void Room::openTheJail()
         // Abre las puertas
         const int tileA = 16 + (13 * 32);
         const int tileB = 16 + (14 * 32);
-        tileMap.at(tileA) = -1;
-        tileMap.at(tileB) = -1;
+        tileMap[tileA] = -1;
+        tileMap[tileB] = -1;
     }
 }

source/room.h

@@ -104,7 +104,7 @@ private:
 	std::string tileMapFile;			  // Fichero con el mapa de indices de tile
 	std::vector<int> tileMap;			  // Indice de los tiles a dibujar en la habitación
 	int autoSurfaceDirection;			  // Sentido en el que arrastran las superficies automáticas de la habitación
-	JA_Sound itemSound;					  // Sonido producido al coger un objeto
+	JA_Sound_t *itemSound;				  // Sonido producido al coger un objeto
 	std::vector<h_line_t> bottomSurfaces; // Lista con las superficies inferiores de la habitación
 	std::vector<h_line_t> topSurfaces;	  // Lista con las superficies superiores de la habitación
 	std::vector<v_line_t> leftSurfaces;	  // Lista con las superficies laterales de la parte izquierda de la habitación

source/scoreboard.cpp

@@ -6,11 +6,11 @@
 ScoreBoard::ScoreBoard(SDL_Renderer *renderer, Resource *resource, Asset *asset, options_t *options, board_t *board)
 {
     // Obten punteros a objetos
+    this->renderer = renderer;
     this->resource = resource;
     this->asset = asset;
-    this->renderer = renderer;
-    this->board = board;
     this->options = options;
+    this->board = board;
 
     // Reserva memoria para los objetos
     itemTexture = resource->getTexture("items.png");
@@ -169,4 +169,10 @@ void ScoreBoard::updateItemsColor()
     {
         itemsColor = stringToColor(options->palette, "magenta");
     }
+}
+
+// Devuelve la cantidad de minutos de juego transcurridos
+int ScoreBoard::getMinutes()
+{
+    return getTime().minutes;
 }

source/scoreboard.h

@@ -84,6 +84,9 @@ public:
 
 	// Quita el modo pausa del marcador
 	void resume();
+
+	// Devuelve la cantidad de minutos de juego transcurridos
+	int getMinutes();
 };
 
 #endif

source/stats.cpp

@@ -60,7 +60,7 @@ void Stats::addDeath(std::string name)
     const int index = findByName(name, bufferList);
     if (index != -1)
     {
-        bufferList.at(index).died++;
+        bufferList[index].died++;
     }
 
     // En caso contrario crea la entrada
@@ -84,7 +84,7 @@ void Stats::addVisit(std::string name)
     const int index = findByName(name, bufferList);
     if (index != -1)
     {
-        bufferList.at(index).visited++;
+        bufferList[index].visited++;
     }
 
     // En caso contrario crea la entrada
@@ -304,8 +304,8 @@ void Stats::updateListFromBuffer()
 
         if (index != -1)
         { // Encontrado. Aumenta sus estadisticas
-            list.at(index).visited += buffer.visited;
-            list.at(index).died += buffer.died;
+            list[index].visited += buffer.visited;
+            list[index].died += buffer.died;
         }
         else
         { // En caso contrario crea la entrada

source/title.cpp

@@ -1,14 +1,16 @@
 #include "title.h"
 
 // Constructor
-Title::Title(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options)
+Title::Title(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section)
 {
 	// Copia la dirección de los objetos
 	this->resource = resource;
 	this->renderer = renderer;
 	this->screen = screen;
 	this->asset = asset;
+	this->input = input;
 	this->options = options;
+	this->section = section;
 
 	// Reserva memoria para los punteros
 	eventHandler = new SDL_Event();
@@ -25,12 +27,11 @@ Title::Title(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *
 
 	// Inicializa variables
 	counter = 0;
-	section.name = SECTION_PROG_TITLE;
-	section.subsection = 0;
+	section->name = SECTION_PROG_TITLE;
+	section->subsection = 0;
 	ticks = 0;
 	ticksSpeed = 15;
 	longText = "HEY JAILERS!! IT'S 2022 AND WE'RE STILL ROCKING LIKE IT'S 1998!!! HAVE YOU HEARD IT? JAILGAMES ARE BACK!! YEEESSS BACK!! MORE THAN 10 TITLES ON JAILDOC'S KITCHEN!! THATS A LOOOOOOT OF JAILGAMES, BUT WHICH ONE WILL STRIKE FIRST? THERE IS ALSO A NEW DEVICE TO COME THAT WILL BLOW YOUR MIND WITH JAILGAMES ON THE GO: P.A.C.O. BUT WAIT! WHAT'S THAT BEAUTY I'M SEEING RIGHT OVER THERE?? OOOH THAT TINY MINIASCII IS PURE LOVE!! I WANT TO LICK EVERY BYTE OF IT!! OH SHIT! AND DON'T FORGET TO BRING BACK THOSE OLD AND FAT MS-DOS JAILGAMES TO GITHUB TO KEEP THEM ALIVE!! WHAT WILL BE THE NEXT JAILDOC RELEASE? WHAT WILL BE THE NEXT PROJECT TO COME ALIVE?? OH BABY WE DON'T KNOW BUT HERE YOU CAN FIND THE ANSWER, YOU JUST HAVE TO COMPLETE JAILDOCTOR'S DILEMMA ... COULD YOU?";
-	// longText = "HEY JAILERS!! IT'S 2022 AND WE'RE STILL ROCKING LIKE IT'S 1998!!!";
 	for (int i = 0; i < (int)longText.length(); ++i)
 	{
 		letter_t l;
@@ -39,9 +40,28 @@ Title::Title(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *
 		l.enabled = false;
 		letters.push_back(l);
 	}
-	letters.at(0).enabled = true;
+	letters[0].enabled = true;
 	marqueeSpeed = 3;
 
+// Crea el cartel de PRESS ENTER
+#ifdef GAME_CONSOLE
+	const std::string caption = "PRESS START TO PLAY";
+#else
+	const std::string caption = "PRESS ENTER TO PLAY";
+#endif
+	const color_t textColor = stringToColor(options->palette, "white");
+	const color_t strokeColor = stringToColor(options->palette, "bright_blue");
+
+	// Crea la textura
+	pressEnterTexture = new Texture(renderer);
+	pressEnterTexture->createBlank(renderer, text->lenght(caption) + 2, text->getCharacterSize() + 2, SDL_TEXTUREACCESS_TARGET);
+	pressEnterTexture->setAsRenderTarget(renderer);
+	pressEnterTexture->setBlendMode(SDL_BLENDMODE_BLEND);
+	text->writeDX(TXT_COLOR | TXT_STROKE, 1, 1, caption, 1, textColor, 1, strokeColor);
+
+	// Crea el sprite
+	pressEnterSprite = new Sprite(128 - (pressEnterTexture->getWidth() / 2), 192 / 5 * 4, pressEnterTexture->getWidth(), pressEnterTexture->getHeight(), pressEnterTexture, renderer);
+
 	// Cambia el color del borde
 	screen->setBorderColor(stringToColor(options->palette, "bright_blue"));
 }
@@ -51,6 +71,8 @@ Title::~Title()
 {
 	delete eventHandler;
 	delete sprite;
+	delete pressEnterSprite;
+	delete pressEnterTexture;
 	delete text;
 }
 
@@ -63,68 +85,54 @@ void Title::checkEventHandler()
 		// Evento de salida de la aplicación
 		if (eventHandler->type == SDL_QUIT)
 		{
-			section.name = SECTION_PROG_QUIT;
+			section->name = SECTION_PROG_QUIT;
 			break;
 		}
+	}
+}
 
-		// Comprueba las teclas que se han pulsado
-		if ((eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONDOWN))
-		{
-			switch (eventHandler->key.keysym.scancode)
-			{
-			case SDL_SCANCODE_ESCAPE:
-				section.name = SECTION_PROG_QUIT;
-				break;
+// Comprueba las entradas
+void Title::checkInput()
+{
 
-			case SDL_SCANCODE_RETURN:
-				section.name = SECTION_PROG_GAME;
-				section.subsection = 0;
-				break;
+	if (input->checkInput(input_exit, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_QUIT;
+	}
 
-			case SDL_SCANCODE_B:
-				screen->switchBorder();
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_toggle_border, REPEAT_FALSE))
+	{
+		screen->switchBorder();
+		resource->reLoadTextures();
+	}
 
-			case SDL_SCANCODE_F:
-				screen->switchVideoMode();
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_fullscreen, REPEAT_FALSE))
+	{
+		screen->switchVideoMode();
+		resource->reLoadTextures();
+	}
 
-			case SDL_SCANCODE_F1:
-				screen->setWindowSize(1);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_dec_size, REPEAT_FALSE))
+	{
+		screen->decWindowSize();
+		resource->reLoadTextures();
+	}
 
-			case SDL_SCANCODE_F2:
-				screen->setWindowSize(2);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_window_inc_size, REPEAT_FALSE))
+	{
+		screen->incWindowSize();
+		resource->reLoadTextures();
+	}
 
-			case SDL_SCANCODE_F3:
-				screen->setWindowSize(3);
-				resource->reLoadTextures();
-				break;
+	else if (input->checkInput(input_swap_palette, REPEAT_FALSE))
+	{
+		switchPalette();
+	}
 
-			case SDL_SCANCODE_F4:
-				screen->setWindowSize(4);
-				resource->reLoadTextures();
-				break;
-
-			case SDL_SCANCODE_F5:
-				switchPalette();
-				break;
-
-#ifdef DEBUG
-			case SDL_SCANCODE_F6:
-				screen->showNotification("MAMA MIRA! SIN MANOS!");
-				break;
-#endif
-
-			default:
-				break;
-			}
-		}
+	else if (input->checkInput(input_accept, REPEAT_FALSE) || input->checkInput(input_pause, REPEAT_FALSE))
+	{
+		section->name = SECTION_PROG_GAME;
+		section->subsection = 0;
 	}
 }
 
@@ -133,20 +141,20 @@ void Title::updateMarquee()
 {
 	for (int i = 0; i < (int)letters.size(); ++i)
 	{
-		if (letters.at(i).enabled)
+		if (letters[i].enabled)
 		{
-			letters.at(i).x -= marqueeSpeed;
-			if (letters.at(i).x < -10)
+			letters[i].x -= marqueeSpeed;
+			if (letters[i].x < -10)
 			{
-				letters.at(i).enabled = false;
+				letters[i].enabled = false;
 			}
 		}
 		else
 		{
-			if (i > 0 && letters.at(i - 1).x < 256 && letters.at(i - 1).enabled)
+			if (i > 0 && letters[i - 1].x < 256 && letters[i - 1].enabled)
 			{
-				letters.at(i).enabled = true;
-				letters.at(i).x = letters.at(i - 1).x + text->lenght(letters.at(i - 1).letter) + 1;
+				letters[i].enabled = true;
+				letters[i].x = letters[i - 1].x + text->lenght(letters[i - 1].letter) + 1;
 			}
 		}
 	}
@@ -167,14 +175,17 @@ void Title::renderMarquee()
 // Actualiza las variables
 void Title::update()
 {
+	// Comprueba el manejador de eventos
+	checkEventHandler();
+
 	// Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
 	if (SDL_GetTicks() - ticks > ticksSpeed)
 	{
 		// Actualiza el contador de ticks
 		ticks = SDL_GetTicks();
 
-		// Comprueba el manejador de eventos
-		checkEventHandler();
+		// Comprueba las entradas
+		checkInput();
 
 		// Incrementa el contador
 		counter++;
@@ -186,10 +197,10 @@ void Title::update()
 		screen->updateNotifier();
 
 		// Comprueba si ha terminado la marquesina y acaba con el titulo
-		if (letters.at(letters.size() - 1).x < -10)
+		if (letters[letters.size() - 1].x < -10)
 		{
-			section.name = SECTION_PROG_CREDITS;
-			section.subsection = 0;
+			section->name = SECTION_PROG_CREDITS;
+			section->subsection = 0;
 		}
 	}
 }
@@ -200,27 +211,13 @@ void Title::render()
 	// Prepara para empezar a dibujar en la textura de juego
 	screen->start();
 
-	// Limpia la pantalla
-	screen->clean();
-
 	// Dibuja el fondo del titulo
 	sprite->render();
 
-	// Dibuja el texto de PRESS ENTER TO PLAY
-	// SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
-	// const SDL_Rect rect = {0, 192 / 5 * 4, 256, 8};
-	// SDL_RenderFillRect(renderer, &rect);
-	// if (counter % 80 < 60)
-	//{
-	//	text->writeCentered(256 / 2, 192 / 5 * 4, "PRESS ENTER TO PLAY");
-	//}
-
 	// Dibuja el texto de PRESS ENTER TO PLAY
 	if (counter % 80 < 60)
 	{
-		const color_t textColor = stringToColor(options->palette, "white");
-		const color_t strokeColor = stringToColor(options->palette, "bright_blue");
-		text->writeDX(TXT_CENTER | TXT_COLOR | TXT_STROKE, 256 / 2, 192 / 5 * 4, "PRESS ENTER TO PLAY", 1, textColor, 1, strokeColor);
+		pressEnterSprite->render();
 	}
 
 	// Dibuja la marquesina
@@ -231,15 +228,13 @@ void Title::render()
 }
 
 // Bucle para el logo del juego
-section_t Title::run()
+void Title::run()
 {
-	while (section.name == SECTION_PROG_TITLE)
+	while (section->name == SECTION_PROG_TITLE)
 	{
 		update();
 		render();
 	}
-
-	return section;
 }
 
 // Recarga las texturas

source/title.h

@@ -2,6 +2,7 @@
 
 #include <SDL2/SDL.h>
 #include "common/asset.h"
+#include "common/input.h"
 #include "common/jail_audio.h"
 #include "common/resource.h"
 #include "common/screen.h"
@@ -25,19 +26,22 @@ private:
 	};
 
 	// Objetos y punteros
-	SDL_Renderer *renderer;	 // El renderizador de la ventana
-	Screen *screen;			 // Objeto encargado de dibujar en pantalla
-	Resource *resource;		 // Objeto con los recursos
-	Asset *asset;			 // Objeto con los ficheros de recursos
-	SDL_Event *eventHandler; // Manejador de eventos
-	Texture *texture;		 // Textura con los graficos
-	Sprite *sprite;			 // Sprite para manejar la textura
-	Text *text;				 // Objeto para escribir texto en pantalla
-	options_t *options;		 // Puntero a las opciones del juego
+	SDL_Renderer *renderer;		// El renderizador de la ventana
+	Screen *screen;				// Objeto encargado de dibujar en pantalla
+	Resource *resource;			// Objeto con los recursos
+	Asset *asset;				// Objeto con los ficheros de recursos
+	Input *input;				// Objeto pata gestionar la entrada
+	SDL_Event *eventHandler;	// Manejador de eventos
+	Texture *texture;			// Textura con los graficos
+	Sprite *sprite;				// Sprite para manejar la textura
+	Text *text;					// Objeto para escribir texto en pantalla
+	options_t *options;			// Puntero a las opciones del juego
+	Texture *pressEnterTexture; // Textura con los graficos de PRESS ENTER
+	Sprite *pressEnterSprite;	// Sprite para manejar la textura de PRESS ENTER
+	section_t *section;			// Estado del bucle principal para saber si continua o se sale
 
 	// Variables
 	int counter;				   // Contador
-	section_t section;			   // Estado del bucle principal para saber si continua o se sale
 	std::string longText;		   // Texto que aparece en la parte inferior del titulo
 	Uint32 ticks;				   // Contador de ticks para ajustar la velocidad del programa
 	Uint32 ticksSpeed;			   // Velocidad a la que se repiten los bucles del programa
@@ -53,6 +57,9 @@ private:
 	// Comprueba el manejador de eventos
 	void checkEventHandler();
 
+	// Comprueba las entradas
+	void checkInput();
+
 	// Actualiza la marquesina
 	void updateMarquee();
 
@@ -67,13 +74,13 @@ private:
 
 public:
 	// Constructor
-	Title(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, options_t *options);
+	Title(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *asset, Input *input, options_t *options, section_t *section);
 
 	// Destructor
 	~Title();
 
 	// Bucle principal
-	section_t run();
+	void run();
 };
 
 #endif