Arreglado un fallo en el salto al cambiar de pantalla hacia arriba

data/enemies/01.enemy

@@ -1,10 +0,0 @@
-tileset=enemy01.png
-x=8
-y=8
-vx=0.1
-vy=0
-x1=8
-x2=200
-y1=8
-y2=8
-color=red

data/room/01.room

@@ -1,37 +1,55 @@
-id=1
-name=Test Room
+name=void main
 bg_color=black
 tileset=room1.png
 room_up=0
 room_down=0
 room_left=0
 room_right=02.room
-tilemap=41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,0,0,0,0,41,41,41,41,41,41,41,41,41,41,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,0,0,41,41,41,41,41,0,0,0,0,0,0,0,0,0,81,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,0,0,0,0,0,0,0,0,0,0,0,0,41,41,41,41,0,0,0,0,0,0,0,0,0,0,0,41,41,41,41,41,41,41,41,0,0,0,0,0,0,0,0,0,41,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,0,0,0,0,0,41,41,0,0,0,0,81,81,81,81,81,81,81,81,81,81,81,81,81,81,81,81,81,81,81,81,81,0,0,0,0,0,41,0,0,0,0,0,0,0,0,0,81,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41,41
+
+[tilemap]
+room1.tmx
+[tilemap-end]
 
 [enemy]
 tileset=enemy01.png
-x=8
+width=16
+height=16
+x=1
 y=0
 vx=0
 vy=0.3
-x1=8
-x2=8
+x1=1
 y1=0
-y2=48
+x2=1
+y2=6
 color=red
 [enemy-end]
 
 [enemy]
 tileset=enemy01.png
-x=40
-y=72
-vx=0.3
+width=16
+height=16
+x=5
+y=9
+vx=0.6
 vy=0
-x1=40
-x2=184
-y1=72
-y2=72
+x1=5
+y1=9
+x2=22
+y2=9
 color=yellow
 [enemy-end]
 
-item=1,10,10
+[item]
+tileset=items.png
+tile=0
+x=1
+y=7
+[item-end]
+
+[item]
+tileset=items.png
+tile=0
+x=17
+y=8
+[item-end]

data/room/02.room

@@ -1,12 +1,33 @@
-id=2
-name=Test Room 2
+name=case switch
 bg_color=black
 tileset=room1.png
 room_up=0
-room_down=0
+room_down=04.room
 room_left=01.room
-room_right=0
-tilemap=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,0,0,0,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,0,0,0,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,0,0,0,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,0,0,0,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,0,0,0,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,0,0,0,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,0,0,0,43,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,43,43,43,43,0,0,0,0,0,0,0,0,0,43,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,43,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,43,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,43,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,83,83,83,83,83,83,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,83,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63,63
-enemy=1,0,0,0,1
-enemy=2,10,0,0,1
-item=1,10,10
+room_right=03.room
+
+[tilemap]
+room2.tmx
+[tilemap-end]
+
+[enemy]
+tileset=enemy01.png
+width=16
+height=16
+x=14
+y=0
+vx=0
+vy=1
+x1=14
+y1=0
+x2=14
+y2=12
+color=purple
+[enemy-end]
+
+[item]
+tileset=items.png
+tile=1
+x=19
+y=6
+[item-end]

data/room/03.room

@@ -0,0 +1,63 @@
+name=the edge
+bg_color=light_black
+tileset=room1.png
+room_up=0
+room_down=0
+room_left=02.room
+room_right=0
+
+[tilemap]
+room3.tmx
+[tilemap-end]
+
+[enemy]
+tileset=enemy02.png
+width=8
+height=16
+x=4
+y=5
+vx=0
+vy=1
+x1=4
+y1=2
+x2=4
+y2=13
+color=green
+[enemy-end]
+
+[enemy]
+tileset=enemy02.png
+width=8
+height=16
+x=10
+y=4
+vx=0
+vy=1
+x1=10
+y1=2
+x2=10
+y2=13
+color=light_blue
+[enemy-end]
+
+[enemy]
+tileset=enemy02.png
+width=8
+height=16
+x=16
+y=3
+vx=0
+vy=1
+x1=16
+y1=2
+x2=16
+y2=13
+color=purple
+[enemy-end]
+
+[item]
+tileset=items.png
+tile=5
+x=12
+y=2
+[item-end]

data/room/04.room

@@ -0,0 +1,78 @@
+name=The Fridge
+bg_color=blue
+tileset=room1.png
+room_up=02.room
+room_down=0
+room_left=0
+room_right=05.room
+
+[tilemap]
+room4.tmx
+[tilemap-end]
+
+[enemy]
+tileset=enemy02.png
+width=8
+height=16
+x=1
+y=3
+vx=1
+vy=0
+x1=1
+y1=3
+x2=14
+y2=3
+color=purple
+[enemy-end]
+
+[enemy]
+tileset=enemy02.png
+width=8
+height=16
+x=30
+y=7
+vx=-0.8
+vy=0
+x1=10
+y1=7
+x2=30
+y2=7
+color=light_white
+[enemy-end]
+
+[enemy]
+tileset=enemy03.png
+width=8
+height=8
+x=15
+y=12
+vx=0.5
+vy=0
+x1=15
+y1=12
+x2=30
+y2=12
+color=light_purple
+[enemy-end]
+
+[item]
+tileset=items.png
+tile=6
+x=2
+y=2
+[item-end]
+
+[item]
+tileset=items.png
+tile=6
+x=29
+y=5
+[item-end]
+
+
+[item]
+tileset=items.png
+tile=6
+x=21
+y=12
+[item-end]

data/room/05.room

@@ -0,0 +1,11 @@
+name=coruscant
+bg_color=light_black
+tileset=room1.png
+room_up=03.room
+room_down=0
+room_left=04.room
+room_right=0
+
+[tilemap]
+room5.tmx
+[tilemap-end]

data/room/room1.tmx

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.9" tiledversion="1.9.0" orientation="orthogonal" renderorder="right-down" width="32" height="16" tilewidth="8" tileheight="8" infinite="0" nextlayerid="2" nextobjectid="1">
+ <tileset firstgid="1" source="../../resources/tilesets/room1.tsx"/>
+ <layer id="1" name="Capa de patrones 1" width="32" height="16">
+  <data encoding="csv">
+21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,0,0,0,0,21,21,21,21,21,21,21,21,21,21,21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,0,0,21,21,21,0,0,0,0,0,0,0,0,0,0,0,211,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,21,21,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,21,21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,21,21,21,21,0,0,0,0,0,21,21,21,21,21,
+21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,211,0,0,0,0,0,0,0,
+21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,0,0,0,0,211,211,211,211,211,211,211,211,211,211,211,211,211,211,211,211,211,211,211,211,0,0,0,0,0,0,0,
+21,0,0,0,0,0,0,0,0,211,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,
+21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21
+</data>
+ </layer>
+</map>

data/room/room2.tmx

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.9" tiledversion="1.9.0" orientation="orthogonal" renderorder="right-down" width="32" height="16" tilewidth="8" tileheight="8" infinite="0" nextlayerid="2" nextobjectid="1">
+ <tileset firstgid="1" source="../../resources/tilesets/room1.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,0,0,0,0,23,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,
+0,0,0,0,0,0,0,0,0,0,0,203,203,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,23,23,23,23,0,0,0,0,0,0,0,0,0,23,
+23,23,23,23,23,23,0,0,0,203,0,0,0,0,0,0,0,0,0,23,0,0,0,0,203,203,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,203,0,0,0,0,0,0,0,0,0,23,0,0,0,0,203,203,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,0,0,0,0,0,0,0,0,0,203,203,23,
+0,0,0,0,0,0,0,203,203,203,203,203,203,0,0,0,0,0,0,23,0,0,0,0,203,203,0,0,0,0,0,23,
+0,0,0,0,0,203,0,0,0,0,0,0,0,0,0,0,0,0,0,23,0,0,0,0,0,0,0,0,0,0,0,23,
+43,23,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,83,83,83,83,83,83,83,83,83,83,83,83,
+43,43,43,43,43,43,43,43,43,43,43,43,43,43,223,0,0,223,43,43,43,43,43,43,43,43,43,43,43,43,43,43
+</data>
+ </layer>
+</map>

data/room/room3.tmx

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.9" tiledversion="1.9.0" orientation="orthogonal" renderorder="right-down" width="32" height="16" tilewidth="8" tileheight="8" infinite="0" nextlayerid="2" nextobjectid="1">
+ <tileset firstgid="1" source="../../resources/tilesets/room1.tsx"/>
+ <layer id="1" name="Capa de patrones 1" width="32" height="16">
+  <data encoding="csv">
+26,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+26,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+26,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+26,0,0,0,0,0,0,0,0,0,0,0,271,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+26,0,0,0,0,0,0,0,0,271,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+26,0,0,0,0,0,271,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+26,0,0,271,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+26,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,271,271,271,271,271,271,271,271,271,271,271,271,271,271,271,271,271,271,0,232,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,232,0,0,0,0,0,0,0,0,0,
+26,26,26,0,0,0,26,26,26,0,0,0,26,26,26,0,0,0,26,26,26,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+</data>
+ </layer>
+</map>

data/room/room4.tmx

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.9" tiledversion="1.9.0" orientation="orthogonal" renderorder="right-down" width="32" height="16" tilewidth="8" tileheight="8" infinite="0" nextlayerid="2" nextobjectid="1">
+ <tileset firstgid="1" source="../../resources/tilesets/room1.tsx"/>
+ <layer id="1" name="Capa de patrones 1" width="32" height="16">
+  <data encoding="csv">
+25,249,249,249,249,249,249,249,249,249,249,249,249,249,0,0,0,0,249,249,249,249,249,249,249,249,249,249,249,249,249,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,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,25,
+25,0,0,0,0,0,0,0,0,0,0,0,0,0,230,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,25,
+25,25,25,25,0,25,25,25,25,25,0,25,25,25,25,0,0,230,0,0,0,0,0,0,0,0,0,0,0,0,0,25,
+25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,270,270,270,270,270,270,270,0,0,270,0,25,
+25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,290,0,0,0,0,0,0,0,25,
+25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,290,0,0,0,0,0,0,0,25,
+25,0,0,0,0,0,0,0,0,0,0,25,25,25,25,0,0,25,25,25,25,25,25,25,0,0,0,0,0,0,0,25,
+25,0,0,0,0,229,229,229,229,229,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,25,
+25,249,249,249,249,249,249,249,249,249,249,249,249,249,249,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25,
+22,0,0,0,0,0,289,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+22,0,0,0,0,0,289,0,0,0,0,0,0,0,0,0,0,0,381,0,0,0,0,0,0,381,0,0,0,0,0,0,
+25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25
+</data>
+ </layer>
+</map>

data/room/room5.tmx

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.9" tiledversion="1.9.0" orientation="orthogonal" renderorder="right-down" width="32" height="16" tilewidth="8" tileheight="8" infinite="0" nextlayerid="2" nextobjectid="1">
+ <tileset firstgid="1" source="../../resources/tilesets/room1.tsx"/>
+ <layer id="1" name="Capa de patrones 1" width="32" height="16">
+  <data encoding="csv">
+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,
+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,
+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,
+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,
+25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,49,0,0,0,0,0,0,0,0,0,0,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+25,0,0,0,0,0,0,0,48,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,48,48,382,382,48,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,48,48,48,47,47,48,48,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48
+</data>
+ </layer>
+</map>

source/animatedsprite.cpp

@@ -4,8 +4,11 @@
 // Constructor
 AnimatedSprite::AnimatedSprite(LTexture *texture, SDL_Renderer *renderer)
 {
-	mRenderer = renderer;
-	mTexture = texture;
+	// Copia los punteros
+	setTexture(texture);
+	setRenderer(renderer);
+
+	init();
 }
 
 // Destructor

source/animatedsprite.h

@@ -27,7 +27,7 @@ private:
 
 public:
     // Constructor
-    AnimatedSprite(LTexture *texture, SDL_Renderer *renderer);
+    AnimatedSprite(LTexture *texture = nullptr, SDL_Renderer *renderer = nullptr);
 
     // Destructor
     ~AnimatedSprite();

source/const.h

@@ -29,9 +29,9 @@ const int VIEW_HEIGHT = SCREEN_HEIGHT * 3;
 
 // Zona de juego
 const int PLAY_AREA_TOP = (0 * BLOCK);
-const int PLAY_AREA_BOTTOM = GAMECANVAS_HEIGHT - (4 * BLOCK);
+const int PLAY_AREA_BOTTOM = (16 * BLOCK);
 const int PLAY_AREA_LEFT = (0 * BLOCK);
-const int PLAY_AREA_RIGHT = GAMECANVAS_WIDTH - (0 * BLOCK);
+const int PLAY_AREA_RIGHT = (32 * BLOCK);
 const int PLAY_AREA_WIDTH = PLAY_AREA_RIGHT - PLAY_AREA_LEFT;
 const int PLAY_AREA_HEIGHT = PLAY_AREA_BOTTOM - PLAY_AREA_TOP;
 const int PLAY_AREA_CENTER_X = PLAY_AREA_LEFT + (PLAY_AREA_WIDTH / 2);
@@ -41,6 +41,11 @@ const int PLAY_AREA_CENTER_Y = PLAY_AREA_TOP + (PLAY_AREA_HEIGHT / 2);
 const int PLAY_AREA_FIRST_QUARTER_Y = PLAY_AREA_HEIGHT / 4;
 const int PLAY_AREA_THIRD_QUARTER_Y = (PLAY_AREA_HEIGHT / 4) * 3;
 
+#define BORDER_TOP 0
+#define BORDER_RIGHT 1
+#define BORDER_BOTTOM 2
+#define BORDER_LEFT 3
+
 // Anclajes de pantalla
 const int GAMECANVAS_CENTER_X = GAMECANVAS_WIDTH / 2;
 const int GAMECANVAS_FIRST_QUARTER_X = GAMECANVAS_WIDTH / 4;

source/director.cpp

@@ -98,6 +98,7 @@ void Director::init(Uint8 name)
 	mInput->bindKey(INPUT_ACCEPT, SDL_SCANCODE_RETURN);
 	mInput->bindKey(INPUT_CANCEL, SDL_SCANCODE_ESCAPE);
 	mInput->bindKey(INPUT_BUTTON_1, SDL_SCANCODE_SPACE);
+	mInput->bindKey(INPUT_BUTTON_2, SDL_SCANCODE_D);
 	mInput->bindKey(INPUT_BUTTON_PAUSE, SDL_SCANCODE_ESCAPE);
 	mInput->bindKey(INPUT_BUTTON_ESCAPE, SDL_SCANCODE_ESCAPE);
 
@@ -198,8 +199,20 @@ void Director::setFileList()
 	mAsset->add("/data/config.bin", data, false);
 	mAsset->add("/data/room/01.room", room);
 	mAsset->add("/data/room/02.room", room);
+	mAsset->add("/data/room/03.room", room);
+	mAsset->add("/data/room/04.room", room);
+	mAsset->add("/data/room/05.room", room);
+	mAsset->add("/data/room/room1.tmx", room);
+	mAsset->add("/data/room/room2.tmx", room);
+	mAsset->add("/data/room/room3.tmx", room);
+	mAsset->add("/data/room/room4.tmx", room);
+	mAsset->add("/data/room/room5.tmx", room);
 	mAsset->add("/media/tilesets/room1.png", bitmap);
 	mAsset->add("/media/enemies/enemy01.png", bitmap);
+	mAsset->add("/media/enemies/enemy02.png", bitmap);
+	mAsset->add("/media/enemies/enemy03.png", bitmap);
+	mAsset->add("/media/player/player01.png", bitmap);
+	mAsset->add("/media/items/items.png", bitmap);
 }
 
 // Carga el fichero de configuración

source/enemy.cpp

@@ -28,18 +28,20 @@ Enemy::Enemy(enemy_t enemy)
     sprite->setVelY(enemy.vy);
 
     // Inicializa el sprite con el resto de parametros comunes
-    sprite->setWidth(16);
-    sprite->setHeight(16);
+    sprite->setWidth(enemy.w);
+    sprite->setHeight(enemy.h);
     sprite->setCurrentFrame(0);
     sprite->setAnimationCounter(0);
     sprite->setAnimationNumFrames(0, 4);
     sprite->setAnimationSpeed(0, 5);
     sprite->setAnimationLoop(0, true);
-    sprite->setAnimationFrames(0, 0, 16 * 0, 0, 16, 16);
-    sprite->setAnimationFrames(0, 1, 16 * 1, 0, 16, 16);
-    sprite->setAnimationFrames(0, 2, 16 * 2, 0, 16, 16);
-    sprite->setAnimationFrames(0, 3, 16 * 3, 0, 16, 16);
+    sprite->setAnimationFrames(0, 0, enemy.w * 0, 0, enemy.w, enemy.h);
+    sprite->setAnimationFrames(0, 1, enemy.w * 1, 0, enemy.w, enemy.h);
+    sprite->setAnimationFrames(0, 2, enemy.w * 2, 0, enemy.w, enemy.h);
+    sprite->setAnimationFrames(0, 3, enemy.w * 3, 0, enemy.w, enemy.h);
     sprite->setSpriteClip(sprite->getAnimationClip(0, 0));
+
+    collider = getRect();
 }
 
 // Destructor
@@ -67,6 +69,7 @@ void Enemy::update()
     sprite->update();
     sprite->animate(0);
     checkPath();
+    collider = getRect();
 }
 
 // Comprueba si ha llegado al limite del recorrido para darse media vuelta
@@ -74,13 +77,23 @@ void Enemy::checkPath()
 {
     if (sprite->getPosX() > x2 || sprite->getPosX() < x1)
     {
-        //sprite->setPosX(sprite->getPosX() - sprite->getVelX());
         sprite->setVelX(sprite->getVelX() * (-1));
     }
 
     if (sprite->getPosY() > y2 || sprite->getPosY() < y1)
     {
-        //sprite->setPosY(sprite->getPosY() - sprite->getVelY());
         sprite->setVelY(sprite->getVelY() * (-1));
     }
 }
+
+// Devuelve el rectangulo que contiene al enemigo
+SDL_Rect Enemy::getRect()
+{
+    return sprite->getRect();
+}
+
+// Obtiene el rectangulo de colision del enemigo
+SDL_Rect &Enemy::getCollider()
+{
+    return collider;
+}

source/enemy.h

@@ -29,6 +29,8 @@ struct enemy_t
 	SDL_Renderer *renderer; // El renderizador de la ventana
 	Asset *asset;			// Objeto con la ruta a todos los ficheros de recursos
 	std::string tileset;	// Fichero con los graficos del enemigo
+	int w;					// Anchura del enemigo
+	int h;					// Altura del enemigo
 	float x;				// Posición inicial en el eje X
 	float y;				// Posición inicial en el eje Y
 	float vx;				// Velocidad en el eje X
@@ -54,6 +56,7 @@ private:
 	int x2;					// Limite derecho de la ruta en el eje X
 	int y1;					// Limite superior de la ruta en el eje Y
 	int y2;					// Limite inferior de la ruta en el eje Y
+	SDL_Rect collider;		// Caja de colisión
 
 	// Comprueba si ha llegado al limite del recorrido para darse media vuelta
 	void checkPath();
@@ -70,6 +73,12 @@ public:
 
 	// Actualiza las variables del objeto
 	void update();
+
+	// Devuelve el rectangulo que contiene al enemigo
+	SDL_Rect getRect();
+
+	// Obtiene el rectangulo de colision del enemigo
+	SDL_Rect &getCollider();
 };
 
 #endif

source/game.cpp

@@ -3,14 +3,22 @@
 // Constructor
 Game::Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Lang *lang, Input *input)
 {
+	// Inicia variables
+	mCurrentRoom = "02.room";
+	mSpawnPoint = {2 * BLOCK, 12 * BLOCK, 0, 0, 0, STATUS_STANDING, SDL_FLIP_NONE};
+	mDebug = false;
+
 	// Copia los punteros
 	mRenderer = renderer;
 	mAsset = asset;
 	mLang = lang;
 	mInput = input;
 
+	// Crea los objetos
 	mScreen = new Screen(window, renderer);
-	mRoom = new Room(mAsset->get("01.room"), mRenderer, mAsset);
+	mItemTracker = new Item_tracker();
+	mRoom = new Room(mAsset->get(mCurrentRoom), mRenderer, mAsset, mItemTracker);
+	mPlayer = new Player(mSpawnPoint, mAsset->get("player01.png"), mRenderer, mAsset, mInput, mRoom);
 	mEventHandler = new SDL_Event();
 	mTextureText = new LTexture();
 	mText = new Text(mAsset->get("smb2.txt"), mTextureText, renderer);
@@ -19,11 +27,25 @@ Game::Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Lang *lang,
 
 Game::~Game()
 {
+	// Borra las referencias a los punteros
 	mRenderer = nullptr;
 	mAsset = nullptr;
 	mLang = nullptr;
 	mInput = nullptr;
 
+	// Libera la memoria de los objetos
+	delete mScreen;
+	mScreen = nullptr;
+
+	delete mItemTracker;
+	mItemTracker = nullptr;
+
+	delete mRoom;
+	mRoom = nullptr;
+
+	delete mPlayer;
+	mPlayer = nullptr;
+
 	delete mEventHandler;
 	mEventHandler = nullptr;
 
@@ -31,12 +53,6 @@ Game::~Game()
 	delete mTextureText;
 	mTextureText = nullptr;
 
-	delete mScreen;
-	mScreen = nullptr;
-
-	delete mRoom;
-	mRoom = nullptr;
-
 	delete mText;
 	mText = nullptr;
 
@@ -106,8 +122,14 @@ void Game::update()
 			}
 		}
 
-		checkInput();
 		mRoom->update();
+		mPlayer->update();
+		checkPlayerAndWalls(); // Debe ir detras del player update, por si se ha metido en algun muro
+		checkPlayerOnBorder();
+		checkPlayerOnFloor();
+		checkPlayerAndItems();
+		checkPlayerAndEnemies();
+		checkInput();
 	}
 }
 
@@ -115,24 +137,51 @@ void Game::update()
 void Game::draw()
 {
 	// Prepara para dibujar el frame
-	const color_t color = {0xAA, 0x55, 0x55};
 	mScreen->start();
-	mScreen->clean(color);
 	mScreen->clean(mRoom->getBGColor());
 
 	mRoom->drawMap();
 	mRoom->drawEnemies();
+	mRoom->drawItems();
+	mPlayer->draw();
 
 	// Texto en el centro de la pantalla
-	mText->writeCentered(GAMECANVAS_CENTER_X, 18 * 8, mRoom->getName());
+	SDL_Rect rect = {0, 16 * 8, PLAY_AREA_RIGHT, 8};
+	color_t color = stringToColor("light_black");
+	SDL_SetRenderDrawColor(mRenderer, color.r, color.g, color.b, 0xFF);
+	SDL_RenderFillRect(mRenderer, &rect);
+
+	mText->writeCentered(GAMECANVAS_CENTER_X, 16 * 8, mRoom->getName());
+
+	// Debug info
+	if (mDebug)
+	{
+		std::string text;
+		text = "status: " + std::to_string(mPlayer->status);
+		mText->write(0, 17 * 8, text);
+
+		text = "foot: " + std::to_string((int)mPlayer->getLeftFoot().y);
+		mText->write(0, 18 * 8, text);
+
+		const int a = (mPlayer->lastPosition.y + 16) / 8;
+		const int b = mPlayer->getLeftFoot().y / 8;
+		text = "tile: " + std::to_string(a) + " - " + std::to_string(b);
+		mText->write(0, 19 * 8, text);
+
+		const bool collision = checkPlayerAndEnemies();
+		text = "collision: " + std::to_string(collision);
+		mText->write(0, 20 * 8, text);
+	}
 
 	// Actualiza la pantalla
 	mScreen->blit();
 }
 
 // Comprueba la entrada
+
 void Game::checkInput()
 {
+	/*
 	if (mInput->checkInput(INPUT_UP, REPEAT_FALSE))
 		changeRoom(mRoom->getRoomUp());
 
@@ -144,6 +193,10 @@ void Game::checkInput()
 
 	if (mInput->checkInput(INPUT_RIGHT, REPEAT_FALSE))
 		changeRoom(mRoom->getRoomRight());
+	*/
+
+	if (mInput->checkInput(INPUT_BUTTON_2, REPEAT_FALSE))
+		mDebug = !mDebug;
 }
 
 // Cambia de habitación
@@ -161,10 +214,153 @@ bool Game::changeRoom(std::string file)
 			mRoom = nullptr;
 
 			// Crea un objeto habitación nuevo a partir del fichero
-			mRoom = new Room(mAsset->get(file), mRenderer, mAsset);
+			mRoom = new Room(mAsset->get(file), mRenderer, mAsset, mItemTracker);
 
 			success = true;
 		}
 
 	return success;
 }
+
+// Comprueba si el jugador esta en el borde de la pantalla
+void Game::checkPlayerOnBorder()
+{
+	if (mPlayer->getOnBorder())
+	{
+		const std::string room_name = mRoom->getRoom(mPlayer->getBorder());
+		if (changeRoom(room_name))
+		{
+			mPlayer->switchBorders();
+			mCurrentRoom = room_name;
+			mSpawnPoint = mPlayer->getSpawnParams();
+		}
+	}
+}
+
+// Comprueba si el jugador esta sobre el suelo
+void Game::checkPlayerOnFloor()
+{
+	// Comprueba si tiene suelo bajo los pies solo cuando no hay velocidad de subida
+	// y solo cuando el pie este encima de un bloque, es decir, en multiplos de 8
+
+	// *** HAY UN POSIBLE PROBLEMA y es que caiga muy rapido y viaje a mas de un pixel de velocidad,
+	// con lo que se saltaria la comprobación
+
+	// *** POSIBLE SOLUCION. Comprobar si el tile actual del pie es diferente al tile del pie previo.
+	// Esto indica que se ha saltado la comprobacion cada 8 pixeles.
+	// En este caso habría que recolocar al jugador en el sitio
+
+	// *** PARECE RESUELTO
+
+	const int a = (mPlayer->lastPosition.y + 16) / 8;
+	const int b = mPlayer->getLeftFoot().y / 8;
+	const bool tile_change = a != b;
+
+	const bool is_not_going_up = mPlayer->getVelY() >= 0;
+	const bool is_tile_aligned = mPlayer->getLeftFoot().y % 8 == 0;
+
+	if (((is_not_going_up) && (is_tile_aligned)) || ((is_not_going_up) && (tile_change)))
+	{
+		bool test = false;
+		test |= (mRoom->getTile(mPlayer->getLeftFoot()) == TILE_SOLID);
+		test |= (mRoom->getTile(mPlayer->getRightFoot()) == TILE_SOLID);
+		test |= (mRoom->getTile(mPlayer->getLeftFoot()) == TILE_TRAVESSABLE);
+		test |= (mRoom->getTile(mPlayer->getRightFoot()) == TILE_TRAVESSABLE);
+
+		// Tiene uno de los pies sobre una superficie
+		if (test)
+		{
+			mPlayer->setStatus(STATUS_STANDING);
+
+			// Si ha habido un cambio de tile, hay que recolocarlo
+			if (tile_change)
+			{
+				int offset = (int)mPlayer->sprite->getPosY() % 8;
+				mPlayer->sprite->setPosY((int)mPlayer->sprite->getPosY() - offset);
+			}
+		}
+		// Tiene ambos pies sobre el vacío
+		else if (mPlayer->getStatus() != STATUS_JUMPING)
+		{
+			mPlayer->setStatus(STATUS_FALLING);
+		}
+	}
+}
+
+// Comprueba que el jugador no atraviese ninguna pared
+void Game::checkPlayerAndWalls()
+{
+	// Obtiene los ocho puntos de colisión del jugador
+	const SDL_Rect rect = mPlayer->getRect();
+	const SDL_Point p1 = {rect.x, rect.y};
+	const SDL_Point p2 = {rect.x + 7, rect.y};
+	const SDL_Point p3 = {rect.x + 7, rect.y + 7};
+	const SDL_Point p4 = {rect.x, rect.y + 7};
+	const SDL_Point p5 = {rect.x, rect.y + 8};
+	const SDL_Point p6 = {rect.x + 7, rect.y + 8};
+	const SDL_Point p7 = {rect.x + 7, rect.y + 15};
+	const SDL_Point p8 = {rect.x, rect.y + 15};
+
+	// Comprueba si ha colisionado con un muro
+	bool wall = false;
+	wall |= (mRoom->getTile(p1) == TILE_SOLID);
+	wall |= (mRoom->getTile(p2) == TILE_SOLID);
+	wall |= (mRoom->getTile(p3) == TILE_SOLID);
+	wall |= (mRoom->getTile(p4) == TILE_SOLID);
+	wall |= (mRoom->getTile(p5) == TILE_SOLID);
+	wall |= (mRoom->getTile(p6) == TILE_SOLID);
+	wall |= (mRoom->getTile(p7) == TILE_SOLID);
+	wall |= (mRoom->getTile(p8) == TILE_SOLID);
+
+	if (wall)
+	{
+		// Si hay colisión, deshace el movimiento y lo pone en modo caída
+		mPlayer->undoLastMove();
+		mPlayer->setStatus(STATUS_FALLING);
+	}
+
+	// Comprueba si ha colisionado con un tile de los que matan al jugador
+	bool death = false;
+	death |= (mRoom->getTile(p1) == TILE_KILL);
+	death |= (mRoom->getTile(p2) == TILE_KILL);
+	death |= (mRoom->getTile(p3) == TILE_KILL);
+	death |= (mRoom->getTile(p4) == TILE_KILL);
+	death |= (mRoom->getTile(p5) == TILE_KILL);
+	death |= (mRoom->getTile(p6) == TILE_KILL);
+	death |= (mRoom->getTile(p7) == TILE_KILL);
+	death |= (mRoom->getTile(p8) == TILE_KILL);
+
+	if (death)
+	{
+		killPlayer();
+	}
+}
+
+// Comprueba las colisiones del jugador con los enemigos
+bool Game::checkPlayerAndEnemies()
+{
+	const bool death = mRoom->enemyCollision(mPlayer->getCollider());
+	if (death)
+	{
+		killPlayer();
+	}
+	return death;
+}
+
+// Comprueba las colisiones del jugador con los objetos
+void Game::checkPlayerAndItems()
+{
+	mRoom->itemCollision(mPlayer->getCollider());
+}
+
+// Mata al jugador
+void Game::killPlayer()
+{
+	// Destruye la habitacion y el jugador
+	delete mRoom;
+	delete mPlayer;
+
+	// Crea la nueva habitación y el nuevo jugador
+	mRoom = new Room(mAsset->get(mCurrentRoom), mRenderer, mAsset, mItemTracker);
+	mPlayer = new Player(mSpawnPoint, mAsset->get("player01.png"), mRenderer, mAsset, mInput, mRoom);
+}

source/game.h

@@ -2,7 +2,6 @@
 #include "ifdefs.h"
 #include "const.h"
 #include "utils.h"
-
 #include "sprite.h"
 #include "movingsprite.h"
 #include "text.h"
@@ -14,6 +13,8 @@
 #include "screen.h"
 #include "asset.h"
 #include "room.h"
+#include "item_tracker.h"
+#include "player.h"
 #include "jail_audio.h"
 
 #ifndef GAME_H
@@ -27,6 +28,8 @@ private:
 	SDL_Event *mEventHandler;	// Manejador de eventos
 	Screen *mScreen;			// Objeto encargado de manejar el renderizador
 	Room *mRoom;				// Objeto encargado de gestionar cada habitación del juego
+	Player *mPlayer;			// Objeto con el jugador
+	Item_tracker *mItemTracker; // Lleva el control de los objetos recogidos
 	Asset *mAsset;				// Objeto con la ruta a todos los ficheros de recursos
 	Lang *mLang;				// Objeto para gestionar los textos en diferentes idiomas
 	Input *mInput;				// Objeto pata gestionar la entrada
@@ -36,6 +39,9 @@ private:
 	Uint32 mTicks;				// Contador de ticks para ajustar la velocidad del programa
 	Uint8 mTicksSpeed;			// Velocidad a la que se repiten los bucles del programa
 	section_t mSection;			// Seccion actual dentro del juego
+	std::string mCurrentRoom;	// Fichero de la habitación actual
+	player_t mSpawnPoint;		// Lugar de la habitación donde aparece el jugador
+	bool mDebug;				// Indica si el modo debug está activo
 
 	// Inicializa las variables
 	void init();
@@ -49,12 +55,30 @@ private:
 	// Pinta los objetos en pantalla
 	void draw();
 
-	// Comprueba la entrada
+	// Comprueba la entrada y actua
 	void checkInput();
 
 	// Cambia de habitación
 	bool changeRoom(std::string file);
 
+	// Comprueba si el jugador esta en el borde de la pantalla y actua
+	void checkPlayerOnBorder();
+
+	// Comprueba si el jugador esta sobre el suelo
+	void checkPlayerOnFloor();
+
+	// Comprueba que el jugador no atraviese ninguna pared
+	void checkPlayerAndWalls();
+
+	// Comprueba las colisiones del jugador con los enemigos
+	bool checkPlayerAndEnemies();
+
+	// Comprueba las colisiones del jugador con los objetos
+	void checkPlayerAndItems();
+
+	// Mata al jugador
+	void killPlayer();
+
 public:
 	// Constructor
 	Game(SDL_Window *window, SDL_Renderer *renderer, Asset *asset, Lang *lang, Input *input);

source/item.cpp

@@ -0,0 +1,86 @@
+#include "item.h"
+#include <fstream>
+#include <sstream>
+
+// Constructor
+Item::Item(item_t item)
+{
+    // Obten punteros a objetos
+    asset = item.asset;
+    renderer = item.renderer;
+
+    // Crea objetos
+    texture = new LTexture();
+    sprite = new Sprite(item.x, item.y, 8, 8, texture, renderer);
+
+    // Carga la textura
+    loadTextureFromFile(texture, asset->get(item.tileset), renderer);
+
+    // Inicia variables
+    sprite->setSpriteClip(item.tile * 8, 0, 8, 8);
+    collider = sprite->getRect();
+
+    // Inicializa los colores
+    color_t c = stringToColor("blue");
+    color.push_back(c);
+
+    c = stringToColor("red");
+    color.push_back(c);
+
+    c = stringToColor("purple");
+    color.push_back(c);
+
+    c = stringToColor("green");
+    color.push_back(c);
+
+    c = stringToColor("cyan");
+    color.push_back(c);
+
+    c = stringToColor("yellow");
+    color.push_back(c);
+}
+
+// Destructor
+Item::~Item()
+{
+    texture->unload();
+    delete texture;
+    texture = nullptr;
+
+    delete sprite;
+    sprite = nullptr;
+}
+
+// Pinta el objeto en pantalla
+void Item::draw()
+{
+    const int index = (counter / 2) % color.size();
+    sprite->getTexture()->setColor(color[index].r, color[index].g, color[index].b);
+    sprite->render();
+    sprite->getTexture()->setColor(255, 255, 255);
+}
+
+// Actualiza las variables del objeto
+void Item::update()
+{
+    counter++;
+}
+
+// Coge el objeto
+void Item::pick()
+{
+    sprite->setEnabled(false);
+}
+
+// Obtiene el rectangulo de colision del objeto
+SDL_Rect &Item::getCollider()
+{
+    return collider;
+}
+
+// Obtiene su ubicación
+SDL_Point Item::getPos()
+{
+    const SDL_Point p = {sprite->getPosX(), sprite->getPosY()};
+    return p;
+}

source/item.h

@@ -0,0 +1,66 @@
+#pragma once
+#include "ifdefs.h"
+#include "utils.h"
+#include "asset.h"
+#include "sprite.h"
+#include <string>
+
+#ifndef ITEM_H
+#define ITEM_H
+
+/*
+Un item deberia tener la siguiente informacion:
+POSICION INICIAL
+PNG ASOCIADO
+*/
+
+struct item_t
+{
+	SDL_Renderer *renderer; // El renderizador de la ventana
+	Asset *asset;			// Objeto con la ruta a todos los ficheros de recursos
+	std::string tileset;	// Fichero con los graficos del item
+	int x;					// Posicion del item en pantalla
+	int y;					// Posicion del item en pantalla
+	int tile;				// Numero de tile dentro de la textura
+};
+
+// Clase Item
+class Item
+{
+private:
+	LTexture *texture; // Textura con los graficos del objeto
+	Sprite *sprite;	   // Sprite del objeto
+
+	SDL_Renderer *renderer;		// El renderizador de la ventana
+	Asset *asset;				// Objeto con la ruta a todos los ficheros de recursos
+	std::vector<color_t> color; // Vector con los colores del objeto
+	int counter;				// Contador interno
+	SDL_Rect collider;			// Rectangulo de colisión
+
+	// Comprueba si ha llegado al limite del recorrido para darse media vuelta
+	void checkPath();
+
+public:
+	// Constructor
+	Item(item_t item);
+
+	// Destructor
+	~Item();
+
+	// Pinta el objeto en pantalla
+	void draw();
+
+	// Actualiza las variables del objeto
+	void update();
+
+	// Coge el item
+	void pick();
+
+	// Obtiene el rectangulo de colision del objeto
+	SDL_Rect &getCollider();
+
+	// Obtiene su ubicación
+	SDL_Point getPos();
+};
+
+#endif

source/item_tracker.cpp

@@ -0,0 +1,87 @@
+#include "item_tracker.h"
+
+// Constructor
+Item_tracker::Item_tracker()
+{
+}
+
+// Destructor
+Item_tracker::~Item_tracker()
+{
+    list.clear();
+}
+
+// Comprueba si el objeto ya ha sido cogido
+bool Item_tracker::hasBeenPicked(std::string name, SDL_Point pos)
+{
+    bool success = false;
+
+    // Primero busca si ya hay una entrada con ese nombre
+    const int index = findByName(name);
+    if (index != -1)
+    {
+        // Luego busca si existe ya una entrada con esa posición
+        if (findByPos(index, pos) != -1)
+        {
+            success = true;
+        }
+    }
+
+    return success;
+}
+
+// Añade el objeto a la lista de objetos cogidos
+void Item_tracker::addItem(std::string name, SDL_Point pos)
+{
+    // Comprueba si el objeto no ha sido recogido con anterioridad
+    if (!hasBeenPicked(name, pos))
+    {
+        // Primero busca si ya hay una entrada con ese nombre
+        const int index = findByName(name);
+        if (index != -1)
+        {
+            list[index].pos.push_back(pos);
+        }
+
+        // En caso contrario crea la entrada
+        else
+        {
+            item_tracker_t item;
+            item.name = name;
+            item.pos.push_back(pos);
+            list.push_back(item);
+        }
+    }
+}
+
+// Busca una entrada en la lista por nombre
+int Item_tracker::findByName(std::string name)
+{
+    const int c = -1;
+
+    for (int i = 0; i < list.size(); i++)
+    {
+        if (list[i].name == name)
+        {
+            return i;
+        }
+    }
+
+    return c;
+}
+
+// Busca una entrada en la lista por posición
+int Item_tracker::findByPos(int index, SDL_Point pos)
+{
+    const int c = -1;
+
+    for (int i = 0; i < list[index].pos.size(); i++)
+    {
+        if ((list[index].pos[i].x == pos.x) && (list[index].pos[i].y == pos.y))
+        {
+            return i;
+        }
+    }
+
+    return c;
+}

source/item_tracker.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "ifdefs.h"
+#include "utils.h"
+#include <string>
+#include <vector>
+
+#ifndef ITEM_TRACKER_H
+#define ITEM_TRACKER_H
+
+struct item_tracker_t
+{
+	std::string name;			// Nombre de la habitación donde se encuentra el objeto
+	std::vector<SDL_Point> pos; // Lista de objetos cogidos de la habitación
+};
+
+// Clase Item_tracker
+class Item_tracker
+{
+private:
+	std::vector<item_tracker_t> list; // Lista con todos los objetos recogidos
+
+	// Busca una entrada en la lista por nombre
+	int findByName(std::string name);
+
+	// Busca una entrada en la lista por posición
+	int findByPos(int index, SDL_Point pos);
+
+public:
+	// Constructor
+	Item_tracker();
+
+	// Destructor
+	~Item_tracker();
+
+	// Comprueba si el objeto ya ha sido cogido
+	bool hasBeenPicked(std::string name, SDL_Point pos);
+
+	// Añade el objeto a la lista de objetos cogidos
+	void addItem(std::string name, SDL_Point pos);
+};
+
+#endif

source/movingsprite.cpp

@@ -2,42 +2,12 @@
 #include "movingsprite.h"
 
 // Constructor
-MovingSprite::MovingSprite()
+MovingSprite::MovingSprite(float x, float y, int w, int h, float velx, float vely, float accelx, float accely, LTexture *texture, SDL_Renderer *renderer)
 {
-	clear();
-}
+	// Copia los punteros
+	setTexture(texture);
+	setRenderer(renderer);
 	
-// Destructor
-MovingSprite::~MovingSprite()
-{
-	clear();
-}
-
-// Reinicia todas las variables
-void MovingSprite::clear()
-{
-	mPosX = 0.0f; // Posición en el eje X
-	mPosY = 0.0f; // Posición en el eje Y
-
-	mVelX = 0.0f; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
-	mVelY = 0.0f; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
-
-	mAccelX = 0.0f; // Aceleración en el eje X. Variación de la velocidad
-	mAccelY = 0.0f; // Aceleración en el eje Y. Variación de la velocidad
-
-	mZoomW = 1.0f; // Zoom aplicado a la anchura
-	mZoomH = 1.0f; // Zoom aplicado a la altura
-
-	mAngle = 0.0;		 // Angulo para dibujarlo
-	mRotate = false;	 // Indica si ha de rotar
-	mRotateSpeed = 0;	 // Velocidad de giro
-	mRotateAmount = 0.0; // Cantidad de grados a girar en cada iteración
-	mCounter = 0;		 // Contador interno
-}
-
-// Iniciador
-void MovingSprite::init(float x, float y, int w, int h, float velx, float vely, float accelx, float accely, LTexture *texture, SDL_Renderer *renderer)
-{
 	// Establece el alto y el ancho del sprite
 	setWidth(w);
 	setHeight(h);
@@ -69,14 +39,44 @@ void MovingSprite::init(float x, float y, int w, int h, float velx, float vely,
 	// Contador interno
 	mCounter = 0;
 
-	// Establece la textura donde están los gráficos para el sprite
-	setTexture(texture);
-
-	// Establece el renderizador
-	setRenderer(renderer);
-
 	// Establece el rectangulo de donde coger la imagen
 	setSpriteClip(0, 0, w, h);
+
+	// Establece el centro de rotación
+	mCenter = {0,0};
+
+	// Establece el tipo de volteado
+	mFlip = SDL_FLIP_NONE;
+};
+
+// Destructor
+MovingSprite::~MovingSprite()
+{
+}
+
+// Reinicia todas las variables
+void MovingSprite::clear()
+{
+	mPosX = 0.0f; // Posición en el eje X
+	mPosY = 0.0f; // Posición en el eje Y
+
+	mVelX = 0.0f; // Velocidad en el eje X. Cantidad de pixeles a desplazarse
+	mVelY = 0.0f; // Velocidad en el eje Y. Cantidad de pixeles a desplazarse
+
+	mAccelX = 0.0f; // Aceleración en el eje X. Variación de la velocidad
+	mAccelY = 0.0f; // Aceleración en el eje Y. Variación de la velocidad
+
+	mZoomW = 1.0f; // Zoom aplicado a la anchura
+	mZoomH = 1.0f; // Zoom aplicado a la altura
+
+	mAngle = 0.0;		 // Angulo para dibujarlo
+	mRotate = false;	 // Indica si ha de rotar
+	mCenter = {0, 0};	 // Centro de rotación
+	mRotateSpeed = 0;	 // Velocidad de giro
+	mRotateAmount = 0.0; // Cantidad de grados a girar en cada iteración
+	mCounter = 0;		 // Contador interno
+
+	mFlip = SDL_FLIP_NONE; // Establece como se ha de voltear el sprite
 }
 
 // Mueve el sprite
@@ -96,7 +96,7 @@ void MovingSprite::move()
 void MovingSprite::render()
 {
 	if (mEnabled)
-		mTexture->render(mRenderer, (int)mPosX, (int)mPosY, &mSpriteClip, mZoomW, mZoomH, mAngle);
+		mTexture->render(mRenderer, (int)mPosX, (int)mPosY, &mSpriteClip, mZoomW, mZoomH, mAngle, &mCenter, mFlip);
 }
 
 // Obtiene el valor de la variable
@@ -284,3 +284,22 @@ void MovingSprite::switchRotate()
 {
 	mRotateAmount *= -1;
 }
+
+// Establece el valor de la variable
+void MovingSprite::setFlip(SDL_RendererFlip flip)
+{
+	mFlip = flip;
+}
+
+// Obtiene el valor de la variable
+SDL_RendererFlip MovingSprite::getFlip()
+{
+	return mFlip;
+}
+
+// Devuelve el rectangulo donde está el sprite
+SDL_Rect MovingSprite::getRect()
+{
+	SDL_Rect rect = {(int)getPosX(), (int)getPosY(), getWidth(), getHeight()};
+	return rect;
+}

source/movingsprite.h

@@ -26,17 +26,16 @@ protected:
     Uint16 mRotateSpeed;    // Velocidad de giro
     double mRotateAmount;   // Cantidad de grados a girar en cada iteración
     Uint16 mCounter;        // Contador interno
+    SDL_Point mCenter;      // Centro de rotación
+    SDL_RendererFlip mFlip; // Indica como se voltea el sprite
 
 public:
     // Constructor
-    MovingSprite();
+    MovingSprite(float x = 0, float y = 0, int w = 0, int h = 0, float velx = 0, float vely = 0, float accelx = 0, float accely = 0, LTexture *texture = nullptr, SDL_Renderer *renderer = nullptr);
 
     // Destructor
     ~MovingSprite();
 
-    // Iniciador
-    void init(float x, float y, int w, int h, float velx, float vely, float accelx, float accely, LTexture *texture, SDL_Renderer *renderer);
-
     // Mueve el sprite
     void move();
 
@@ -132,6 +131,15 @@ public:
 
     // Cambia el sentido de la rotación
     void switchRotate();
+
+    // Establece el valor de la variable
+    void setFlip(SDL_RendererFlip flip);
+
+    // Obtiene el valor de la variable
+    SDL_RendererFlip getFlip();
+
+    // Devuelve el rectangulo donde está el sprite
+    SDL_Rect getRect();
 };
 
 #endif

source/player.cpp

@@ -2,12 +2,15 @@
 #include <fstream>
 #include <sstream>
 
+// CAUTION!!!!! si no se gasta al final, quitar la referencia a la habitación
+
 // Constructor
-Player::Player(std::string _tileset, SDL_Renderer *_renderer, Asset *_asset)
+Player::Player(player_t ini, std::string _tileset, SDL_Renderer *_renderer, Asset *_asset, Input *_input, Room *_room)
 {
     // Obten punteros a objetos
     asset = _asset;
     renderer = _renderer;
+    input = _input;
 
     // Crea objetos
     texture = new LTexture();
@@ -18,6 +21,34 @@ Player::Player(std::string _tileset, SDL_Renderer *_renderer, Asset *_asset)
 
     // Inicializa variables
     color = stringToColor("white");
+    onBorder = false;
+    border = BORDER_TOP;
+
+    jump_ini = ini.jump_ini;
+    status = ini.status;
+
+    sprite->setPosX(ini.x);
+    sprite->setPosY(ini.y);
+    sprite->setVelX(ini.vx);
+    sprite->setVelY(ini.vy);
+
+    sprite->setWidth(8);
+    sprite->setHeight(16);
+    sprite->setCurrentFrame(0);
+    sprite->setAnimationCounter(0);
+    sprite->setAnimationNumFrames(0, 4);
+    sprite->setAnimationSpeed(0, 5);
+    sprite->setAnimationLoop(0, true);
+    sprite->setAnimationFrames(0, 0, 8 * 0, 0, 8, 16);
+    sprite->setAnimationFrames(0, 1, 8 * 1, 0, 8, 16);
+    sprite->setAnimationFrames(0, 2, 8 * 2, 0, 8, 16);
+    sprite->setAnimationFrames(0, 3, 8 * 3, 0, 8, 16);
+    sprite->setSpriteClip(sprite->getAnimationClip(0, 0));
+
+    sprite->setFlip(ini.flip);
+
+    lastPosition = getRect();
+    collider = getRect();
 }
 
 // Destructor
@@ -42,6 +73,230 @@ void Player::draw()
 // Actualiza las variables del objeto
 void Player::update()
 {
-    sprite->update();
-    sprite->animate(0);
+
+    setLastPosition(); // Guarda la posición actual en la variable lastPosition
+    checkInput();      // Comprueba las entradas y modifica variables
+    move();            // Recalcula la posición del jugador y su animación
+    checkBorders();    // Comprueba si está situado en alguno de los cuatro bordes de la habitación
+    applyGravity();    // Aplica gravedad al jugador
+    checkJump();       // Comprueba si ha finalizado el salto
+    collider = getRect();
+}
+
+// Comprueba las entradas y modifica variables
+void Player::checkInput()
+{
+    // Solo comprueba las entradas de dirección cuando está de pie
+    if ((input->checkInput(INPUT_LEFT, REPEAT_TRUE)) && (status == STATUS_STANDING))
+    {
+        sprite->setVelX(-0.6f);
+        sprite->setFlip(SDL_FLIP_HORIZONTAL);
+    }
+    else if ((input->checkInput(INPUT_RIGHT, REPEAT_TRUE)) && (status == STATUS_STANDING))
+    {
+        sprite->setVelX(0.6f);
+        sprite->setFlip(SDL_FLIP_NONE);
+    }
+    else if (status == STATUS_STANDING)
+    {
+        sprite->setVelX(0);
+    }
+
+    if (input->checkInput(INPUT_UP, REPEAT_TRUE))
+    {
+        setStatus(STATUS_JUMPING);
+    }
+}
+
+// Indica si el jugador esta en uno de los cuatro bordes de la pantalla
+bool Player::getOnBorder()
+{
+    return onBorder;
+}
+
+// Indica en cual de los cuatro bordes se encuentra
+int Player::getBorder()
+{
+    return border;
+}
+
+// Comprueba si está situado en alguno de los cuatro bordes de la habitación
+void Player::checkBorders()
+{
+    if (sprite->getPosX() < PLAY_AREA_LEFT)
+    {
+        border = BORDER_LEFT;
+        onBorder = true;
+    }
+    else if (sprite->getPosX() > PLAY_AREA_RIGHT - sprite->getWidth())
+    {
+        border = BORDER_RIGHT;
+        onBorder = true;
+    }
+    else if (sprite->getPosY() < PLAY_AREA_TOP)
+    {
+        border = BORDER_TOP;
+        onBorder = true;
+    }
+    else if (sprite->getPosY() > PLAY_AREA_BOTTOM - sprite->getHeight())
+    {
+        border = BORDER_BOTTOM;
+        onBorder = true;
+    }
+    else
+    {
+        onBorder = false;
+    }
+}
+
+// Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
+void Player::switchBorders()
+{
+    if (border == BORDER_TOP)
+    {
+        sprite->setPosY(PLAY_AREA_BOTTOM - sprite->getHeight() - 1);
+        jump_ini += 128;
+    }
+    else if (border == BORDER_BOTTOM)
+    {
+        sprite->setPosY(PLAY_AREA_TOP + 1);
+    }
+    else if (border == BORDER_RIGHT)
+    {
+        sprite->setPosX(PLAY_AREA_LEFT + 1);
+    }
+    if (border == BORDER_LEFT)
+    {
+        sprite->setPosX(PLAY_AREA_RIGHT - sprite->getWidth() - 1);
+    }
+
+    onBorder = false;
+}
+
+// Obtiene el valor del pixel inferior izquierdo del jugador
+SDL_Point Player::getLeftFoot()
+{
+    SDL_Point point = {(int)sprite->getPosX(), (int)sprite->getPosY() + sprite->getHeight()};
+    return point;
+}
+
+// Obtiene el valor del pixel inferior derecho del jugador
+SDL_Point Player::getRightFoot()
+{
+    SDL_Point point = {(int)sprite->getPosX() + sprite->getWidth() - 1, (int)sprite->getPosY() + sprite->getHeight()};
+    return point;
+}
+
+// Cambia el estado del jugador
+void Player::setStatus(int value)
+{
+    // Si quiere cambiar a saltando, ha de ser desde quieto
+    if ((value == STATUS_JUMPING) && (status == STATUS_STANDING))
+    {
+        status = STATUS_JUMPING;
+        sprite->setVelY(-MAX_VY);
+        jump_ini = sprite->getPosY();
+    }
+
+    // Modifica el estado a 'cayendo'
+    if (value == STATUS_FALLING)
+    {
+        status = STATUS_FALLING;
+        sprite->setVelY(MAX_VY);
+        sprite->setVelX(0);
+    }
+
+    // Modifica el estado a 'de pie'
+    if (value == STATUS_STANDING)
+    {
+        status = STATUS_STANDING;
+        sprite->setVelY(0.0f);
+    }
+}
+
+// Obtiene el estado del jugador
+int Player::getStatus()
+{
+    return status;
+}
+
+// Obtiene la velocidad en el eje Y del jugador
+float Player::getVelY()
+{
+    return sprite->getVelY();
+}
+
+// Aplica gravedad al jugador
+void Player::applyGravity()
+{
+    if (status == STATUS_JUMPING)
+    {
+        sprite->setVelY(sprite->getVelY() + GRAVITY);
+        if (sprite->getVelY() > MAX_VY)
+        {
+            sprite->setVelY(MAX_VY);
+        }
+    }
+}
+
+// Obtiene el rectangulo que delimita al jugador
+SDL_Rect Player::getRect()
+{
+    return sprite->getRect();
+}
+
+// Obtiene el rectangulo de colision del jugador
+SDL_Rect &Player::getCollider()
+{
+    return collider;
+}
+
+// Guarda la posición actual en la variable lastPosition
+void Player::setLastPosition()
+{
+    lastPosition = getRect();
+}
+
+// Deshace el ultimo movimiento
+void Player::undoLastMove()
+{
+    sprite->setPosX(lastPosition.x);
+    sprite->setPosY(lastPosition.y);
+}
+
+// Recalcula la posición del jugador y su animación
+void Player::move()
+{
+    sprite->update();
+    if (sprite->getVelX() != 0)
+    {
+        sprite->animate(0);
+    }
+}
+
+// Comprueba si ha finalizado el salto
+void Player::checkJump()
+{
+    if (status == STATUS_JUMPING)
+        if (sprite->getVelY() > 0)
+            if (sprite->getPosY() > jump_ini)
+            {
+                setStatus(STATUS_FALLING);
+            }
+}
+
+// Obtiene algunos parametros del jugador
+player_t Player::getSpawnParams()
+{
+    player_t params;
+    
+    params.x = sprite->getPosX();
+    params.y = sprite->getPosY();
+    params.vx = sprite->getVelX();
+    params.vy = sprite->getVelY();
+    params.jump_ini = jump_ini;
+    params.status = status;
+    params.flip = sprite->getFlip();
+
+    return params;
 }

source/player.h

@@ -1,28 +1,79 @@
 #pragma once
 #include "ifdefs.h"
+#include "const.h"
 #include "utils.h"
 #include "asset.h"
+#include "room.h"
 #include "animatedsprite.h"
+#include "input.h"
 #include <string>
 
 #ifndef PLAYER_H
 #define PLAYER_H
 
+//#define VX 0.6
+#define STATUS_STANDING 0
+#define STATUS_JUMPING 1
+#define STATUS_FALLING 2
+
+#define GRAVITY 0.035f
+#define MAX_VY 1.2f
+
+struct player_t
+{
+	float x;
+	float y;
+	float vx;
+	float vy;
+	int jump_ini;
+	int status;
+    SDL_RendererFlip flip;
+};
+
 // Clase Player
 class Player
 {
 private:
 	LTexture *texture; // Textura con los graficos del enemigo
-	AnimatedSprite *sprite; // Sprite del enemigo
+	Input *input;	   // Objeto para gestionar la entrada
 
 	SDL_Renderer *renderer; // El renderizador de la ventana
 	Asset *asset;			// Objeto con la ruta a todos los ficheros de recursos
 	color_t color;			// Color del jugador
+	SDL_Rect collider;		// Caja de colisión
 
+	bool onBorder; // Indica si el jugador esta en uno de los cuatro bordes de la pantalla
+	int border;	   // Indica en cual de los cuatro bordes se encuentra
+
+	// Comprueba las entradas y modifica variables
+	void checkInput();
+
+	// Comprueba si se halla en alguno de los cuatro bordes
+	void checkBorders();
+
+	// Asigna velocidad negativa en el eje Y al jugador
+	void jump();
+
+	// Aplica gravedad al jugador
+	void applyGravity();
+
+	// Guarda la posición actual en la variable lastPosition
+	void setLastPosition();
+
+	// Recalcula la posición del jugador y su animación
+	void move();
+
+	// Comprueba si ha finalizado el salto
+	void checkJump();
 
 public:
+	AnimatedSprite *sprite; // Sprite del enemigo
+	SDL_Rect lastPosition;	// Contiene la ultima posición del jugador, por si hay que deshacer algun movimiento
+	int jump_ini;			// Valor del eje Y en el que se inicia el salto
+	int status;				// Estado en el que se encuentra el jugador. Util apara saber si está saltando o cayendo
+
 	// Constructor
-	Player(std::string _tileset, SDL_Renderer *_renderer, Asset *_asset);
+	Player(player_t ini, std::string _tileset, SDL_Renderer *_renderer, Asset *_asset, Input *_input, Room *_room);
 
 	// Destructor
 	~Player();
@@ -32,6 +83,42 @@ public:
 
 	// Actualiza las variables del objeto
 	void update();
+
+	// Indica si el jugador esta en uno de los cuatro bordes de la pantalla
+	bool getOnBorder();
+
+	// Indica en cual de los cuatro bordes se encuentra
+	int getBorder();
+
+	// Cambia al jugador de un borde al opuesto. Util para el cambio de pantalla
+	void switchBorders();
+
+	// Obtiene el valor del pixel inferior izquierdo del jugador
+	SDL_Point getLeftFoot();
+
+	// Obtiene el valor del pixel inferior derecho del jugador
+	SDL_Point getRightFoot();
+
+	// Cambia el estado del jugador
+	void setStatus(int value);
+
+	// Obtiene el estado del jugador
+	int getStatus();
+
+	// Obtiene la velocidad en el eje Y del jugador
+	float getVelY();
+
+	// Obtiene el rectangulo que delimita al jugador
+	SDL_Rect getRect();
+
+	// Obtiene el rectangulo de colision del jugador
+	SDL_Rect &getCollider();
+
+	// Deshace el ultimo movimiento
+	void undoLastMove();
+
+	// Obtiene algunos parametros del jugador
+	player_t getSpawnParams();
 };
 
 #endif

source/room.cpp

@@ -4,11 +4,15 @@
 #include <sstream>
 
 // Constructor
-Room::Room(std::string _file_path, SDL_Renderer *_renderer, Asset *_asset)
+Room::Room(std::string _file_path, SDL_Renderer *_renderer, Asset *_asset, Item_tracker *_item_tracker)
 {
-    texture = new LTexture();
+    // Copia los punteros a objetos
     asset = _asset;
     renderer = _renderer;
+    item_tracker = _item_tracker;
+
+    // Crea los objetos
+    texture = new LTexture();
     load(_file_path);
     loadTextureFromFile(texture, asset->get(tileset), renderer);
 
@@ -37,6 +41,12 @@ Room::~Room()
         delete enemy;
     }
     enemy_list.clear();
+
+    for (auto item : item_list)
+    {
+        delete item;
+    }
+    item_list.clear();
 }
 
 // Carga las variables desde un fichero
@@ -56,7 +66,7 @@ bool Room::load(std::string _file_path)
         printf("Reading file %s\n", filename.c_str());
         while (std::getline(file, line))
         {
-            // Si la linea contiene el texto [enemy] se realiza un proceso distinto
+            // Si la linea contiene el texto [enemy] se realiza el proceso de carga de un enemigo
             if (line == "[enemy]")
             {
                 enemy_t enemy;
@@ -80,6 +90,88 @@ bool Room::load(std::string _file_path)
                 // Añade el enemigo al vector de enemigos
                 enemy_list.push_back(new Enemy(enemy));
             }
+
+            // Si la linea contiene el texto [tilemap] se realiza el proceso de carga del fichero tmx
+            else if (line == "[tilemap]")
+            {
+                // printf("Loading tilemap...\n");
+                do
+                {
+                    std::getline(file, line);
+                    if (line.find(".tmx") != std::string::npos)
+                    {
+                        // printf("Reading file %s\n", asset->get(line).c_str());
+                        std::ifstream file2(asset->get(line)); // Abre el fichero tmx
+                        if (file2.good())
+                        {
+                            bool data_read = false;
+                            while (std::getline(file2, line)) // Lee el fichero linea a linea
+                            {
+                                if (!data_read)
+                                { // Lee lineas hasta que encuentre donde empiezan los datos del mapa
+                                    int pos = 0;
+                                    do
+                                    {
+                                        std::getline(file2, line);
+                                        // printf("parsing: %s\n", line.c_str());
+
+                                        pos = line.find("data encoding");
+                                        // printf("pos: %i\n", pos);
+
+                                    } while (pos == std::string::npos);
+
+                                    do
+                                    { // Se introducen los valores separados por comas en un vector
+                                        data_read = true;
+                                        std::getline(file2, line);
+                                        if (line != "</data>")
+                                        {
+                                            // printf("data: %s\n", line.c_str());
+                                            std::stringstream ss(line);
+                                            std::string tmp;
+                                            while (getline(ss, tmp, ','))
+                                            {
+                                                // printf("tile: %s\n", tmp.c_str());
+                                                tilemap.push_back(std::stoi(tmp));
+                                            }
+                                        }
+                                    } while (line != "</data>");
+                                }
+                            }
+                        }
+                    }
+                } while (line != "[tilemap-end]");
+            }
+
+            // Si la linea contiene el texto [item] se realiza el proceso de carga de un item
+            else if (line == "[item]")
+            {
+                item_t item;
+                item.asset = asset;
+                item.renderer = renderer;
+
+                do
+                {
+                    std::getline(file, line);
+
+                    // Encuentra la posición del caracter '='
+                    int pos = line.find("=");
+                    // Procesa las dos subcadenas
+                    if (!setItem(&item, line.substr(0, pos), line.substr(pos + 1, line.length())))
+                    {
+                        printf("Warning: file %s\n, unknown parameter \"%s\"\n", filename.c_str(), line.substr(0, pos).c_str());
+                        success = false;
+                    }
+                } while (line != "[item-end]");
+
+                // Añade el item al vector de items
+                const SDL_Point itemPos = {item.x, item.y};
+                if (!item_tracker->hasBeenPicked(name, itemPos))
+                {
+                    item_list.push_back(new Item(item));
+                }
+            }
+
             // En caso contrario se parsea el fichero para buscar las variables y los valores
             else
             {
@@ -114,11 +206,7 @@ bool Room::setVars(std::string _var, std::string _value)
     // Indicador de éxito en la asignación
     bool success = true;
 
-    if (_var == "id")
-    {
-        id = _value;
-    }
-    else if (_var == "name")
+    if (_var == "name")
     {
         name = _value;
     }
@@ -156,6 +244,9 @@ bool Room::setVars(std::string _var, std::string _value)
             tilemap.push_back(std::stoi(tmp));
         }
     }
+    else if (_var == "")
+    {
+    }
     else
     {
         success = false;
@@ -174,13 +265,21 @@ bool Room::setEnemy(enemy_t *enemy, std::string _var, std::string _value)
     {
         enemy->tileset = _value;
     }
+    else if (_var == "width")
+    {
+        enemy->w = std::stof(_value);
+    }
+    else if (_var == "height")
+    {
+        enemy->h = std::stof(_value);
+    }
     else if (_var == "x")
     {
-        enemy->x = std::stof(_value);
+        enemy->x = std::stof(_value) * BLOCK;
     }
     else if (_var == "y")
     {
-        enemy->y = std::stof(_value);
+        enemy->y = std::stof(_value) * BLOCK;
     }
     else if (_var == "vx")
     {
@@ -192,24 +291,60 @@ bool Room::setEnemy(enemy_t *enemy, std::string _var, std::string _value)
     }
     else if (_var == "x1")
     {
-        enemy->x1 = std::stoi(_value);
+        enemy->x1 = std::stoi(_value) * BLOCK;
     }
     else if (_var == "x2")
     {
-        enemy->x2 = std::stoi(_value);
+        enemy->x2 = std::stoi(_value) * BLOCK;
     }
     else if (_var == "y1")
     {
-        enemy->y1 = std::stoi(_value);
+        enemy->y1 = std::stoi(_value) * BLOCK;
     }
     else if (_var == "y2")
     {
-        enemy->y2 = std::stoi(_value);
+        enemy->y2 = std::stoi(_value) * BLOCK;
     }
     else if (_var == "color")
     {
         enemy->color = stringToColor(_value);
     }
+    else if (_var == "[enemy-end]")
+    {
+    }
+    else
+    {
+        success = false;
+    }
+
+    return success;
+}
+
+// Asigna variables a una estructura item_t
+bool Room::setItem(item_t *item, std::string _var, std::string _value)
+{
+    // Indicador de éxito en la asignación
+    bool success = true;
+
+    if (_var == "tileset")
+    {
+        item->tileset = _value;
+    }
+    else if (_var == "x")
+    {
+        item->x = std::stof(_value) * BLOCK;
+    }
+    else if (_var == "y")
+    {
+        item->y = std::stof(_value) * BLOCK;
+    }
+    else if (_var == "tile")
+    {
+        item->tile = std::stof(_value);
+    }
+    else if (_var == "[item-end]")
+    {
+    }
     else
     {
         success = false;
@@ -272,6 +407,15 @@ void Room::drawEnemies()
     }
 }
 
+// Dibuja los objetos en pantalla
+void Room::drawItems()
+{
+    for (auto item : item_list)
+    {
+        item->draw();
+    }
+}
+
 // Actualiza las variables y objetos de la habitación
 void Room::update()
 {
@@ -279,28 +423,96 @@ void Room::update()
     {
         enemy->update();
     }
+
+    for (auto item : item_list)
+    {
+        item->update();
+    }
 }
 
-// Devuelve el valor de la variable
-std::string Room::getRoomUp()
+// Devuelve la cadena del fichero de la habitación contigua segun el borde
+std::string Room::getRoom(int border)
 {
+    switch (border)
+    {
+    case BORDER_TOP:
         return room_up;
-}
+        break;
 
-// Devuelve el valor de la variable
-std::string Room::getRoomDown()
-{
+    case BORDER_BOTTOM:
         return room_down;
-}
+        break;
 
-// Devuelve el valor de la variable
-std::string Room::getRoomLeft()
-{
-    return room_left;
-}
-
-// Devuelve el valor de la variable
-std::string Room::getRoomRight()
-{
+    case BORDER_RIGHT:
         return room_right;
+        break;
+
+    case BORDER_LEFT:
+        return room_left;
+        break;
+
+    default:
+        break;
+    }
+    return "";
+}
+
+// Devuelve el tipo de tile que hay en ese pixel
+int Room::getTile(SDL_Point point)
+{
+    int pos = ((point.y / 8) * 32) + (point.x / 8);
+    int tile = TILE_EMPTY;
+
+    if (pos < 512)
+    {
+        // Los tiles entre el 1 y el 80 son solidos
+        if ((tilemap[pos] > 0) && (tilemap[pos] < 201))
+        {
+            return TILE_SOLID;
+        }
+
+        // Los tiles mayores de 80 son atravesables
+        if ((tilemap[pos] > 200) && (tilemap[pos] < 381))
+        {
+            return TILE_TRAVESSABLE;
+        }
+
+        // Los tiles mayores de 80 son atravesables
+        if ((tilemap[pos] > 380) && (tilemap[pos] < 400))
+        {
+            return TILE_KILL;
+        }
+    }
+
+    return tile;
+}
+
+// Indica si hay colision con un enemigo a partir de un rectangulo
+bool Room::enemyCollision(SDL_Rect &rect)
+{
+    bool collision = false;
+
+    for (auto enemy : enemy_list)
+    {
+        collision |= checkCollision(rect, enemy->getCollider());
+    }
+
+    return collision;
+}
+
+// Indica si hay colision con un objeto a partir de un rectangulo
+bool Room::itemCollision(SDL_Rect &rect)
+{
+    bool collision = false;
+    for (auto item : item_list)
+    {
+        if (checkCollision(rect, item->getCollider()))
+        {
+            item->pick();
+            item_tracker->addItem(name, item->getPos());
+            collision = true;
+        }
+    }
+
+    return collision;
 }

source/room.h

@@ -4,12 +4,19 @@
 #include "utils.h"
 #include "asset.h"
 #include "enemy.h"
+#include "item.h"
+#include "item_tracker.h"
 #include <string>
 #include <vector>
 
 #ifndef ROOM_H
 #define ROOM_H
 
+#define TILE_EMPTY 0
+#define TILE_SOLID 1
+#define TILE_TRAVESSABLE 2
+#define TILE_KILL 3
+
 /*
 Cada habitación se crea y destruye cada vez que se entra o sale de la misma
 Cada habitacion si que tendra lo siguiente:
@@ -28,7 +35,6 @@ LISTADO DE ITEMS (tipo, posicion)
 class Room
 {
 private:
-	std::string id;					 // Identificador
 	std::string name;				 // Nombre de la habitación
 	color_t bg_color;				 // Color de fondo de la habitación
 	std::string room_up;			 // Identificador de la habitación que se encuentra arriba
@@ -38,9 +44,10 @@ private:
 	std::string tileset;			 // Imagen con los graficos para la habitación
 	std::vector<int> tilemap;		 // Indice de los tiles a dibujar en la habitación
 	std::vector<Enemy *> enemy_list; // Listado con los enemigos de la habitación
-	std::vector<int> item_list;		 // Listado con los items que hay en la habitación
+	std::vector<Item *> item_list;	 // Listado con los items que hay en la habitación
 	LTexture *texture;				 // Textura con los graficos de la habitación
 	Asset *asset;					 // Objeto con la ruta a todos los ficheros de recursos
+	Item_tracker *item_tracker;		 // Lleva el control de los objetos recogidos
 	SDL_Renderer *renderer;			 // El renderizador de la ventana
 	SDL_Texture *map_texture;		 // Textura para dibujar el mapa de la habitación
 
@@ -53,12 +60,15 @@ private:
 	// Asigna variables a una estructura enemy_t
 	bool setEnemy(enemy_t *enemy, std::string _var, std::string _value);
 
+	// Asigna variables a una estructura item_t
+	bool setItem(item_t *item, std::string _var, std::string _value);
+
 	// Pinta el mapa de la habitación en la textura
 	void fillMapTexture();
 
 public:
 	// Constructor
-	Room(std::string _file_path, SDL_Renderer *_renderer, Asset *_asset);
+	Room(std::string _file_path, SDL_Renderer *_renderer, Asset *_asset, Item_tracker *_item_tracker);
 
 	// Destructor
 	~Room();
@@ -75,20 +85,23 @@ public:
 	// Dibuja los enemigos en pantalla
 	void drawEnemies();
 
+	// Dibuja los objetos en pantalla
+	void drawItems();
+
 	// Actualiza las variables y objetos de la habitación
 	void update();
 
-	// Devuelve el valor de la variable
-	std::string getRoomUp();
+	// Devuelve la cadena del fichero de la habitación contigua segun el borde
+	std::string getRoom(int border);
 
-	// Devuelve el valor de la variable
-	std::string getRoomDown();
+	// Devuelve el tipo de tile que hay en ese pixel
+	int getTile(SDL_Point point);
 
-	// Devuelve el valor de la variable
-	std::string getRoomLeft();
+	// Indica si hay colision con un enemigo a partir de un rectangulo
+	bool enemyCollision(SDL_Rect &rect);
 
-	// Devuelve el valor de la variable
-	std::string getRoomRight();
+	// Indica si hay colision con un objeto a partir de un rectangulo
+	bool itemCollision(SDL_Rect &rect);
 };
 
 #endif

source/sprite.cpp

@@ -1,29 +1,16 @@
 #include "sprite.h"
 
 // Constructor
-Sprite::Sprite()
+Sprite::Sprite(int x, int y, int w, int h, LTexture *texture, SDL_Renderer *renderer)
 {
-	init(0, 0, 0, 0, nullptr, nullptr);
-}
-
-// Destructor
-Sprite::~Sprite()
-{
-	mTexture = nullptr;
-	mRenderer = nullptr;
-}
-
-// Inicializador
-void Sprite::init(int x, int y, int w, int h, LTexture *texture, SDL_Renderer *renderer)
-{
-	// Establece la posición X,Y del sprite
-	setPosX(x);
-	setPosY(y);
-
 	// Establece el alto y el ancho del sprite
 	setWidth(w);
 	setHeight(h);
 
+	// Establece la posición X,Y del sprite
+	setPosX(x);
+	setPosY(y);
+
 	// Establece el puntero al renderizador de la ventana
 	setRenderer(renderer);
 
@@ -31,22 +18,21 @@ void Sprite::init(int x, int y, int w, int h, LTexture *texture, SDL_Renderer *r
 	setTexture(texture);
 
 	// Establece el rectangulo de donde coger la imagen
-	setSpriteClip(0, 0, w, h);
+	setSpriteClip(x, y, w, h);
 
-	// Habilita el objeto
+	// Inicializa variables
 	setEnabled(true);
 }
 
-// Inicializador
-void Sprite::init(SDL_Rect rect, LTexture *texture, SDL_Renderer *renderer)
+Sprite::Sprite(SDL_Rect rect, LTexture *texture, SDL_Renderer *renderer)
 {
 	// Establece el alto y el ancho del sprite
-	mWidth = rect.w;
-	mHeight = rect.h;
+	setWidth(rect.w);
+	setHeight(rect.h);
 
 	// Establece la posición X,Y del sprite
-	mPosX = rect.x;
-	mPosY = rect.y;
+	setPosX(rect.x);
+	setPosY(rect.y);
 
 	// Establece el puntero al renderizador de la ventana
 	setRenderer(renderer);
@@ -56,13 +42,25 @@ void Sprite::init(SDL_Rect rect, LTexture *texture, SDL_Renderer *renderer)
 
 	// Establece el rectangulo de donde coger la imagen
 	setSpriteClip(rect);
+
+	// Inicializa variables
+	setEnabled(true);
+}
+
+// Destructor
+Sprite::~Sprite()
+{
+	mTexture = nullptr;
+	mRenderer = nullptr;
 }
 
 // Muestra el sprite por pantalla
 void Sprite::render()
 {
 	if (mEnabled)
+	{
 		mTexture->render(mRenderer, mPosX, mPosY, &mSpriteClip);
+	}
 }
 
 // Obten el valor de la variable
@@ -163,3 +161,10 @@ bool Sprite::isEnabled()
 {
 	return mEnabled;
 }
+
+// Devuelve el rectangulo donde está el sprite
+SDL_Rect Sprite::getRect()
+{
+	SDL_Rect rect = {getPosX(), getPosY(), getWidth(), getHeight()};
+	return rect;
+}

source/sprite.h

@@ -22,15 +22,12 @@ protected:
 
 public:
     // Constructor
-    Sprite();
+    Sprite(int x = 0, int y = 0, int w = 0, int h = 0, LTexture *texture = nullptr, SDL_Renderer *renderer = nullptr);
+    Sprite(SDL_Rect rect, LTexture *texture, SDL_Renderer *renderer);
 
     // Destructor
     ~Sprite();
 
-    // Inicializador
-    void init(int x, int y, int w, int h, LTexture *texture, SDL_Renderer *renderer);
-    void init(SDL_Rect rect, LTexture *texture, SDL_Renderer *renderer);
-
     // Muestra el sprite por pantalla
     void render();
 
@@ -81,6 +78,9 @@ public:
 
     // Comprueba si el objeto está habilitado
     bool isEnabled();
+
+    // Devuelve el rectangulo donde está el sprite
+    SDL_Rect getRect();
 };
 
 #endif

source/text.cpp

@@ -6,7 +6,8 @@
 // Constructor
 Text::Text(std::string file, LTexture *texture, SDL_Renderer *renderer)
 {
-	mSprite = new Sprite();
+	SDL_Rect rect = {0,0,0,0};
+	mSprite = new Sprite(rect, texture, renderer);
 	mSprite->setTexture(texture);
 	mSprite->setRenderer(renderer);
 	mFile = file;

source/utils.h

@@ -74,7 +74,7 @@ bool checkCollision(circle_t &a, circle_t &b);
 bool checkCollision(circle_t &a, SDL_Rect &b);
 
 // Detector de colisiones entre un dos rectangulos
-bool checkCollision(SDL_Rect a, SDL_Rect b);
+bool checkCollision(SDL_Rect &a, SDL_Rect &b);
 
 // Carga un archivo de imagen en una textura
 bool loadTextureFromFile(LTexture *texture, std::string path, SDL_Renderer *renderer);

todo.txt

@@ -0,0 +1,45 @@
+[x] Hacer que deje de poder moverse tras el salto al alcanzar la misma posicion en altura que tenia cuando saltó
+[x] Arreglar que no atraviese tiles atravaseables al caer muy rapido
+[x] Leer los mapas directamente del archivo tmx
+[x] Crear la clase item
+[x] Colisiones con los enemigos
+[x] Decidir un diseño para qué sucede en caso de morir: Recordar el punto por donde se entró al mapa y la velocidad en el eje X/Y que llevaba el personaje, crear puntos de reaparicion en las habitaciones, etc
+    En el Jet Set Willy el juego recuerda la posicion y el momento. En las Tres Luces de Glaurung solo la posición. Se va a optar por seguir el diseño del Jet Set Willy
+[x] Crear tiles que maten
+[ ] Crear tiles que deslicen, (no tipo hielo sino cinta)
+[ ] Tiles animados
+[ ] Crear ascensores
+[ ] Enemigos de diferente tamaño
+[ ] Color de los items
+[ ] Temporizador de inicio de los items
+
+
+TEMAS:
+arounders
+paku simbel
+jail battle
+arounders race
+aee gba
+matatunos
+sigmasua
+calculin doom
+leaper reaper
+mini ascii
+mappy
+paco
+chirping
+abad y batman
+jail
+counter strike
+starcraft
+diablo
+jailparty
+maniac mansion
+molotov
+tutorials
+gavina
+puzzle restorer
+qvoid
+brick roll
+dante's fall
+repairing computers