API tools faq
paste
Advertisement
YorKnEz

Untitled

YorKnEz
Nov 11th, 2019
127
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 21.72 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Copyright 2019 YorKnEz
  3. */
  4.  
  5. #include <SDL2/SDL.h>
  6. #include <stdio.h>
  7. #include <cstdlib>
  8. #include <time.h>
  9.  
  10. #define TITLE "Dino Game"
  11.  
  12. typedef unsigned int uint;
  13.  
  14. uint16_t window_height = 480, window_width = 1024;
  15.  
  16. uint fps = 60, frames = 0, score;
  17. uint minframetime = 1000 / fps;
  18.  
  19. bool quit = false, nextob = true;
  20.  
  21. SDL_Keycode keycode = SDLK_d;
  22.  
  23. typedef struct Object {
  24. int x;
  25. int y;
  26. int width;
  27. int height;
  28. int type;
  29. int fly;
  30. char hitbox[22][27];
  31. } Object;
  32.  
  33. Object dinosaur = { 100, 308, 18, 22, 0 }, obstacle1, obstacle2;
  34.  
  35. char dinosaur_walk0_hitbox[22][27] = {
  36. " 111111 ",
  37. " 11 11111",
  38. " 11111111",
  39. " 11111111",
  40. " 11111111",
  41. " 11111 ",
  42. " 11111 ",
  43. " 11111111",
  44. "1 11111 ",
  45. "1 111111 ",
  46. "11 1111111111 ",
  47. "111 111111111 1 ",
  48. "11111111111111 ",
  49. "11111111111111 ",
  50. " 1111111111111 ",
  51. " 11111111111 ",
  52. " 11111111 ",
  53. " 1111111 ",
  54. " 111 11 ",
  55. " 11 1 ",
  56. " 1 1 ",
  57. " 11 11 "
  58. };
  59.  
  60. char dinosaur_walk1_hitbox[22][27] = {
  61. " 111111 ",
  62. " 11 11111",
  63. " 11111111",
  64. " 11111111",
  65. " 11111111",
  66. " 11111 ",
  67. " 11111 ",
  68. " 11111111",
  69. "1 11111 ",
  70. "1 111111 ",
  71. "11 1111111111 ",
  72. "111 111111111 1 ",
  73. "11111111111111 ",
  74. "11111111111111 ",
  75. " 1111111111111 ",
  76. " 11111111111 ",
  77. " 11111111 ",
  78. " 1111111 ",
  79. " 1 11 ",
  80. " 11 1 ",
  81. " 1 ",
  82. " 11 "
  83. };
  84.  
  85. char dinosaur_walk2_hitbox[22][27] = {
  86. " 111111 ",
  87. " 11 11111",
  88. " 11111111",
  89. " 11111111",
  90. " 11111111",
  91. " 11111 ",
  92. " 11111 ",
  93. " 11111111",
  94. "1 11111 ",
  95. "1 111111 ",
  96. "11 1111111111 ",
  97. "111 111111111 1 ",
  98. "11111111111111 ",
  99. "11111111111111 ",
  100. " 1111111111111 ",
  101. " 11111111111 ",
  102. " 11111111 ",
  103. " 1111111 ",
  104. " 111 1 ",
  105. " 11 11 ",
  106. " 1 ",
  107. " 11 "
  108. };
  109.  
  110. char dinosaur_walk3_hitbox[22][27] = {
  111. "1 1111111 ",
  112. "111 1111111 111111111",
  113. "1111111111111111111 111111",
  114. " 1111111111111111111111111",
  115. " 111111111111111111111111",
  116. " 11111111111111111111111",
  117. " 111111111111111111 ",
  118. " 1111111111 1111111 ",
  119. " 111111 1 ",
  120. " 111 1 11 ",
  121. " 11 11 ",
  122. " 1 ",
  123. " 11 "
  124. };
  125.  
  126. char dinosaur_walk4_hitbox[22][27] = {
  127. "1 1111111 ",
  128. "111 1111111 111111111",
  129. "1111111111111111111 111111",
  130. " 1111111111111111111111111",
  131. " 111111111111111111111111",
  132. " 11111111111111111111111",
  133. " 111111111111111111 ",
  134. " 1111111111 1111111 ",
  135. " 111111 1 ",
  136. " 1 111 11 ",
  137. " 11 11 ",
  138. " 1 ",
  139. " 11 "
  140. };
  141.  
  142. int walk = 1;
  143.  
  144. void update_dino_hitbox() {
  145.  
  146. if (walk == 1) {
  147. for (int i = 0; i < dinosaur.height; i++) {
  148. for (int j = 0; j < dinosaur.width; j++) {
  149. dinosaur.hitbox[i][j] = dinosaur_walk2_hitbox[i][j];
  150. }
  151. }
  152.  
  153. walk = 2;
  154. } else if (walk == 2) {
  155. for (int i = 0; i < dinosaur.height; i++) {
  156. for (int j = 0; j < dinosaur.width; j++) {
  157. dinosaur.hitbox[i][j] = dinosaur_walk1_hitbox[i][j];
  158. }
  159. }
  160.  
  161. walk = 1;
  162. } else if (walk == 3) {
  163. for (int i = 0; i < dinosaur.height; i++) {
  164. for (int j = 0; j < dinosaur.width; j++) {
  165. dinosaur.hitbox[i][j] = dinosaur_walk0_hitbox[i][j];
  166. }
  167. }
  168.  
  169. walk = 2;
  170. } else if (walk == 4) {
  171. for (int i = 0; i < dinosaur.height; i++) {
  172. for (int j = 0; j < dinosaur.width; j++) {
  173. dinosaur.hitbox[i][j] = dinosaur_walk4_hitbox[i][j];
  174. }
  175. }
  176.  
  177. walk = 5;
  178. } else if (walk == 5) {
  179. for (int i = 0; i < dinosaur.height; i++) {
  180. for (int j = 0; j < dinosaur.width; j++) {
  181. dinosaur.hitbox[i][j] = dinosaur_walk3_hitbox[i][j];
  182. }
  183. }
  184.  
  185. walk = 4;
  186. }
  187. }
  188.  
  189. char obstacle1_hitbox[22][27] = {
  190. " ",
  191. " ",
  192. " ",
  193. " ",
  194. " ",
  195. " ",
  196. " ",
  197. " ",
  198. " ",
  199. " 1111 ",
  200. " 1111111 ",
  201. " 111111111 ",
  202. " 11111111111 ",
  203. " 111111111111 ",
  204. " 1111111111111 ",
  205. " 111111111111111 ",
  206. " 111111111111111 ",
  207. " 111111111111111 ",
  208. " 1111111111111111 ",
  209. " 11111111111111111",
  210. "111111111111111111",
  211. "111111111111111111",
  212. };
  213.  
  214. char obstacle2_hitbox[22][27] = {
  215. " 111 ",
  216. " 11111 ",
  217. " 11111 ",
  218. " 11111 ",
  219. " 11111 1 ",
  220. " 11111 111 ",
  221. " 1 11111 111 ",
  222. " 111 11111 111 ",
  223. " 111 111111111 ",
  224. " 111 111111111 ",
  225. " 111111111111 ",
  226. " 111111111 ",
  227. " 11111111 ",
  228. " 11111 ",
  229. " 11111 ",
  230. " 11111 ",
  231. " 11111 ",
  232. " 11111 ",
  233. " 11111 ",
  234. " 1 111111 1 ",
  235. " 1 ",
  236. " 1 1 "
  237. };
  238.  
  239. char obstacle3_hitbox[22][27] = {
  240. " 11 ",
  241. " 1111 11 ",
  242. " 11111 111 ",
  243. " 11111 1111 ",
  244. " 111 11111 1111 ",
  245. "11111111111111111111111111",
  246. " 1111111111111 ",
  247. " 1111111 ",
  248. " ",
  249. " ",
  250. " "
  251. };
  252.  
  253. char obstacle3_hitbox2[22][27] = {
  254. " ",
  255. " ",
  256. " ",
  257. " ",
  258. " 111 11111111 ",
  259. "11111111111111111111111111",
  260. " 1111111111111 ",
  261. " 111111111 ",
  262. " 11111 1111 ",
  263. " 11111 111 ",
  264. " 111 "
  265. };
  266.  
  267. char zero[5][4] = {
  268. "111",
  269. "1 1",
  270. "1 1",
  271. "1 1",
  272. "111"
  273. },
  274. one[5][4] = {
  275. "11 ",
  276. " 1 ",
  277. " 1 ",
  278. " 1 ",
  279. "111"
  280. },
  281. two[5][4] = {
  282. "111",
  283. " 1",
  284. "111",
  285. "1 ",
  286. "111"
  287. },
  288. three[5][4] = {
  289. "111",
  290. " 1",
  291. "111",
  292. " 1",
  293. "111"
  294. },
  295. four[5][4] = {
  296. " 1",
  297. " 11",
  298. "1 1",
  299. "111",
  300. " 1"
  301. },
  302. five[5][4] = {
  303. "111",
  304. "1 ",
  305. "111",
  306. " 1",
  307. "111"
  308. },
  309. six[5][4] = {
  310. "111",
  311. "1 ",
  312. "111",
  313. "1 1",
  314. "111"
  315. },
  316. seven[5][4] = {
  317. "111",
  318. " 1",
  319. " 1 ",
  320. "1 ",
  321. "1 "
  322. },
  323. eight[5][4] = {
  324. "111",
  325. "1 1",
  326. "111",
  327. "1 1",
  328. "111"
  329. },
  330. nine[5][4] = {
  331. "111",
  332. "1 1",
  333. "111",
  334. " 1",
  335. "111"
  336. },
  337. digit1[5][4] = {
  338. "111",
  339. "1 1",
  340. "1 1",
  341. "1 1",
  342. "111"
  343. },
  344. digit2[5][4] = {
  345. "111",
  346. "1 1",
  347. "1 1",
  348. "1 1",
  349. "111"
  350. },
  351. digit3[5][4] = {
  352. "111",
  353. "1 1",
  354. "1 1",
  355. "1 1",
  356. "111"
  357. },
  358. digit4[5][4] = {
  359. "111",
  360. "1 1",
  361. "1 1",
  362. "1 1",
  363. "111"
  364. },
  365. digit5[5][4] = {
  366. "111",
  367. "1 1",
  368. "1 1",
  369. "1 1",
  370. "111"
  371. },
  372. digit6[5][4] = {
  373. "111",
  374. "1 1",
  375. "1 1",
  376. "1 1",
  377. "111"
  378. },
  379. digit[5][4] = {
  380. "111",
  381. "1 1",
  382. "1 1",
  383. "1 1",
  384. "111"
  385. };
  386.  
  387. void digit_update (char digit[5][4], char new_digit[5][4]) {
  388. for (int i = 0; i < 5; i++) {
  389. for (int j = 0; j < 3; j++) {
  390. digit[i][j] = new_digit[i][j];
  391. }
  392. }
  393. }
  394.  
  395. void update_digits () {
  396. int score_cpy = score;
  397. int digit_cnt = 0;
  398.  
  399. /*digit_update(digit1, zero);
  400. digit_update(digit2, zero);
  401. digit_update(digit3, zero);
  402. digit_update(digit4, zero);
  403. digit_update(digit5, zero);
  404. digit_update(digit6, zero);*/
  405.  
  406. while (score_cpy != 0) {
  407. for (int i = 0; i < 10; i++) {
  408. if (score_cpy % 10 == i) {
  409. if (i == 0) {
  410. digit_update(digit, zero);
  411. } else if (i == 1) {
  412. digit_update(digit, one);
  413. } else if (i == 2) {
  414. digit_update(digit, two);
  415. } else if (i == 3) {
  416. digit_update(digit, three);
  417. } else if (i == 4) {
  418. digit_update(digit, four);
  419. } else if (i == 5) {
  420. digit_update(digit, five);
  421. } else if (i == 6) {
  422. digit_update(digit, six);
  423. } else if (i == 7) {
  424. digit_update(digit, seven);
  425. } else if (i == 8) {
  426. digit_update(digit, eight);
  427. } else if (i == 9) {
  428. digit_update(digit, nine);
  429. }
  430.  
  431. if (digit_cnt == 0) {
  432. digit_update(digit1, digit);
  433. } else if (digit_cnt == 1) {
  434. digit_update(digit2, digit);
  435. } else if (digit_cnt == 2) {
  436. digit_update(digit3, digit);
  437. } else if (digit_cnt == 3) {
  438. digit_update(digit4, digit);
  439. } else if (digit_cnt == 4) {
  440. digit_update(digit5, digit);
  441. } else if (digit_cnt == 5) {
  442. digit_update(digit6, digit);
  443. }
  444. }
  445. }
  446.  
  447. digit_cnt++;
  448.  
  449. score_cpy /= 10;
  450. }
  451. }
  452.  
  453. int initial_y = 308;
  454.  
  455. float obstacle_v = 10, initial_v = 65, velocity = 65, gravity = -20, dt = 0.16;
  456.  
  457. bool jump = false, duck = false;
  458.  
  459. void events(SDL_Window *window);
  460.  
  461. void draw(SDL_Renderer *renderer);
  462.  
  463. void update (float dt, int &y) {
  464. y -= velocity * dt;
  465. velocity += gravity * dt;
  466.  
  467. if (initial_y == dinosaur.y) {
  468. jump = false;
  469.  
  470. velocity = initial_v;
  471. }
  472.  
  473. if (dinosaur.y > 308) {
  474. dinosaur.y = 308;
  475.  
  476. velocity = initial_v;
  477.  
  478. jump = false;
  479. }
  480. }
  481.  
  482. void generate_obstacle (Object &obstacle) {
  483. obstacle.type = rand() % 99 + 1;
  484.  
  485. if (obstacle.type % 3 == 0) {
  486. obstacle = { window_width + 1, 308, 18, 22, 1, 0 };
  487.  
  488. for (int i = 0; i < obstacle.height; i++) {
  489. for (int j = 0; j < obstacle.width; j++) {
  490. obstacle.hitbox[i][j] = obstacle1_hitbox[i][j];
  491. }
  492. }
  493. } else if (obstacle.type % 2 == 0) {
  494. obstacle = { window_width + 1, 308, 18, 22, 2, 0 };
  495.  
  496. for (int i = 0; i < obstacle.height; i++) {
  497. for (int j = 0; j < obstacle.width; j++) {
  498. obstacle.hitbox[i][j] = obstacle2_hitbox[i][j];
  499. }
  500. }
  501. } else if (obstacle.type % 3 != 0 && obstacle.type % 2 != 0) {
  502. int y = rand() % 3 + 1;
  503.  
  504. if (y == 1) {
  505. obstacle = { window_width + 1, 248, 26, 11, 3, 1 };
  506. } else if (y == 2) {
  507. obstacle = { window_width + 1, 292, 26, 11, 3, 1 };
  508. } else if (y == 3) {
  509. obstacle = { window_width + 1, 352, 26, 11, 3, 1 };
  510. }
  511.  
  512. for (int i = 0; i < obstacle.height; i++) {
  513. for (int j = 0; j < obstacle.width; j++) {
  514. obstacle.hitbox[i][j] = obstacle3_hitbox[i][j];
  515. }
  516. }
  517. }
  518. }
  519.  
  520. void copy_obstacle (Object &obstacle1, Object &obstacle2) {
  521. obstacle1.height = obstacle2.height;
  522. obstacle1.width = obstacle2.width;
  523. obstacle1.x = obstacle2.x;
  524. obstacle1.y = obstacle2.y;
  525. obstacle1.type = obstacle2.type;
  526. obstacle1.fly = obstacle2.fly;
  527.  
  528. for (int i = 0; i < obstacle1.height; i++) {
  529. for (int j = 0; j < obstacle1.width; j++) {
  530. obstacle1.hitbox[i][j] = obstacle2.hitbox[i][j];
  531. }
  532. }
  533. }
  534.  
  535. void obstacle3_animation (Object &obstacle) {
  536. if (obstacle.fly) {
  537. for (int i = 0; i < obstacle.height; i++) {
  538. for (int j = 0; j < obstacle.width; j++) {
  539. obstacle.hitbox[i][j] = obstacle3_hitbox2[i][j];
  540. }
  541. }
  542.  
  543. obstacle.fly = 0;
  544. } else if (!obstacle.fly) {
  545. for (int i = 0; i < obstacle.height; i++) {
  546. for (int j = 0; j < obstacle.width; j++) {
  547. obstacle.hitbox[i][j] = obstacle3_hitbox[i][j];
  548. }
  549. }
  550.  
  551. obstacle.fly = 1;
  552. }
  553. }
  554.  
  555. bool collision (Object object) {
  556. for (int i = 0; i < dinosaur.height; i++) {
  557. for (int j = 0; j < dinosaur.width; j++) {
  558. if (dinosaur.hitbox[i][j] == '1') {
  559. if ((dinosaur.x + (j * 4) >= object.x) && (dinosaur.x + (j*4) < object.x + (object.width * 4)) && (dinosaur.y + (i*4) >= object.y) && (dinosaur.y + (i*4) < object.y + (object.height * 4))) {
  560. for (int k = 0; k < object.height; k++) {
  561. for (int l = 0; l < object.width; l++) {
  562. if (object.hitbox[k][l] == '1') {
  563. if ((dinosaur.x + (j*4) >= object.x + (l*4) && dinosaur.x + (j*4) <= object.x + ((l+1)*4)-1) && (dinosaur.y + (i*4) >= object.y + (k*4) && dinosaur.y + (i*4) <= object.y + ((k+1)*4)-1)) {
  564. return true;
  565. }
  566. }
  567. }
  568. }
  569. }
  570. }
  571. }
  572. }
  573.  
  574.  
  575. /*if (object.x + (object.width*4) >= dinosaur.x && dinosaur.x + (dinosaur.width*4) >= object.x && object.y + (object.height*4) >= dinosaur.y && dinosaur.y + (dinosaur.height*4) >= object.y) {
  576. return true;
  577. }*/
  578.  
  579.  
  580. return false;
  581. }
  582.  
  583. int main(int argv, char** args)
  584. {
  585. srand(time(NULL));
  586.  
  587. SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS);
  588.  
  589. SDL_Window *window =
  590. SDL_CreateWindow(
  591. TITLE,
  592. SDL_WINDOWPOS_CENTERED,
  593. SDL_WINDOWPOS_CENTERED,
  594. window_width,
  595. window_height,
  596. SDL_WINDOW_SHOWN);
  597.  
  598. SDL_Renderer *renderer =
  599. SDL_CreateRenderer(
  600. window,
  601. -1,
  602. SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
  603.  
  604. generate_obstacle(obstacle1);
  605.  
  606. // INITIALIZE DINO HITBOX
  607.  
  608. for (int i = 0; i < dinosaur.height; i++) {
  609. for (int j = 0; j < dinosaur.width; j++) {
  610. dinosaur.hitbox[i][j] = dinosaur_walk0_hitbox[i][j];
  611. }
  612. }
  613.  
  614. while (!quit) {
  615. int start = SDL_GetTicks();
  616. frames++;
  617.  
  618. printf("%d %f (o1: %d, o2: %d) %d\n", start, obstacle_v, obstacle1.x, obstacle2.x, frames);
  619.  
  620. events(window);
  621.  
  622. if (frames % 2 == 0) {
  623. score++;
  624.  
  625. update_digits();
  626. }
  627.  
  628.  
  629. if (jump) {
  630. walk = 3;
  631.  
  632. update_dino_hitbox();
  633.  
  634. update(dt, dinosaur.y);
  635. }
  636.  
  637. if (frames % 6 == 0) {
  638. if (duck) update_dino_hitbox();
  639.  
  640. if (!jump && !duck) update_dino_hitbox();
  641.  
  642. if (obstacle1.type == 3) obstacle3_animation(obstacle1);
  643. if (obstacle2.type == 3) obstacle3_animation(obstacle2);
  644. }
  645.  
  646. if (collision(obstacle1) || collision(obstacle2)) quit = true;
  647.  
  648. if (obstacle1.x + obstacle1.width * 4 <= window_width-(500 + rand() % 100) && nextob) {
  649. generate_obstacle(obstacle2);
  650.  
  651. nextob = false;
  652. }
  653.  
  654. if (obstacle1.x + obstacle1.width * 4 < 0) {
  655. copy_obstacle(obstacle1, obstacle2);
  656.  
  657. nextob = true;
  658.  
  659. if (obstacle2.x > window_width)
  660. generate_obstacle(obstacle2);
  661. }
  662.  
  663. draw(renderer);
  664.  
  665. SDL_RenderPresent(renderer);
  666.  
  667. int time = SDL_GetTicks() - start;
  668. int sleepTime = minframetime - time;
  669. if (sleepTime > 0) {
  670. SDL_Delay(sleepTime);
  671. }
  672. if (frames % 300 == 0) {
  673. obstacle_v += 0.25;
  674.  
  675. if (obstacle_v > 15) {
  676. obstacle_v = 15;
  677. }
  678. }
  679. }
  680.  
  681. SDL_DestroyWindow(window);
  682. SDL_DestroyRenderer(renderer);
  683. SDL_Quit();
  684.  
  685. return 0;
  686. }
  687.  
  688. void events(SDL_Window *window) {
  689. SDL_Event event;
  690.  
  691. while (SDL_PollEvent(&event) != 0) {
  692. if (event.type == SDL_QUIT) {
  693. quit = true;
  694. } else if (event.type == SDL_KEYDOWN) {
  695. SDL_Keycode new_keycode = event.key.keysym.sym;
  696.  
  697. if (new_keycode == SDLK_SPACE && !duck) {
  698.  
  699. jump = true;
  700.  
  701. keycode = new_keycode;
  702.  
  703. break;
  704. } else if (new_keycode == SDLK_s && !duck && !jump) {
  705. duck = true;
  706.  
  707. dinosaur.width = 26;
  708. dinosaur.height = 13;
  709. dinosaur.y = 340;
  710.  
  711. walk = 4;
  712.  
  713. update_dino_hitbox();
  714.  
  715. break;
  716. } else if (new_keycode == SDLK_s && duck) {
  717. duck = false;
  718.  
  719. dinosaur.width = 18;
  720. dinosaur.height = 22;
  721. dinosaur.y = 308;
  722.  
  723. walk = 2;
  724.  
  725. update_dino_hitbox();
  726.  
  727. break;
  728. }
  729. }
  730. }
  731. }
  732.  
  733. void draw(SDL_Renderer *renderer) {
  734. SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
  735. SDL_RenderClear(renderer);
  736.  
  737. SDL_Rect rect = { 0, 0, window_width, window_height};
  738. SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
  739. SDL_RenderFillRect(renderer, &rect);
  740.  
  741. rect = { 0, window_height-100, window_width, 1};
  742. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  743. SDL_RenderFillRect(renderer, &rect);
  744.  
  745. // <--- START DRAW DINOSAUR --->
  746.  
  747. for (int i = 0; i < dinosaur.height; i++) {
  748. for (int j = 0; j < dinosaur.width; j++) {
  749. if (dinosaur.hitbox[i][j] == '1') {
  750. SDL_Rect rect = { dinosaur.x + j*4, dinosaur.y + i*4, 4, 4};
  751. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  752. SDL_RenderFillRect(renderer, &rect);
  753. }
  754. }
  755. }
  756.  
  757. // <--- END DRAW DINOSAUR --->
  758.  
  759. // <--- START DRAW OBSTACLES --->
  760.  
  761. for (int i = 0; i < obstacle1.height; i++) {
  762. for (int j = 0; j < obstacle1.width; j++) {
  763. if (obstacle1.hitbox[i][j] == '1') {
  764. SDL_Rect rect = { obstacle1.x + j*4, obstacle1.y + i*4, 4, 4};
  765. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  766. SDL_RenderFillRect(renderer, &rect);
  767. }
  768. }
  769. }
  770.  
  771. obstacle1.x -= obstacle_v;
  772.  
  773. for (int i = 0; i < obstacle2.height; i++) {
  774. for (int j = 0; j < obstacle2.width; j++) {
  775. if (obstacle2.hitbox[i][j] == '1') {
  776. SDL_Rect rect = { obstacle2.x + j*4, obstacle2.y + i*4, 4, 4};
  777. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  778. SDL_RenderFillRect(renderer, &rect);
  779. }
  780. }
  781. }
  782.  
  783. obstacle2.x -= obstacle_v;
  784.  
  785. // <--- END DRAW OBSTACLES --->
  786.  
  787. // <--- START DRAW SCORE --->
  788.  
  789. for (int k = 0; k < 6; k++) {
  790. for (int i = 0; i < 5; i++) {
  791. for (int j = 0; j < 3; j++) {
  792. if (k == 0) {
  793. if (digit6[i][j] == '1') {
  794. SDL_Rect rect = { ((j+(k*3)) * 10), (i * 10), 10, 10 };
  795. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  796. SDL_RenderFillRect(renderer, &rect);
  797. }
  798. } else if (k == 1) {
  799. if (digit5[i][j] == '1') {
  800. SDL_Rect rect = { ((j+(k*3)+1) * 10), (i * 10), 10, 10 };
  801. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  802. SDL_RenderFillRect(renderer, &rect);
  803. }
  804. } else if (k == 2) {
  805. if (digit4[i][j] == '1') {
  806. SDL_Rect rect = { ((j+(k*3)+2) * 10), (i * 10), 10, 10 };
  807. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  808. SDL_RenderFillRect(renderer, &rect);
  809. }
  810. } else if (k == 3) {
  811. if (digit3[i][j] == '1') {
  812. SDL_Rect rect = { ((j+(k*3)+3) * 10), (i * 10), 10, 10 };
  813. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  814. SDL_RenderFillRect(renderer, &rect);
  815. }
  816. } else if (k == 4) {
  817. if (digit2[i][j] == '1') {
  818. SDL_Rect rect = { ((j+(k*3)+4) * 10), (i * 10), 10, 10 };
  819. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  820. SDL_RenderFillRect(renderer, &rect);
  821. }
  822. } else if (k == 5) {
  823. if (digit1[i][j] == '1') {
  824. SDL_Rect rect = { ((j+(k*3)+5) * 10), (i * 10), 10, 10 };
  825. SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  826. SDL_RenderFillRect(renderer, &rect);
  827. }
  828. }
  829. }
  830. }
  831. }
  832.  
  833. // <--- END DRAW SCORE --->
  834.  
  835. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!