You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
638 lines
19 KiB
638 lines
19 KiB
#include "bunker.h" |
|
#include "stdlib.h" |
|
#include "xintc_l.h" // Provides handy macros for the interrupt controller. |
|
|
|
int x_y[4] = {BUNKER1_X, BUNKER2_X, BUNKER3_X, BUNKER4_X}; |
|
int initial_x = 70; |
|
int initial_y = 300; |
|
int tank_y_position = 420; |
|
|
|
void renderBunker(unsigned int* framePointer) { // draw for the first time |
|
short x=0, y=0; |
|
|
|
int i,j; |
|
for(j = 0; j < 4; j++) { |
|
initial_x = x_y[j]; |
|
for(i=0; i<10; i++){ |
|
switch(i){ |
|
case 0: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_left0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x)*640 + initial_x+y] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x)*640 + initial_x+y] = 0x00000000; |
|
} |
|
} |
|
} |
|
break; |
|
case 1: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_normal0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x)*640 + initial_x+y+BLOCK_WIDTH] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x)*640 + initial_x+y+BLOCK_WIDTH] = 0x00000000; |
|
} |
|
} |
|
} |
|
break; |
|
case 2: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_normal0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x)*640 + initial_x+y+BLOCK_WIDTH*2] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x)*640 + initial_x+y+BLOCK_WIDTH*2] = 0x00000000; |
|
} |
|
} |
|
} |
|
break; |
|
|
|
case 3: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_right0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x)*640 + initial_x+y+BLOCK_WIDTH*3] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x)*640 + initial_x+y+BLOCK_WIDTH*3] = 0x00000000; |
|
} |
|
} |
|
} |
|
|
|
break; |
|
case 4: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_normal0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT)*640 + initial_x+y] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT)*640 + initial_x+y] = 0x00000000; |
|
} |
|
} |
|
} |
|
break; |
|
case 5: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_center_left0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT)*640 + initial_x+y+BLOCK_WIDTH] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT)*640 + initial_x+y+BLOCK_WIDTH] = 0x00000000; |
|
} |
|
} |
|
} |
|
break; |
|
case 6: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_center_right0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT)*640 + initial_x+y+BLOCK_WIDTH*2] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT)*640 + initial_x+y+BLOCK_WIDTH*2] = 0x00000000; |
|
} |
|
} |
|
} |
|
break; |
|
case 7: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_normal0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT)*640 + initial_x+y+BLOCK_WIDTH*3] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT)*640 + initial_x+y+BLOCK_WIDTH*3] = 0x00000000; |
|
} |
|
} |
|
} |
|
break; |
|
|
|
case 8: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_normal0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT*2)*640 + initial_x+y] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT*2)*640 + initial_x+y] = 0x00000000; |
|
} |
|
} |
|
} |
|
break; |
|
case 9: |
|
for(x = 0; x < BLOCK_HEIGHT; x++) { |
|
for(y = 0; y < BLOCK_WIDTH; y++){ |
|
if ((block_normal0[x%16] & (1<<(BLOCK_WIDTH-1-y)))) { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT*2)*640 + initial_x+y+BLOCK_WIDTH*3] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+x+BLOCK_HEIGHT*2)*640 + initial_x+y+BLOCK_WIDTH*3] = 0x00000000; |
|
} |
|
} |
|
} |
|
break; |
|
default : |
|
|
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
void erodeBunker(unsigned int* framePointer, int which_bunker, int which_block){ |
|
// int which_block = rand()%10; |
|
short* bunker; |
|
int i, j; |
|
int block_row, block_col; |
|
switch(which_bunker){ // select a bunker that I want to erode |
|
case 0: |
|
bunker = getBunker1(); |
|
break; |
|
case 1: |
|
bunker = getBunker2(); |
|
break; |
|
case 2: |
|
bunker = getBunker3(); |
|
break; |
|
case 3: |
|
bunker = getBunker4(); |
|
break; |
|
default : |
|
break; |
|
} |
|
|
|
switch(which_block){ // 'block_row, block_col' are used to calculate to find out the position of framePointer |
|
case 0: |
|
block_row = 0; |
|
block_col = 0; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
break; |
|
case 1: |
|
block_row = 0; |
|
block_col = 1; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
|
|
break; |
|
case 2: |
|
block_row = 0; |
|
block_col = 2; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
|
|
break; |
|
case 3: |
|
block_row = 0; |
|
block_col = 3; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
|
|
break; |
|
case 4: |
|
block_row = 1; |
|
block_col = 0; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
|
|
break; |
|
case 5: |
|
block_row = 1; |
|
block_col = 1; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
|
|
break; |
|
case 6: |
|
block_row = 1; |
|
block_col = 2; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
|
|
break; |
|
case 7: |
|
block_row = 1; |
|
block_col = 3; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
|
|
break; |
|
case 8: |
|
block_row = 2; |
|
block_col = 0; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
|
|
break; |
|
case 9: |
|
block_row = 2; |
|
block_col = 3; |
|
blankBlock(framePointer, which_bunker, which_block, block_row, block_col); |
|
updateBlock(framePointer, which_bunker, which_block, block_row, block_col, bunker); |
|
|
|
break; |
|
|
|
default : |
|
|
|
break; |
|
} |
|
|
|
} |
|
// This function runs first to make a block empty, and then draw an eroded block by 'updateBlock()' function |
|
void blankBlock(unsigned int* framePointer, int which_bunker, int which_block, int block_row, int block_col){ |
|
int i, j; |
|
initial_x = x_y[which_bunker]; |
|
for(i = 0; i < BLOCK_HEIGHT; i++){ |
|
for(j = 0; j < BLOCK_WIDTH; j++){ |
|
framePointer[(initial_y+i+BLOCK_HEIGHT*block_row)*640 + initial_x+j+BLOCK_WIDTH*block_col] = 0x00000000; |
|
} |
|
} |
|
} |
|
|
|
void updateBlock(unsigned int* framePointer, int which_bunker, int which_block, int block_row, int block_col, short* bunker){ |
|
int i, j; |
|
initial_x = x_y[which_bunker]; |
|
|
|
int* which_state; |
|
|
|
if(bunker[which_block]==0){ // depending on the block selected and bunker status, 'which_state' points to a pre-defined eroded block |
|
bunker[which_block] = 1; |
|
if(which_block == 0){ |
|
which_state = block_left1; |
|
} |
|
else if(which_block == 1 || which_block == 2 || which_block == 4 || which_block == 7 || which_block == 8 || which_block == 9){ |
|
which_state = block_normal1; |
|
} |
|
else if(which_block == 3){ |
|
which_state = block_right1; |
|
} |
|
else if(which_block == 5){ |
|
which_state = block_center_left1; |
|
} |
|
else if(which_block == 6){ |
|
which_state = block_center_right1; |
|
} |
|
} |
|
else if(bunker[which_block]==1){ |
|
bunker[which_block] = 2; |
|
if(which_block == 0){ |
|
which_state = block_left2; |
|
} |
|
else if(which_block == 1 || which_block == 2 || which_block == 4 || which_block == 7 || which_block == 8 || which_block == 9){ |
|
which_state = block_normal2; |
|
} |
|
else if(which_block == 3){ |
|
which_state = block_right2; |
|
} |
|
else if(which_block == 5){ |
|
which_state = block_center_left2; |
|
} |
|
else if(which_block == 6){ |
|
which_state = block_center_right2; |
|
} |
|
} |
|
else if(bunker[which_block]==2){ |
|
bunker[which_block] = 3; |
|
if(which_block == 0){ |
|
which_state = block_left3; |
|
} |
|
else if(which_block == 1 || which_block == 2 || which_block == 4 || which_block == 7 || which_block == 8 || which_block == 9){ |
|
which_state = block_normal3; |
|
} |
|
else if(which_block == 3){ |
|
which_state = block_right3; |
|
} |
|
else if(which_block == 5){ |
|
which_state = block_center_left3; |
|
} |
|
else if(which_block == 6){ |
|
which_state = block_center_right3; |
|
} |
|
} |
|
else{ |
|
bunker[which_block] = 4; |
|
which_state = empty; |
|
} |
|
|
|
for(i = 0; i < BLOCK_HEIGHT; i++){ |
|
for(j = 0; j < BLOCK_WIDTH; j++){ |
|
if ((which_state[i%16] & (1<<(BLOCK_WIDTH-1-j)))) { |
|
framePointer[(initial_y+i+BLOCK_HEIGHT*block_row)*640 + initial_x+j+BLOCK_WIDTH*block_col] = 0x0000FF00; |
|
} else { |
|
framePointer[(initial_y+i+BLOCK_HEIGHT*block_row)*640 + initial_x+j+BLOCK_WIDTH*block_col] = 0x00000000; |
|
} |
|
} |
|
} |
|
} |
|
void selectBlock(unsigned int* framePointer, int bullet){ |
|
int bullet_x; |
|
int bullet_y; |
|
short hit = 0; |
|
short* bunker; |
|
int counter=0; |
|
short dying = 0; |
|
int gameover = 0; |
|
|
|
switch(bullet){ |
|
case 1: |
|
bullet_x = getAlien1BulletPositionX()+3; |
|
bullet_y = getAlien1BulletPositionY()+10; |
|
break; |
|
case 2: |
|
bullet_x = getAlien2BulletPositionX()+3; |
|
bullet_y = getAlien2BulletPositionY()+10; |
|
break; |
|
case 3: |
|
bullet_x = getAlien3BulletPositionX()+3; |
|
bullet_y = getAlien3BulletPositionY()+10; |
|
break; |
|
case 4: |
|
bullet_x = getAlien4BulletPositionX()+3; |
|
bullet_y = getAlien4BulletPositionY()+10; |
|
break; |
|
case 5: |
|
bullet_x = getTankBulletPositionX()+3; |
|
bullet_y = getTankBulletPositionY(); |
|
default: |
|
break; |
|
} |
|
|
|
if(bullet_x >= BUNKER1_X-3 && bullet_x < BUNKER1_X+64+3){ |
|
bunker = getBunker1(); |
|
if(bullet_y > initial_y && bullet_y < initial_y+16){ |
|
if(bullet_x >= BUNKER1_X-3 && bullet_x < BUNKER1_X+16 && bunker[0] != 4){ |
|
erodeBunker(framePointer, 0, 0); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER1_X+16 && bullet_x < BUNKER1_X+32 && bunker[1] != 4){ |
|
erodeBunker(framePointer, 0, 1); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER1_X+32 && bullet_x < BUNKER1_X+48 && bunker[2] != 4){ |
|
erodeBunker(framePointer, 0, 2); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER1_X+48 && bullet_x < BUNKER1_X+64+3 && bunker[3] != 4){ |
|
erodeBunker(framePointer, 0, 3); |
|
hit = 1; |
|
} |
|
} |
|
if(bullet_y>initial_y+16 && bullet_y<initial_y+32){ |
|
if(bullet_x >= BUNKER1_X-3 && bullet_x < BUNKER1_X+16 && bunker[4] != 4){ |
|
erodeBunker(framePointer, 0, 4); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER1_X+16 && bullet_x < BUNKER1_X+32 && bunker[5] != 4){ |
|
erodeBunker(framePointer, 0, 5); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER1_X+32 && bullet_x < BUNKER1_X+48 && bunker[6] != 4){ |
|
erodeBunker(framePointer, 0, 6); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER1_X+48 && bullet_x < BUNKER1_X+64+3 && bunker[7] != 4){ |
|
erodeBunker(framePointer, 0, 7); |
|
hit = 1; |
|
} |
|
} |
|
if(bullet_y>initial_y+32 && bullet_y<initial_y+48){ |
|
if(bullet_x >= BUNKER1_X-3 && bullet_x<BUNKER1_X+16 && bunker[8] != 4){ |
|
erodeBunker(framePointer, 0, 8); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER1_X+48 && bullet_x<BUNKER1_X+64+3 && bunker[9] != 4){ |
|
erodeBunker(framePointer, 0, 9); |
|
hit = 1; |
|
} |
|
} |
|
|
|
} |
|
|
|
if(bullet_x > BUNKER2_X-3 && bullet_x < BUNKER2_X+64+3){ |
|
bunker = getBunker2(); |
|
if(bullet_y>initial_y && bullet_y<initial_y+16){ |
|
if(bullet_x >= BUNKER2_X-3 && bullet_x<BUNKER2_X+16 && bunker[0] != 4){ |
|
erodeBunker(framePointer, 1, 0); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER2_X+16 && bullet_x<BUNKER2_X+32 && bunker[1] != 4){ |
|
erodeBunker(framePointer, 1, 1); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER2_X+32 && bullet_x<BUNKER2_X+48 && bunker[2] != 4){ |
|
erodeBunker(framePointer, 1, 2); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER2_X+48 && bullet_x<BUNKER2_X+64+3 && bunker[3] != 4){ |
|
erodeBunker(framePointer, 1, 3); |
|
hit = 1; |
|
} |
|
} |
|
if(bullet_y>initial_y+16 && bullet_y<initial_y+32){ |
|
if(bullet_x >= BUNKER2_X-3 && bullet_x<BUNKER2_X+16 && bunker[4] != 4){ |
|
erodeBunker(framePointer, 1, 4); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER2_X+16 && bullet_x<BUNKER2_X+32 && bunker[5] != 4){ |
|
erodeBunker(framePointer, 1, 5); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER2_X+32 && bullet_x<BUNKER2_X+48 && bunker[6] != 4){ |
|
erodeBunker(framePointer, 1, 6); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER2_X+48 && bullet_x<BUNKER2_X+64+3 && bunker[7] != 4){ |
|
erodeBunker(framePointer, 1, 7); |
|
hit = 1; |
|
} |
|
} |
|
if(bullet_y>initial_y+32 && bullet_y<initial_y+48){ |
|
if(bullet_x >= BUNKER2_X-3 && bullet_x<BUNKER2_X+16 && bunker[8] != 4){ |
|
erodeBunker(framePointer, 1, 8); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER2_X+48 && bullet_x<BUNKER2_X+64+3 && bunker[9] != 4){ |
|
erodeBunker(framePointer, 1, 9); |
|
hit = 1; |
|
} |
|
} |
|
|
|
} |
|
|
|
if(bullet_x > BUNKER3_X-3 && bullet_x < BUNKER3_X+64+3){ |
|
bunker = getBunker3(); |
|
if(bullet_y>initial_y && bullet_y<initial_y+16){ |
|
if(bullet_x >= BUNKER3_X-3 && bullet_x<BUNKER3_X+16 && bunker[0] != 4){ |
|
erodeBunker(framePointer, 2, 0); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER3_X+16 && bullet_x<BUNKER3_X+32 && bunker[1] != 4){ |
|
erodeBunker(framePointer, 2, 1); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER3_X+32 && bullet_x<BUNKER3_X+48 && bunker[2] != 4){ |
|
erodeBunker(framePointer, 2, 2); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER3_X+48 && bullet_x<BUNKER3_X+64+3 && bunker[3] != 4){ |
|
erodeBunker(framePointer, 2, 3); |
|
hit = 1; |
|
} |
|
} |
|
if(bullet_y>initial_y+16 && bullet_y<initial_y+32){ |
|
if(bullet_x >= BUNKER3_X-3 && bullet_x<BUNKER3_X+16 && bunker[4] != 4){ |
|
erodeBunker(framePointer, 2, 4); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER3_X+16 && bullet_x<BUNKER3_X+32 && bunker[5] != 4){ |
|
erodeBunker(framePointer, 2, 5); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER3_X+32 && bullet_x<BUNKER3_X+48 && bunker[6] != 4){ |
|
erodeBunker(framePointer, 2, 6); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER3_X+48 && bullet_x<BUNKER3_X+64+3 && bunker[7] != 4){ |
|
erodeBunker(framePointer, 2, 7); |
|
hit = 1; |
|
} |
|
} |
|
if(bullet_y>initial_y+32 && bullet_y<initial_y+48){ |
|
if(bullet_x >= BUNKER3_X-3 && bullet_x<BUNKER3_X+16 && bunker[8] != 4){ |
|
erodeBunker(framePointer, 2, 8); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER3_X+48 && bullet_x<BUNKER3_X+64+3 && bunker[9] != 4){ |
|
erodeBunker(framePointer, 2, 9); |
|
hit = 1; |
|
} |
|
} |
|
} |
|
|
|
if(bullet_x > BUNKER4_X-3 && bullet_x < BUNKER4_X+64+3){ |
|
bunker = getBunker4(); |
|
if(bullet_y>initial_y && bullet_y<initial_y+16){ |
|
if(bullet_x >= BUNKER4_X-3 && bullet_x<BUNKER4_X+16 && bunker[0] != 4){ |
|
erodeBunker(framePointer, 3, 0); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER4_X+16 && bullet_x<BUNKER4_X+32 && bunker[1] != 4){ |
|
erodeBunker(framePointer, 3, 1); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER4_X+32 && bullet_x<BUNKER4_X+48 && bunker[2] != 4){ |
|
erodeBunker(framePointer, 3, 2); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER4_X+48 && bullet_x<BUNKER4_X+64+3 && bunker[3] != 4){ |
|
erodeBunker(framePointer, 3, 3); |
|
hit = 1; |
|
} |
|
} |
|
if(bullet_y>initial_y+16 && bullet_y<initial_y+32){ |
|
if(bullet_x >= BUNKER4_X-3 && bullet_x<BUNKER4_X+16 && bunker[4] != 4){ |
|
erodeBunker(framePointer, 3, 4); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER4_X+16 && bullet_x<BUNKER4_X+32 && bunker[5] != 4){ |
|
erodeBunker(framePointer, 3, 5); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER4_X+32 && bullet_x<BUNKER4_X+48 && bunker[6] != 4){ |
|
erodeBunker(framePointer, 3, 6); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER4_X+48 && bullet_x<BUNKER4_X+64+3 && bunker[7] != 4){ |
|
erodeBunker(framePointer, 3, 7); |
|
hit = 1; |
|
} |
|
} |
|
if(bullet_y>initial_y+32 && bullet_y<initial_y+48){ |
|
if(bullet_x >= BUNKER4_X-3 && bullet_x<BUNKER4_X+16 && bunker[8] != 4){ |
|
erodeBunker(framePointer, 3, 8); |
|
hit = 1; |
|
} |
|
if(bullet_x >= BUNKER4_X+48 && bullet_x<BUNKER4_X+64+3 && bunker[9] != 4){ |
|
erodeBunker(framePointer, 3, 9); |
|
hit = 1; |
|
} |
|
} |
|
} |
|
|
|
if(bullet_y > tank_y_position && bullet_y < tank_y_position+16){ |
|
if(bullet_x >= getTankPositionX()-3 && bullet_x < getTankPositionX()+32+3){ |
|
setHaveTankDeathSound(1); |
|
|
|
counter = 0; |
|
// xil_printf("tank dies\r\n"); |
|
|
|
// disable interrupt to stop the whole game for little bit |
|
// XIntc_MasterDisable(XPAR_INTC_0_BASEADDR); |
|
|
|
setAlien1BulletState(0); |
|
blankAlienBullet(framePointer, getAlien1BulletPositionX(), getAlien1BulletPositionY()); |
|
setAlien2BulletState(0); |
|
blankAlienBullet(framePointer, getAlien2BulletPositionX(), getAlien2BulletPositionY()); |
|
setAlien3BulletState(0); |
|
blankAlienBullet(framePointer, getAlien3BulletPositionX(), getAlien3BulletPositionY()); |
|
setAlien4BulletState(0); |
|
blankAlienBullet(framePointer, getAlien4BulletPositionX(), getAlien4BulletPositionY()); |
|
setTankBulletState(0); |
|
blankTankBullet(framePointer, getTankBulletPositionX(), getTankBulletPositionY()); |
|
|
|
gameover = tankDied(framePointer); |
|
|
|
if(!gameover){ |
|
|
|
// for tank dying animation |
|
while(counter < 1000){ |
|
// if(counter%250){ |
|
|
|
if(dying == 0){ |
|
dying = 1; |
|
blankTank(framePointer); |
|
renderDying1(framePointer); |
|
} |
|
else{ |
|
dying = 0; |
|
blankTank(framePointer); |
|
renderDying2(framePointer); |
|
} |
|
// } |
|
counter++; |
|
} |
|
|
|
// reenable interrupt |
|
// XIntc_MasterEnable(XPAR_INTC_0_BASEADDR); |
|
renderTank(framePointer); |
|
} |
|
} |
|
} |
|
|
|
if(hit){ |
|
|
|
switch(bullet){ |
|
case 1: |
|
setAlien1BulletState(0); |
|
blankAlienBullet(framePointer, bullet_x-3, bullet_y-10); |
|
break; |
|
case 2: |
|
setAlien2BulletState(0); |
|
blankAlienBullet(framePointer, bullet_x-3, bullet_y-10); |
|
break; |
|
case 3: |
|
setAlien3BulletState(0); |
|
blankAlienBullet(framePointer, bullet_x-3, bullet_y-10); |
|
break; |
|
case 4: |
|
setAlien4BulletState(0); |
|
blankAlienBullet(framePointer, bullet_x-3, bullet_y-10); |
|
break; |
|
case 5: |
|
setTankBulletState(0); |
|
blankTankBullet(framePointer, bullet_x, bullet_y); |
|
break; |
|
|
|
default: |
|
break; |
|
} |
|
} |
|
|
|
}
|
|
|