API tools faq
paste
Advertisement
Guest User

Exercice du lundi - 5

a guest
Jan 2nd, 2015
452
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.50 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * Copyright (C) 2015 Guillaume Charifi
  3.  *
  4.  * This library is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU Lesser General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 2.1 of the License, or (at your option) any later version.
  8.  *
  9.  * This library is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.  * Lesser General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Lesser General Public
  15.  * License along with this library; if not, write to the Free Software
  16.  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17.  */
  18.  
  19. #include <stdlib.h>
  20. #include <time.h>
  21.  
  22. #include "libhang.h"
  23. #include "libhang/libsuicide.h"
  24. #include "libhang/obj_classes/ColoredCube.h"
  25.  
  26. #define ENTITIES_DISTANCE (1./10.)
  27.  
  28. #define UNDEFINED 0
  29. #define ZOMBIE    1
  30. #define HUNTER    2
  31. #define VILLAGER  3
  32.  
  33. static int nb_zombies = 0;
  34. static int nb_hunters = 0;
  35. static int nb_villagers = 0;
  36. static int nb_rounds = 0;
  37.  
  38. static int nb_single = 0;
  39. static int nb_double = 0;
  40. static int nb_dead_zombies = 0;
  41. static int nb_dead_victims = 0;
  42. static int nb_dead_hunters = 0;
  43.  
  44. static int hunters_attacked = 0;
  45. static int zombies_attacked = 0;
  46.  
  47. static int results_displayed = 0;
  48.  
  49. static struct cube {
  50.     int type;
  51.     int dir_x;
  52.     int dir_y;
  53.     int used;
  54.     int moved;
  55.     lh_obj_t *cube;
  56.  
  57.     int is_target;
  58. } cubes[20][20] = {0};
  59.  
  60. static volatile int terminate = 0;
  61.  
  62. static inline void pre_move(void)
  63. {
  64.     for(int i=0; i<20; i++) {
  65.         for(int j=0; j<20; j++) {
  66.             cubes[i][j].dir_x = 0;
  67.             cubes[i][j].dir_y = 0;
  68.             cubes[i][j].moved = 0;
  69.  
  70.             if(!cubes[i][j].cube)
  71.                 continue;
  72.  
  73.             cubes[i][j].used = 1;
  74.  
  75.             int i_min = (i == 0) ? 0 : i-1;
  76.             int j_min = (j == 0) ? 0 : j-1;
  77.             int i_max = (i == 19) ? 19 : i+1;
  78.             int j_max = (j == 19) ? 19 : j+1;
  79.  
  80.             if(cubes[i][j].type == VILLAGER
  81.                     && cubes[i_min][j_min].type != ZOMBIE
  82.                     && cubes[i_max][j_min].type != ZOMBIE
  83.                     && cubes[i_min][j_max].type != ZOMBIE
  84.                     && cubes[i_max][j_max].type != ZOMBIE
  85.                     && cubes[i_min][j].type != ZOMBIE
  86.                     && cubes[i][j_min].type != ZOMBIE
  87.                     && cubes[i_max][j].type != ZOMBIE
  88.                     && cubes[i][j_max].type != ZOMBIE)
  89.                 continue;
  90.  
  91.             switch((int)(((float)rand() / (float)RAND_MAX) * 8.)) {
  92.                 case 0:
  93.                     if(cubes[i][j].type != ZOMBIE) {
  94.                         if(cubes[i_min][j_min].cube)
  95.                             break;
  96.  
  97.                         cubes[i][j].dir_x = -1;
  98.                         cubes[i][j].dir_y = -1;
  99.                         break;
  100.                     }
  101.                 case 1:
  102.                     if(cubes[i_min][j].cube)
  103.                         break;
  104.  
  105.                     cubes[i][j].dir_x = -1;
  106.                     break;
  107.                 case 2:
  108.                     if(cubes[i][j].type != ZOMBIE) {
  109.                         if(cubes[i_max][j_max].cube)
  110.                             break;
  111.  
  112.                         cubes[i][j].dir_x = 1;
  113.                         cubes[i][j].dir_y = 1;
  114.                         break;
  115.                     }
  116.                 case 3:
  117.                     if(cubes[i_max][j].cube)
  118.                         break;
  119.  
  120.                     cubes[i][j].dir_x = 1;
  121.                     break;
  122.                 case 4:
  123.                     if(cubes[i][j].type != ZOMBIE) {
  124.                         if(cubes[i_max][j_min].cube)
  125.                             break;
  126.  
  127.                         cubes[i][j].dir_x = 1;
  128.                         cubes[i][j].dir_y = -1;
  129.                         break;
  130.                     }
  131.                 case 5:
  132.                     if(cubes[i][j_min].cube)
  133.                         break;
  134.  
  135.                     cubes[i][j].dir_y = -1;
  136.                     break;
  137.                 case 6:
  138.                     if(cubes[i][j].type != ZOMBIE) {
  139.                         if(cubes[i_min][j_max].cube)
  140.                             break;
  141.  
  142.                         cubes[i][j].dir_x = -1;
  143.                         cubes[i][j].dir_y = 1;
  144.                         break;
  145.                     }
  146.                 default:
  147.                     if(cubes[i][j_max].cube)
  148.                         break;
  149.  
  150.                     cubes[i][j].dir_y = 1;
  151.             }
  152.  
  153.             if((i == 0 && cubes[i][j].dir_x < 0)
  154.                     || (i == 19 && cubes[i][j].dir_x > 0))
  155.                 cubes[i][j].dir_x = 0;
  156.             if((j == 0 && cubes[i][j].dir_y < 0)
  157.                     || (j == 19 && cubes[i][j].dir_y > 0))
  158.                 cubes[i][j].dir_y = 0;
  159.  
  160.             if(cubes[i + cubes[i][j].dir_x][j + cubes[i][j].dir_y].used) {
  161.                 cubes[i][j].dir_x = 0;
  162.                 cubes[i][j].dir_y = 0;
  163.             } else {
  164.                 cubes[i + cubes[i][j].dir_x][j + cubes[i][j].dir_y].used = 1;
  165.             }
  166.         }
  167.     }
  168. }
  169.  
  170. static inline void move(lh_window_t *window)
  171. {
  172.     int rand_y = ((int)((float)rand() / (float)RAND_MAX * 2.)) ? -1 : 1;
  173.  
  174.     for(float n = 0; n < 100; n++) {
  175.         for(int i=0; i<20; i++) {
  176.             for(int j=0; j<20; j++) {
  177.                 if(!cubes[i][j].cube)
  178.                     continue;
  179.  
  180.                 if(!cubes[i][j].dir_x && !cubes[i][j].dir_y) {
  181.                     cubes[i][j].cube->angle.x = 0;
  182.                     cubes[i][j].cube->angle.y = rand_y * n / 99. * LH_PI * 2.;
  183.                     cubes[i][j].cube->angle.z = 0;
  184.                     continue;
  185.                 }
  186.  
  187.                 cubes[i][j].cube->pos.x += cubes[i][j].dir_x * ENTITIES_DISTANCE / 100.f;
  188.                 cubes[i][j].cube->pos.z += cubes[i][j].dir_y * ENTITIES_DISTANCE / 100.f;
  189.  
  190.                 if(cubes[i][j].dir_x && cubes[i][j].dir_y) {
  191.                     cubes[i][j].cube->angle.z = -cubes[i][j].dir_x * n / 99. * LH_PI / 2.;
  192.                     cubes[i][j].cube->angle.x = cubes[i][j].dir_y * n / 99. * LH_PI / 2.;
  193.                 } else {
  194.                     cubes[i][j].cube->angle.z = -cubes[i][j].dir_x * n / 99. * LH_PI / 2.;
  195.                     cubes[i][j].cube->angle.x = cubes[i][j].dir_y * n / 99. * LH_PI / 2.;
  196.                 }
  197.                 cubes[i][j].cube->angle.y = 0;
  198.             }
  199.         }
  200.  
  201.         lhDirtyObjBuffer(window);
  202.         lhDelay(5);
  203.     }
  204. }
  205.  
  206. static inline void post_move(lh_window_t *window)
  207. {
  208.     for(int i=0; i<20; i++) {
  209.         for(int j=0; j<20; j++) {
  210.             cubes[i][j].used = 0;
  211.  
  212.             if(!cubes[i][j].cube || cubes[i][j].moved)
  213.                 continue;
  214.  
  215.             int new_i = i + cubes[i][j].dir_x;
  216.             int new_j = j + cubes[i][j].dir_y;
  217.  
  218.             if(new_i == i && new_j == j)
  219.                 continue;
  220.  
  221.             cubes[new_i][new_j].type = cubes[i][j].type;
  222.             cubes[new_i][new_j].cube = cubes[i][j].cube;
  223.             cubes[i][j].type = UNDEFINED;
  224.             cubes[i][j].cube = NULL;
  225.  
  226.             cubes[new_i][new_j].cube->pos.x = new_i * ENTITIES_DISTANCE - (ENTITIES_DISTANCE * 19. / 2.);
  227.             cubes[new_i][new_j].cube->pos.z = new_j * ENTITIES_DISTANCE - (ENTITIES_DISTANCE * 19. / 2.);
  228.  
  229.             cubes[i][j].moved = 1;
  230.             cubes[new_i][new_j].moved = 1;
  231.         }
  232.     }
  233.  
  234.     lhDirtyObjBuffer(window);
  235. }
  236.  
  237. static inline void pre_hunter_attack(void)
  238. {
  239.     hunters_attacked = 0;
  240.     if(!nb_hunters || !nb_zombies)
  241.         return;
  242.  
  243.     for(int i=0; i<20; i++) {
  244.         for(int j=0; j<20; j++) {
  245.             if(!cubes[i][j].cube || cubes[i][j].type != HUNTER)
  246.                 continue;
  247.                
  248.             int nb_targets = 0;
  249.  
  250.             int i_min = (i == 0) ? 0 : i-1;
  251.             int j_min = (j == 0) ? 0 : j-1;
  252.             int i_max = (i == 19) ? 19 : i+1;
  253.             int j_max = (j == 19) ? 19 : j+1;
  254.  
  255.             if(cubes[i_min][j_min].cube && cubes[i_min][j_min].type == ZOMBIE && !cubes[i_min][j_min].is_target) { cubes[i_min][j_min].is_target = 1; nb_targets++; }
  256.             if(cubes[i_max][j_min].cube && cubes[i_max][j_min].type == ZOMBIE && !cubes[i_max][j_min].is_target) { cubes[i_max][j_min].is_target = 1; nb_targets++; }
  257.             if(nb_targets < 2)
  258.                 if(cubes[i_min][j_max].cube && cubes[i_min][j_max].type == ZOMBIE && !cubes[i_min][j_max].is_target) { cubes[i_min][j_max].is_target = 1; nb_targets++; }
  259.             if(nb_targets < 2)
  260.                 if(cubes[i_max][j_max].cube && cubes[i_max][j_max].type == ZOMBIE && !cubes[i_max][j_max].is_target) { cubes[i_max][j_max].is_target = 1; nb_targets++; }
  261.  
  262.             if(nb_targets < 2)
  263.                 if(cubes[i_min][j].cube && cubes[i_min][j].type == ZOMBIE && !cubes[i_min][j].is_target) { cubes[i_min][j].is_target = 1; nb_targets++; }
  264.             if(nb_targets < 2)
  265.                 if(cubes[i][j_min].cube && cubes[i][j_min].type == ZOMBIE && !cubes[i][j_min].is_target) { cubes[i][j_min].is_target = 1; nb_targets++; }
  266.             if(nb_targets < 2)
  267.                 if(cubes[i_max][j].cube && cubes[i_max][j].type == ZOMBIE && !cubes[i_max][j].is_target) { cubes[i_max][j].is_target = 1; nb_targets++; }
  268.             if(nb_targets < 2)
  269.                 if(cubes[i][j_max].cube && cubes[i][j_max].type == ZOMBIE && !cubes[i][j_max].is_target) { cubes[i][j_max].is_target = 1; nb_targets++; }
  270.  
  271.             if(nb_targets) hunters_attacked = 1;
  272.  
  273.             if(nb_targets == 1) nb_single++;
  274.             if(nb_targets == 2) nb_double++;
  275.             nb_dead_zombies += nb_targets;;
  276.         }
  277.     }
  278. }
  279.  
  280. static inline void hunter_attack(lh_window_t *window)
  281. {
  282.     if(!hunters_attacked)
  283.         return;
  284.  
  285.     for(float n = 0; n < 100; n++) {
  286.         for(int i=0; i<20; i++) {
  287.             for(int j=0; j<20; j++) {
  288.                 if(!cubes[i][j].cube || !cubes[i][j].is_target)
  289.                     continue;
  290.  
  291.                 lhColoredCubeSetColor(window, cubes[i][j].cube, &LH_RGBA(1.f, (float)n / 99.f, (float)n / 99.f, 1.f - (float)n / 99.f));
  292.             }
  293.         }
  294.  
  295.         lhDirtyObjBuffer(window);
  296.         lhDelay(5);
  297.     }
  298. }
  299.  
  300. static inline void post_hunter_attack(lh_window_t *window)
  301. {
  302.     if(!hunters_attacked)
  303.         return;
  304.  
  305.     for(int i=0; i<20; i++) {
  306.         for(int j=0; j<20; j++) {
  307.             if(!cubes[i][j].cube || !cubes[i][j].is_target)
  308.                 continue;
  309.  
  310.             lhDeleteColoredCube(window, cubes[i][j].cube);
  311.            
  312.             nb_zombies--;
  313.             cubes[i][j].type = UNDEFINED;
  314.             cubes[i][j].cube = NULL;
  315.             cubes[i][j].is_target = 0;
  316.         }
  317.     }
  318. }
  319.  
  320.  
  321. static inline void pre_zombie_attack(void)
  322. {
  323.     zombies_attacked = 0;
  324.     if(!nb_zombies || (!nb_villagers && !nb_hunters))
  325.         return;
  326.  
  327.     for(int i=0; i<20; i++) {
  328.         for(int j=0; j<20; j++) {
  329.             if(!cubes[i][j].cube || cubes[i][j].type != ZOMBIE)
  330.                 continue;
  331.  
  332.             int nb_targets = 0;
  333.  
  334.             int i_min = (i == 0) ? 0 : i-1;
  335.             int j_min = (j == 0) ? 0 : j-1;
  336.             int i_max = (i == 19) ? 19 : i+1;
  337.             int j_max = (j == 19) ? 19 : j+1;
  338.  
  339.             if(cubes[i_min][j].cube && (cubes[i_min][j].type == VILLAGER || cubes[i_min][j].type == HUNTER) && !cubes[i_min][j].is_target) { cubes[i_min][j].is_target = 1; nb_targets++; if(cubes[i_min][j].type == VILLAGER) nb_dead_victims++; else nb_dead_hunters++; }
  340.             if(cubes[i][j_min].cube && (cubes[i][j_min].type == VILLAGER || cubes[i][j_min].type == HUNTER) && !cubes[i][j_min].is_target) { cubes[i][j_min].is_target = 1; nb_targets++; if(cubes[i][j_min].type == VILLAGER) nb_dead_victims++; else nb_dead_hunters++; }
  341.             if(cubes[i_max][j].cube && (cubes[i_max][j].type == VILLAGER || cubes[i_max][j].type == HUNTER) && !cubes[i_max][j].is_target) { cubes[i_max][j].is_target = 1; nb_targets++; if(cubes[i_max][j].type == VILLAGER) nb_dead_victims++; else nb_dead_hunters++; }
  342.             if(cubes[i][j_max].cube && (cubes[i][j_max].type == VILLAGER || cubes[i][j_max].type == HUNTER) && !cubes[i][j_max].is_target) { cubes[i][j_max].is_target = 1; nb_targets++; if(cubes[i][j_max].type == VILLAGER) nb_dead_victims++; else nb_dead_hunters++; }
  343.            
  344.             if(nb_targets)
  345.                 zombies_attacked = 1;
  346.         }
  347.     }
  348. }
  349.  
  350. static inline void zombie_attack(lh_window_t *window)
  351. {
  352.     if(!zombies_attacked)
  353.         return;
  354.  
  355.     for(float n = 0; n < 100; n++) {
  356.         for(int i=0; i<20; i++) {
  357.             for(int j=0; j<20; j++) {
  358.                 if(!cubes[i][j].cube || !cubes[i][j].is_target)
  359.                     continue;
  360.                 float m = (float)n / 99.f;
  361.  
  362.                 lhColoredCubeSetColor(window, cubes[i][j].cube, &LH_RGBA(m, (cubes[i][j].type == VILLAGER) ? 1. : m, (cubes[i][j].type == HUNTER) ? 1. : m,  1.f - m));
  363.             }
  364.         }
  365.  
  366.         lhDirtyObjBuffer(window);
  367.         lhDelay(5);
  368.     }
  369.  
  370.     for(float n = 0; n < 100; n++) {
  371.         for(int i=0; i<20; i++) {
  372.             for(int j=0; j<20; j++) {
  373.                 if(!cubes[i][j].cube || !cubes[i][j].is_target)
  374.                     continue;
  375.                 float m = (float)n / 99.f;
  376.  
  377.                 lhColoredCubeSetColor(window, cubes[i][j].cube, &LH_RGBA(1.f, 1.f - m, 1.f - m, m));
  378.             }
  379.         }
  380.  
  381.         lhDirtyObjBuffer(window);
  382.         lhDelay(5);
  383.     }
  384. }
  385.  
  386. static inline void post_zombie_attack(void)
  387. {
  388.     if(!zombies_attacked)
  389.         return;
  390.  
  391.     for(int i=0; i<20; i++) {
  392.         for(int j=0; j<20; j++) {
  393.             if(!cubes[i][j].cube || !cubes[i][j].is_target)
  394.                 continue;
  395.  
  396.             if(cubes[i][j].type == HUNTER) nb_hunters--;
  397.             if(cubes[i][j].type == VILLAGER) nb_villagers--;
  398.             nb_zombies++;
  399.  
  400.             cubes[i][j].type = ZOMBIE;
  401.             cubes[i][j].is_target = 0;
  402.         }
  403.     }
  404. }
  405.  
  406. static inline void disp_results(void)
  407. {
  408.     if(results_displayed)
  409.         return;
  410.  
  411.     printf("Fin de la partie !\n"
  412.            "Nombre de single-kills : %d.\n"
  413.            "Nombre de double-kills : %d.\n"
  414.            "Nombre de zombies exterminés : %d.\n"
  415.            "Nombre de victimes zombifiées : %d.\n"
  416.            "Nombre de chasseurs zombifiés : %d.\n",
  417.             nb_single,
  418.             nb_double,
  419.             nb_dead_zombies,
  420.             nb_dead_victims,
  421.             nb_dead_hunters);
  422.  
  423.     results_displayed = 1;
  424. }
  425.  
  426. static void *anim(void *window)
  427. {
  428.     while(1) {
  429.         if(terminate)
  430.             break;
  431.         if(!nb_rounds) {
  432.             nb_zombies = 0;
  433.             nb_hunters = 0;
  434.             nb_villagers = 0;
  435.  
  436.             disp_results();
  437.         }
  438.  
  439.         pre_move();
  440.         move(window);
  441.         post_move(window);
  442.  
  443.         pre_hunter_attack();
  444.         hunter_attack(window);
  445.         post_hunter_attack(window);
  446.  
  447.         pre_zombie_attack();
  448.         zombie_attack(window);
  449.         post_zombie_attack();
  450.  
  451.         lhDirtyObjBuffer(window);
  452.  
  453.         while(lhIsDirtyObjBuffer(window))
  454.             lhDelay(0);
  455.  
  456.         if(nb_rounds > 0)
  457.             nb_rounds--;
  458.     }
  459. }
  460.  
  461. static inline void fflushstdin(void)
  462. {
  463.     int c;
  464.     while((c = fgetc(stdin)) != EOF && c != '\n');
  465. }
  466.  
  467. int main()
  468. {
  469.     lh_window_t *window;
  470.     lh_thread_t *anim_thread;
  471.  
  472.     srand(time(NULL));
  473.  
  474.     int ret = 0;
  475.     do {
  476.         printf("Nombre de zombies : ");
  477.         ret = scanf("%d", &nb_zombies);
  478.         fflushstdin();
  479.     } while(ret != 1 || nb_zombies < 0);
  480.     do {
  481.         printf("Nombre de chasseurs : ");
  482.         ret = scanf("%d", &nb_hunters);
  483.         fflushstdin();
  484.     } while(ret != 1 || nb_hunters < 0);
  485.     do {
  486.         printf("Nombre de villageois : ");
  487.         ret = scanf("%d", &nb_villagers);
  488.         fflushstdin();
  489.     } while(ret != 1 || nb_villagers < 0);
  490.     do {
  491.         printf("Nombre de tours : ");
  492.         ret = scanf("%d", &nb_rounds);
  493.         fflushstdin();
  494.     } while(ret != 1);
  495.            
  496.     if(nb_zombies + nb_hunters + nb_villagers > 20 * 20) {
  497.         fprintf(stderr, "Dépassement du nombre maximal d'entités.\n");
  498.         return -1;
  499.     }
  500.  
  501.     lhInit();
  502.  
  503.     window = lhCreateWindow("Exo du Lundi 5", 0, 0, 600, 600, LH_DEFAULT_DEPTH);
  504.  
  505.     lhEnableMSAA(window, LH_MSAA_NONE);
  506.  
  507.     lhSetRenderDistances(window, &LH_DISTANCES(.1f, 500.f));
  508.     lhSetBackColor(window, &LH_RGBA(.1f, .1f, .1f, 1.f));
  509.     lhSetAmbientLight(window, &LH_RGB(0.f, 0.f, .1f));
  510.  
  511.     lhEnableLight(window, 0, LH_TRUE);
  512.     lhSetLightParameters(window, 0, &LH_RGB(1.f, 1.f, 1.f), &LH_VEC3(0.f, -1.f, 0.f));
  513.  
  514.     lhSetCameraPos(window, &LH_VEC3(0.f, 2.f, 0.f));
  515.     lhSetCameraAngle(window, &LH_VEC3(-.5 * LH_PI, 0.f, 0.f));
  516.  
  517.     lhRegColoredCube(window);
  518.  
  519.  
  520.     int nb_remaining = nb_zombies + nb_hunters + nb_villagers;
  521.     int nb_zombies_remaining = nb_zombies;
  522.     int nb_hunters_remaining = nb_hunters;
  523.     int nb_villagers_remaining = nb_villagers;
  524.  
  525.     while(nb_remaining) {
  526.         for(int i=0; i<20 && nb_remaining; i++) {
  527.             for(int j=0; j<20 && nb_remaining; j++) {
  528.                 lh_rgba_t color;
  529.  
  530.                 if(cubes[i][j].cube)
  531.                     continue;
  532.  
  533.                 switch((int)(((float)rand() / (float)RAND_MAX) * (3.f + 20.f * 20.f * nb_remaining / (nb_zombies + nb_hunters + nb_villagers)))) {
  534.                     case 0:
  535.                         if(!nb_zombies_remaining) continue;
  536.  
  537.                         color.r = 1.f;
  538.                         color.g = 0.f;
  539.                         color.b = 0.f;
  540.                         color.a = 1.f;
  541.                         cubes[i][j].type = ZOMBIE;
  542.  
  543.                         nb_zombies_remaining--;
  544.                         break;
  545.  
  546.                     case 1:
  547.                         if(!nb_hunters_remaining) continue;
  548.  
  549.                         color.r = 0.f;
  550.                         color.g = 0.f;
  551.                         color.b = 1.f;
  552.                         color.a = 1.f;
  553.                         cubes[i][j].type = HUNTER;
  554.  
  555.                         nb_hunters_remaining--;
  556.                         break;
  557.  
  558.                     case 2:
  559.                         if(!nb_villagers_remaining) continue;
  560.  
  561.                         color.r = 0.f;
  562.                         color.g = 1.f;
  563.                         color.b = 0.f;
  564.                         color.a = 1.f;
  565.                         cubes[i][j].type = VILLAGER;
  566.  
  567.                         nb_villagers_remaining--;
  568.                         break;
  569.  
  570.                     default:
  571.                         continue;
  572.                 }
  573.  
  574.                 cubes[i][j].cube = lhNewColoredCube(window, 1.f / 30.f, &LH_VEC3(i * ENTITIES_DISTANCE - (ENTITIES_DISTANCE * 19. / 2.), 0.f, j * ENTITIES_DISTANCE - (ENTITIES_DISTANCE * 19. / 2.)), &LH_VEC3(0.f, 0.f, 0.f), &color, LH_TRUE);
  575.  
  576.                 nb_remaining--;
  577.             }
  578.         }
  579.     }
  580.  
  581.     anim_thread = lhCreateThread(anim, window);
  582.  
  583.     lhStartDrawing(window);
  584.     lhEnterEventLoop(window);
  585.  
  586.     terminate = 1;
  587.     lhWaitThread(anim_thread, NULL);
  588.     lhReleaseThread(anim_thread);
  589.  
  590.     lhDestroyWindow(window);
  591.  
  592.     disp_results();
  593.  
  594.     return 0;
  595. }
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!