- Canvis que vaig fer fa 2 messos, però no sé en què estava pensant, he de arreglar-ho.

- Añadido getEntry(r,g,b) a systempalette
- [WIP] Modificaciones a la clase Textura
2023-02-13 11:50:37 +01:00 · 2023-02-13 11:41:56 +01:00 · 2022-12-02 12:30:25 +01:00 · 2022-12-02 12:29:59 +01:00 · 2022-12-02 12:29:37 +01:00 · 2022-12-01 20:05:15 +01:00
62 changed files with 763 additions and 542 deletions
--- a/32
+++ b/32
@@ -9,6 +9,7 @@ windowsRelease = $(executable)-$(version)-win32-x64.zip
 macosIntelRelease = $(executable)-$(version)-macos-intel.dmg
 macosAppleSiliconRelease = $(executable)-$(version)-macos-apple-silicon.dmg
 linuxRelease = $(executable)-$(version)-linux.tar.gz
+opendinguxRelease = $(executable).opk

 windows:
 	@echo off
@@ -139,4 +140,33 @@ linux_release:
 	cd "$(releaseFolder)" &&	tar -czvf "../$(linuxRelease)" *

 # Remove data
-	rm -rdf "$(releaseFolder)"
+	rm -rdf "$(releaseFolder)"
+
+opendingux:
+	/opt/gcw0-toolchain/usr/bin/mipsel-linux-g++ -D GCWZERO -I/opt/gcw0-toolchain/usr/mipsel-gcw0-linux-uclibc/sysroot/usr/include/SDL2 -D_GNU_SOURCE=1 -D_REENTRANT -lSDL2 -lSDL2_mixer -lstdc++ -std=c++11 $(source) -o "$(executable)"
+
+opendingux_release:
+# Remove data
+	rm -rdf "$(releaseFolder)"
+
+# Create folders
+	mkdir -p "$(releaseFolder)"
+
+# Copy data
+	cp -R data "$(releaseFolder)"
+	cp -R default.gcw0.desktop "$(releaseFolder)"
+	cp -R icon.png "$(releaseFolder)"
+
+# Delete data
+	rm -f "$(releaseFolder)/data/room/map.world"
+	rm -f "$(releaseFolder)/data/room/standard.tsx"
+
+# Build
+	/opt/gcw0-toolchain/usr/bin/mipsel-linux-g++ -D GCWZERO -I/opt/gcw0-toolchain/usr/mipsel-gcw0-linux-uclibc/sysroot/usr/include/SDL2 -D_GNU_SOURCE=1 -D_REENTRANT -lSDL2 -lSDL2_mixer -lstdc++ -std=c++11 $(source) -o "$(releaseFolder)/$(executable)"
+
+# Pack files
+	rm -f "$(opendinguxRelease)"
+	cd "$(releaseFolder)" &&	/opt/gcw0-toolchain/usr/bin/mksquashfs ./default.gcw0.desktop ./icon.png ./data ./$(executable) "../$(opendinguxRelease)" -all-root -noappend -no-exports -no-xattrs
+
+# Remove data
+	rm -rdf "$(releaseFolder)"
--- a/build.txt
+++ b/build.txt
@@ -0,0 +1,3 @@
+/opt/gcw0-toolchain/usr/bin/mipsel-linux-g++ -D GCWZERO -I/opt/gcw0-toolchain/usr/mipsel-gcw0-linux-uclibc/sysroot/usr/include/SDL2 -D_GNU_SOURCE=1 -D_REENTRANT -lSDL2 -lstdc++ -std=c++11 source/*.cpp source/common/*.cpp -o jdd
+sftp root@10.1.1.2:jdd <<< $'put jdd'
+ssh root@10.1.1.2
--- a/data/enemies/diskette.ani
+++ b/data/enemies/diskette.ani
--- a/data/enemies/diskette.png
+++ b/data/enemies/diskette.png
--- a/data/room/02.room
+++ b/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
--- a/data/room/02.tmx
+++ b/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>
--- a/data/room/05.room
+++ b/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
--- a/data/room/05.tmx
+++ b/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,
--- a/data/room/12.room
+++ b/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
--- a/data/room/17.room
+++ b/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
--- a/data/room/18.tmx
+++ b/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,
--- a/data/room/19.tmx
+++ b/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,
--- a/data/room/27.room
+++ b/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
--- a/data/room/28.tmx
+++ b/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,
--- a/data/room/34.room
+++ b/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
--- a/data/room/36.room
+++ b/data/room/36.room
@@ -1,4 +1,4 @@
-name=STATIC
+name=BE CAREFUL WITH THE FUSE
 bgColor=black
 border=bright_cyan
 tileMapFile=36.tmx
--- a/data/room/50.room
+++ b/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
--- a/data/room/50.tmx
+++ b/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,
--- a/data/tilesets/standard.png
+++ b/data/tilesets/standard.png
--- a/data/tilesets/standard_zxarne.png
+++ b/data/tilesets/standard_zxarne.png
--- a/default.gcw0.desktop
+++ b/default.gcw0.desktop
@@ -0,0 +1,10 @@
+[Desktop Entry]
+Version=1.6
+Type=Application
+Name=JailDoctor's Dilemma
+Comment=JailDoctor's Dilemma
+Icon=icon
+Exec=jaildoctors_dilemma
+Categories=games;Game;SDL;
+Terminal=false
+
--- a/icon.png
+++ b/icon.png
--- a/source/common/animatedsprite.cpp
+++ b/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;
 }
--- a/source/common/asset.cpp
+++ b/source/common/asset.cpp
@@ -4,7 +4,11 @@
 // Constructor
 Asset::Asset(std::string executablePath)
 {
+#ifdef __MIPSEL
+    this->executablePath = ".";
+#else
    this->executablePath = executablePath.substr(0, executablePath.find_last_of("\\/"));
+#endif
    longestName = 0;
    verbose = true;
 }
--- a/source/common/destsurface.cpp
+++ b/source/common/destsurface.cpp
@@ -0,0 +1,30 @@
+#include "destsurface.h"
+#include "systempalette.h"
+
+namespace DestSurface
+{
+	uint8_t *pixels = nullptr;
+    int width, height;
+
+    void init(int width, int height)
+    {
+        if (pixels==nullptr) pixels = new uint8_t[width*height];
+        DestSurface::width = width;
+        DestSurface::height = height;
+    }
+
+    void clear(uint32_t color)
+    {
+        SDL_memset(pixels, SystemPalette::getEntry(color), width*height);
+    }
+
+    uint8_t *getPixels()
+    {
+        return pixels;    
+    }
+
+    int getWidth()
+    {
+        return width;
+    }
+}
--- a/source/common/destsurface.h
+++ b/source/common/destsurface.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <SDL2/SDL.h>
+
+namespace DestSurface
+{
+    void init(int width, int height);
+
+    void clear(uint32_t color);
+
+    uint8_t *getPixels();
+
+    int getWidth();
+}
--- a/source/common/input.cpp
+++ b/source/common/input.cpp
@@ -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
 	{
--- a/source/common/jail_audio.cpp
+++ b/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
--- a/source/common/jail_audio.h
+++ b/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);
--- a/source/common/jail_audio_sdlmixer.cpp
+++ b/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
--- a/source/common/menu.cpp
+++ b/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();
 }

@@ -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;
 	}
 }

--- a/source/common/menu.h
+++ b/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
--- a/source/common/notify.cpp
+++ b/source/common/notify.cpp
@@ -38,7 +38,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 +47,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,10 +114,10 @@ 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);
        }
    }
--- a/source/common/notify.h
+++ b/source/common/notify.h
@@ -57,7 +57,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();
--- a/source/common/screen.cpp
+++ b/source/common/screen.cpp
@@ -1,6 +1,8 @@
 #include "screen.h"
 #include <string>
 #include <iostream>
+#include "destsurface.h"
+#include "systempalette.h"

 // Constructor
 Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, options_t *options)
@@ -28,7 +30,7 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, options
    borderColor = {0x00, 0x00, 0x00};

    // Crea la textura donde se dibujan los graficos del juego
-    gameCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, gameCanvasWidth, gameCanvasHeight);
+    gameCanvas = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, gameCanvasWidth, gameCanvasHeight);
    if (gameCanvas == nullptr)
    {
        if (options->console)
@@ -37,6 +39,8 @@ Screen::Screen(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, options
        }
    }

+    DestSurface::init(gameCanvasWidth, gameCanvasHeight);
+
    // Establece el modo de video
    setVideoMode(options->videoMode);

@@ -53,26 +57,34 @@ Screen::~Screen()
 // Limpia la pantalla
 void Screen::clean(color_t color)
 {
-    SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 0xFF);
-    SDL_RenderClear(renderer);
+    DestSurface::clear((color.r<<24) + (color.g<<16) + (color.b<<8) + 255);
 }

 // Prepara para empezar a dibujar en la textura de juego
 void Screen::start()
 {
-    SDL_SetRenderTarget(renderer, gameCanvas);
+    //SDL_SetRenderTarget(renderer, gameCanvas);
 }

 // Vuelca el contenido del renderizador en pantalla
 void Screen::blit()
 {
    // Vuelve a dejar el renderizador en modo normal
-    SDL_SetRenderTarget(renderer, nullptr);
+    //SDL_SetRenderTarget(renderer, nullptr);

    // Borra el contenido previo
    SDL_SetRenderDrawColor(renderer, borderColor.r, borderColor.g, borderColor.b, 0xFF);
    SDL_RenderClear(renderer);

+    uint8_t *destSurface = DestSurface::getPixels();
+
+    Uint32 *pixels;
+    int pitch;
+    int size = gameCanvasWidth*gameCanvasHeight;
+    SDL_LockTexture(gameCanvas, NULL, (void**)&pixels, &pitch);
+    for (int i=0;i<size;++i) pixels[i] = SystemPalette::getRGBA(destSurface[i]);
+    SDL_UnlockTexture(gameCanvas);
+
    // Copia la textura de juego en el renderizador en la posición adecuada
    SDL_RenderCopy(renderer, gameCanvas, nullptr, &dest);

@@ -344,7 +356,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);
 }

@@ -383,9 +395,9 @@ void Screen::renderNotifications()
        return;
    }

-    SDL_RenderSetLogicalSize(renderer, notificationLogicalWidth, notificationLogicalHeight);
+    //SDL_RenderSetLogicalSize(renderer, notificationLogicalWidth, notificationLogicalHeight);
    notify->render();
-    SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
+    //SDL_RenderSetLogicalSize(renderer, windowWidth, windowHeight);
 }

 // Establece el tamaño de las notificaciones
--- a/source/common/sprite.cpp
+++ b/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;
--- a/source/common/systempalette.cpp
+++ b/source/common/systempalette.cpp
@@ -0,0 +1,60 @@
+#include "systempalette.h"
+
+namespace SystemPalette
+{
+
+    uint32_t    entries[256];           // Las 256 entradas de la paleta
+    uint8_t     numEntries;             // El número de entradas existente actualmente
+
+    // Vacía la paleta 
+    void Clear()
+    {
+        // Fijamos el color transparente en 0 y el blanco en 1
+        entries[0] = 0x00000000;  // Transparente
+        entries[1] = 0xffffffff;  // Blanco
+
+        numEntries = 2;
+
+        // Ya que 'getRGBA' no comprueba que el índice solicitado sea menor que
+        //   'numentries', rellenamos con 'negro' todas las entradas no usadas.
+        for (int i = 2; i < 256; ++i ) entries[i] = 0x000000ff;
+    }
+
+    // Obtenemos el índice de la paleta para el color especificado. Si no existe se crea.
+    uint8_t getEntry(const uint32_t color)
+    {
+        // ATENCIÓN!!! Si intentamos introducir más de 256 colores empezará a
+        //   sobreescribir los primeros colores. Al menos no corromperá la
+        //   memoria. Pensar la mejor forma de controlar esto.
+
+        // Recorremos la paleta...
+        for (int i = 0; i < numEntries; ++i)
+        {
+            // Si encontramos el color, devolvemos su índice y salimos
+            if (entries[i] == color) return i;
+        }
+
+        // Si no se ha encontrado, lo ponemos al final
+        entries[numEntries] = color;
+
+        // Y devolvemos su índice
+        return numEntries++;
+    }
+
+    // Versión de getEntry para obtener el color con los componentes R, G y B
+    uint8_t getEntry(const uint8_t r, const uint8_t g, const uint8_t b)
+    {
+        return getEntry( (r<<24) + (g<<16) + (b<<8) + 255 );
+    }
+
+    // Dado un índice, devolvemos su color
+    uint32_t getRGBA(const uint8_t entry)
+    {
+        // ATENCIÓN!!! No compruebo que el parámetro 'entry' sea menor que el
+        //   miembro 'numEntries', por lo que se puede acceder a colores no
+        //   definidos (por ejemplo tener 4 colores y acceder al color 8). La
+        //   razón es que necesito que esta función sea lo más rápida posible.
+        //   En cualquier caso, nunca se va a salir de la memoria ni nada raro.
+        return entries[entry];
+    }
+}
--- a/source/common/systempalette.h
+++ b/source/common/systempalette.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <stdint.h>
+
+namespace SystemPalette
+{
+    // Vacía la paleta 
+    void Clear();
+
+    // Obtenemos el índice de la paleta para el color especificado. Si no existe se crea.
+    uint8_t getEntry(const uint32_t color);
+
+    // Versión de getEntry para obtener el color con los componentes R, G y B
+    uint8_t getEntry(const uint8_t r, const uint8_t g, const uint8_t b);
+
+    // Dado un índice, devolvemos su color
+    uint32_t getRGBA(const uint8_t entry);
+}
--- a/source/common/texture.cpp
+++ b/source/common/texture.cpp
@@ -3,6 +3,8 @@
 #define STB_IMAGE_IMPLEMENTATION
 #include "stb_image.h"
 #include <iostream>
+#include "systempalette.h"
+#include "destsurface.h"

 // Constructor
 Texture::Texture(SDL_Renderer *renderer, std::string path, bool verbose)
@@ -12,14 +14,15 @@ Texture::Texture(SDL_Renderer *renderer, std::string path, bool verbose)
 	this->path = path;

 	// Inicializa
-	texture = nullptr;
-	width = 0;
-	height = 0;
+	this->pixels = nullptr;
+	this->width = 0;
+	this->height = 0;
+	this->color = 0xffffffff;

 	// Carga el fichero en la textura
 	if (path != "")
 	{
-		loadFromFile(path, renderer, verbose);
+		loadFromFile(path, verbose);
 	}
 }

@@ -31,7 +34,7 @@ Texture::~Texture()
 }

 // Carga una imagen desde un fichero
-bool Texture::loadFromFile(std::string path, SDL_Renderer *renderer, bool verbose)
+bool Texture::loadFromFile(std::string path, bool verbose)
 {
 	const std::string filename = path.substr(path.find_last_of("\\/") + 1);
 	int req_format = STBI_rgb_alpha;
@@ -50,89 +53,39 @@ bool Texture::loadFromFile(std::string path, SDL_Renderer *renderer, bool verbos
 		}
 	}

-	int depth, pitch;
-	Uint32 pixel_format;
-	if (req_format == STBI_rgb)
-	{
-		depth = 24;
-		pitch = 3 * width; // 3 bytes por pixel * pixels per linea
-		pixel_format = SDL_PIXELFORMAT_RGB24;
-	}
-	else
-	{ // STBI_rgb_alpha (RGBA)
-		depth = 32;
-		pitch = 4 * width;
-		pixel_format = SDL_PIXELFORMAT_RGBA32;
-	}
-
 	// Limpia
 	unload();

-	// La textura final
-	SDL_Texture *newTexture = nullptr;
-
-	// Carga la imagen desde una ruta específica
-	SDL_Surface *loadedSurface = SDL_CreateRGBSurfaceWithFormatFrom((void *)data, width, height, depth, pitch, pixel_format);
-	if (loadedSurface == nullptr)
-	{
-		if (verbose)
-		{
-			std::cout << "Unable to load image " << path.c_str() << std::endl;
-		}
-	}
-	else
-	{
-		// Crea la textura desde los pixels de la surface
-		newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface);
-		if (newTexture == nullptr)
-		{
-			if (verbose)
-			{
-				std::cout << "Unable to create texture from " << path.c_str() << "! SDL Error: " << SDL_GetError() << std::endl;
-			}
-		}
-		else
-		{
-			// Obtiene las dimensiones de la imagen
-			this->width = loadedSurface->w;
-			this->height = loadedSurface->h;
-		}
-
-		// Elimina la textura cargada
-		SDL_FreeSurface(loadedSurface);
-	}
+	this->width = width;
+	this->height = height;
+	const int size = width*height;
+	this->pixels = new uint8_t[size];
+	for (int i = 0; i < size; ++i) this->pixels[i] = SystemPalette::getEntry(data[i]);

 	// Return success
-	texture = newTexture;
-	return texture != nullptr;
+	stbi_image_free(data);
+	return this->pixels != nullptr;
 }

 // Crea una textura en blanco
 bool Texture::createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess access)
 {
 	// Crea una textura sin inicializar
-	texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, access, width, height);
-	if (texture == nullptr)
-	{
-		std::cout << "Unable to create blank texture! SDL Error: " << SDL_GetError() << std::endl;
-	}
-	else
-	{
-		this->width = width;
-		this->height = height;
-	}
+	this->pixels = new uint8_t[width*height];
+	this->width = width;
+	this->height = height;

-	return texture != nullptr;
+	return this->pixels != nullptr;
 }

 // Libera la memoria de la textura
 void Texture::unload()
 {
 	// Libera la textura si existe
-	if (texture != nullptr)
+	if (pixels != nullptr)
 	{
-		SDL_DestroyTexture(texture);
-		texture = nullptr;
+		delete[] pixels;
+		pixels = nullptr;
 		width = 0;
 		height = 0;
 	}
@@ -141,19 +94,19 @@ void Texture::unload()
 // Establece el color para la modulacion
 void Texture::setColor(Uint8 red, Uint8 green, Uint8 blue)
 {
-	SDL_SetTextureColorMod(texture, red, green, blue);
+	this->color = (red << 24) + (green << 16) + (blue << 8) + 255;
 }

 // Establece el blending
 void Texture::setBlendMode(SDL_BlendMode blending)
 {
-	SDL_SetTextureBlendMode(texture, blending);
+	//SDL_SetTextureBlendMode(texture, blending);
 }

 // Establece el alpha para la modulación
 void Texture::setAlpha(Uint8 alpha)
 {
-	SDL_SetTextureAlphaMod(texture, alpha);
+	//SDL_SetTextureAlphaMod(texture, alpha);
 }

 // Renderiza la textura en un punto específico
@@ -173,13 +126,24 @@ void Texture::render(SDL_Renderer *renderer, int x, int y, SDL_Rect *clip, float
 	renderQuad.h = renderQuad.h * zoomH;

 	// Renderiza a pantalla
-	SDL_RenderCopyEx(renderer, texture, clip, &renderQuad, angle, center, flip);
+	//SDL_RenderCopyEx(renderer, texture, clip, &renderQuad, angle, center, flip);
+
+	uint8_t *destSurface = DestSurface::getPixels();
+	int canvasWidth = DestSurface::getWidth();
+
+	int y_inc = 1, y_ini = 0, y_fin = renderQuad.h-1; if (flip && SDL_FLIP_VERTICAL==SDL_FLIP_VERTICAL) { auto tmp=y_ini; y_ini=y_fin; y_fin=tmp; y_inc=-1; }
+	int x_inc = 1, x_ini = 0, x_fin = renderQuad.w-1; if (flip && SDL_FLIP_HORIZONTAL==SDL_FLIP_HORIZONTAL) { auto tmp=x_ini; x_ini=x_fin; x_fin=tmp; x_inc=-1; }
+	for (int yy=y_ini; yy <= y_fin; yy += y_inc) {
+		for (int xx=x_ini; xx <= x_fin; xx += x_inc) {
+			destSurface[ x+xx + y+yy * canvasWidth ] = pixels[ clip->x+xx + clip->y+yy * width ];
+		}
+	}
 }

 // Establece la textura como objetivo de renderizado
 void Texture::setAsRenderTarget(SDL_Renderer *renderer)
 {
-	SDL_SetRenderTarget(renderer, texture);
+	//SDL_SetRenderTarget(renderer, texture);
 }

 // Obtiene el ancho de la imagen
@@ -203,5 +167,5 @@ bool Texture::reLoad()
 // Obtiene la textura
 SDL_Texture *Texture::getSDLTexture()
 {
-	return texture;
+	return nullptr; //texture;
 }
--- a/source/common/texture.h
+++ b/source/common/texture.h
@@ -11,13 +11,14 @@ class Texture
 {
 private:
    // Objetos y punteros
-    SDL_Texture *texture;   // La textura
+    uint8_t      *pixels;   // Los pixels de esta textura
    SDL_Renderer *renderer; // Renderizador donde dibujar la textura

    // Variables
    int width;        // Ancho de la imagen
    int height;       // Alto de la imagen
    std::string path; // Ruta de la imagen de la textura
+    uint32_t color;   // Color para el pintado de 1 bit (sprites y tal)

 public:
    // Constructor
@@ -27,7 +28,7 @@ public:
    ~Texture();

    // Carga una imagen desde un fichero
-    bool loadFromFile(std::string path, SDL_Renderer *renderer, bool verbose = false);
+    bool loadFromFile(std::string path, bool verbose = false);

    // Crea una textura en blanco
    bool createBlank(SDL_Renderer *renderer, int width, int height, SDL_TextureAccess = SDL_TEXTUREACCESS_STREAMING);
--- a/source/credits.cpp
+++ b/source/credits.cpp
@@ -200,7 +200,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"));

--- a/source/demo.cpp
+++ b/source/demo.cpp
@@ -15,7 +15,7 @@ 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;
@@ -164,8 +164,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();
@@ -260,7 +260,7 @@ void Demo::checkRoomChange()
 		}
 		else
 		{
-			changeRoom(rooms.at(roomIndex));
+			changeRoom(rooms[roomIndex]);
 		}
 	}
 }
--- a/source/director.cpp
+++ b/source/director.cpp
@@ -18,7 +18,7 @@ Director::Director(int argc, char *argv[])
 	section.subsection = SUBSECTION_LOGO_TO_INTRO;

 #ifdef DEBUG
-	section.name = SECTION_PROG_GAME;
+	section.name = SECTION_PROG_LOGO;
 #endif

 	// Crea e inicializa las opciones del programa
@@ -121,7 +121,7 @@ void Director::initOptions()
 	options->videoMode = 0;
 	options->windowSize = 3;
 	options->filter = FILTER_NEAREST;
-	options->vSync = true;
+	options->vSync = false;
 	options->integerScale = true;
 	options->keepAspect = true;
 	options->borderEnabled = true;
@@ -129,8 +129,12 @@ void Director::initOptions()
 	options->borderHeight = 24;
 	options->palette = p_zxspectrum;

+#ifdef GAME_CONSOLE
+	options->windowSize = 1;
+#endif
+
 	// Estos valores no se guardan en el fichero de configuraci´ón
-	options->console = false;
+	options->console = true;
 	options->cheat.infiniteLives = false;
 	options->cheat.invincible = false;
 	options->cheat.jailEnabled = false;
@@ -581,7 +585,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 +648,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");
@@ -755,7 +759,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 +840,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");
@@ -1230,14 +1234,14 @@ void Director::initInput()
 	input->bindKey(INPUT_BUTTON_PAUSE, SDL_SCANCODE_ESCAPE);
 	input->bindKey(INPUT_BUTTON_ESCAPE, SDL_SCANCODE_ESCAPE);

-	input->bindGameControllerButton(INPUT_UP, SDL_CONTROLLER_BUTTON_DPAD_UP);
+	input->bindGameControllerButton(INPUT_UP, SDL_CONTROLLER_BUTTON_B);
 	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_PAUSE, SDL_CONTROLLER_BUTTON_START);
 	input->bindGameControllerButton(INPUT_BUTTON_ESCAPE, SDL_CONTROLLER_BUTTON_GUIDE);
 }

@@ -1533,8 +1537,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);
--- a/source/director.h
+++ b/source/director.h
@@ -49,7 +49,7 @@ private:

 	// 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

--- a/source/ending.cpp
+++ b/source/ending.cpp
@@ -119,16 +119,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();
        }
    }

@@ -511,7 +511,7 @@ void Ending::updateCounters()
        counter++;
    }

-    if (counter > scenes.at(scene).counterEnd - 100)
+    if (counter > scenes[scene].counterEnd - 100)
    {
        coverCounter++;
    }
@@ -522,20 +522,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 +543,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;
@@ -639,20 +639,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"));
    }
 }
--- a/source/ending.h
+++ b/source/ending.h
@@ -70,7 +70,7 @@ private:
 	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();
--- a/source/ending2.cpp
+++ b/source/ending2.cpp
@@ -288,7 +288,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 +469,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 +497,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 +536,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 +547,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 +565,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 +576,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 +624,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);
    }
 }

--- a/source/ending2.h
+++ b/source/ending2.h
@@ -39,7 +39,7 @@ private:
 	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
--- a/source/game.cpp
+++ b/source/game.cpp
@@ -256,8 +256,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();
--- a/source/game.h
+++ b/source/game.h
@@ -43,13 +43,13 @@ private:
 	Stats *stats;			  // Objeto encargado de gestionar las estadísticas

 	// 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
--- a/source/game_over.cpp
+++ b/source/game_over.cpp
@@ -198,13 +198,13 @@ void GameOver::updateColor()
        // 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];
    }
 }

--- a/source/game_over.h
+++ b/source/game_over.h
@@ -40,7 +40,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();
--- a/source/intro.cpp
+++ b/source/intro.cpp
@@ -36,16 +36,8 @@ Intro::Intro(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *
 	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)
@@ -154,25 +146,24 @@ void Intro::updateLoad()
 	{
 		// 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,57 +171,36 @@ 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
@@ -253,14 +223,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 +232,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();

--- a/source/intro.h
+++ b/source/intro.h
@@ -38,13 +38,12 @@ private:
 	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
+	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();
--- a/source/item.cpp
+++ b/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);
 }
--- a/source/logo.cpp
+++ b/source/logo.cpp
@@ -26,13 +26,13 @@ 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
@@ -142,22 +142,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 +173,72 @@ 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);
 	}
 }

--- a/source/player.h
+++ b/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
--- a/source/room.cpp
+++ b/source/room.cpp
@@ -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
@@ -763,37 +764,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 +821,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 +956,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 +974,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 +1019,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 +1037,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 +1081,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 +1091,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 +1129,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 +1139,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 +1166,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 +1207,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 +1257,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 +1275,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 +1300,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);
@@ -1532,7 +1533,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;
    }
 }
--- a/source/room.h
+++ b/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
--- a/source/stats.cpp
+++ b/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
--- a/source/title.cpp
+++ b/source/title.cpp
@@ -30,7 +30,6 @@ Title::Title(SDL_Renderer *renderer, Screen *screen, Resource *resource, Asset *
 	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 +38,24 @@ 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
+	const std::string caption = "PRESS ENTER TO PLAY";
+	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 +65,8 @@ Title::~Title()
 {
 	delete eventHandler;
 	delete sprite;
+	delete pressEnterSprite;
+	delete pressEnterTexture;
 	delete text;
 }

@@ -70,6 +86,12 @@ void Title::checkEventHandler()
 		// Comprueba las teclas que se han pulsado
 		if ((eventHandler->type == SDL_KEYDOWN && eventHandler->key.repeat == 0) || (eventHandler->type == SDL_JOYBUTTONDOWN))
 		{
+			if (eventHandler->type == SDL_JOYBUTTONDOWN)
+			{
+				section.name = SECTION_PROG_GAME;
+				section.subsection = 0;
+			}
+
 			switch (eventHandler->key.keysym.scancode)
 			{
 			case SDL_SCANCODE_ESCAPE:
@@ -133,20 +155,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;
 			}
 		}
 	}
@@ -186,7 +208,7 @@ 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;
@@ -200,27 +222,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
--- a/source/title.h
+++ b/source/title.h
@@ -25,15 +25,17 @@ 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
+	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

 	// Variables
 	int counter;				   // Contador
Author	SHA1	Message	Date
Raimon Zamora	908ffa6d55	- Canvis que vaig fer fa 2 messos, però no sé en què estava pensant, he de arreglar-ho.	2023-02-13 11:50:37 +01:00
Raimon Zamora	d230259e42	- Añadido getEntry(r,g,b) a systempalette	2023-02-13 11:41:56 +01:00
JailDoctor	a61c2e8d46	- [WIP] Modificaciones a la clase Textura	2022-12-02 12:30:25 +01:00
JailDoctor	9bb9d26417	- Clase para pintado al pixel sobre una textura	2022-12-02 12:29:59 +01:00
JailDoctor	a96ce4afc9	- Creada la paleta de sistema	2022-12-02 12:29:37 +01:00
Raimon Zamora	29a2ebf221	- Added opendingux build stage to Makefile	2022-12-01 20:05:15 +01:00
Raimon Zamora	bcccfb026f	- Files needed to create opk package	2022-12-01 20:05:00 +01:00
Raimon Zamora	aad60d9849	- Added Some build notes to the repo	2022-12-01 20:04:36 +01:00
JailDoctor	4de0743a77	-Some options for Opendingux	2022-12-01 20:02:26 +01:00
JailDoctor	80e91e7acd	- Executable Path in OpenDingux is exe name alone. Set "." instead	2022-12-01 20:02:12 +01:00
Sergio Valor	4cbe55c2d4	Actualizado jail_audio a la última versión	2022-12-01 19:51:53 +01:00
Sergio Valor	564f316586	Cambiado el nombre del enemigo diskette a floppy	2022-12-01 19:32:59 +01:00
Sergio Valor	522ab8e726	Cambios cosméticos en algunas habitaciones. Cambiado el nombre de STATIC a BE CAREFUL WITH THE FUSE	2022-12-01 19:31:35 +01:00
Sergio Valor Martinez	4911282777	El color de fondo de la habitación se pinta en la textura del mapa	2022-12-01 11:40:35 +01:00
Sergio Valor Martinez	06ecabc676	Corregido un "memory leak" en texture.cpp	2022-12-01 10:43:58 +01:00
Sergio Valor Martinez	5d89a3057e	Optimizado un poco el title.cpp	2022-11-30 13:43:47 +01:00
Sergio Valor Martinez	75228cc451	Eliminado el resto de accesos a vector mediante at()	2022-11-30 12:09:45 +01:00
Sergio Valor Martinez	357eec20b1	Eliminados la mayor parte de accesos a vector mediante at()	2022-11-30 12:03:37 +01:00
Sergio Valor Martinez	62c1e2715e	Preparando el juego para ser compatble con consolas	2022-11-30 11:06:27 +01:00
Sergio Valor Martinez	34fc2b6b06	Optimizada la intro	2022-11-30 10:10:10 +01:00
Sergio Valor Martinez	6557dea2bb	Merge branch 'master' of https://gitea.sustancia.synology.me/JailDesigner/jaildoctors_dilemma	2022-11-30 08:27:11 +01:00
Sergio Valor Martinez	2caea7ba6e	Optimizando la intro	2022-11-30 08:26:16 +01:00