ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 1.
Hexadecimal [16-Bits]



                              1 ;MIT License
                              2 
                              3 ;Copyright (c) 2021 Fedora Adventures Pixeltronics
                              4 
                              5 ;Permission is hereby granted, free of charge, to any person obtaining a copy
                              6 ;of this software and associated documentation files (the "Software"), to deal
                              7 ;in the Software without restriction, including without limitation the rights
                              8 ;to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
                              9 ;copies of the Software, and to permit persons to whom the Software is
                             10 ;furnished to do so, subject to the following conditions:
                             11 
                             12 ;The above copyright notice and this permission notice shall be included in all
                             13 ;copies or substantial portions of the Software.
                             14 
                             15 ;THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
                             16 ;IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
                             17 ;FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
                             18 ;AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
                             19 ;LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
                             20 ;OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
                             21 ;SOFTWARE.
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 2.
Hexadecimal [16-Bits]



                             22 .include "physics.h.s"
                              1 ;MIT License
                              2 
                              3 ;Copyright (c) 2021 Fedora Adventures Pixeltronics
                              4 
                              5 ;Permission is hereby granted, free of charge, to any person obtaining a copy
                              6 ;of this software and associated documentation files (the "Software"), to deal
                              7 ;in the Software without restriction, including without limitation the rights
                              8 ;to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
                              9 ;copies of the Software, and to permit persons to whom the Software is
                             10 ;furnished to do so, subject to the following conditions:
                             11 
                             12 ;The above copyright notice and this permission notice shall be included in all
                             13 ;copies or substantial portions of the Software.
                             14 
                             15 ;THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
                             16 ;IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
                             17 ;FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
                             18 ;AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
                             19 ;LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
                             20 ;OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
                             21 ;SOFTWARE.
                             22 .globl sys_physics_update
                             23 .globl sys_physics_update_pj
                             24 .globl sys_physics_initialize_pj_jump
                             25 .globl sys_physics_pj_jump
                             26 .globl sys_physics_pj_move_left
                             27 .globl sys_physics_pj_move_right
                             28 .globl sys_physics_pj_fall
                             29 .globl sys_physics_check_all_collisions_move_down
                             30 .globl sys_physics_check_collisions_move_down
                             31 .globl sys_physics_check_all_collisions_move_up
                             32 .globl sys_physics_check_collisions_move_up
                             33 .globl sys_physics_check_all_collisions_move_left
                             34 .globl sys_physics_check_collisions_move_left
                             35 .globl sys_physics_check_all_collisions_move_right
                             36 .globl sys_physics_check_collisions_move_right
                             37 .globl sys_physics_check_collision
                             38 .globl sys_physics_check_door_collision
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 3.
Hexadecimal [16-Bits]



                             23 .include "man/entity.h.s"
                              1 ;MIT License
                              2 
                              3 ;Copyright (c) 2021 Fedora Adventures Pixeltronics
                              4 
                              5 ;Permission is hereby granted, free of charge, to any person obtaining a copy
                              6 ;of this software and associated documentation files (the "Software"), to deal
                              7 ;in the Software without restriction, including without limitation the rights
                              8 ;to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
                              9 ;copies of the Software, and to permit persons to whom the Software is
                             10 ;furnished to do so, subject to the following conditions:
                             11 
                             12 ;The above copyright notice and this permission notice shall be included in all
                             13 ;copies or substantial portions of the Software.
                             14 
                             15 ;THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
                             16 ;IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
                             17 ;FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
                             18 ;AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
                             19 ;LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
                             20 ;OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
                             21 ;SOFTWARE.
                             22 ;;archivo de cabecera para hacer include de las funciones
                             23 ;;
                             24 .globl _fedora_sprites_00
                             25 .globl _fedora_sprites_01
                             26 
                     0011    27 entity_size = 17
                     001E    28 max_entities = 30
                             29 ;;Constantes para definir en que byte está cada dato
                             30 ;; Nuestros datos de cada entidad son:
                             31 ;; Com
                     0000    32 e_cmps = 0
                     0001    33 e_cmps_physics = 1
                     0002    34 e_h = 2
                     0003    35 e_w = 3
                     0004    36 e_vx = 4
                     0005    37 e_vy = 5
                     0006    38 e_altura_salto = 6
                     0007    39 e_maxy = 7
                             40 ;e_color = 10
                     0008    41 e_ptr_sprite = 8 ;; esto usa 2 bytes
                     000A    42 e_prev_ptr = 10  ;; puntero 2 bytes
                     000C    43 e_movimiento1 = 12
                     000D    44 e_movimiento2 = 13
                     000E    45 e_movimiento3 = 14
                     000F    46 e_x = 15
                     0010    47 e_y = 16
                             48 
                     0080    49 e_cmps_alive = 0x80
                     0040    50 e_cmps_render = 0x40
                     0020    51 e_cmps_player = 0x20
                     0010    52 e_cmps_door = 0x10
                     0008    53 e_cmps_treasure = 0x08
                     0004    54 e_cmps_platform = 0x04
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 4.
Hexadecimal [16-Bits]



                             55 
                     0080    56 e_cmps_phy_left = 0x80
                     0040    57 e_cmps_phy_right = 0x40
                     0020    58 e_cmps_phy_jumping = 0x20
                     0010    59 e_cmps_phy_falling = 0x10
                             60 
                             61 
                             62 
                             63 ;;FUNCIONES PUBLICAS
                             64 .globl getEntityInArray
                             65 .globl getNumEntities
                             66 .globl create_entity
                             67 .globl man_entity_put_player_in_ix
                             68 .globl man_entity_put_platforms_in_iy
                             69 .globl man_entity_put_treasure_in_iy
                             70 .globl man_entity_put_door_in_iy
                             71 .globl man_entity_reset
                             72 .globl man_entity_init
                             73 .globl man_map_init
                             74 .globl create_entity_1
                             75 .globl create_entity_2
                             76 ;;CONSTANTES
                             77 .globl entity_size
                             78 .globl max_entities
                             79 .globl e_cmps
                             80 .globl e_cmps_physics
                             81 .globl e_h
                             82 .globl e_w
                             83 .globl e_x
                             84 .globl e_y
                             85 .globl e_vx
                             86 .globl e_vy
                             87 .globl e_altura_salto
                             88 .globl e_maxy
                             89 ;.globl e_color
                             90 .globl e_ptr_sprite
                             91 .globl e_cmps_alive
                             92 .globl e_cmps_render
                             93 .globl e_cmps_phy_left
                             94 .globl e_cmps_phy_right
                             95 .globl e_cmps_phy_jumping
                             96 .globl e_cmps_phy_falling
                             97 .globl e_movimiento1
                             98 .globl e_movimiento2
                             99 .globl e_movimiento3
                            100 
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 5.
Hexadecimal [16-Bits]



                             24 .include "game.h.s"
                              1 ;MIT License
                              2 
                              3 ;Copyright (c) 2021 Fedora Adventures Pixeltronics
                              4 
                              5 ;Permission is hereby granted, free of charge, to any person obtaining a copy
                              6 ;of this software and associated documentation files (the "Software"), to deal
                              7 ;in the Software without restriction, including without limitation the rights
                              8 ;to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
                              9 ;copies of the Software, and to permit persons to whom the Software is
                             10 ;furnished to do so, subject to the following conditions:
                             11 
                             12 ;The above copyright notice and this permission notice shall be included in all
                             13 ;copies or substantial portions of the Software.
                             14 
                             15 ;THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
                             16 ;IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
                             17 ;FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
                             18 ;AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
                             19 ;LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
                             20 ;OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
                             21 ;SOFTWARE.
                             22 .globl sys_game_update
                             23 .globl sys_game_check_treasure
                             24 .globl sys_game_check_door
                             25 .globl sys_game_catch_treasure
                             26 .globl sys_game_open_door
                             27 .globl sys_game_exit_level
                             28 .globl sys_game_die
                             29 .globl mainMenu
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 6.
Hexadecimal [16-Bits]



                             25 
                             26 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                             27 ;;
                             28 ;; FUNCION DE ACTUALIZACION DE TODAS LAS FISICAS
                             29 ;;
                             30 ;; Descripcion
                             31 ;;
                             32 ;; Parametros de entrada
                             33 ;;
                             34 ;; Parametros de salida
                             35 ;;
                             36 ;; Modifica los registros
                             37 ;;
                             38 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6D7F                      39 sys_physics_update:
                             40 ; Llamo a la funcion de actualizar la fisica del personaje
   6D7F CD 83 6D      [17]   41     call sys_physics_update_pj
   6D82 C9            [10]   42 ret
                             43 
                             44 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                             45 ;;
                             46 ;; FUNCION DE ACTUALIZACION DE LA FISICA DEL PERSONAJE
                             47 ;;
                             48 ;; Descripcion
                             49 ;; 
                             50 ;; Parametros de entrada
                             51 ;;
                             52 ;; Parametros de salida
                             53 ;;
                             54 ;; Modifica los registros
                             55 ;;
                             56 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6D83                      57 sys_physics_update_pj:
                             58 
                             59     ;compruebo si el personaje se tiene que mover a la izquierda
   6D83 CD F4 6D      [17]   60     call sys_physics_pj_move_left
                             61     ;compruebo si el personaje se tiene que mover a la derecha
   6D86 CD 0E 6E      [17]   62     call sys_physics_pj_move_right
                             63     ;actualizo componente X
   6D89 DD 46 04      [19]   64     ld b, e_vx(ix)
   6D8C DD 7E 0F      [19]   65     ld a, e_x(ix)
   6D8F 80            [ 4]   66     add b
   6D90 DD 77 0F      [19]   67     ld e_x(ix), a
                             68     ;compruebo si el personaje esta en accion de caida
   6D93 CD 2C 6E      [17]   69     call sys_physics_pj_fall
                             70     ;compruebo si el personaje esta en accion de salto
   6D96 CD C9 6D      [17]   71     call sys_physics_pj_jump
                             72     ;actualizo componente Y
   6D99 DD 46 05      [19]   73     ld b, e_vy(ix)
   6D9C DD 7E 10      [19]   74     ld a, e_y(ix)
   6D9F 80            [ 4]   75     add b
   6DA0 DD 77 10      [19]   76     ld e_y(ix), a
   6DA3 C9            [10]   77 ret
                             78 
                             79 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 7.
Hexadecimal [16-Bits]



                             80 ;;
                             81 ;; FUNCION DE COMIENZO DEL SALTO
                             82 ;;
                             83 ;; Descripcion
                             84 ;;    Se actualiza la velocidad vertical del personaje y se obtiene la altura maxima a la que puede llegar el pj con ese salto, 
                             85 ;;    considerando siempre que el personaje no este ya saltando (para evitar multiples pulsaciones del boton de salto), ni
                             86 ;;    cayendo (porque si el pj no esta apoyado en una supercicie, no puede saltar)
                             87 ;; Parametros de entrada
                             88 ;; - IX: puntero a la entidad personaje
                             89 ;; Parametros de salida
                             90 ;;
                             91 ;; Modifica los registros
                             92 ;; - AF, B
                             93 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6DA4                      94 sys_physics_initialize_pj_jump:
                             95     ;compruebo si el pj esta saltando ya, o esta cayendo
   6DA4 3E 30         [ 7]   96     ld a, #(e_cmps_phy_jumping | e_cmps_phy_falling)  ;cargo el vector de componentes en a
   6DA6 DD A6 01      [19]   97     and e_cmps_physics(ix)                    
   6DA9 20 1D         [12]   98     jr nz, fin_funcion_spipj            ;si alguna de las dos componentes es 1, esta comparacion no sera 0, por lo que no debo inicializar
                             99     ;;inicializo el salto
   6DAB DD 7E 10      [19]  100     ld  a, e_y(ix)                      ;posicion actual
   6DAE DD 96 06      [19]  101     sub e_altura_salto(ix)              ;altura que puede saltar el pj
   6DB1 38 05         [12]  102     jr c, cargar_0_spipj
   6DB3 DD 77 07      [19]  103     ld e_maxy(ix), a                    ;altura maxima a la que llegara el pj durante el salto
   6DB6 18 04         [12]  104     jr continuar_funcion_spipj
   6DB8                     105 cargar_0_spipj:
   6DB8 DD 36 07 00   [19]  106     ld  e_maxy(ix), #0                  ;el maximo es 0 porque choca con el techo
   6DBC                     107 continuar_funcion_spipj:
   6DBC DD 36 05 FF   [19]  108     ld e_vy(ix), #-1                    ;velocidad vertical, porque esta saltando
                            109 
   6DC0 DD 7E 01      [19]  110     ld a, e_cmps_physics(ix)            ;cargo el vector de componentes
   6DC3 F6 20         [ 7]  111     or #(e_cmps_phy_jumping)            ;añado la componente de salto al vector
   6DC5 DD 77 01      [19]  112     ld e_cmps_physics(ix), a            ;guardo el vector actualizado
   6DC8                     113 fin_funcion_spipj:
   6DC8 C9            [10]  114 ret
                            115 
                            116 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            117 ;;
                            118 ;; FUNCION DE SALTO
                            119 ;;
                            120 ;; Descripcion
                            121 ;; 
                            122 ;; Parametros de entrada
                            123 ;; - IX: Puntero a la entidad personaje
                            124 ;; Parametros de salida
                            125 ;;
                            126 ;; Modifica los registros
                            127 ;;
                            128 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6DC9                     129 sys_physics_pj_jump:
                            130     ;compruebo si estoy saltando (el bit de salto esta activo)
   6DC9 3E 20         [ 7]  131     ld a, #(e_cmps_phy_jumping)
   6DCB DD 46 01      [19]  132     ld b, e_cmps_physics(ix)                    ;cargo el vector de componentes en a
   6DCE A0            [ 4]  133     and b                               ;miro solo la componente de salto
                            134     ;si no estoy saltando, voy al final
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 8.
Hexadecimal [16-Bits]



   6DCF 28 22         [12]  135     jr z, fin_funcion_sppj
                            136     ;si estoy saltando
                            137     ; compruebo si ya he llegado al maximo de la altura que puedo saltar
   6DD1 DD 7E 10      [19]  138     ld a, e_y(ix)
   6DD4 DD 46 07      [19]  139     ld b, e_maxy(ix)
   6DD7 90            [ 4]  140     sub b                                   ;comparo ambas posiciones
   6DD8 28 0D         [12]  141     jr z, actualizar_flags_pj_sppj          ;si es cero, he llegado al maximo y tengo que empezar a bajar
                            142     ; compruebo si choco contra la parte inferior de alguna plataforma
   6DDA CD B4 6E      [17]  143     call sys_physics_check_all_collisions_move_up
                            144     ;si choco con alguna tengo que dejar de saltar y empezar a caer
   6DDD FE 01         [ 7]  145     cp a, #1    
   6DDF 28 06         [12]  146     jr z, actualizar_flags_pj_sppj
                            147     ;si no he chocado con ninguna y puedo seguir subiendo, pongo la velocidad de subida en -1 para ir para arriba
   6DE1 DD 36 05 FF   [19]  148     ld e_vy(ix), #-1
   6DE5 18 0C         [12]  149     jr fin_funcion_sppj
   6DE7                     150 actualizar_flags_pj_sppj:                   ;actualizo los flags de salto y caída
                            151     ;pongo a 0 el flag e_cmps_phy_jumping
   6DE7 06 20         [ 7]  152     ld b, #(e_cmps_phy_jumping)
   6DE9 DD 7E 01      [19]  153     ld a, e_cmps_physics(ix)                    ;cargo el vector de componentes en a
   6DEC A8            [ 4]  154     xor b                               ;pongo en flag en 0
                            155     ;pongo a 1 el flag e_cmps__phy_falling
   6DED 06 10         [ 7]  156     ld b, #(e_cmps_phy_falling)
   6DEF B0            [ 4]  157     or b
   6DF0 DD 77 01      [19]  158     ld e_cmps_physics(ix), a
   6DF3                     159 fin_funcion_sppj:                           ;fin de la funcion
   6DF3 C9            [10]  160 ret
                            161 
                            162 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            163 ;;
                            164 ;; FUNCION DE MOVIMIENTO A LA IZQUIERDA
                            165 ;;
                            166 ;; Descripcion
                            167 ;; 
                            168 ;; Parametros de entrada
                            169 ;;
                            170 ;; Parametros de salida
                            171 ;;
                            172 ;; Modifica los registros
                            173 ;;
                            174 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6DF4                     175 sys_physics_pj_move_left:
                            176     
   6DF4 DD 7E 01      [19]  177     ld a, e_cmps_physics(ix)                    ;cargo el vector de componentes
   6DF7 E6 80         [ 7]  178     and #(e_cmps_phy_left)
   6DF9 28 12         [12]  179     jr z, fin_funcion_sppml                     ;si no estoy moviendo a la izquierda, voy al final
   6DFB DD 7E 0F      [19]  180     ld a, e_x(ix)
   6DFE FE 00         [ 7]  181     cp a, #0                                ;compruebo si estoy a la izquierda del todo de la pantalla
   6E00 28 0B         [12]  182     jr z, fin_funcion_sppml                 ;en caso de estar, simplemente no muevo al personaje y salgo de la funcion
                            183     ;compruebo si choco contra la parte derecha de alguna plataforma
   6E02 CD 06 6F      [17]  184     call sys_physics_check_all_collisions_move_left
   6E05 FE 01         [ 7]  185     cp a, #1
   6E07 28 04         [12]  186     jr z, fin_funcion_sppml
                            187     ;si no choco con nada y no estoy a la izquierda de la pantalla, pongo la velocidad a -1 para ir a la izquierda
   6E09 DD 36 04 FF   [19]  188     ld e_vx(ix), #-1
   6E0D                     189 fin_funcion_sppml:
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 9.
Hexadecimal [16-Bits]



   6E0D C9            [10]  190 ret
                            191 
                            192 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            193 ;;
                            194 ;; FUNCION DE MOVIMIENTO A LA DERECHA
                            195 ;;
                            196 ;; Descripcion
                            197 ;; 
                            198 ;; Parametros de entrada
                            199 ;;
                            200 ;; Parametros de salida
                            201 ;;
                            202 ;; Modifica los registros
                            203 ;;
                            204 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6E0E                     205 sys_physics_pj_move_right:
                            206 
   6E0E DD 7E 01      [19]  207     ld a, e_cmps_physics(ix)                    ;cargo el vector de componentes
   6E11 E6 40         [ 7]  208     and #(e_cmps_phy_right)
   6E13 28 16         [12]  209     jr z, fin_funcion_sppmr                     ;si no estoy moviendo a la izquierda, voy al final
                            210     ;compruebo si estoy a la derecha del todo de la pantalla
   6E15 DD 46 03      [19]  211     ld b, e_w(ix)
   6E18 DD 7E 0F      [19]  212     ld a, e_x(ix)
   6E1B 80            [ 4]  213     add b                                   ;a la coordenada x le sumo el ancho del objeto, para ver si toco la pared derecha
   6E1C FE 50         [ 7]  214     cp a, #80
   6E1E 28 0B         [12]  215     jr z, fin_funcion_sppmr                 ;en caso de estar, simplemente no muevo al personaje y salgo de la funcion
                            216     ;compruebo si choco contra la parte derecha de alguna plataforma
   6E20 CD 5B 6F      [17]  217     call sys_physics_check_all_collisions_move_right
   6E23 FE 01         [ 7]  218     cp a, #1
   6E25 28 04         [12]  219     jr z, fin_funcion_sppmr
                            220     ;si no choco con nada y no estoy a la derecha de la pantalla, pongo la velocidad a 1 para ir a la derecha
   6E27 DD 36 04 01   [19]  221     ld e_vx(ix), #1
   6E2B                     222 fin_funcion_sppmr:
   6E2B C9            [10]  223 ret
                            224 
                            225 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            226 ;;
                            227 ;; FUNCION DE ACTUALIZACION DE LA CAIDA DEL PERSONAJE
                            228 ;;
                            229 ;; Descripcion
                            230 ;; 
                            231 ;; Parametros de entrada
                            232 ;;
                            233 ;; Parametros de salida
                            234 ;;
                            235 ;; Modifica los registros
                            236 ;;
                            237 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6E2C                     238 sys_physics_pj_fall:
                            239     ;compruebo si estoy en trayectoria ascendente durante un salto. Es el unico momento donde no puedo caer
   6E2C 3E 20         [ 7]  240     ld a, #(e_cmps_phy_jumping)  
   6E2E DD 46 01      [19]  241     ld b, e_cmps_physics(ix)                    ;cargo el vector de componentes en a
   6E31 A0            [ 4]  242     and b
                            243     ;salgo de la funcion porque no se aplica
   6E32 20 30         [12]  244     jr nz, fin_funcion_sppf
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 10.
Hexadecimal [16-Bits]



                            245     ;compruebo si estoy en la parte inferior de la pantalla, pues ahi muero
   6E34 DD 7E 10      [19]  246     ld a, e_y(ix)
   6E37 DD 46 02      [19]  247     ld b, e_h(ix)
   6E3A 80            [ 4]  248     add b
   6E3B FE C8         [ 7]  249     cp a, #200
   6E3D 20 03         [12]  250     jr nz, sppf_continue
   6E3F CD 5C 70      [17]  251     call sys_game_die
                            252 ;    jr fin_funcion_sppf
                            253     ;compruebo si choco contra la parte superior de alguna plataforma
   6E42                     254 sppf_continue:
   6E42 CD 65 6E      [17]  255     call sys_physics_check_all_collisions_move_down
   6E45 FE 01         [ 7]  256     cp a, #1
                            257     ;si he colisionado con una plataforma, dejo de caer
   6E47 28 0F         [12]  258     jr z, sppf_detener_caida                
   6E49                     259 sppf_caer: 
   6E49 DD 36 05 01   [19]  260     ld e_vy(ix), #1
                            261     ;marcar el flag de caida a 1
   6E4D DD 7E 01      [19]  262     ld a, e_cmps_physics(ix)
   6E50 06 10         [ 7]  263     ld b, #(e_cmps_phy_falling)             ;cargo el vector de componentes en a
   6E52 B0            [ 4]  264     or b                                ;pongo en flag en 1
   6E53 DD 77 01      [19]  265     ld e_cmps_physics(ix), a
                            266     ;salgo de la funcion de caida
   6E56 18 0C         [12]  267     jr fin_funcion_sppf  
   6E58                     268 sppf_detener_caida:
   6E58 DD 36 05 00   [19]  269     ld e_vy(ix), #0                         ;velocidad de caida = 0
                            270     ;marcar el flag de caida a 0 
   6E5C DD 7E 01      [19]  271     ld a, e_cmps_physics(ix)                    ;cargo el vector de componentes en a
   6E5F CB A7         [ 8]  272     res 4, a                               ;pongo en flag en 0  
   6E61 DD 77 01      [19]  273     ld e_cmps_physics(ix), a  
   6E64                     274 fin_funcion_sppf:    
   6E64 C9            [10]  275 ret
                            276 
                            277 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            278 ;;
                            279 ;; FUNCION PARA COMPROBAR SI EL PERSONAJE ESTA DE PIE SOBRE ALGUN OBJETO
                            280 ;;
                            281 ;; Descripcion
                            282 ;; 
                            283 ;; Parametros de entrada
                            284 ;;
                            285 ;; Parametros de salida
                            286 ;; - IY: Puntero a una entidad plataforma
                            287 ;; - IX: Puntero a la entidad personaje
                            288 ;; - A: 1 si el personaje choca contra alguna plataforma, 0 si no chocan
                            289 ;;
                            290 ;; Modifica los registros
                            291 ;; AF, c, DE, IX, IY
                            292 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6E65                     293 sys_physics_check_all_collisions_move_down:
                            294     ;cargo en IX el puntero del personaje
                            295 ;    call man_entity_put_player_in_ix
                            296     ;hay que recorrer todos los objetos de tipo plataforma del juego. Para ello tengo que hacer dos cosas:
                            297     ;cargo el puntero a la primera entidad en el registro IY
   6E65 CD 0D 62      [17]  298     call man_entity_put_platforms_in_iy
   6E68 CD BB 61      [17]  299     call getNumEntities
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 11.
Hexadecimal [16-Bits]



   6E6B 0E 03         [ 7]  300     ld c, #3
   6E6D 91            [ 4]  301     sub c
   6E6E 4F            [ 4]  302     ld c, a              ;cargo el numero de entidades menos cuatro, que son el personaje, la lava, la puerta y el tesoro    
   6E6F                     303 bucle_spcacmd:    
   6E6F CD 87 6E      [17]  304     call sys_physics_check_collisions_move_down         ;compruebo que no chocan el personaje yl tesoro actual
   6E72 FE 01         [ 7]  305     cp a, #1
   6E74 28 0E         [12]  306     jr z, spcacmd_return_1                              ;si chocan, he acabado el bucle y retorno 1
                            307     ;si no, hago la siguiente iteracion del bucle
   6E76                     308 spcacmd_preparar_siguiente_iteracion:
   6E76 0D            [ 4]  309     dec c
   6E77 28 07         [12]  310     jr z, spcacmd_return_0                  ;si ya no me quedan entidades que revisar, salgo del bucle y retorno 0
                            311     ;si no, paso a la siguiente plataforma a comprobar y vuelvo al principio del bucle
   6E79 11 11 00      [10]  312     ld de, #entity_size
   6E7C FD 19         [15]  313     add iy, de                              ;siguiente plataforma
   6E7E 18 EF         [12]  314     jr bucle_spcacmd
   6E80                     315 spcacmd_return_0:
   6E80 3E 00         [ 7]  316     ld a, #0
   6E82 18 02         [12]  317     jr fin_funcion_spcacmd  
   6E84                     318 spcacmd_return_1:
   6E84 3E 01         [ 7]  319     ld a, #1
   6E86                     320 fin_funcion_spcacmd:    
   6E86 C9            [10]  321 ret
                            322 
                            323 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            324 ;;
                            325 ;; FUNCION PARA COMPROBAR SI EL PERSONAJE ESTA DE PIE SOBRE UN OBJETO CONCRETO
                            326 ;;
                            327 ;; Descripcion
                            328 ;;   Comprueba si las coordenadas X e Y del personaje y una entidad indicada se solapan en algun punto.
                            329 ;;
                            330 ;; Parametros de entrada
                            331 ;; - IX: puntero a la entidad plataforma
                            332 ;; - IY: puntero a la entidad personaje
                            333 ;;
                            334 ;; Parametros de salida
                            335 ;; - A: 1 si el personaje choca contra alguna plataforma, 0 si no chocan
                            336 ;;
                            337 ;; Modifica los registros
                            338 ;; AF, B
                            339 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6E87                     340 sys_physics_check_collisions_move_down:
                            341     ;obtengo la coordenada Y del personaje y le sumo su altura. Esa es su parte inferior
   6E87 DD 7E 10      [19]  342     ld a, e_y(ix)
   6E8A DD 86 02      [19]  343     add e_h(ix)
   6E8D FD 46 10      [19]  344     ld b, e_y(iy)               ;cargo la coordenada Y del tesoro
   6E90 B8            [ 4]  345     cp b                        ;comparo ambas coordenadas Y a ver si son iguales
   6E91 20 1E         [12]  346     jr nz, spccmd_poner_a_a_0   ;si son distintas, he terminado de comprobar porque el pj yl tesoro están a distinta altura
                            347     ;si son iguales, entonces he detectado que el personaje puede estar pisando esa plataforma concreta. Hay que comprobar las coordenadas X
   6E93 DD 7E 0F      [19]  348     ld a, e_x(ix)               ;cargo la coordenada X del personaje
   6E96 DD 86 03      [19]  349     add e_w(ix)               ;cargo la anchura del personaje y los sumo
   6E99 47            [ 4]  350     ld b, a                     ;guardo el valor en el registro B
   6E9A FD 7E 0F      [19]  351     ld a, e_x(iy)               ;cargo la coordenada X del tesoro               
   6E9D 90            [ 4]  352     sub b                       ;si al restar, obtengo negativo, es porque la parte derecha del personaje es menor que la parte izquierda del tesoro, por lo que no se tocan
   6E9E 30 11         [12]  353     jr nc, spccmd_poner_a_a_0
                            354     ;pero si el carry es cero, hay que comprobar el choque por el otro lado del tesoro
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 12.
Hexadecimal [16-Bits]



   6EA0 FD 7E 0F      [19]  355     ld a, e_x(iy)               ;cargo la coordenada X del tesoro
   6EA3 FD 86 03      [19]  356     add e_w(iy)               ;cargo la anchura del tesoro y las sumo
   6EA6 47            [ 4]  357     ld b, a                     ;guardo el valor en B
   6EA7 DD 7E 0F      [19]  358     ld a, e_x(ix)               ;cargo la coordenada X del personaje
   6EAA 90            [ 4]  359     sub b                       ;si al restar obtengo negativo, es porque el personaje está más a la derecha que la parte derecha del tesoro, y por tanto no chocan
   6EAB 30 04         [12]  360     jr nc, spccmd_poner_a_a_0
   6EAD 3E 01         [ 7]  361     ld a, #1
   6EAF 18 02         [12]  362     jr fin_funcion_spccmd
   6EB1                     363 spccmd_poner_a_a_0:    
   6EB1 3E 00         [ 7]  364     ld a, #0
   6EB3                     365 fin_funcion_spccmd:
   6EB3 C9            [10]  366 ret 
                            367 
                            368 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            369 ;;
                            370 ;; FUNCION PARA COMPROBAR SI EL PERSONAJE SE DA EN LA CABEZA CON ALGUNA PLATAFORMA
                            371 ;;
                            372 ;; Descripcion
                            373 ;; 
                            374 ;; Parametros de entrada
                            375 ;;
                            376 ;; Parametros de salida
                            377 ;; - IX: Puntero a una entidad plataforma
                            378 ;; - IY: Puntero a la entidad personaje
                            379 ;; - A: 1 si el personaje choca contra alguna plataforma, 0 si no chocan
                            380 ;;
                            381 ;; Modifica los registros
                            382 ;; AF, C, DE, IX, IY
                            383 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6EB4                     384 sys_physics_check_all_collisions_move_up:
                            385     ;cargo en IY el puntero del personaje
                            386 ;    call man_entity_put_player_in_ix
                            387     ;hay que recorrer todos los objetos de tipo plataforma del juego. Para ello tengo que hacer dos cosas:
                            388     ;cargo el puntero a la primera entidad en el registro IX
   6EB4 CD 0D 62      [17]  389     call man_entity_put_platforms_in_iy
   6EB7 CD BB 61      [17]  390     call getNumEntities
   6EBA 0E 03         [ 7]  391     ld c, #3
   6EBC 91            [ 4]  392     sub c
   6EBD 4F            [ 4]  393     ld c, a              ;cargo el numero de entidades menos cuatro, que son el personaje, la lava, la puerta y el tesoro     
   6EBE                     394 bucle_spcacmu:    
   6EBE CD D6 6E      [17]  395     call sys_physics_check_collisions_move_up         ;compruebo que no chocan el personaje yl tesoro actual
   6EC1 FE 01         [ 7]  396     cp a, #1
   6EC3 28 0E         [12]  397     jr z, spcacmu_return_1                              ;si chocan, he acabado el bucle y retorno 1
                            398     ;si no, hago la siguiente iteracion del bucle
   6EC5                     399 spcacmu_preparar_siguiente_iteracion:
   6EC5 0D            [ 4]  400     dec c
   6EC6 28 07         [12]  401     jr z, spcacmu_return_0                  ;si ya no me quedan entidades que revisar, salgo del bucle y retorno 0
                            402     ;si no, paso a la siguiente plataforma a comprobar y vuelvo al principio del bucle
   6EC8 11 11 00      [10]  403     ld de, #entity_size
   6ECB FD 19         [15]  404     add iy, de                              ;siguiente plataforma
   6ECD 18 EF         [12]  405     jr bucle_spcacmu
   6ECF                     406 spcacmu_return_0:
   6ECF 3E 00         [ 7]  407     ld a, #0
   6ED1 18 02         [12]  408     jr fin_funcion_spcacmu 
   6ED3                     409 spcacmu_return_1:
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 13.
Hexadecimal [16-Bits]



   6ED3 3E 01         [ 7]  410     ld a, #1
   6ED5                     411 fin_funcion_spcacmu:    
   6ED5 C9            [10]  412 ret
                            413 
                            414 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            415 ;;
                            416 ;; FUNCION PARA COMPROBAR SI EL PERSONAJE SE DA EN LA CABEZA CON UN OBJETO CONCRETO
                            417 ;;
                            418 ;; Descripcion
                            419 ;;   Comprueba si las coordenadas X e Y del personaje y una entidad indicada se solapan en algun punto.
                            420 ;;
                            421 ;; Parametros de entrada
                            422 ;; - IX: puntero a la entidad plataforma
                            423 ;; - IY: puntero a la entidad personaje
                            424 ;;
                            425 ;; Parametros de salida
                            426 ;; - A: 1 si el personaje choca contra alguna plataforma, 0 si no chocan
                            427 ;;
                            428 ;; Modifica los registros
                            429 ;; AF, B
                            430 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6ED6                     431 sys_physics_check_collisions_move_up:
                            432     ;obtengo la coordenada Y del tesoro y le sumo la altura 
   6ED6 FD 7E 10      [19]  433     ld a, e_y(iy)
   6ED9 FD 46 02      [19]  434     ld b, e_h(iy)
   6EDC 80            [ 4]  435     add b
   6EDD DD 46 10      [19]  436     ld b, e_y(ix)               ;cargo la coordenada Y del personaje
   6EE0 B8            [ 4]  437     cp b                        ;comparo ambas coordenadas Y a ver si son iguales
   6EE1 20 20         [12]  438     jr nz, spccmu_poner_a_a_0   ;si son distintas, he terminado de comprobar porque el pj yl tesoro están a distinta altura
                            439     ;si son iguales, entonces he detectado que el personaje puede estar golpeando esa plataforma concreta. Hay que comprobar las coordenadas X
   6EE3 DD 7E 0F      [19]  440     ld a, e_x(ix)               ;cargo la coordenada X del personaje
   6EE6 DD 46 03      [19]  441     ld b, e_w(ix)               ;cargo la anchura del personaje y los sumo
   6EE9 80            [ 4]  442     add b
   6EEA 47            [ 4]  443     ld b, a                     ;guardo el valor en el registro B
   6EEB FD 7E 0F      [19]  444     ld a, e_x(iy)               ;cargo la coordenada X del tesoro               
   6EEE 90            [ 4]  445     sub b                       ;si al restar, obtengo negativo, es porque la parte derecha del personaje es menor que la parte izquierda del tesoro, por lo que no se tocan
   6EEF 30 12         [12]  446     jr nc, spccmu_poner_a_a_0
                            447     ;pero si el carry es cero, hay que comprobar el choque por el otro lado del tesoro
   6EF1 FD 7E 0F      [19]  448     ld a, e_x(iy)               ;cargo la coordenada X del tesoro
   6EF4 FD 46 03      [19]  449     ld b, e_w(iy)               ;cargo la anchura del tesoro y las sumo
   6EF7 80            [ 4]  450     add b
   6EF8 47            [ 4]  451     ld b, a                     ;guardo el valor en B
   6EF9 DD 7E 0F      [19]  452     ld a, e_x(ix)               ;cargo la coordenada X del personaje
   6EFC 90            [ 4]  453     sub b                       ;si al restar obtengo negativo, es porque el personaje está más a la derecha que la parte derecha del tesoro, y por tanto no chocan
   6EFD 30 04         [12]  454     jr nc, spccmu_poner_a_a_0
   6EFF 3E 01         [ 7]  455     ld a, #1
   6F01 18 02         [12]  456     jr fin_funcion_spccmu
   6F03                     457 spccmu_poner_a_a_0:    
   6F03 3E 00         [ 7]  458     ld a, #0
   6F05                     459 fin_funcion_spccmu:
   6F05 C9            [10]  460 ret  
                            461 
                            462 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            463 ;;
                            464 ;; FUNCION PARA COMPROBAR SI EL PERSONAJE CHOCA CONTRA CON ALGUNA PLATAFORMA QUE ESTE A SU IZQUIERDA
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 14.
Hexadecimal [16-Bits]



                            465 ;;
                            466 ;; Descripcion
                            467 ;; 
                            468 ;; Parametros de entrada
                            469 ;;
                            470 ;; Parametros de salida
                            471 ;; - IX: Puntero a una entidad plataforma
                            472 ;; - IY: Puntero a la entidad personaje
                            473 ;; - A: 1 si el personaje choca contra alguna plataforma, 0 si no chocan
                            474 ;;
                            475 ;; Modifica los registros
                            476 ;; AF, B, DE, IX, IY
                            477 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6F06                     478 sys_physics_check_all_collisions_move_left:
                            479     ;cargo en IX el puntero del personaje
   6F06 CD 01 62      [17]  480     call man_entity_put_player_in_ix
                            481     ;hay que recorrer todos los objetos de tipo plataforma del juego.
                            482     ;cargo el puntero a la primera entidad en el registro IY
   6F09 CD 0D 62      [17]  483     call man_entity_put_platforms_in_iy
   6F0C CD BB 61      [17]  484     call getNumEntities
   6F0F 0E 03         [ 7]  485     ld c, #3
   6F11 91            [ 4]  486     sub c
   6F12 4F            [ 4]  487     ld c, a              ;cargo el numero de entidades menos cuatro, que son el personaje, la lava, la puerta y el tesoro 
   6F13                     488 bucle_spcacml:    
   6F13 CD 2B 6F      [17]  489     call sys_physics_check_collisions_move_left         ;compruebo que no chocan el personaje yl tesoro actual
   6F16 FE 01         [ 7]  490     cp a, #1
   6F18 28 0E         [12]  491     jr z, spcacml_return_1                              ;si chocan, he acabado el bucle y retorno 1
                            492     ;si no, hago la siguiente iteracion del bucle
   6F1A                     493 spcacml_preparar_siguiente_iteracion:
   6F1A 0D            [ 4]  494     dec c
   6F1B 28 07         [12]  495     jr z, spcacml_return_0                  ;si ya no me quedan entidades que revisar, salgo del bucle y retorno 0
                            496     ;si no, paso a la siguiente plataforma a comprobar y vuelvo al principio del bucle
   6F1D 11 11 00      [10]  497     ld de, #entity_size
   6F20 FD 19         [15]  498     add iy, de                              ;siguiente plataforma
   6F22 18 EF         [12]  499     jr bucle_spcacml
   6F24                     500 spcacml_return_0:
   6F24 3E 00         [ 7]  501     ld a, #0
   6F26 18 02         [12]  502     jr fin_funcion_spcacml 
   6F28                     503 spcacml_return_1:
   6F28 3E 01         [ 7]  504     ld a, #1
   6F2A                     505 fin_funcion_spcacml:    
   6F2A C9            [10]  506 ret
                            507 
                            508 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            509 ;;
                            510 ;; FUNCION PARA COMPROBAR SI EL PERSONAJE CHOCA A LA IZQUIERDA CON UN OBJETO CONCRETO
                            511 ;;
                            512 ;; Descripcion
                            513 ;;   Comprueba si las coordenadas X e Y del personaje y una entidad indicada se solapan en algun punto.
                            514 ;;
                            515 ;; Parametros de entrada
                            516 ;; - IX: puntero a la entidad plataforma
                            517 ;; - IY: puntero a la entidad personaje
                            518 ;;
                            519 ;; Parametros de salida
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 15.
Hexadecimal [16-Bits]



                            520 ;; - A: 1 si el personaje choca contra alguna plataforma, 0 si no chocan
                            521 ;;
                            522 ;; Modifica los registros
                            523 ;; AF, B
                            524 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6F2B                     525 sys_physics_check_collisions_move_left:
                            526     ;obtengo la coordenada X del tesoro y le sumo su anchura
   6F2B FD 7E 0F      [19]  527     ld a, e_x(iy)
   6F2E FD 46 03      [19]  528     ld b, e_w(iy)
   6F31 80            [ 4]  529     add b
   6F32 DD 46 0F      [19]  530     ld b, e_x(ix)               ;cargo la coordenada X del personaje
   6F35 B8            [ 4]  531     cp b                        ;comparo ambas coordenadas X a ver si son iguales
   6F36 20 20         [12]  532     jr nz, spccml_poner_a_a_0   ;si son distintas, he terminado de comprobar porque el pj yl tesoro están a distinta distancia
                            533     ;si son iguales, entonces he detectado que el personaje puede estar golpeando esa plataforma concreta. Hay que comprobar la coordenada Y
   6F38 FD 7E 10      [19]  534     ld a, e_y(iy)               ;cargo la coordenada Y del tesoro
   6F3B FD 46 02      [19]  535     ld b, e_h(iy)               ;cargo la altura del tesoro y los sumo. Esto es la parte inferior del tesoro
   6F3E 80            [ 4]  536     add b
   6F3F 47            [ 4]  537     ld b, a                     ;guardo el valor de la cabeza en el registro B
   6F40 DD 7E 10      [19]  538     ld a, e_y(ix)               ;cargo la coordenada Y del personaje . Esto es su cabeza              
   6F43 90            [ 4]  539     sub b                       ;si al restar, obtengo negativo, es porque la cabeza del personaje esta por debajo que la parte inferior del tesoro, por lo que no se tocan
   6F44 30 12         [12]  540     jr nc, spccml_poner_a_a_0
                            541     ;pero si el carry es cero, hay que comprobar los pies del personaje
   6F46 DD 7E 10      [19]  542     ld a, e_y(ix)               ;cargo la coordenada Y del personaje
   6F49 DD 46 02      [19]  543     ld b, e_h(ix)               ;cargo la altura del personaje y los sumo. Esa es la altura de los pies
   6F4C 80            [ 4]  544     add b
   6F4D 3D            [ 4]  545     dec a
   6F4E FD 46 10      [19]  546     ld b, e_y(iy)               ;cargo la coordenada Y del tesoro (la altura)
   6F51 90            [ 4]  547     sub b                       ;si al restar obtengo negativo, es porque los pies del personaje estan por encima del tesoro, y por tanto no chocan
   6F52 38 04         [12]  548     jr c, spccml_poner_a_a_0
   6F54 3E 01         [ 7]  549     ld a, #1
   6F56 18 02         [12]  550     jr fin_funcion_spccml
   6F58                     551 spccml_poner_a_a_0:    
   6F58 3E 00         [ 7]  552     ld a, #0
   6F5A                     553 fin_funcion_spccml:
   6F5A C9            [10]  554 ret  
                            555 
                            556 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            557 ;;
                            558 ;; FUNCION PARA COMPROBAR SI EL PERSONAJE CHOCA CONTRA CON ALGUNA PLATAFORMA QUE ESTE A SU DERECHA
                            559 ;;
                            560 ;; Descripcion
                            561 ;; 
                            562 ;; Parametros de entrada
                            563 ;;
                            564 ;; Parametros de salida
                            565 ;; - IX: Puntero a una entidad plataforma
                            566 ;; - IY: Puntero a la entidad personaje
                            567 ;; - A: 1 si el personaje choca contra alguna plataforma, 0 si no chocan
                            568 ;;
                            569 ;; Modifica los registros
                            570 ;; AF, B, DE, IX, IY
                            571 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6F5B                     572 sys_physics_check_all_collisions_move_right:
                            573     ;cargo en IY el puntero del personaje
                            574 ;    call man_entity_put_player_in_iy
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 16.
Hexadecimal [16-Bits]



                            575     ;hay que recorrer todos los objetos de tipo plataforma del juego.
                            576     ;cargo el puntero a la primera entidad en el registro IX
   6F5B CD 0D 62      [17]  577     call man_entity_put_platforms_in_iy
   6F5E CD BB 61      [17]  578     call getNumEntities
   6F61 0E 03         [ 7]  579     ld c, #3
   6F63 91            [ 4]  580     sub c
   6F64 4F            [ 4]  581     ld c, a              ;cargo el numero de entidades menos cuatro, que son el personaje, la lava, la puerta y el tesoro 
   6F65                     582 bucle_spcacmr:    
   6F65 CD 7D 6F      [17]  583     call sys_physics_check_collisions_move_right        ;compruebo que no chocan el personaje yl tesoro actual
   6F68 FE 01         [ 7]  584     cp a, #1
   6F6A 28 0E         [12]  585     jr z, spcacmr_return_1                              ;si chocan, he acabado el bucle y retorno 1
                            586     ;si no, hago la siguiente iteracion del bucle
   6F6C                     587 spcacmr_preparar_siguiente_iteracion:
   6F6C 0D            [ 4]  588     dec c
   6F6D 28 07         [12]  589     jr z, spcacmr_return_0                  ;si ya no me quedan entidades que revisar, salgo del bucle y retorno 0
                            590     ;si no, paso a la siguiente plataforma a comprobar y vuelvo al principio del bucle
   6F6F 11 11 00      [10]  591     ld de, #entity_size
   6F72 FD 19         [15]  592     add iy, de                              ;siguiente plataforma
   6F74 18 EF         [12]  593     jr bucle_spcacmr
   6F76                     594 spcacmr_return_0:
   6F76 3E 00         [ 7]  595     ld a, #0
   6F78 18 02         [12]  596     jr fin_funcion_spcacmr
   6F7A                     597 spcacmr_return_1:
   6F7A 3E 01         [ 7]  598     ld a, #1
   6F7C                     599 fin_funcion_spcacmr:    
   6F7C C9            [10]  600 ret
                            601 
                            602 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            603 ;;
                            604 ;; FUNCION PARA COMPROBAR SI EL PERSONAJE CHOCA A LA DERECHA CON UN OBJETO CONCRETO
                            605 ;;
                            606 ;; Descripcion
                            607 ;;   Comprueba si las coordenadas X e Y del personaje y una entidad indicada se solapan en algun punto.
                            608 ;;
                            609 ;; Parametros de entrada
                            610 ;; - IX: puntero a la entidad plataforma
                            611 ;; - IY: puntero a la entidad personaje
                            612 ;;
                            613 ;; Parametros de salida
                            614 ;; - A: 1 si el personaje choca contra alguna plataforma, 0 si no chocan
                            615 ;;
                            616 ;; Modifica los registros
                            617 ;; AF, B
                            618 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6F7D                     619 sys_physics_check_collisions_move_right:
                            620     ;obtengo la coordenada X del personaje y le sumo su anchura
   6F7D DD 7E 0F      [19]  621     ld a, e_x(ix)
   6F80 DD 46 03      [19]  622     ld b, e_w(ix)
   6F83 80            [ 4]  623     add b
   6F84 FD 46 0F      [19]  624     ld b, e_x(iy)               ;cargo la coordenada X del tesoro
   6F87 B8            [ 4]  625     cp b                        ;comparo ambas coordenadas X a ver si son iguales
   6F88 20 20         [12]  626     jr nz, spccmr_poner_a_a_0   ;si son distintas, he terminado de comprobar porque el pj yl tesoro están a distinta distancia
                            627     ;si son iguales, entonces he detectado que el personaje puede estar golpeando esa plataforma concreta. Hay que comprobar la coordenada Y
   6F8A DD 7E 10      [19]  628     ld a, e_y(ix)               ;cargo la coordenada Y del personaje
   6F8D DD 46 02      [19]  629     ld b, e_h(ix)               ;cargo la altura del personaje y los sumo
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 17.
Hexadecimal [16-Bits]



   6F90 80            [ 4]  630     add b
   6F91 47            [ 4]  631     ld b, a                     ;guardo el valor de la cabeza en el registro B
   6F92 FD 7E 10      [19]  632     ld a, e_y(iy)               ;cargo la coordenada Y del tesoro               
   6F95 90            [ 4]  633     sub b                       ;si al restar, obtengo negativo, es porque la cabeza del personaje esta por debajo que la parte inferior del tesoro, por lo que no se tocan
   6F96 30 12         [12]  634     jr nc, spccmr_poner_a_a_0
                            635     ;pero si el carry es cero, hay que comprobar los pies del personaje
   6F98 FD 7E 10      [19]  636     ld a, e_y(iy)               ;cargo la coordenada Y del tesoro
   6F9B FD 46 02      [19]  637     ld b, e_h(iy)               ;cargo la altura del tesoro y las sumo
   6F9E 80            [ 4]  638     add b
   6F9F 3D            [ 4]  639     dec a
   6FA0 DD 46 10      [19]  640     ld b, e_y(ix)               ;cargo la coordenada Y del personaje (los pies)
   6FA3 90            [ 4]  641     sub b                       ;si al restar obtengo negativo, es porque los pies del personaje estan por encima del tesoro, y por tanto no chocan
   6FA4 38 04         [12]  642     jr c, spccmr_poner_a_a_0
   6FA6 3E 01         [ 7]  643     ld a, #1
   6FA8 18 02         [12]  644     jr fin_funcion_spccmr
   6FAA                     645 spccmr_poner_a_a_0:    
   6FAA 3E 00         [ 7]  646     ld a, #0
   6FAC                     647 fin_funcion_spccmr:
   6FAC C9            [10]  648 ret
                            649 
                            650 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            651 ;;
                            652 ;; FUNCION DE CHOQUE DEL JUGADOR CON EL DIAMANTE
                            653 ;;
                            654 ;; Descripcion
                            655 ;;
                            656 ;; Parametros de entrada
                            657 ;; - IX: Puntero de la entidad que se mueve y colisiona
                            658 ;; - IY: Puntero de la entidad que esta fija y algo choca contra ella
                            659 ;; Parametros de salida
                            660 ;;
                            661 ;; Modifica los registros
                            662 ;;
                            663 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6FAD                     664 sys_physics_check_collision:
                            665     ; EJE HORIZONTAL
                            666     ; IY < IX
   6FAD FD 7E 0F      [19]  667     ld a, e_x(iy)           ;Coordenada X del tesoro
   6FB0 47            [ 4]  668     ld b, a                 ;Muevo a b para usarlo más tarde
   6FB1 FD 86 03      [19]  669     add e_w(iy)
   6FB4 DD 4E 0F      [19]  670     ld c, e_x(ix)           ;Anchura del tesoro. La cargo en C para reutilizar mas abajo
   6FB7 91            [ 4]  671     sub c                   ;Coordenada X del personaje
   6FB8 D8            [11]  672     ret c                   ;Si la resta es < 0, Carry = 1. No hay colision. Fin de la funcion
                            673     ; IX < IY
   6FB9 79            [ 4]  674     ld a, c                 ;Coordenada X del personaje
   6FBA DD 86 03      [19]  675     add e_w(ix)             ;Anchura de del personaje. La sumo directamente
   6FBD 90            [ 4]  676     sub b                   ;Resto la coordenada X del tesoro
   6FBE D8            [11]  677     ret c                   ;Si la resta es < 0, Carry = 1. No hay colision. Fin de la funcion
                            678     ; EJE VERTICAL
                            679     ; IY < IX
   6FBF FD 7E 10      [19]  680     ld a, e_y(iy)           ;Coordenada Y del tesoro
   6FC2 47            [ 4]  681     ld b, a                 ;Muevo a b para usarlo más tarde
   6FC3 FD 86 02      [19]  682     add e_h(iy)
   6FC6 DD 4E 10      [19]  683     ld c, e_y(ix)           ;Altura del tesoro. La cargo en C para reutilizar mas abajo
   6FC9 91            [ 4]  684     sub c                   ;Coordenada Y del personaje
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 18.
Hexadecimal [16-Bits]



   6FCA D8            [11]  685     ret c                   ;Si la resta es < 0, Carry = 1. No hay colision. Fin de la funcion
                            686     ; IX < IY
   6FCB 79            [ 4]  687     ld a, c                 ;Coordenada Y del personaje
   6FCC DD 86 02      [19]  688     add e_h(ix)             ;Altura de del personaje. La sumo directamente
   6FCF 90            [ 4]  689     sub b                   ;Resto la coordenada Y del tesoro
                            690     ;No es necesario hacer el ultimo ret. El carry se respeta al volver, y es lo que hay que usar como retorno de la funcion   
   6FD0 C9            [10]  691 ret
                            692 
                            693 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                            694 ;;
                            695 ;; FUNCION DE CHOQUE DEL JUGADOR CON LA PUERTA
                            696 ;;
                            697 ;; Descripcion
                            698 ;;
                            699 ;; La funcion va a reutilizar componentes de la puerta que no se usan, para construir una bounding box mas pequeña. Las componentes son:
                            700 ;;
                            701 ;; Nueva X: E_vX
                            702 ;; Nueva Y: E_VY
                            703 ;; Nueva H: E_ALTURA_SALTO
                            704 ;; Nueva W: E_MAXY
                            705 ;;
                            706 ;;
                            707 ;; Parametros de entrada
                            708 ;; - IX: Puntero de la entidad que se mueve y colisiona
                            709 ;; - IY: Puntero de la entidad que esta fija y algo choca contra ella
                            710 ;; Parametros de salida
                            711 ;;
                            712 ;; Modifica los registros
                            713 ;;
                            714 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   6FD1                     715 sys_physics_check_door_collision:
                            716     ; EJE HORIZONTAL
                            717     ; IY < IX
   6FD1 FD 7E 04      [19]  718     ld a, e_vx(iy)           ;Coordenada X del tesoro
   6FD4 47            [ 4]  719     ld b, a                 ;Muevo a b para usarlo más tarde
   6FD5 FD 86 07      [19]  720     add e_maxy(iy)
   6FD8 DD 4E 0F      [19]  721     ld c, e_x(ix)           ;Anchura del tesoro. La cargo en C para reutilizar mas abajo
   6FDB 91            [ 4]  722     sub c                   ;Coordenada X del personaje
   6FDC D8            [11]  723     ret c                   ;Si la resta es < 0, Carry = 1. No hay colision. Fin de la funcion
                            724     ; IX < IY
   6FDD 79            [ 4]  725     ld a, c                 ;Coordenada X del personaje
   6FDE DD 86 03      [19]  726     add e_w(ix)             ;Anchura de del personaje. La sumo directamente
   6FE1 90            [ 4]  727     sub b                   ;Resto la coordenada X del tesoro
   6FE2 D8            [11]  728     ret c                   ;Si la resta es < 0, Carry = 1. No hay colision. Fin de la funcion
                            729     ; EJE VERTICAL
                            730     ; IY < IX
   6FE3 FD 7E 05      [19]  731     ld a, e_vy(iy)           ;Coordenada Y del tesoro
   6FE6 47            [ 4]  732     ld b, a                 ;Muevo a b para usarlo más tarde
   6FE7 FD 86 06      [19]  733     add e_altura_salto(iy)
   6FEA DD 4E 10      [19]  734     ld c, e_y(ix)           ;Altura del tesoro. La cargo en C para reutilizar mas abajo
   6FED 91            [ 4]  735     sub c                   ;Coordenada Y del personaje
   6FEE D8            [11]  736     ret c                   ;Si la resta es < 0, Carry = 1. No hay colision. Fin de la funcion
                            737     ; IX < IY
   6FEF 79            [ 4]  738     ld a, c                 ;Coordenada Y del personaje
   6FF0 DD 86 02      [19]  739     add e_h(ix)             ;Altura de del personaje. La sumo directamente
ASxxxx Assembler V02.00 + NoICE + SDCC mods  (Zilog Z80 / Hitachi HD64180), page 19.
Hexadecimal [16-Bits]



   6FF3 90            [ 4]  740     sub b                   ;Resto la coordenada Y del tesoro
                            741     ;No es necesario hacer el ultimo ret. El carry se respeta al volver, y es lo que hay que usar como retorno de la funcion   
   6FF4 C9            [10]  742 ret
