API tools faq
paste
denisb413

Untitled

denisb413
Jun 4th, 2013
91
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 39.08 KB | None | 0 0
raw download clone embed print report
  1. #include <allegro.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <dos.h>
  5. #include <time.h>
  6.  
  7. // global
  8. int fps = 0;
  9.  
  10. int fps_antigo = 0;
  11. int fps_speed = 0;
  12.  
  13. // prototipo do contador de frames
  14. void frame_rate();
  15.  
  16. // prototipo do contador de velocidade
  17. void incrementa_speed();
  18.  
  19. int main() {
  20. allegro_init();
  21. char txt[50];
  22. install_keyboard();
  23.  
  24. set_color_depth(32);
  25. set_gfx_mode(GFX_AUTODETECT_WINDOWED,592,379,0,0);
  26. PALETTE pal;
  27. BITMAP *buffer = create_bitmap(592,379);
  28. const int limite_cenario = 250;
  29. int x=40, y=limite_cenario - 10;
  30. int a=200, b=limite_cenario - 10;
  31. int z = 0, apertou=0, seila=1, seila2=0;
  32.  
  33. install_timer();
  34.  
  35. // a cada 1 segundo mostra quantas vezes a imagem foi impressa na tela
  36. install_int( frame_rate, 1000 );
  37.  
  38. install_int_ex( incrementa_speed, BPS_TO_TIMER(40) );
  39.  
  40. //declarando pulo
  41.  
  42. bool parou = false;
  43.  
  44. bool andou = false;
  45.  
  46.  
  47. bool pulou = false;
  48.  
  49. bool pulou_parado = false;
  50.  
  51. bool pulou2 = false;
  52.  
  53. bool duck = false;
  54.  
  55. bool duck2 = false;
  56.  
  57. bool socando = false;
  58.  
  59. bool socando2 = false;
  60.  
  61. bool kicking = false;
  62.  
  63. bool kicking2 = false;
  64.  
  65. bool socando_jumping = false;
  66.  
  67. bool socando_jumping2 = false;
  68.  
  69. bool socando_ducking = false;
  70.  
  71. bool socando_ducking2 = false;
  72.  
  73. bool kicking_jumping = false;
  74.  
  75. bool kicking_jumping2 = false;
  76.  
  77. bool kicking_ducking = false;
  78.  
  79. bool kicking_ducking2 = false;
  80.  
  81.  
  82.  
  83. // Gravidade: quanto maior, mais rápida será a queda
  84. const float gravidade = 2.7;
  85.  
  86. // Força do pulo
  87. int forca = 0;
  88.  
  89.  
  90. //declarando diversos
  91.  
  92. int dir = 1;
  93.  
  94. int esq = 1;
  95.  
  96. int abaixo = 1;
  97.  
  98. int cont_seila = 1;
  99.  
  100. int cont_pos_ducking = 1;
  101.  
  102. int cont_pos_soco = 1;
  103.  
  104. int cont_pos_kick = 1;
  105.  
  106. int cont_pos_jumping = 1;
  107.  
  108. int cont_pos_jumping_parado = 1;
  109.  
  110. int cont_pos_soco_ducking = 1;
  111.  
  112. int cont_pos_kick_ducking = 1;
  113.  
  114. int cont_pos_soco_jumping = 1;
  115.  
  116. int cont_pos_kick_jumping = 1;
  117.  
  118. int oi;
  119.  
  120.  
  121.  
  122. //-----------declarando bitmaps---------
  123.  
  124. BITMAP *parado[20];
  125. parado[1] = load_bitmap("p01.bmp",pal);
  126. parado[2] = load_bitmap("p02.bmp",pal);
  127. parado[3] = load_bitmap("p03.bmp",pal);
  128. parado[4] = load_bitmap("p04.bmp",pal);
  129. parado[5] = load_bitmap("p05.bmp",pal);
  130. parado[6] = load_bitmap("p06.bmp",pal);
  131. parado[7] = load_bitmap("p07.bmp",pal);
  132. parado[8] = load_bitmap("p08.bmp",pal);
  133. parado[9] = load_bitmap("p09.bmp",pal);
  134. parado[10] = load_bitmap("p010.bmp",pal);
  135. parado[11] = load_bitmap("p011.bmp",pal);
  136. parado[12] = load_bitmap("p012.bmp",pal);
  137. parado[13] = load_bitmap("p013.bmp",pal);
  138. parado[14] = load_bitmap("p014.bmp",pal);
  139. parado[15] = load_bitmap("p015.bmp",pal);
  140. parado[16] = load_bitmap("p016.bmp",pal);
  141. parado[17] = load_bitmap("p017.bmp",pal);
  142. parado[18] = load_bitmap("p018.bmp",pal);
  143.  
  144. BITMAP *andando[10];
  145. andando[1] = load_bitmap("a01.bmp",pal);
  146. andando[2] = load_bitmap("a02.bmp",pal);
  147. andando[3] = load_bitmap("a03.bmp",pal);
  148. andando[4] = load_bitmap("a04.bmp",pal);
  149. andando[5] = load_bitmap("a05.bmp",pal);
  150. andando[6] = load_bitmap("a06.bmp",pal);
  151. andando[7] = load_bitmap("a07.bmp",pal);
  152. andando[8] = load_bitmap("a08.bmp",pal);
  153.  
  154.  
  155. int posicao_andando = 1;
  156.  
  157. BITMAP *andando2[10];
  158. andando2[1] = load_bitmap("a201.bmp",pal);
  159. andando2[2] = load_bitmap("a202.bmp",pal);
  160. andando2[3] = load_bitmap("a203.bmp",pal);
  161. andando2[4] = load_bitmap("a204.bmp",pal);
  162. andando2[5] = load_bitmap("a205.bmp",pal);
  163. andando2[6] = load_bitmap("a206.bmp",pal);
  164. andando2[7] = load_bitmap("a207.bmp",pal);
  165. andando2[8] = load_bitmap("a208.bmp",pal);
  166. andando2[9] = load_bitmap("a209.bmp",pal);
  167.  
  168. int posicao_andando2 = 1;
  169.  
  170. BITMAP *jumping[15];
  171. jumping[1] = load_bitmap("j01.bmp",pal);
  172. jumping[2] = load_bitmap("j02.bmp",pal);
  173. jumping[3] = load_bitmap("j03.bmp",pal);
  174. jumping[4] = load_bitmap("j04.bmp",pal);
  175. jumping[5] = load_bitmap("j05.bmp",pal);
  176. jumping[6] = load_bitmap("j06.bmp",pal);
  177. jumping[7] = load_bitmap("j07.bmp",pal);
  178. jumping[8] = load_bitmap("j08.bmp",pal);
  179. jumping[9] = load_bitmap("j09.bmp",pal);
  180. jumping[10] = load_bitmap("j010.bmp",pal);
  181. jumping[11] = load_bitmap("j011.bmp",pal);
  182.  
  183. int posicao_jumping = 1;
  184.  
  185. //
  186.  
  187. BITMAP *jumping_parado[10];
  188. jumping_parado[1] = load_bitmap("jp01.bmp",pal);
  189. jumping_parado[2] = load_bitmap("jp02.bmp",pal);
  190. jumping_parado[3] = load_bitmap("jp03.bmp",pal);
  191.  
  192. int posicao_jumping_parado = 1;
  193.  
  194. //
  195.  
  196. BITMAP *jumping2[10];
  197. jumping2[1] = load_bitmap("j201.bmp",pal);
  198. jumping2[2] = load_bitmap("j202.bmp",pal);
  199. jumping2[3] = load_bitmap("j203.bmp",pal);
  200.  
  201. int posicao_jumping2 = 1;
  202.  
  203. //
  204.  
  205.  
  206. BITMAP *ducking[10];
  207. ducking[1] = load_bitmap("d01.bmp",pal);
  208. ducking[2] = load_bitmap("d02.bmp",pal);
  209. ducking[3] = load_bitmap("d03.bmp",pal);
  210.  
  211. int posicao_ducking = 0;
  212.  
  213. //
  214.  
  215.  
  216. BITMAP *ducking2[10];
  217. ducking2[1] = load_bitmap("d201.bmp",pal);
  218. ducking2[2] = load_bitmap("d202.bmp",pal);
  219. ducking2[3] = load_bitmap("d203.bmp",pal);
  220.  
  221. int posicao_ducking2 = 1;
  222.  
  223. //
  224.  
  225. BITMAP *arena = load_bitmap("Arena.bmp",pal);
  226.  
  227. //
  228.  
  229. BITMAP *soco[10];
  230. soco[1] = load_bitmap("s01.bmp",pal);
  231. soco[2] = load_bitmap("s02.bmp",pal);
  232. soco[3] = load_bitmap("s03.bmp",pal);
  233. soco[4] = load_bitmap("s04.bmp",pal);
  234. soco[5] = load_bitmap("s05.bmp",pal);
  235.  
  236. int posicao_soco = 1;
  237.  
  238. //
  239.  
  240. BITMAP *kick[15];
  241. kick[1] = load_bitmap("k01.bmp",pal);
  242. kick[2] = load_bitmap("k02.bmp",pal);
  243. kick[3] = load_bitmap("k03.bmp",pal);
  244. kick[4] = load_bitmap("k04.bmp",pal);
  245. kick[5] = load_bitmap("k05.bmp",pal);
  246. kick[6] = load_bitmap("k06.bmp",pal);
  247. kick[7] = load_bitmap("k07.bmp",pal);
  248. kick[8] = load_bitmap("k08.bmp",pal);
  249. kick[9] = load_bitmap("k09.bmp",pal);
  250. kick[10] = load_bitmap("k010.bmp",pal);
  251. kick[11] = load_bitmap("k011.bmp",pal);
  252.  
  253. int posicao_kick = 1;
  254.  
  255. //
  256.  
  257. BITMAP *soco_ducking[10];
  258. soco_ducking[1] = load_bitmap("sd01.bmp",pal);
  259. soco_ducking[2] = load_bitmap("sd02.bmp",pal);
  260. soco_ducking[3] = load_bitmap("sd03.bmp",pal);
  261. soco_ducking[4] = load_bitmap("sd04.bmp",pal);
  262. soco_ducking[5] = load_bitmap("sd05.bmp",pal);
  263.  
  264. int posicao_soco_ducking = 1;
  265.  
  266. //
  267.  
  268. BITMAP *soco_jumping[10];
  269. soco_jumping[1] = load_bitmap("sj01.bmp",pal);
  270. soco_jumping[2] = load_bitmap("sj02.bmp",pal);
  271. soco_jumping[3] = load_bitmap("sj03.bmp",pal);
  272.  
  273. int posicao_soco_jumping = 1;
  274.  
  275. //
  276.  
  277. BITMAP *kick_jumping[10];
  278. kick_jumping[1] = load_bitmap("kj01.bmp",pal);
  279. kick_jumping[2] = load_bitmap("kj02.bmp",pal);
  280. kick_jumping[3] = load_bitmap("kj03.bmp",pal);
  281.  
  282. int posicao_kick_jumping = 1;
  283.  
  284. //
  285.  
  286. BITMAP *kick_ducking[10];
  287. kick_ducking[1] = load_bitmap("kd01.bmp",pal);
  288. kick_ducking[2] = load_bitmap("kd02.bmp",pal);
  289. kick_ducking[3] = load_bitmap("kd03.bmp",pal);
  290. kick_ducking[4] = load_bitmap("kd04.bmp",pal);
  291. kick_ducking[5] = load_bitmap("kd05.bmp",pal);
  292. kick_ducking[6] = load_bitmap("kd06.bmp",pal);
  293.  
  294. int posicao_kick_ducking = 1;
  295.  
  296. while(!key[KEY_ESC]) {
  297. while ( ::fps_speed > 0 )
  298. {
  299.  
  300.  
  301. clear(buffer);
  302.  
  303. if (duck == true){
  304. parou = false;
  305. }
  306.  
  307. if (parou == true){
  308. cont_seila++;
  309. posicao_ducking = 1;
  310. posicao_soco_ducking = 1;
  311. }
  312.  
  313. if (cont_seila == 3){
  314. cont_seila = 1;
  315. }
  316.  
  317. if (cont_seila == 2){
  318. seila++;
  319. }
  320.  
  321.  
  322. if (pulou == false && duck == false && pulou_parado == false){
  323. parou = true;
  324. }
  325.  
  326. //contador kicking
  327. if (kicking == true){
  328. cont_pos_kick++;
  329. if (cont_pos_kick == 3){
  330. cont_pos_kick = 1;
  331. }
  332.  
  333. if (cont_pos_kick == 2){
  334. posicao_kick ++;
  335. }
  336. }
  337.  
  338. //contador socando
  339.  
  340. if (socando == true){
  341. cont_pos_soco++;
  342. if (cont_pos_soco == 4){
  343. cont_pos_soco = 1;
  344. }
  345.  
  346. if (cont_pos_soco == 3){
  347. posicao_soco ++;
  348. }
  349. }
  350. //contador do socando ducking
  351.  
  352. if (socando_ducking == true){
  353. cont_pos_soco_ducking++;
  354. if (cont_pos_soco_ducking == 4){
  355. cont_pos_soco_ducking = 1;
  356. }
  357.  
  358. if (cont_pos_soco_ducking == 3){
  359. posicao_soco_ducking ++;
  360. }
  361. }
  362.  
  363. //contador do kick ducking
  364.  
  365. if (kicking_ducking == true){
  366. cont_pos_kick_ducking++;
  367. if (cont_pos_kick_ducking == 4){
  368. cont_pos_kick_ducking = 1;
  369. }
  370.  
  371. if (cont_pos_kick_ducking == 3){
  372. posicao_kick_ducking ++;
  373. }
  374. }
  375.  
  376. //contador do socando jumping
  377.  
  378. if (socando_jumping == true){
  379. cont_pos_soco_jumping++;
  380. if (cont_pos_soco_jumping == 3){
  381. cont_pos_soco_jumping = 1;
  382. }
  383.  
  384. if (cont_pos_soco_jumping == 2){
  385. posicao_soco_jumping ++;
  386. }
  387. }
  388.  
  389. //contador do kick jumping
  390.  
  391. if (kicking_jumping == true){
  392.  
  393. posicao_kick_jumping ++;
  394.  
  395. }
  396.  
  397. //contador do jumping
  398.  
  399. if (pulou == true){
  400. cont_pos_jumping++;
  401. if (cont_pos_jumping == 3){
  402. cont_pos_jumping = 1;
  403. }
  404.  
  405. if (cont_pos_jumping == 2){
  406. posicao_jumping ++;
  407. }
  408. }
  409.  
  410. //contador do jumping parado
  411.  
  412. if (pulou_parado == true){
  413. cont_pos_jumping_parado++;
  414. if (cont_pos_jumping_parado == 5){
  415. cont_pos_jumping_parado = 1;
  416. }
  417.  
  418. if (cont_pos_jumping_parado == 4){
  419. posicao_jumping_parado ++;
  420. }
  421. }
  422.  
  423.  
  424.  
  425.  
  426. andou = false;
  427.  
  428. duck2 = false;
  429.  
  430. socando2 = false;
  431.  
  432.  
  433. kicking2 = false;
  434.  
  435.  
  436.  
  437. socando_jumping2 = false;
  438.  
  439.  
  440.  
  441. socando_ducking2 = false;
  442.  
  443.  
  444.  
  445. kicking_jumping2 = false;
  446.  
  447.  
  448. kicking_ducking2 = false;
  449.  
  450.  
  451. //jumping
  452. if (key[KEY_UP] && (key[KEY_LEFT] || key[KEY_RIGHT]) && pulou == false && duck == false && pulou_parado == false)
  453. {
  454. pulou = true;
  455. parou = false;
  456. posicao_jumping = 1;
  457. // força do pulo
  458. forca = 35;
  459. }
  460.  
  461. //jumping parado
  462. if (key[KEY_UP] && pulou == false && duck == false && pulou_parado == false)
  463. {
  464. pulou_parado = true;
  465. parou = false;
  466. posicao_jumping_parado = 1;
  467. // força do pulo
  468. forca = 35;
  469. }
  470.  
  471. duck = false;
  472.  
  473. //ducking
  474. if(key[KEY_DOWN] && duck == false && socando == false && kicking == false && pulou==false) {
  475. duck = true;
  476. cont_pos_ducking++;
  477.  
  478. }
  479.  
  480. if (cont_pos_ducking == 3){
  481. cont_pos_ducking = 1;
  482. }
  483.  
  484. if (cont_pos_ducking == 2){
  485. posicao_ducking ++;
  486. }
  487.  
  488.  
  489.  
  490.  
  491.  
  492. //soco
  493. if(key[KEY_A] && duck == false && socando == false && kicking == false && pulou == false) {
  494. socando = true;
  495. parou = false;
  496. }
  497. //soco jumping
  498. if(key[KEY_A] && pulou == true && socando_jumping == false) {
  499. socando_jumping = true;
  500. posicao_soco_jumping = 1;
  501. parou = false;
  502. }
  503. //kick jumping
  504. if(key[KEY_S] && pulou == true && socando_jumping == false) {
  505. kicking_jumping = true;
  506. posicao_kick_jumping = 1;
  507. parou = false;
  508. }
  509. //soco ducking
  510. if(key[KEY_A] && duck == true && socando_ducking == false) {
  511. socando_ducking = true;
  512. parou = false;
  513. }
  514.  
  515. //kick ducking
  516. if(key[KEY_S] && duck == true && kicking_ducking == false) {
  517. kicking_ducking = true;
  518. parou = false;
  519. }
  520. //kick
  521. if(key[KEY_S] && duck == false && socando == false && kicking == false && pulou == false) {
  522. kicking = true;
  523. parou = false;
  524. }
  525.  
  526.  
  527. //andar direita
  528. if(key[KEY_RIGHT] && duck == false && socando == false && kicking == false) {
  529. x=x+5;
  530. dir++;
  531. esq=0;
  532. if (dir==4){
  533. dir=0;
  534. }
  535. andou = true;
  536. parou = false;
  537. }
  538.  
  539.  
  540.  
  541. //andar esquerda
  542. if(key[KEY_LEFT] && duck == false && socando == false && kicking == false) {
  543. x=x-5;
  544. esq++;
  545. dir=0;
  546. if (esq==4){
  547. esq=0;
  548. }
  549. andou = true;
  550. parou = false;
  551. }
  552.  
  553.  
  554. if (dir == 3){
  555. posicao_andando ++;
  556. }
  557.  
  558. if (esq == 3){
  559. posicao_andando --;
  560. }
  561.  
  562.  
  563.  
  564.  
  565.  
  566. // Isto vai fazer com que o personagem vá voltado para o chão
  567. forca = (int)(forca - gravidade);
  568. y = y - forca;
  569.  
  570. // Esse if vai barrar nosso personagem de passar pelo chão ( limite )
  571. if (y > limite_cenario-10)
  572. {
  573. y = limite_cenario-10;
  574.  
  575. pulou = false;
  576. pulou_parado = false;
  577. socando_jumping = false;
  578. kicking_jumping = false;
  579. forca = 0;
  580. parou = true;
  581. }
  582.  
  583. ////--------------config posicoes----------------
  584.  
  585.  
  586.  
  587. //pos andando
  588. if (posicao_andando == 0){
  589. posicao_andando = 8;
  590. }
  591. if (posicao_andando == 9){
  592. posicao_andando = 1;
  593. }
  594.  
  595. //pos parou
  596. if (seila == 19){
  597. seila = 1;
  598. }
  599.  
  600.  
  601. //pos abaixando
  602. if (posicao_ducking == 4){
  603. posicao_ducking = 3;
  604. }
  605.  
  606. //pos soco
  607. if (posicao_soco == 6){
  608. socando = false;
  609. posicao_soco = 1;
  610. cont_pos_soco = 1;
  611. }
  612.  
  613. //pos kick
  614. if (posicao_kick == 12){
  615. kicking = false;
  616. posicao_kick = 1;
  617. cont_pos_kick = 1;
  618. }
  619.  
  620. //pos jumping
  621.  
  622. if (posicao_jumping == 12){
  623. posicao_jumping = 11;
  624. cont_pos_jumping = 1;
  625. }
  626.  
  627. //pos jumping parado
  628.  
  629. if (posicao_jumping_parado == 4){
  630. posicao_jumping_parado = 3;
  631. cont_pos_jumping_parado = 1;
  632. }
  633.  
  634. //pos soco ducking
  635.  
  636. if (posicao_soco_ducking == 6){
  637. socando_ducking = false;
  638. posicao_soco_ducking = 1;
  639. cont_pos_soco_ducking = 1;
  640. }
  641.  
  642. //pos kick ducking
  643.  
  644. if (posicao_kick_ducking == 7){
  645. kicking_ducking = false;
  646. posicao_kick_ducking = 1;
  647. cont_pos_kick_ducking = 1;
  648. }
  649. //pos soco jumping
  650.  
  651. if (posicao_soco_jumping == 4){
  652. posicao_soco_jumping = 3;
  653. cont_pos_soco_jumping = 1;
  654. }
  655.  
  656. //pos kick jumping
  657.  
  658. if (posicao_kick_jumping == 4){
  659. posicao_kick_jumping = 3;
  660. cont_pos_kick_jumping = 1;
  661. }
  662. //----------------desenhando----------------------
  663.  
  664. if (parou == true )
  665. {
  666. draw_sprite(buffer, arena, 1,1 );
  667. if (seila == 1){
  668. draw_sprite(buffer, parado[seila], x-4,y+5 );
  669. }
  670. if (seila == 2){
  671. draw_sprite(buffer, parado[seila], x-5,y+3 );
  672. }
  673. if (seila == 3){
  674. draw_sprite(buffer, parado[seila], x-3,y+1 );
  675. }
  676. if (seila == 4){
  677. draw_sprite(buffer, parado[seila], x,y );
  678. }
  679. if (seila == 5){
  680. draw_sprite(buffer, parado[seila], x+3,y );
  681. }
  682. if (seila == 6){
  683. draw_sprite(buffer, parado[seila], x+4,y );
  684. }
  685. if (seila == 7){
  686. draw_sprite(buffer, parado[seila], x+5,y+1 );
  687. }
  688. if (seila == 8){
  689. draw_sprite(buffer, parado[seila], x+6,y+2 );
  690. }
  691. if (seila == 9){
  692. draw_sprite(buffer, parado[seila], x+6,y+3 );
  693. }
  694. if (seila == 10){
  695. draw_sprite(buffer, parado[seila], x+6,y+3 );
  696. }
  697. if (seila == 11){
  698. draw_sprite(buffer, parado[seila], x+6,y+2 );
  699. }
  700. if (seila == 12){
  701. draw_sprite(buffer, parado[seila], x+5,y+1 );
  702. }
  703. if (seila == 13){
  704. draw_sprite(buffer, parado[seila], x+4,y );
  705. }
  706. if (seila == 14){
  707. draw_sprite(buffer, parado[seila], x+3,y );
  708. }
  709. if (seila == 15){
  710. draw_sprite(buffer, parado[seila], x,y );
  711. }
  712. if (seila == 16){
  713. draw_sprite(buffer, parado[seila], x-3,y );
  714. }
  715. if (seila == 17){
  716. draw_sprite(buffer, parado[seila], x-5,y+1 );
  717. }
  718. if (seila == 18){
  719. draw_sprite(buffer, parado[seila], x-4,y+3 );
  720. }
  721.  
  722.  
  723.  
  724. }
  725.  
  726. if (andou == true )
  727. {
  728. draw_sprite(buffer, arena, 1,1 );
  729. draw_sprite(buffer, andando[posicao_andando], x,y );
  730.  
  731. }
  732.  
  733.  
  734. if (pulou == true && pulou_parado == false && socando_jumping == false && kicking_jumping == false )
  735. {
  736. draw_sprite(buffer, arena, 1,1 );
  737. if (posicao_jumping == 1){
  738. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  739. }
  740. if (posicao_jumping == 2){
  741. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  742. }
  743. if (posicao_jumping == 3){
  744. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  745. }
  746. if (posicao_jumping == 4){
  747. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  748. }
  749. if (posicao_jumping == 5){
  750. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  751. }
  752. if (posicao_jumping == 6){
  753. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  754. }
  755. if (posicao_jumping == 7){
  756. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  757. }
  758. if (posicao_jumping == 8){
  759. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  760. }
  761. if (posicao_jumping == 9){
  762. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  763. }
  764. if (posicao_jumping == 10){
  765. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  766. }
  767. if (posicao_jumping == 11){
  768. draw_sprite(buffer, jumping[posicao_jumping], x,y );
  769. }
  770.  
  771.  
  772.  
  773.  
  774. }
  775.  
  776.  
  777. if (pulou_parado == true && pulou == false && socando_jumping == false && kicking_jumping == false)
  778. {
  779. draw_sprite(buffer, arena, 1,1 );
  780. if (posicao_jumping_parado == 1){
  781. draw_sprite(buffer, jumping_parado[posicao_jumping_parado], x,y );
  782. }
  783. if (posicao_jumping_parado == 2){
  784. draw_sprite(buffer, jumping_parado[posicao_jumping_parado], x,y );
  785. }
  786. if (posicao_jumping_parado == 3){
  787. draw_sprite(buffer, jumping_parado[posicao_jumping_parado], x,y );
  788. }
  789.  
  790. }
  791.  
  792.  
  793. if (duck == true && socando_ducking == false && kicking_ducking == false)
  794. {
  795. draw_sprite(buffer, arena, 1,1 );
  796. if (posicao_ducking == 1){
  797. draw_sprite(buffer, ducking[posicao_ducking], x,y+10 );
  798. }
  799. else if (posicao_ducking == 2){
  800. draw_sprite(buffer, ducking[posicao_ducking], x,y+41 );
  801. }
  802. else{
  803. draw_sprite(buffer, ducking[posicao_ducking], x,y+54 );
  804. }
  805.  
  806. }
  807.  
  808. //PROBLEMA TA AQUI! QUANDO UM ABAIXO O OUTRO DESAPARECE! a ideia é usar varios ifs e funcoes
  809.  
  810.  
  811. if (socando == true )
  812. {
  813. draw_sprite(buffer, arena, 1,1 );
  814. if (posicao_soco == 1){
  815. draw_sprite(buffer, soco[posicao_soco], x,y );
  816. }
  817. if (posicao_soco == 2){
  818. draw_sprite(buffer, soco[posicao_soco], x,y );
  819. }
  820. if (posicao_soco == 3){
  821. draw_sprite(buffer, soco[posicao_soco], x,y );
  822. }
  823. if (posicao_soco == 4){
  824. draw_sprite(buffer, soco[posicao_soco], x,y );
  825. }
  826. if (posicao_soco == 5){
  827. draw_sprite(buffer, soco[posicao_soco], x,y );
  828. }
  829.  
  830.  
  831. }
  832.  
  833. if (duck2 == true )
  834. {
  835. draw_sprite(buffer, arena, 1,1 );
  836. draw_sprite(buffer, ducking2[posicao_ducking2], a,b+50 );
  837.  
  838. }
  839.  
  840. if (kicking == true )
  841. {
  842. draw_sprite(buffer, arena, 1,1 );
  843. if (posicao_soco == 1){
  844. draw_sprite(buffer, kick[posicao_kick], x,y );
  845. }
  846. if (posicao_soco == 2){
  847. draw_sprite(buffer, kick[posicao_kick], x,y );
  848. }
  849. if (posicao_soco == 3){
  850. draw_sprite(buffer, kick[posicao_kick], x,y );
  851. }
  852. if (posicao_soco == 4){
  853. draw_sprite(buffer, kick[posicao_kick], x,y );
  854. }
  855. if (posicao_soco == 5){
  856. draw_sprite(buffer, kick[posicao_kick], x,y );
  857. }
  858. if (posicao_soco == 6){
  859. draw_sprite(buffer, kick[posicao_kick], x,y );
  860. }
  861. if (posicao_soco == 7){
  862. draw_sprite(buffer, kick[posicao_kick], x,y );
  863. }
  864. if (posicao_soco == 8){
  865. draw_sprite(buffer, kick[posicao_kick], x,y );
  866. }
  867. if (posicao_soco == 9){
  868. draw_sprite(buffer, kick[posicao_kick], x,y );
  869. }
  870. if (posicao_soco == 10){
  871. draw_sprite(buffer, kick[posicao_kick], x,y );
  872. }
  873. if (posicao_soco == 11){
  874. draw_sprite(buffer, kick[posicao_kick], x,y );
  875. }
  876.  
  877.  
  878. }
  879. if (socando_jumping == true )
  880. {
  881. draw_sprite(buffer, arena, 1,1 );
  882. if (posicao_soco_jumping == 1){
  883. draw_sprite(buffer, soco_jumping[posicao_soco_jumping], x,y );
  884. }
  885. if (posicao_soco_jumping == 2){
  886. draw_sprite(buffer, soco_jumping[posicao_soco_jumping], x,y );
  887. }
  888. if (posicao_soco_jumping == 3){
  889. draw_sprite(buffer, soco_jumping[posicao_soco_jumping], x,y );
  890. }
  891.  
  892.  
  893. }
  894. if (socando_ducking == true )
  895. {
  896. draw_sprite(buffer, arena, 1,1 );
  897. if (posicao_soco_ducking == 1){
  898. draw_sprite(buffer, soco_ducking[posicao_soco_ducking], x,y+50 );
  899. }
  900. if (posicao_soco_ducking == 2){
  901. draw_sprite(buffer, soco_ducking[posicao_soco_ducking], x,y+50 );
  902. }
  903. if (posicao_soco_ducking == 3){
  904. draw_sprite(buffer, soco_ducking[posicao_soco_ducking], x,y+50 );
  905. }
  906. if (posicao_soco_ducking == 4){
  907. draw_sprite(buffer, soco_ducking[posicao_soco_ducking], x,y+50 );
  908. }
  909. if (posicao_soco_ducking == 5){
  910. draw_sprite(buffer, soco_ducking[posicao_soco_ducking], x,y+50 );
  911. }
  912.  
  913. }
  914. if (kicking_jumping == true )
  915. {
  916. draw_sprite(buffer, arena, 1,1 );
  917. if (posicao_soco_jumping == 1){
  918. draw_sprite(buffer, kick_jumping[posicao_kick_jumping], x,y );
  919. }
  920. if (posicao_soco_jumping == 2){
  921. draw_sprite(buffer, kick_jumping[posicao_kick_jumping], x,y );
  922. }
  923. if (posicao_soco_jumping == 3){
  924. draw_sprite(buffer, kick_jumping[posicao_kick_jumping], x,y );
  925. }
  926.  
  927.  
  928. }
  929. if (kicking_ducking == true )
  930. {
  931. draw_sprite(buffer, arena, 1,1 );
  932. if (posicao_soco_jumping == 1){
  933. draw_sprite(buffer, kick_ducking[posicao_kick_ducking], x,y+50 );
  934. }
  935. if (posicao_soco_jumping == 2){
  936. draw_sprite(buffer, kick_ducking[posicao_kick_ducking], x,y+50 );
  937. }
  938. if (posicao_soco_jumping == 3){
  939. draw_sprite(buffer, kick_ducking[posicao_kick_ducking], x,y+50 );
  940. }
  941. if (posicao_soco_jumping == 4){
  942. draw_sprite(buffer, kick_ducking[posicao_kick_ducking], x,y+50 );
  943. }
  944. if (posicao_soco_jumping == 5){
  945. draw_sprite(buffer, kick_ducking[posicao_kick_ducking], x,y+50 );
  946. }
  947. if (posicao_soco_jumping == 6){
  948. draw_sprite(buffer, kick_ducking[posicao_kick_ducking], x,y+50 );
  949. }
  950.  
  951.  
  952. }
  953.  
  954.  
  955. sprintf(txt,"FPS: %d jumping:%d jumping_parado:%d", ::fps_antigo, posicao_jumping, posicao_jumping_parado);
  956. textout_ex(buffer,font,txt,5,5,makecol(255,0,0),-1);
  957. //desenhar tudo
  958. draw_sprite(screen, buffer, 0, 0);
  959.  
  960. ::fps_speed--;
  961. ::fps++;
  962.  
  963.  
  964. }
  965.  
  966.  
  967.  
  968. };
  969. return 0;
  970. }
  971. END_OF_MAIN();
  972.  
  973. void frame_rate()
  974. {
  975. ::fps_antigo = ::fps;
  976. ::fps = 0;
  977. }
  978.  
  979. void incrementa_speed()
  980. {
  981. ::fps_speed++;
  982. }
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!