API tools faq
paste
NightFox

Spirits DS - Character controller

NightFox
Mar 12th, 2013
325
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 31.98 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. -------------------------------------------------
  3.  
  4.     Spirits DS
  5.  
  6.     Archivo de funciones del personaje
  7.  
  8.     Requiere DevkitARM
  9.     Requiere NightFox's Lib
  10.  
  11.     Codigo por NightFox
  12.     http://www.nightfoxandco.com
  13.     Inicio 02 de Septiembre del 2011
  14.  
  15.     (c)2008 - 2012 NightFox & Co.
  16.  
  17. -------------------------------------------------
  18. */
  19.  
  20.  
  21.  
  22. /*
  23. -------------------------------------------------
  24.     Includes
  25. -------------------------------------------------
  26. */
  27.  
  28. // Includes C
  29. #include <stdio.h>
  30.  
  31. // Includes propietarios NDS
  32. #include <nds.h>
  33.  
  34. // Includes librerias propias
  35. #include <nf_lib.h>
  36.  
  37. // Includes del juego
  38. #include "includes.h"
  39.  
  40.  
  41.  
  42. // Funcion CharacterMain();
  43. void CharacterMain(void) {
  44.    
  45.     // Mueve el personaje
  46.     CharacterMove();
  47.     // Obtencion de objetos
  48.     CharacterGetItem();
  49.  
  50. }
  51.  
  52.  
  53.  
  54. // Funcion CharacterCheckRight();
  55. u16 CharacterCheckRight(s8 add) {
  56.  
  57.     // Variables
  58.     s32 x, y;
  59.     s32 fx, fy;
  60.     s32 start, end;
  61.     s16 tile = 0;
  62.     s16 result = T_AIR;
  63.  
  64.     // Variables de posicion
  65.     fx = (CHARACTER.pos_fx >> 8);
  66.     fy = (CHARACTER.pos_fy >> 8);
  67.  
  68.     // Calcula el rango de tiles a analizar
  69.     x = (fx + CHARACTER.right + add);
  70.     start = (fy - CHARACTER.up[0]);
  71.     end = (fy + CHARACTER.down);
  72.  
  73.     // Analiza los tiles del lateral (steps de 1/2 tile)
  74.     for (y = start; y <= end; y += 4) {
  75.         tile = NF_GetTile(MAINMAP_SLOT, x, y);
  76.         // Si el tile es pared...
  77.         if (tile == T_WALL) {
  78.             result = T_WALL;
  79.             y = end;
  80.         }
  81.     }
  82.  
  83.     // Devuelve el resultado
  84.     return result;
  85.  
  86. }
  87.  
  88.  
  89.  
  90. // Funcion CharacterCheckLeft();
  91. u16 CharacterCheckLeft(s8 add) {
  92.  
  93.     // Variables
  94.     s32 x, y;
  95.     s32 fx, fy;
  96.     s32 start, end;
  97.     s16 tile = 0;
  98.     s16 result = T_AIR;
  99.  
  100.     // Variables de posicion
  101.     fx = (CHARACTER.pos_fx >> 8);
  102.     fy = (CHARACTER.pos_fy >> 8);
  103.  
  104.     // Calcula el rango de tiles a analizar
  105.     x = (fx - CHARACTER.left - add);
  106.     start = (fy - CHARACTER.up[0]);
  107.     end = (fy + CHARACTER.down);
  108.  
  109.     // Analiza los tiles del lateral (steps de 1/2 tile)
  110.     for (y = start; y <= end; y += 4) {
  111.         tile = NF_GetTile(MAINMAP_SLOT, x, y);
  112.         // Si el tile es pared...
  113.         if (tile == T_WALL) {
  114.             result = T_WALL;
  115.             y = end;
  116.         }
  117.     }
  118.  
  119.     // Devuelve el resultado
  120.     return result;
  121.  
  122. }
  123.  
  124.  
  125.  
  126. // Funcion CharacterCheckUp();
  127. u16 CharacterCheckUp(s8 add) {
  128.  
  129.     // Variables
  130.     s32 x, y;
  131.     s32 fx, fy;
  132.     s32 start, end;
  133.     s16 tile = 0;
  134.     s16 result = T_AIR;
  135.     s16 air = 0, stair = 0;
  136.  
  137.     // Variables de posicion
  138.     fx = (CHARACTER.pos_fx >> 8);
  139.     fy = (CHARACTER.pos_fy >> 8);
  140.  
  141.     // Calcula el rango de tiles a analizar
  142.     y = (fy - CHARACTER.up[0] - add);
  143.     start = (fx - CHARACTER.left);
  144.     end = (fx + CHARACTER.right);
  145.  
  146.     // Analiza los tiles del lateral (steps de 1 pixel)
  147.     for (x = start; x <= end; x ++) {
  148.         tile = NF_GetTile(MAINMAP_SLOT, x, y);
  149.         // Si el tile es pared o puerta cerrada...
  150.         switch (tile) {
  151.             case T_WALL:    // Muros
  152.                 result = T_WALL;
  153.                 x = end;
  154.                 break;
  155.             case T_STAIR:   // Escalera
  156.                 stair ++;
  157.                 break;
  158.             case T_AIR:     // Aire
  159.                 air ++;
  160.                 break;
  161.             default:        // Nada
  162.                 break;
  163.         }
  164.     }
  165.  
  166.     // Si no hay muro, decide el resultado
  167.     if (result != T_WALL) {
  168.         // Decide si es aire o pared
  169.         if (air >= stair) {
  170.             result = T_AIR;
  171.         } else {
  172.             result = T_STAIR;
  173.         }
  174.         // Verifica si se la pulsado algun interruptor
  175.         tile = NF_GetTile(MAINMAP_SLOT, CHARACTER.pos_x, y);
  176.         switch (tile) {
  177.             case T_SWITCH_A:
  178.                 result = T_SWITCH_A;
  179.                 break;
  180.             case T_SWITCH_B:
  181.                 result = T_SWITCH_B;
  182.                 break;
  183.             case T_SWITCH_C:
  184.                 result = T_SWITCH_C;
  185.                 break;
  186.             case T_SWITCH_D:
  187.                 result = T_SWITCH_D;
  188.                 break;
  189.             case T_SWITCH_E:
  190.                 result = T_SWITCH_E;
  191.                 break;
  192.             default:    // Nada
  193.                 break;
  194.         }
  195.     }
  196.  
  197.     // Devuelve el resultado
  198.     return result;
  199.  
  200. }
  201.  
  202.  
  203.  
  204. // Funcion CharacterCheckDown();
  205. u16 CharacterCheckDown(s8 add) {
  206.  
  207.     // Variables
  208.     s32 x, y;
  209.     s32 fx, fy;
  210.     s32 start, end;
  211.     s16 tile = 0;
  212.     s16 result = T_AIR;
  213.     s16 air = 0, stair = 0;
  214.  
  215.     // Variables de posicion
  216.     fx = (CHARACTER.pos_fx >> 8);
  217.     fy = (CHARACTER.pos_fy >> 8);
  218.  
  219.     // Calcula el rango de tiles a analizar
  220.     y = (fy + CHARACTER.down + add);
  221.     start = (fx - CHARACTER.left);
  222.     end = (fx + CHARACTER.right);
  223.  
  224.     // Analiza los tiles abajo (steps de 1 pixel)
  225.     for (x = start; x <= end; x ++) {
  226.         tile = NF_GetTile(MAINMAP_SLOT, x, y);
  227.         // Si el tile es pared o puerta cerrada...
  228.         switch (tile) {
  229.             case T_WALL:    // Muros
  230.                 result = T_WALL;
  231.                 x = end;
  232.                 break;
  233.             case T_STEEP:   // Escalon
  234.                 result = T_STEEP;
  235.                 x = end;
  236.                 break;
  237.             case T_STAIR:   // Escaleras
  238.                 stair ++;
  239.                 break;
  240.             case T_AIR:     // Aire
  241.                 air ++;
  242.                 break;
  243.             default:        // Nada
  244.                 break;
  245.         }
  246.     }
  247.  
  248.     // Si no hay muro o escalon, decide el resultado
  249.     if ((result != T_WALL) && (result != T_STEEP)) {
  250.         // Decide si es aire o pared
  251.         if (air >= stair) {
  252.             result = T_AIR;
  253.         } else {
  254.             result = T_STAIR;
  255.         }
  256.     }
  257.  
  258.     // Devuelve el resultado
  259.     return result;
  260.  
  261. }
  262.  
  263.  
  264.  
  265. // Funcion CharacterFall();
  266. void CharacterFall(void) {
  267.  
  268.     /*
  269.     -------------------------------------------------
  270.         Variables
  271.     -------------------------------------------------
  272.     */
  273.  
  274.     u16 t_down = T_AIR;
  275.     u16 t_inside = T_AIR;
  276.  
  277.  
  278.     /*
  279.     -------------------------------------------------
  280.         Analiza las posibilidades
  281.     -------------------------------------------------
  282.     */
  283.  
  284.     // Obten el tile inferior
  285.     t_down = CharacterCheckDown(1);
  286.  
  287.     // Calcula si te vas a caer
  288.     if (((t_down == T_AIR) && !CHARACTER.is_jump) || ((t_down == T_STEEP) && CHARACTER.force_down)) {
  289.         // Registra la coordenada de inicio de caida
  290.         if (!CHARACTER.fall) CHARACTER.fall_y = CHARACTER.pos_y;
  291.         // Se va a caer
  292.         CHARACTER.fall = true;
  293.         // Aceleracion inicial de la caida
  294.         if (CHARACTER.air_speed == 0) {
  295.             CHARACTER.air_speed = CHARACTER_AIR_MIN_SPEED;
  296.         }
  297.     } else {
  298.         CHARACTER.fall = false;
  299.     }
  300.  
  301.  
  302.     /*
  303.     -------------------------------------------------
  304.         Aplica las acciones
  305.     -------------------------------------------------
  306.     */
  307.  
  308.     // El personaje se cae
  309.     if (CHARACTER.fall) {
  310.         // Nueva posicion
  311.         CHARACTER.pos_fy += CHARACTER.air_speed;
  312.         // Calcula si te sales de los limites...
  313.         t_down = CharacterCheckDown(1);
  314.         if ((t_down == T_WALL) || (t_down == T_STEEP)) {
  315.             // Si encuentras un muro
  316.             if (t_down == T_WALL) {
  317.                 // Deten la caida
  318.                 CHARACTER.fall = false;
  319.                 CHARACTER.air_speed = 0;
  320.                 // Calcula si se pierde vida con la caida
  321.                 FallDamage();
  322.                 // Ajusta el personaje al nivel del suelo/escalon
  323.                 t_inside = CharacterCheckDown(0);
  324.                 while (t_inside == T_WALL) {
  325.                     // Ajusta la posicion
  326.                     CHARACTER.pos_fy -= 64;
  327.                     // Verifica de nuevo
  328.                     t_inside = CharacterCheckDown(0);
  329.                 }
  330.             }
  331.             // Si encuentras un escalon
  332.             if (t_down == T_STEEP) {
  333.                 // Si no estas en un forzado de caida, ajustalo
  334.                 if (!CHARACTER.force_down) {
  335.                     // Deten la caida
  336.                     CHARACTER.fall = false;
  337.                     CHARACTER.air_speed = 0;
  338.                     // Calcula si se pierde vida con la caida
  339.                     FallDamage();
  340.                     // Ajusta el personaje al nivel del suelo/escalon
  341.                     t_inside = CharacterCheckDown(0);
  342.                     while (t_inside == T_STEEP) {
  343.                         // Ajusta la posicion
  344.                         CHARACTER.pos_fy -= 64;
  345.                         // Verifica de nuevo
  346.                         t_inside = CharacterCheckDown(0);
  347.                     }
  348.                 } else {
  349.                     // Aceleracion de la caida
  350.                     if (CHARACTER.air_speed < CHARACTER_AIR_MAX_SPEED) {
  351.                         CHARACTER.air_speed += (CHARACTER.air_speed >> 4);
  352.                         if (CHARACTER.air_speed > CHARACTER_AIR_MAX_SPEED) CHARACTER.air_speed = CHARACTER_AIR_MAX_SPEED;
  353.                     }
  354.                 }
  355.             }
  356.         } else {
  357.             // Aceleracion de la caida
  358.             if (CHARACTER.air_speed < CHARACTER_AIR_MAX_SPEED) {
  359.                 CHARACTER.air_speed += (CHARACTER.air_speed >> 4);
  360.                 if (CHARACTER.air_speed > CHARACTER_AIR_MAX_SPEED) CHARACTER.air_speed = CHARACTER_AIR_MAX_SPEED;
  361.             }
  362.         }
  363.         // Debes cancelar el forzado de caida?
  364.         if (CHARACTER.force_down && (t_down != T_STEEP)) CHARACTER.force_down = false;
  365.     }
  366.  
  367. }
  368.  
  369.  
  370. // Funcion CharacterStairs();
  371. void CharacterStairs(void) {
  372.  
  373.     /*
  374.     -------------------------------------------------
  375.         Variables
  376.     -------------------------------------------------
  377.     */
  378.  
  379.     u16 t_up = T_AIR, t_down = T_AIR;
  380.  
  381.  
  382.     /*
  383.     -------------------------------------------------
  384.         Analiza las posibilidades
  385.     -------------------------------------------------
  386.     */
  387.  
  388.     // Opten los tiles
  389.     t_up = CharacterCheckUp(1);
  390.     t_down = CharacterCheckDown(1);
  391.  
  392.     // Calcula si puedes subir la escalera
  393.     if (t_up == T_STAIR) {
  394.         CHARACTER.stair_up = true;
  395.     } else {
  396.         CHARACTER.stair_up = false;
  397.     }
  398.  
  399.     // Calcula si puedes bajar la escalera
  400.     if (t_down == T_STAIR) {
  401.         CHARACTER.stair_down = true;
  402.     } else {
  403.         CHARACTER.stair_down = false;
  404.     }
  405.  
  406.     // Calcula si estas colgado de una escalera
  407.     if ((t_up == T_STAIR) && (t_down == T_STAIR)) {
  408.         CHARACTER.in_stair = true;
  409.     } else {
  410.         CHARACTER.in_stair = false;
  411.     }
  412.  
  413.  
  414.     /*
  415.     -------------------------------------------------
  416.         Aplica las acciones
  417.     -------------------------------------------------
  418.     */
  419.  
  420.     // Si no estas saltando o cayendo...
  421.     if (!CHARACTER.is_jump && !CHARACTER.fall) {
  422.  
  423.         // Subir por la escalera
  424.         if (CHARACTER.stair_up && KEYHELD.up) {
  425.             // Nueva posicion
  426.             CHARACTER.pos_fy -= CHARACTER_WALK_SPEED;
  427.             // Resetea aceleracion en el aire
  428.             CHARACTER.air_speed = 0;
  429.         }
  430.  
  431.         // Bajar por la escalera
  432.         if (CHARACTER.stair_down && KEYHELD.down) {
  433.             // Nueva posicion
  434.             CHARACTER.pos_fy += CHARACTER_WALK_SPEED;
  435.             // Resetea aceleracion en el aire
  436.             CHARACTER.air_speed = 0;
  437.         }
  438.  
  439.     }
  440.  
  441. }
  442.  
  443.  
  444.  
  445. // Funcion CharacterJump();
  446. void CharacterJump(void) {
  447.  
  448.     /*
  449.     -------------------------------------------------
  450.         Variables
  451.     -------------------------------------------------
  452.     */
  453.  
  454.     u16 t_up = T_AIR, t_down = T_AIR, t_left = T_AIR, t_right = T_AIR, t_inside = T_AIR;
  455.  
  456.  
  457.     /*
  458.     -------------------------------------------------
  459.         Analiza las posibilidades
  460.     -------------------------------------------------
  461.     */
  462.  
  463.     // Calcula si puedes saltar
  464.     if (!CHARACTER.is_jump && !CHARACTER.fall && !CHARACTER.in_stair && !CHARACTER.stair_down && !CHARACTER.spell) {
  465.         CHARACTER.can_jump = true;
  466.     } else {
  467.         CHARACTER.can_jump = false;
  468.     }
  469.  
  470.  
  471.     /*
  472.     -------------------------------------------------
  473.         Se solicita que saltes con B?
  474.     -------------------------------------------------
  475.     */
  476.  
  477.     if (CHARACTER.can_jump && KEYPRESS.b && !KEYHELD.down) {
  478.         // Salta recto
  479.         if (!KEYHELD.left && !KEYHELD.right) {
  480.             CHARACTER.jump_direction = 0;
  481.         } else {
  482.             // Salta a la derecha
  483.             if (KEYHELD.right) CHARACTER.jump_direction = CHARACTER_JUMP_SIDE_SPEED;
  484.             // Salta a la izquierda
  485.             if (KEYHELD.left) CHARACTER.jump_direction = -CHARACTER_JUMP_SIDE_SPEED;
  486.         }
  487.         // Registra el salto
  488.         CHARACTER.can_jump = false;
  489.         CHARACTER.is_jump = true;
  490.         CHARACTER.jump_up = true;
  491.         CHARACTER.air_speed = CHARACTER_AIR_MAX_SPEED;
  492.         CHARACTER.jump_height = 0;
  493.     }
  494.  
  495.  
  496.     /*
  497.     -------------------------------------------------
  498.         Se solicita que te descuelgues con B?
  499.     -------------------------------------------------
  500.     */
  501.  
  502.     if (CHARACTER.can_jump && KEYPRESS.b && KEYHELD.down) CHARACTER.force_down = true;
  503.  
  504.  
  505.     /*
  506.     -------------------------------------------------
  507.         Ejecuta el salto
  508.     -------------------------------------------------
  509.     */
  510.  
  511.     if (CHARACTER.is_jump) {
  512.  
  513.         // Si hay movimiento lateral...
  514.         if (CHARACTER.jump_direction != 0) {
  515.             // Calculos de posicion lateral y altura del salto
  516.             CHARACTER.pos_fx += CHARACTER.jump_direction;
  517.             if (CHARACTER.jump_direction > 0) {
  518.                 // Ajusta el limite derecho
  519.                 t_right = CharacterCheckRight(0);
  520.                 while (t_right == T_WALL) {
  521.                     CHARACTER.pos_fx -= 64;
  522.                     t_right = CharacterCheckRight(0);
  523.                 }
  524.             } else {
  525.                 // Ajusta el limite izquierdo
  526.                 t_left = CharacterCheckLeft(0);
  527.                 while (t_left == T_WALL) {
  528.                     CHARACTER.pos_fx += 64;
  529.                     t_left = CharacterCheckLeft(0);
  530.                 }
  531.             }
  532.         }
  533.        
  534.         // Salto ascendente?
  535.         if (CHARACTER.jump_up) {
  536.  
  537.             // Calcula la nueva posicion
  538.             CHARACTER.pos_fy -= CHARACTER.air_speed;
  539.             CHARACTER.jump_height += CHARACTER.air_speed;
  540.             // Y verifica las colisiones
  541.             t_up = CharacterCheckUp(1);
  542.             // Y si has terminado de ascender
  543.             if ((CHARACTER.jump_height >= CHARACTER_JUMP_MAX_HEIGHT) || !KEYHELD.b || (t_up == T_WALL)) {
  544.                 // Registra la altura maxima del salto
  545.                 CHARACTER.fall_y = CHARACTER.pos_y;
  546.                 // Indicalo
  547.                 CHARACTER.jump_up = false;
  548.                 // Marca que estas a medio escalon
  549.                 t_inside = CharacterCheckDown(0);
  550.                 if (t_inside == T_STEEP) CHARACTER.force_down = true;
  551.                 // Ajusta la posicion del personaje
  552.                 t_up = CharacterCheckUp(0);
  553.                 while (t_up == T_WALL) {
  554.                     CHARACTER.pos_fy += 64;
  555.                     t_up = CharacterCheckUp(0);
  556.                 }
  557.             } else {
  558.                 // Si no, calcula la nueva aceleracion
  559.                 if (CHARACTER.air_speed > CHARACTER_AIR_MIN_SPEED) {
  560.                     CHARACTER.air_speed -= (CHARACTER.air_speed >> 4);
  561.                     if (CHARACTER.air_speed < CHARACTER_AIR_MIN_SPEED) CHARACTER.air_speed = CHARACTER_AIR_MIN_SPEED;
  562.                 }
  563.             }
  564.  
  565.         } else {    // Descenso del salto
  566.  
  567.             // Calcula la nueva posicion
  568.             CHARACTER.pos_fy += CHARACTER.air_speed;
  569.             CHARACTER.jump_height -= CHARACTER.air_speed;
  570.             // Y verifica las colisiones
  571.             t_up = CharacterCheckUp(1);
  572.             t_down = CharacterCheckDown(1);
  573.             // Y si has terminado de descender
  574.             if ((t_down == T_WALL) || (t_down == T_STEEP) || ((t_up == T_STAIR) && (t_down == T_STAIR) && KEYHELD.up)) {
  575.                 // Tocas un muro
  576.                 if (t_down == T_WALL) {
  577.                     // Cancela el salto
  578.                     CHARACTER.is_jump = false;
  579.                     // Borra la aceleracion en el aire si has tocado el suelo
  580.                     CHARACTER.air_speed = 0;
  581.                     // Ajusta la posicion del personaje
  582.                     t_inside = CharacterCheckDown(0);
  583.                     while (t_inside == T_WALL) {
  584.                         CHARACTER.pos_fy -= 64;
  585.                         t_inside = CharacterCheckDown(0);
  586.                     }
  587.                     // Calcula si se pierde vida con la caida
  588.                     FallDamage();
  589.                 }
  590.                 // Estas en una escalera
  591.                 if (((t_up == T_STAIR) && (t_down == T_STAIR) && KEYHELD.up)) {
  592.                     // Cancela el salto
  593.                     CHARACTER.is_jump = false;
  594.                     // Borra la aceleracion en el aire si has tocado el suelo
  595.                     CHARACTER.air_speed = 0;
  596.                 }
  597.                 // Tocas un escalon
  598.                 if (t_down == T_STEEP) {
  599.                     // Si no estas en un forzado de caida, ajustalo
  600.                     if (!CHARACTER.force_down) {
  601.                         // Deten la caida
  602.                         CHARACTER.is_jump = false;
  603.                         CHARACTER.air_speed = 0;
  604.                         // Ajusta el personaje al nivel del suelo/escalon
  605.                         t_inside = CharacterCheckDown(0);
  606.                         while (t_inside == T_STEEP) {
  607.                             // Ajusta la posicion
  608.                             CHARACTER.pos_fy -= 64;
  609.                             // Verifica de nuevo
  610.                             t_inside = CharacterCheckDown(0);
  611.                         }
  612.                         // Calcula si se pierde vida con la caida
  613.                         FallDamage();
  614.                     } else {
  615.                         // Si no, calcula la nueva aceleracion
  616.                         if (CHARACTER.air_speed < CHARACTER_AIR_MAX_SPEED) {
  617.                             CHARACTER.air_speed += (CHARACTER.air_speed >> 4);
  618.                             if (CHARACTER.air_speed > CHARACTER_AIR_MAX_SPEED) CHARACTER.air_speed = CHARACTER_AIR_MAX_SPEED;
  619.                         }
  620.                     }
  621.                 }
  622.             } else {
  623.                 // Si no, calcula la nueva aceleracion
  624.                 if (CHARACTER.air_speed < CHARACTER_AIR_MAX_SPEED) {
  625.                     CHARACTER.air_speed += (CHARACTER.air_speed >> 4);
  626.                     if (CHARACTER.air_speed > CHARACTER_AIR_MAX_SPEED) CHARACTER.air_speed = CHARACTER_AIR_MAX_SPEED;
  627.                 }
  628.             }
  629.  
  630.             // Debes cancelar el forzado de caida?
  631.             if (CHARACTER.force_down && (t_down != T_STEEP)) CHARACTER.force_down = false;
  632.  
  633.         }
  634.  
  635.     }
  636.  
  637. }
  638.  
  639.  
  640.  
  641. // Funcion CharacterWalk();
  642. void CharacterWalk(void) {
  643.  
  644.     /*
  645.     -------------------------------------------------
  646.         Variables
  647.     -------------------------------------------------
  648.     */
  649.  
  650.     u16 t_left = T_AIR, t_right = T_AIR;    // Almacena los tiles
  651.  
  652.  
  653.     /*
  654.     -------------------------------------------------
  655.         Analiza las posibilidades
  656.     -------------------------------------------------
  657.     */
  658.  
  659.     // Analiza los tiles de alrededor
  660.     t_left = CharacterCheckLeft(1);
  661.     t_right = CharacterCheckRight(1);
  662.  
  663.     // Calcula si puedes ir a la derecha
  664.     if ((t_right != T_WALL) && !CHARACTER.fall && !CHARACTER.is_jump) {
  665.         CHARACTER.mov_right = true;
  666.     } else {
  667.         CHARACTER.mov_right = false;
  668.     }
  669.  
  670.     // Calcula si puedes ir a la izquierda
  671.     if ((t_left != T_WALL) && !CHARACTER.fall && !CHARACTER.is_jump) {
  672.         CHARACTER.mov_left = true;
  673.     } else {
  674.         CHARACTER.mov_left = false;
  675.     }
  676.  
  677.  
  678.     /*
  679.     -------------------------------------------------
  680.         Aplica las acciones
  681.     -------------------------------------------------
  682.     */
  683.  
  684.     // Si no estas presionando arriba/abajo
  685.     if (!KEYHELD.up && !KEYHELD.down) {
  686.  
  687.         // Andar a la derecha
  688.         if (KEYHELD.right && CHARACTER.mov_right) {
  689.             // Nueva posicion
  690.             CHARACTER.pos_fx += CHARACTER_WALK_SPEED;
  691.             // Resetea aceleracion en el aire
  692.             CHARACTER.air_speed = 0;
  693.         }
  694.  
  695.         // Andar a la izquierda
  696.         if (KEYHELD.left && CHARACTER.mov_left) {
  697.             // Nueva posicion
  698.             CHARACTER.pos_fx -= CHARACTER_WALK_SPEED;
  699.             // Resetea aceleracion en el aire
  700.             CHARACTER.air_speed = 0;
  701.         }
  702.  
  703.     }
  704.  
  705. }
  706.  
  707.  
  708.  
  709. // Funcion CharacterAdjustPosition();
  710. void CharacterAdjustPosition(void) {
  711.  
  712.     /*
  713.     -------------------------------------------------
  714.         Variables
  715.     -------------------------------------------------
  716.     */
  717.  
  718.     u16 t_left = T_AIR, t_right = T_AIR, t_down = T_AIR;    // Almacena los tiles
  719.  
  720.  
  721.     /*
  722.     -------------------------------------------------
  723.         Ajusta el personaje a derecha e izquierda
  724.     -------------------------------------------------
  725.     */
  726.  
  727.     // Ajusta el limite derecho
  728.     t_right = CharacterCheckRight(0);
  729.     // Si estavas a medio salto, cancela el desplazamiento lateral
  730.     if (CHARACTER.is_jump && (CHARACTER.jump_direction > 0) && (t_right == T_WALL)) CHARACTER.jump_direction = 0;
  731.     // Ajusta la posicion a la derecha
  732.     while (t_right == T_WALL) {
  733.         CHARACTER.pos_fx -= 64;
  734.         t_right = CharacterCheckRight(0);
  735.     }
  736.  
  737.     // Ajusta el limite izquierdo
  738.     t_left = CharacterCheckLeft(0);
  739.     // Si estavas a medio salto, cancela el desplazamiento lateral
  740.     if (CHARACTER.is_jump && (CHARACTER.jump_direction < 0) && (t_left == T_WALL)) CHARACTER.jump_direction = 0;
  741.     // Ajusta la posicion de la izquierda
  742.     while (t_left == T_WALL) {
  743.         CHARACTER.pos_fx += 64;
  744.         t_left = CharacterCheckLeft(0);
  745.     }
  746.  
  747.     /*
  748.     -------------------------------------------------
  749.         Ajusta el nivel del suelo del personaje
  750.     -------------------------------------------------
  751.     */
  752.     t_down = CharacterCheckDown(0);
  753.     while (t_down == T_WALL) {
  754.         CHARACTER.pos_fy -= 64;
  755.         t_down = CharacterCheckDown(0);
  756.     }
  757.  
  758. }
  759.  
  760.  
  761.  
  762. // Funcion CharacterAnimation();
  763. void CharacterAnimation(void) {
  764.  
  765.     /*
  766.     -------------------------------------------------
  767.         Variables
  768.     -------------------------------------------------
  769.     */
  770.  
  771.     // Por defecto, no estas agachado
  772.     CHARACTER.duck = 0;
  773.  
  774.  
  775.     /*
  776.     -------------------------------------------------
  777.         Acciones
  778.     -------------------------------------------------
  779.     */
  780.  
  781.     // Juego de animaciones cayendo
  782.     if (CHARACTER.fall) {
  783.         // Si entras en esta animacion
  784.         if (CHARACTER.anim != CHARACTER_ANIM_FALL) {
  785.             CHARACTER.anim = CHARACTER_ANIM_FALL;
  786.             CHARACTER.frame = 12;
  787.             CHARACTER.frame_cnt = 0;
  788.         }
  789.         // Animacion caerse (Frames 12 a 13)
  790.         CHARACTER.frame_cnt ++;
  791.         if (CHARACTER.frame_cnt > 6) {
  792.             CHARACTER.frame_cnt = 0;
  793.             CHARACTER.frame ++;
  794.             if (CHARACTER.frame > 13) CHARACTER.frame = 12;
  795.         }
  796.     }
  797.  
  798.  
  799.     // Juego de animaciones saltando
  800.     if (CHARACTER.is_jump) {
  801.  
  802.         // Salto hacia arriba
  803.         if (CHARACTER.jump_up) {
  804.  
  805.             // Registra la animacion
  806.             if (CHARACTER.anim != CHARACTER_ANIM_JUMP) {
  807.                 CHARACTER.anim = CHARACTER_ANIM_JUMP;
  808.                 CHARACTER.frame_cnt = 0;
  809.             }
  810.             // Salto arriba (Frame 10)
  811.             CHARACTER.frame = 10;
  812.  
  813.         } else {    // Salto hacia abajo
  814.  
  815.             // Si aun estas en la altura del salto normal
  816.             if (CHARACTER.jump_height >= 0) {
  817.  
  818.                 // Salto abajo (Frame 11)
  819.                 CHARACTER.frame = 11;
  820.  
  821.             } else {    // Si estas cayendote...
  822.  
  823.                 // Si entras en esta animacion
  824.                 if (CHARACTER.anim != CHARACTER_ANIM_FALL) {
  825.                     CHARACTER.anim = CHARACTER_ANIM_FALL;
  826.                     CHARACTER.frame = 12;
  827.                     CHARACTER.frame_cnt = 0;
  828.                 }
  829.                 // Animacion caerse (Frames 12 a 13)
  830.                 CHARACTER.frame_cnt ++;
  831.                 if (CHARACTER.frame_cnt > 6) {
  832.                     CHARACTER.frame_cnt = 0;
  833.                     CHARACTER.frame ++;
  834.                     if (CHARACTER.frame > 13) CHARACTER.frame = 12;
  835.                 }
  836.  
  837.             }
  838.  
  839.         }
  840.  
  841.     }
  842.  
  843.  
  844.     // Juego de animaciones en la escalera
  845.     if ((CHARACTER.in_stair || CHARACTER.stair_down) && !CHARACTER.is_jump && !CHARACTER.fall) {
  846.         // Si entras en esta animacion
  847.         if (CHARACTER.anim != CHARACTER_ANIM_STAIRS) {
  848.             CHARACTER.anim = CHARACTER_ANIM_STAIRS;
  849.             CHARACTER.frame = 8;
  850.             CHARACTER.frame_cnt = 0;
  851.         }
  852.         // Animacion si puedes moverte
  853.         if (
  854.             (CHARACTER.stair_up && KEYHELD.up)
  855.             ||
  856.             (CHARACTER.stair_down && KEYHELD.down)
  857.             ||
  858.             (CHARACTER.mov_right && KEYHELD.right && !KEYHELD.up)
  859.             ||
  860.             (CHARACTER.mov_left && KEYHELD.left && !KEYHELD.up)
  861.             ) {
  862.             // Animacion moviendose por la escalera (Frames 8 a 9)
  863.             CHARACTER.frame_cnt ++;
  864.             if (CHARACTER.frame_cnt > 10) {
  865.                 CHARACTER.frame_cnt = 0;
  866.                 CHARACTER.frame ++;
  867.                 if (CHARACTER.frame > 9) CHARACTER.frame = 8;
  868.             }
  869.         }
  870.     }
  871.  
  872.     // Juego de animaciones en el suelo (Quieto, andar, agacharse, lanzar hechizo)
  873.     if (!CHARACTER.fall && !CHARACTER.in_stair && !CHARACTER.stair_down && !CHARACTER.is_jump) {
  874.  
  875.         // Si estas lanzando el hechizo...
  876.         if (CHARACTER.spell) {
  877.  
  878.             // Si entras en esta animacion
  879.             if (CHARACTER.anim != CHARACTER_ANIM_SPELL) {
  880.                 CHARACTER.anim = CHARACTER_ANIM_SPELL;
  881.                 CHARACTER.frame = 14;
  882.                 CHARACTER.frame_cnt = 0;
  883.             }
  884.             // Animacion andando (Frames 14 a 16)
  885.             CHARACTER.frame_cnt ++;
  886.             if (CHARACTER.frame_cnt > 5) {
  887.                 CHARACTER.frame_cnt = 0;
  888.                 CHARACTER.frame ++;
  889.                 // Si la animacion termina...
  890.                 if (CHARACTER.frame > 16) {
  891.                     CHARACTER.frame = 0;
  892.                     CHARACTER.spell = false;
  893.                 }
  894.             }
  895.  
  896.         } else {    // Si no estas lanzando el hechizo
  897.  
  898.             // Si no estas presionando arriba/abajo...
  899.             if (!KEYHELD.up && !KEYHELD.down) {
  900.            
  901.                 // Andar
  902.                 if ((CHARACTER.mov_right && KEYHELD.right) || (CHARACTER.mov_left && KEYHELD.left)) {
  903.                     // Si entras en esta animacion
  904.                     if (CHARACTER.anim != CHARACTER_ANIM_WALK) {
  905.                         CHARACTER.anim = CHARACTER_ANIM_WALK;
  906.                         CHARACTER.frame = 1;
  907.                         CHARACTER.frame_cnt = 0;
  908.                     }
  909.                     // Animacion andando (Frames 1 a 6)
  910.                     CHARACTER.frame_cnt ++;
  911.                     if (CHARACTER.frame_cnt > 5) {
  912.                         CHARACTER.frame_cnt = 0;
  913.                         CHARACTER.frame ++;
  914.                         if (CHARACTER.frame > 6) CHARACTER.frame = 1;
  915.                     }
  916.                 } else {
  917.                     // Quieto (Frame 0)
  918.                     CHARACTER.anim = CHARACTER_ANIM_STANDBY;
  919.                     CHARACTER.frame = 0;
  920.                     CHARACTER.frame_cnt = 0;
  921.                 }
  922.  
  923.             } else {
  924.  
  925.                 if (KEYHELD.down) {
  926.                     // Agachado (Frame 7)
  927.                     CHARACTER.anim = CHARACTER_ANIM_DUCK;
  928.                     CHARACTER.frame = 7;
  929.                     CHARACTER.frame_cnt = 0;
  930.                     CHARACTER.duck = 1;
  931.                 } else {
  932.                     // Quieto (Frame 0)
  933.                     CHARACTER.anim = CHARACTER_ANIM_STANDBY;
  934.                     CHARACTER.frame = 0;
  935.                     CHARACTER.frame_cnt = 0;
  936.                 }
  937.  
  938.             }
  939.  
  940.         }
  941.  
  942.     }
  943.  
  944.     // Calcula y marca la direccion a la que miras
  945.     if (
  946.         (CHARACTER.anim != CHARACTER_ANIM_FALL)
  947.         &&
  948.         (CHARACTER.anim != CHARACTER_ANIM_JUMP)
  949.         ) {
  950.         if (KEYHELD.right && CHARACTER.flip) CHARACTER.flip = false;
  951.         if (KEYHELD.left && !CHARACTER.flip) CHARACTER.flip = true;
  952.     }
  953.    
  954. }
  955.  
  956.  
  957.  
  958. // Funcion CharacterMove();
  959. void CharacterMove(void) {
  960.  
  961.     /*
  962.     -------------------------------------------------
  963.         Movimiento del personaje
  964.     -------------------------------------------------
  965.     */
  966.  
  967.     // Procesa si se cae
  968.     CharacterFall();
  969.  
  970.     // Procesa el salto
  971.     CharacterJump();
  972.  
  973.     // Procesa moverte por las escaleras
  974.     CharacterStairs();
  975.  
  976.     // Procesa el andar (si no estas disparando el hechizo)
  977.     if (!CHARACTER.spell) CharacterWalk();
  978.  
  979.     // Ajusta la posicion del personaje, para que no atraviese ningun limite
  980.     CharacterAdjustPosition();
  981.  
  982.     // Animacion del personaje
  983.     CharacterAnimation();
  984.  
  985.  
  986.     /*
  987.     -------------------------------------------------
  988.         Ajustes de posicion
  989.     -------------------------------------------------
  990.     */
  991.  
  992.     CHARACTER.pos_x = (CHARACTER.pos_fx >> 8);
  993.     CHARACTER.pos_y = (CHARACTER.pos_fy >> 8);
  994.     CHARACTER.stage = GetStage(CHARACTER.pos_x, CHARACTER.pos_y);
  995.  
  996.     /*
  997.     -------------------------------------------------
  998.         Invulnerable
  999.     -------------------------------------------------
  1000.     */
  1001.     if (CHARACTER.immunity > 0) {
  1002.         CHARACTER.immunity --;
  1003.         CHARACTER.show = !CHARACTER.show;
  1004.         if (CHARACTER.immunity == 0) {
  1005.             CHARACTER.show = true;
  1006.         }
  1007.     }
  1008.  
  1009. }
  1010.  
  1011.  
  1012.  
  1013. // Funcion CameraCharacterHide();
  1014. void CameraCharacterHide(u8 screen, u8 stage) {
  1015.  
  1016.     /*
  1017.     -------------------------------------------------
  1018.         Gestion del Personaje
  1019.     -------------------------------------------------
  1020.     */
  1021.  
  1022.     // Calcula la posicion del sprite en la pantalla
  1023.     s32 spr_x = (CHARACTER.pos_x - STAGE[stage].stg_left - CAMERA[screen].bg_x);
  1024.     s32 spr_y = (CHARACTER.pos_y - STAGE[stage].stg_top);
  1025.  
  1026.     // Calcula si esta en pantalla
  1027.     if (
  1028.         (spr_x < -32)
  1029.         ||
  1030.         (spr_x > 287)
  1031.         ||
  1032.         (spr_y < -32)
  1033.         ||
  1034.         (spr_y > 223)
  1035.         ) {
  1036.         // No lo esta
  1037.         CHARACTER.on_screen[screen] = false;
  1038.         CHARACTER.scr_x[screen] = -64;
  1039.         CHARACTER.scr_y[screen] = -64;
  1040.         // Destruye el sprite
  1041.         if (CHARACTER.created[screen]) {
  1042.             CHARACTER.created[screen] = false;
  1043.             NF_DeleteSprite(screen, CHARACTER_SPR_ID);
  1044.             NF_FreeSpriteGfx(screen, CHARACTER_SPR_ID);
  1045.         }
  1046.     }
  1047.  
  1048. }
  1049.  
  1050.  
  1051.  
  1052. // Funcion CameraCharacterShow();
  1053. void CameraCharacterShow(u8 screen, u8 stage) {
  1054.  
  1055.     /*
  1056.     -------------------------------------------------
  1057.         Gestion del Personaje
  1058.     -------------------------------------------------
  1059.     */
  1060.  
  1061.     // Calcula la posicion del sprite en la pantalla
  1062.     s32 spr_x = (CHARACTER.pos_x - STAGE[stage].stg_left - CAMERA[screen].bg_x);
  1063.     s32 spr_y = (CHARACTER.pos_y - STAGE[stage].stg_top);
  1064.  
  1065.     // Calcula si esta en pantalla
  1066.     if (
  1067.         (spr_x >= -32)
  1068.         &&
  1069.         (spr_x <= 287)
  1070.         &&
  1071.         (spr_y >= -32)
  1072.         &&
  1073.         (spr_y <= 223)
  1074.         ) {
  1075.         // Esta en pantalla
  1076.         CHARACTER.on_screen[screen] = true;
  1077.         CHARACTER.scr_x[screen] = spr_x;
  1078.         CHARACTER.scr_y[screen] = spr_y;
  1079.         // Si no esta creado, crealo
  1080.         if (!CHARACTER.created[screen]) {
  1081.             CHARACTER.created[screen] = true;
  1082.             NF_VramSpriteGfx(screen, ID_CHARACTER, CHARACTER_SPR_ID, true);
  1083.             NF_CreateSprite(screen, CHARACTER_SPR_ID, CHARACTER_SPR_ID, CHARACTER_SPR_PAL, (CHARACTER.scr_x[screen] - CHARACTER.spr_left), (CHARACTER.scr_y[screen] - CHARACTER.spr_up));
  1084.             NF_SpriteLayer(screen, CHARACTER_SPR_ID, SPRITES_LAYER);
  1085.         }
  1086.         // Frame del evento especial (fin de juego)
  1087.         if ((screen == 1) && (CHARACTER.frame == 21)) {
  1088.             NF_SpriteFrame(screen, CHARACTER_SPR_ID, 22);
  1089.         } else {
  1090.             // Frame normal
  1091.             NF_SpriteFrame(screen, CHARACTER_SPR_ID, CHARACTER.frame);
  1092.         }
  1093.         // Actualiza el Sprite
  1094.         NF_ShowSprite(screen, CHARACTER_SPR_ID, CHARACTER.show);
  1095.         NF_HflipSprite(screen, CHARACTER_SPR_ID, CHARACTER.flip);
  1096.         NF_MoveSprite(screen, CHARACTER_SPR_ID, (CHARACTER.scr_x[screen] - CHARACTER.spr_left), (CHARACTER.scr_y[screen] - CHARACTER.spr_up));
  1097.     }
  1098.  
  1099. }
  1100.  
  1101.  
  1102.  
  1103. // Funcion CharacterGetItem();
  1104. void CharacterGetItem(void) {
  1105.  
  1106.     // Variables
  1107.     s32 char_xa, char_xb, char_ya, char_yb;     // Limites personaje
  1108.     s32 item_xa, item_xb, item_ya, item_yb;     // Limites item
  1109.     bool checkit = false;                       // Flag de verificacion
  1110.  
  1111.     // Si se pulsa A, verifica si se puede coger un item
  1112.     if (KEYPRESS.a) {
  1113.         // Si el personaje esta en condiciones de coger un item...
  1114.         if (
  1115.             !CHARACTER.is_jump
  1116.             &&
  1117.             !CHARACTER.fall
  1118.             &&
  1119.             !CHARACTER.in_stair
  1120.             &&
  1121.             (CHARACTER.duck == 0)
  1122.             ) {
  1123.             // Verificado
  1124.             checkit = true;
  1125.         }
  1126.     }
  1127.  
  1128.     // Si la verificacion ha sido correcta, comprueba si se ha cogido alguno
  1129.     if (checkit) {
  1130.  
  1131.         // Calcula las coordenadas de referencia del personaje
  1132.         char_xa = (CHARACTER.pos_x - CHARACTER.left);
  1133.         char_xb = (CHARACTER.pos_x + CHARACTER.right);
  1134.         char_ya = (CHARACTER.pos_y - CHARACTER.up[0]);
  1135.         char_yb = (CHARACTER.pos_y + CHARACTER.down);
  1136.  
  1137.         // Verifica si se puede coger la Bola de cristal
  1138.         if (!CRISTALLBALL.done) {
  1139.             // Calcula las coordenadas de referencia de la bola
  1140.             item_xa = CRISTALLBALL.pos_x;
  1141.             item_xb = (CRISTALLBALL.pos_x + CRISTALLBALL.width);
  1142.             item_ya = CRISTALLBALL.pos_y;
  1143.             item_yb = (CRISTALLBALL.pos_y + CRISTALLBALL.height);
  1144.             // Verifica si se ha tocado la bola al pulsar el boton
  1145.             if (CheckRectCollision(char_xa, char_ya, char_xb, char_yb, item_xa, item_ya, item_xb, item_yb)) {
  1146.                 // Coge la bola
  1147.                 GetCristallball();
  1148.             }
  1149.         }
  1150.  
  1151.         // Verifica si se puede coger el libro de hechizos
  1152.         if (!SPELLBOOK.done) {
  1153.             // Calcula las coordenadas de referencia del libro de hechizos
  1154.             item_xa = SPELLBOOK.pos_x;
  1155.             item_xb = (SPELLBOOK.pos_x + SPELLBOOK.width);
  1156.             item_ya = SPELLBOOK.pos_y;
  1157.             item_yb = (SPELLBOOK.pos_y + SPELLBOOK.height);
  1158.             // Verifica si se ha tocado la bola al pulsar el boton
  1159.             if (CheckRectCollision(char_xa, char_ya, char_xb, char_yb, item_xa, item_ya, item_xb, item_yb)) {
  1160.                 // Coge el libro
  1161.                 GetSpellbook();
  1162.             }
  1163.         }
  1164.  
  1165.         // Verifica si se puede coger la varita magica
  1166.         if (!MAGICWAND.done) {
  1167.             // Calcula las coordenadas de referencia de la bola
  1168.             item_xa = MAGICWAND.pos_x;
  1169.             item_xb = (MAGICWAND.pos_x + MAGICWAND.width);
  1170.             item_ya = MAGICWAND.pos_y;
  1171.             item_yb = (MAGICWAND.pos_y + MAGICWAND.height);
  1172.             // Verifica si se ha tocado la bola al pulsar el boton
  1173.             if (CheckRectCollision(char_xa, char_ya, char_xb, char_yb, item_xa, item_ya, item_xb, item_yb)) {
  1174.                 // Coge la varita
  1175.                 GetMagicwand();
  1176.             }
  1177.         }
  1178.  
  1179.     }
  1180.  
  1181. }
  1182.  
  1183.  
  1184.  
  1185. // Funcion CharacterRevivePoint();
  1186. void CharacterRevivePoint(void) {
  1187.  
  1188.     /*
  1189.     -------------------------------------------------
  1190.         Verifica si hay que crear un
  1191.         punto de resurreccion
  1192.     -------------------------------------------------
  1193.     */
  1194.  
  1195.     // Si has cambiado de stage...
  1196.     if (CHARACTER.stage != REVIVE.stage) {
  1197.         // Y el personaje no se esta cayendo ni saltando
  1198.         if (!CHARACTER.is_jump && !CHARACTER.fall && (CHARACTER.stage != 19)) {
  1199.             CharacterBackupPos();
  1200.         }
  1201.     }
  1202.  
  1203.     // Actualiza la posicion de referencia para la siguiente verificacion
  1204.     CHARACTER.old_x = CHARACTER.pos_x;
  1205.     CHARACTER.old_y = CHARACTER.pos_y;
  1206.  
  1207. }
  1208.  
  1209.  
  1210.  
  1211. // Funcion CharacterBackupPos();
  1212. void CharacterBackupPos(void) {
  1213.  
  1214.     // Variables
  1215.     s16 x = 0;
  1216.  
  1217.     // Calcula el desplazamiento lateral
  1218.     if (CHARACTER.pos_y == CHARACTER.old_y) {
  1219.         if (CHARACTER.pos_x > CHARACTER.old_x) {
  1220.             x = 32;
  1221.         } else {
  1222.             x = -32;
  1223.         }
  1224.     }
  1225.  
  1226.     // Copia los datos
  1227.     REVIVE.air_speed = CHARACTER.air_speed;
  1228.     REVIVE.anim = CHARACTER.anim;
  1229.     REVIVE.can_jump = CHARACTER.can_jump;
  1230.     REVIVE.duck = CHARACTER.duck;
  1231.     REVIVE.fall = CHARACTER.fall;
  1232.     REVIVE.flip = CHARACTER.flip;
  1233.     REVIVE.force_down = CHARACTER.force_down;
  1234.     REVIVE.frame = CHARACTER.frame;
  1235.     REVIVE.frame_cnt = CHARACTER.frame_cnt;
  1236.     REVIVE.in_stair = CHARACTER.in_stair;
  1237.     REVIVE.is_jump = CHARACTER.is_jump;
  1238.     REVIVE.jump_direction = CHARACTER.jump_direction;
  1239.     REVIVE.jump_height = CHARACTER.jump_height;
  1240.     REVIVE.jump_up = CHARACTER.jump_up;
  1241.     REVIVE.mov_left = CHARACTER.mov_left;
  1242.     REVIVE.mov_right = CHARACTER.mov_right;
  1243.     REVIVE.pos_x = (CHARACTER.pos_x + x);
  1244.     REVIVE.pos_y = CHARACTER.pos_y;
  1245.     REVIVE.pos_fx = (REVIVE.pos_x << 8);
  1246.     REVIVE.pos_fy = (REVIVE.pos_y << 8);
  1247.     REVIVE.spell = CHARACTER.spell;
  1248.     REVIVE.stage = CHARACTER.stage;
  1249.     REVIVE.stair_down = CHARACTER.stair_down;
  1250.     REVIVE.stair_up = CHARACTER.stair_up;
  1251.  
  1252. }
  1253.  
  1254.  
  1255.  
  1256. // Funcion CharacterRestorePos();
  1257. void CharacterRestorePos(void) {
  1258.  
  1259.     CHARACTER.air_speed = REVIVE.air_speed;
  1260.     CHARACTER.anim = REVIVE.anim;
  1261.     CHARACTER.can_jump = REVIVE.can_jump;
  1262.     CHARACTER.duck = REVIVE.duck;
  1263.     CHARACTER.fall = REVIVE.fall;
  1264.     CHARACTER.flip = REVIVE.flip;
  1265.     CHARACTER.force_down = REVIVE.force_down;
  1266.     CHARACTER.frame = REVIVE.frame;
  1267.     CHARACTER.frame_cnt = REVIVE.frame_cnt;
  1268.     CHARACTER.in_stair = REVIVE.in_stair;
  1269.     CHARACTER.is_jump = REVIVE.is_jump;
  1270.     CHARACTER.jump_direction = REVIVE.jump_direction;
  1271.     CHARACTER.jump_height = REVIVE.jump_height;
  1272.     CHARACTER.jump_up = REVIVE.jump_up;
  1273.     CHARACTER.mov_left = REVIVE.mov_left;
  1274.     CHARACTER.mov_right = REVIVE.mov_right;
  1275.     CHARACTER.pos_fx = REVIVE.pos_fx;
  1276.     CHARACTER.pos_fy = REVIVE.pos_fy;
  1277.     CHARACTER.pos_x = REVIVE.pos_x;
  1278.     CHARACTER.pos_y = REVIVE.pos_y;
  1279.     CHARACTER.spell = REVIVE.spell;
  1280.     CHARACTER.stage = REVIVE.stage;
  1281.     CHARACTER.stair_down = REVIVE.stair_down;
  1282.     CHARACTER.stair_up = REVIVE.stair_up;
  1283.  
  1284. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!