API tools faq
paste
Guest User

Untitled

a guest
Apr 21st, 2018
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.52 KB | None | 0 0
raw download clone embed print report
  1. #include "blast_it.h"
  2. #include "gui.h"
  3. #include "game.h"
  4. #include <stdlib.h>
  5. #include <stdio.h>
  6. #include <math.h>
  7.  
  8. void detect_collision_exp(Game* game, Explosion* exp);
  9. void move_enemy(Game * game, Enemy * enemy);
  10. void plaats_enemies(Game* game);
  11. void add_powerup(Game* game,int x,int y);
  12. void freeze_enemies(Game* game);
  13. void increment_score(Game* game,Enemy* enemy);
  14. int spread(Game * game, Explosion * exp, int dir);
  15. void move_player(Game * game, int dir);
  16. void lineOfFire(Game * game, Explosion * exp, int dir);
  17.  
  18. void init_game(Game * game, int level_nr)
  19. {
  20. LevelInfo level_info = {10,10,1,DESERT,0.5,2,1,0.5};
  21. Player player={1*TILE_SIZE,1*TILE_SIZE,EAST,3,20};
  22. Level level;
  23. init_level(&level,level_info);
  24. game->game_over=0;
  25. game->level=level;
  26. game->score=0;
  27. gui_set_level_info(&level_info);
  28. game->player=player;
  29. plaats_enemies(game);
  30. gui_start_timer();
  31. }
  32.  
  33. void plaats_enemies(Game* game){
  34. int aantalEnemies=game->level.level_info.nr_of_enemies;
  35. Enemy enemy = {0, 0, EAST,0,1,0,0};
  36. game->enemies=(Enemy*)calloc(aantalEnemies,sizeof(Enemy));
  37. while(aantalEnemies>0){
  38. int i= (rand() % (game->level.level_info.height-2)+1);
  39. int j= (rand() % (game->level.level_info.width-2)+1);
  40. if(aantalEnemies==1&&game->level.level_info.spawn_boss){
  41. enemy.is_boss=1;
  42. enemy.remaining_lives=3;
  43. }
  44. if(game->level.entities[i][j].type==EMPTY_SPACE&&!(i==1&&j==1)&&!(i==1&&j==2)&&!(i==2&&j==1)){
  45. enemy.x=j*TILE_SIZE;
  46. enemy.y=i*TILE_SIZE;
  47. game->enemies[game->level.level_info.nr_of_enemies-aantalEnemies]=enemy;
  48. aantalEnemies--;
  49. }
  50. }
  51. game->enemies_left=game->level.level_info.nr_of_enemies;
  52. }
  53.  
  54. void do_game_loop(Game * game)
  55. {
  56. int stop = 0;
  57.  
  58. while(!stop) {
  59. check_game_input(game);
  60. update_game(game);
  61. render_game(game);
  62. if(game->game_over||game->enemies_left==0)
  63. stop=1;
  64. }
  65. if(game->game_over){
  66. gui_set_game_over();
  67. }
  68. else gui_set_finished_level(game->score);
  69. destroy_level(&game->level);
  70. }
  71.  
  72. void check_game_input(Game * game)
  73. {
  74. int movement = gui_is_movement_key_down();
  75. int moves[4] = {(movement&UP)==UP,(movement&RIGHT)==RIGHT,(movement&DOWN)==DOWN,(movement&LEFT)==LEFT};
  76. int i;
  77. game->input.hasMoved=0;
  78. for (i=0;i<4;i++){
  79. (game->input).moves[i]=moves[i];
  80. game->input.hasMoved+=moves[i];
  81. }
  82. game->input.dropBomb = gui_is_space_pressed();
  83. }
  84.  
  85. void update_game(Game * game)
  86. {
  87. /* Do player movement */
  88. do_player_movement(game);
  89.  
  90. /* Check enemies (move, collision with player) */
  91. do_enemy_ai(game);
  92.  
  93. /* Process bonus items */
  94. process_bonus_items(game);
  95.  
  96. /* Process bombs */
  97. process_bombs(game);
  98. }
  99.  
  100. void render_game(Game * game)
  101. {
  102. int i;
  103. for(i=0;i<game->enemies_left;i++){
  104. gui_add_enemy(&game->enemies[i]);
  105. }
  106. render_level(&game->level);
  107. gui_add_player(&game->player);
  108. gui_draw_buffer();
  109. gui_set_bombs_left(game->player.remaining_bombs);
  110. gui_set_enemies_left(game->enemies_left);
  111. }
  112.  
  113. void destroy_game(Game * game)
  114. {
  115. free(game->enemies);
  116. free(game->level.entities);
  117. }
  118.  
  119. void do_player_movement(Game * game){
  120. Player* player=&game->player;
  121. int prevx=player->x;
  122. int prevy=player->y;
  123. int centx=prevx+(TILE_SIZE/2);
  124. int centy=prevy+(TILE_SIZE/2);
  125.  
  126. if(game->input.hasMoved){
  127. int i;
  128. for(i=0;i<4;i++){
  129. //MOVEMENT
  130. if(game->input.moves[i]){
  131. move_player(game, i);
  132. }
  133. }
  134. //ORIENTATION
  135. if(game->player.x>prevx){
  136. game->player.orientation=EAST;
  137. }
  138. else if (game->player.x<prevx) {
  139. game->player.orientation=WEST;
  140. }
  141. if(game->player.y>prevy){
  142. game->player.orientation=SOUTH;
  143. }
  144. else if(game->player.y<prevy) {
  145. game->player.orientation=NORTH;
  146. }
  147. if(game->player.x==prevx&&game->player.y==prevy){
  148. for(i=0;i<4;i++)
  149. if(game->input.moves[i]==1){
  150. game->player.orientation=i;
  151. }
  152. }
  153. }
  154. if(game->input.dropBomb){
  155. if(game->player.remaining_bombs>0){
  156. int x=(centx/TILE_SIZE);
  157. int y=(centy/TILE_SIZE);
  158. if(game->level.entities[y][x].type==EMPTY_SPACE){
  159. Bomb bom={BOMB,x*TILE_SIZE,y*TILE_SIZE,BOMB_TICKS};
  160. game->level.entities[y][x].type=BOMB;
  161. game->level.entities[y][x].bomb=bom;
  162. game->player.remaining_bombs--;
  163. }
  164. }
  165. }
  166. }
  167.  
  168. void move_player(Game * game, int dir){
  169. int x = game->player.x;
  170. int y = game->player.y;
  171. int dy = -((dir+1)%2)*(pow((double)-1,dir/2));
  172. int dx = (dir%2)*(pow((double)-1,(dir-1)/2));
  173. if(x%TILE_SIZE==0&&y%TILE_SIZE==0){
  174. if(game->level.entities[(y/TILE_SIZE)+dy][(x/TILE_SIZE)+dx].type!=OBSTACLE&&game->level.entities[(y/TILE_SIZE)+dy][(x/TILE_SIZE)+dx].type!=BOMB){
  175. game->player.x+=dx*PLAYER_MOVEMENT_INCREMENT;
  176. game->player.y+=dy*PLAYER_MOVEMENT_INCREMENT;
  177. }
  178. } else {
  179. int xm = x%TILE_SIZE;
  180. int ym = y%TILE_SIZE;
  181. game->player.x+=(xm/(xm-(xm!=1)))*dx*PLAYER_MOVEMENT_INCREMENT;
  182. game->player.y+=(ym/(ym-(ym!=1)))*dy*PLAYER_MOVEMENT_INCREMENT;
  183.  
  184. }
  185.  
  186.  
  187. }
  188.  
  189. void do_enemy_ai(Game * game)
  190. {
  191. int i;
  192. for(i=0;i<game->enemies_left;i++){
  193. Enemy enemy=game->enemies[i];
  194. int verschil=30;//oneindig
  195. if(enemy.frozen==0){
  196. move_enemy(game,game->enemies+i);
  197. }
  198. else{
  199. (game->enemies+i)->frozen--;
  200. }
  201. if(enemy.y==game->player.y){
  202. verschil=abs((enemy.x-game->player.x));
  203. }
  204. else if(enemy.x==game->player.x){
  205. verschil=abs((enemy.y-game->player.y));
  206. }
  207. if(verschil<15){
  208. game->game_over=1;
  209. }
  210. }
  211. }
  212.  
  213. void move_enemy(Game * game, Enemy * enemy){
  214. int x = enemy->x;
  215. int y = enemy->y;
  216. int move_dir = enemy->move_direction;
  217. if(x%TILE_SIZE==0&&y%TILE_SIZE==0){
  218. int movement[4]={0,0,0,0};
  219. int i;
  220.  
  221.  
  222. for(i = 0; i < 4; i++){
  223. int dy = -((i+1)%2)*(pow((double)-1,i/2));
  224. int dx = (i%2)*(pow((double)-1,(i-1)/2));
  225. if(game->level.entities[(y/TILE_SIZE)+dy][(x/TILE_SIZE)+dx].type!=OBSTACLE&&game->level.entities[(y/TILE_SIZE)+dy][(x/TILE_SIZE)+dx].type!=BOMB)
  226. movement[i]=rand()+1;
  227. }
  228. if(movement[move_dir]>0){
  229. // Enemy loopt niet IN een explosie
  230. /*int dy = -((move_dir+1)%2)*(pow((double)-1,move_dir/2));
  231. int dx = (move_dir%2)*(pow((double)-1,(move_dir-1)/2));
  232. if(game->level.entities[(y/TILE_SIZE)+dy][(x/TILE_SIZE)+dx].type==EXPLOSION){
  233. movement[move_dir]=0;
  234. }
  235. else*/
  236. // Indien enemy nog naar voren kan, willen we niet dat hij al omkeert
  237. movement[(move_dir+2)%4] = 0;
  238. }
  239. move_dir=0;
  240. for(i=0;i<4;i++){
  241. if(movement[i]>movement[move_dir])
  242. move_dir = i;
  243. }
  244. if(movement[move_dir]==0)
  245. return;
  246. enemy->move_direction=(ORIENTATION) move_dir;
  247. }
  248. enemy->x+= (move_dir%2)*(pow((double)-1,(move_dir-1)/2))*ENEMY_MOVEMENT_INCREMENT*pow(((double)BOSS_MOVEMENT_INCREMENT)/ENEMY_MOVEMENT_INCREMENT,enemy->is_boss);
  249. enemy->y+= -((move_dir+1)%2)*(pow((double)-1,move_dir/2))*ENEMY_MOVEMENT_INCREMENT*pow(((double)BOSS_MOVEMENT_INCREMENT)/ENEMY_MOVEMENT_INCREMENT,enemy->is_boss);
  250. }
  251.  
  252. void process_bonus_items(Game * game){
  253. int centx=(game->player.x+(TILE_SIZE/2))/TILE_SIZE;
  254. int centy=(game->player.y+(TILE_SIZE/2))/TILE_SIZE;
  255. if(game->level.entities[centy][centx].type==POWERUP){
  256. Powerup up=game->level.entities[centy][centx].powerup;
  257. EmptySpace emp={EMPTY_SPACE,centx*TILE_SIZE,centy*TILE_SIZE};
  258. if(up.powerup_type==EXTRA_BOMB){
  259. game->player.remaining_bombs++;
  260. }
  261. else if(up.powerup_type==EXTRA_POWER){
  262. if(game->player.current_bomb_power<PLAYER_MAX_POWER)
  263. game->player.current_bomb_power++;
  264. }
  265. else if(up.powerup_type==FREEZE_ENEMIES){
  266. freeze_enemies(game);
  267. }
  268. game->level.entities[centy][centx].type=EMPTY_SPACE;
  269. game->level.entities[centy][centx].empty_space=emp;
  270. }
  271. }
  272.  
  273. void freeze_enemies(Game* game){
  274. int i;
  275. for(i=0;i<game->enemies_left;i++){
  276. game->enemies[i].frozen=FREEZE_DURATION;
  277. }
  278. }
  279.  
  280. void add_powerup(Game* game,int x,int y){
  281. int getal= rand()%100;
  282. int ratio=(int)100*game->level.level_info.bonus_spawn_ratio;
  283. if(getal<ratio){
  284. Powerup power={POWERUP,x,y,EXTRA_POWER};
  285. int i=rand()%3;
  286. if(i==0){
  287. power.powerup_type=EXTRA_BOMB;
  288. }
  289. else if(i==1){
  290. power.powerup_type=EXTRA_POWER;
  291. }
  292. else if(i==2){
  293. power.powerup_type=FREEZE_ENEMIES;
  294. }
  295. game->level.entities[y/TILE_SIZE][x/TILE_SIZE].type=POWERUP;
  296. game->level.entities[y/TILE_SIZE][x/TILE_SIZE].powerup=power;
  297. }
  298. }
  299.  
  300. void process_bombs(Game * game)
  301. {
  302. int i;
  303. int j;
  304. for(i=0;i<game->level.level_info.height;i++)
  305. for(j=0;j<game->level.level_info.width;j++){
  306. if(game->level.entities[i][j].type==BOMB){
  307. Bomb* bom=&game->level.entities[i][j].bomb;
  308. if(bom->ticks_left>0){
  309. bom->ticks_left--;
  310.  
  311. }
  312. else{
  313. int power = game->player.current_bomb_power;
  314. Explosion exp={EXPLOSION,bom->x,bom->y,{power,power,power,power},power,EXPLOSION_TICKS};
  315. //Spread berekenen
  316. detect_collision_exp(game,&exp);
  317. game->level.entities[i][j].type=EXPLOSION;
  318. game->level.entities[i][j].explosion=exp;
  319. }
  320. } else {
  321. if(game->level.entities[i][j].type==EXPLOSION){
  322. Explosion* exp=&game->level.entities[i][j].explosion;
  323. if(exp->ticks_left>0){
  324. exp->ticks_left--;
  325. {
  326. int k;
  327. for(k=0;k<4;k++){
  328. lineOfFire(game, exp, k);
  329. detect_collision_exp(game, exp);
  330. }
  331. }
  332. }
  333. else{
  334. EmptySpace emp={EMPTY_SPACE,exp->x,exp->y};
  335. game->level.entities[i][j].type=EMPTY_SPACE;
  336. game->level.entities[i][j].empty_space=emp;
  337. }
  338. }
  339. }}
  340. }
  341.  
  342. void increment_score(Game* game,Enemy* enemy){
  343. if(enemy->is_boss){
  344. game->score+=SCORE_BOSS;
  345. }
  346. else{
  347. int plus=BASE_SCORE_ENEMY-gui_get_timer_score();
  348. if(plus>0)
  349. game->score+=plus;
  350. }
  351. }
  352.  
  353. void detect_collision_exp(Game* game, Explosion* exp){
  354. int i;
  355. // Voor de vier orientaties de spread berekenen
  356. for(i=0;i<4;i++){
  357. exp->spread[i] = spread(game, exp, i);
  358. }
  359. }
  360.  
  361.  
  362. int spread(Game * game, Explosion * exp, int dir){
  363. int i=1;
  364. int cox=exp->x/TILE_SIZE;
  365. int coy=exp->y/TILE_SIZE;
  366. int spread = 0;
  367. int dy = -((dir+1)%2)*(pow((double)-1,dir/2));
  368. int dx = (dir%2)*(pow((double)-1,(dir-1)/2));
  369. int cnt = 1;
  370. while(i<=exp->spread[dir]&&cnt){
  371. if(game->level.entities[coy+dy*i][cox+dx*i].type==OBSTACLE){
  372. spread+=game->level.entities[coy+dy*i][cox+dx*i].obstacle.is_destructable;
  373. cnt=0;
  374. } else {
  375. int k = 0;
  376. while(k<game->enemies_left&&cnt){
  377. Enemy* enemy=&game->enemies[k];
  378. int encox=(enemy->x+(TILE_SIZE/2))/TILE_SIZE;
  379. int encoy=(enemy->y+(TILE_SIZE/2))/TILE_SIZE;
  380. if(encox==(cox)+(dx*i)&&encoy==coy+(dy*i))
  381. cnt = 0;
  382. k++;
  383. }
  384. spread++;
  385. }
  386. i++;
  387. }
  388. return spread;
  389. }
  390.  
  391. void lineOfFire(Game * game, Explosion * exp, int dir){
  392. int cox=exp->x/TILE_SIZE;
  393. int coy=exp->y/TILE_SIZE;
  394. int dy = -((dir+1)%2)*(pow((double)-1,dir/2));
  395. int dx = (dir%2)*(pow((double)-1,(dir-1)/2));
  396. int i;
  397. for(i = 1; i <= exp->spread[dir]; i++){
  398. if(game->level.entities[coy+dy*i][cox+dx*i].type==OBSTACLE){
  399. EmptySpace emp={EMPTY_SPACE,(cox+dx*i)*TILE_SIZE,(coy+dy*i)*TILE_SIZE};
  400. game->level.entities[coy+dy*i][cox+dx*i].type=EMPTY_SPACE;
  401. game->level.entities[coy+dy*i][cox+dx*i].empty_space=emp;
  402. add_powerup(game,(cox+dx*i)*TILE_SIZE,(coy+dy*i)*TILE_SIZE);
  403. } else {
  404. int k;
  405. for(k=0;k<game->enemies_left;k++){
  406. Enemy* enemy=&game->enemies[k];
  407. int encox=(enemy->x+(TILE_SIZE/2))/TILE_SIZE;
  408. int encoy=(enemy->y+(TILE_SIZE/2))/TILE_SIZE;
  409. if(encox==(cox)+(dx*i)&&encoy==coy+(dy*i)&&!enemy->is_boss){
  410. add_powerup(game,(cox+dx*i)*TILE_SIZE,(coy+dy*i)*TILE_SIZE);
  411. increment_score(game,enemy);
  412. game->enemies[k]=game->enemies[game->enemies_left-1];
  413. game->enemies_left--;
  414. if(game->enemies_left>0)
  415. game->enemies=(Enemy*)realloc(game->enemies,game->enemies_left*sizeof(Enemy));
  416. k--;
  417. }
  418. }
  419. }
  420. }
  421. }
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!