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.
872 lines
31 KiB
872 lines
31 KiB
#include <stdio.h> |
|
#include "platform.h" |
|
#include "xparameters.h" |
|
#include "xaxivdma.h" |
|
#include "xio.h" |
|
#include "time.h" |
|
#include "unistd.h" |
|
#include "xgpio.h" // Provides access to PB GPIO driver. |
|
#include "mb_interface.h" // provides the microblaze interrupt enables, etc. |
|
#include "xintc_l.h" // Provides handy macros for the interrupt controller. |
|
#include "xac97_l.h" |
|
#include "nes.h" |
|
#include "global.h" |
|
#include <xuartlite_l.h> |
|
|
|
XGpio gpLED; // This is a handle for the LED GPIO block. |
|
XGpio gpPB; // This is a handle for the push-button GPIO block. |
|
|
|
|
|
#define DEBUG |
|
#define FRAME_BUFFER_0_ADDR 0xC5000000 // Starting location in DDR where we will store the images that we display. |
|
#define VOL_ATTN_MIN 0x0 |
|
#define VOL_ATTN_MAX 0x1f |
|
|
|
Xuint32 vol_attn = 0x10; |
|
|
|
int mytimer = 0; |
|
int mycounter = 0; |
|
|
|
int onesec; |
|
int fifteenms; |
|
int fivems; |
|
int tenms; |
|
int buttonValid; |
|
int currentButtonState; |
|
int speed = 30; |
|
|
|
int holding; |
|
|
|
int gameState = 1; |
|
|
|
|
|
void increaseVolume() { |
|
if((int)vol_attn > VOL_ATTN_MIN) { |
|
vol_attn = vol_attn - 0x1; |
|
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_MasterVol, vol_attn | (vol_attn << 8)); |
|
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_AuxOutVol, vol_attn | (vol_attn << 8)); |
|
} |
|
} |
|
void decreaseVolume() { |
|
if((int)vol_attn < VOL_ATTN_MAX) { |
|
vol_attn = vol_attn + 0x1; |
|
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_MasterVol, vol_attn | (vol_attn << 8)); |
|
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_AuxOutVol, vol_attn | (vol_attn << 8)); |
|
} |
|
} |
|
void delayDying() { |
|
int counter = 0; |
|
while(counter < 500000){ |
|
counter++; |
|
} |
|
} |
|
|
|
void setGameState(int mystate){ |
|
gameState = mystate; |
|
} |
|
|
|
unsigned int * framePointer = (unsigned int *) FRAME_BUFFER_0_ADDR; |
|
|
|
void pb_interrupt_handler(); |
|
|
|
int isBottom(int value) { |
|
short* aliens = getAliens(); |
|
|
|
if(value > 43) { |
|
return 1; |
|
} |
|
if(value < 44 && value > 32) { |
|
if(aliens[value+11] == 0) { |
|
return 1; |
|
} |
|
else { |
|
return 0; |
|
} |
|
} |
|
if(value < 33 && value > 21) { |
|
if(aliens[value+11] == 0 && aliens[value+22] == 0) { |
|
return 1; |
|
} |
|
else { |
|
return 0; |
|
} |
|
} |
|
if(value < 22 && value > 10) { |
|
if(aliens[value+11] == 0 && aliens[value+22] == 0 && aliens[value+33] == 0) { |
|
return 1; |
|
} |
|
else { |
|
return 0; |
|
} |
|
} |
|
if(value < 11) { |
|
if(aliens[value+11] == 0 && aliens[value+22] == 0 && aliens[value+33] == 0 && aliens[value+44] == 0) { |
|
return 1; |
|
} |
|
else { |
|
return 0; |
|
} |
|
} |
|
} |
|
|
|
int whatRow(int position) { |
|
if(position > 43) { |
|
return 120; |
|
} |
|
if(position < 44 && position > 32) { |
|
return 94; |
|
} |
|
if(position < 33 && position > 21) { |
|
return 68; |
|
} |
|
if(position < 22 && position > 10) { |
|
return 42; |
|
} |
|
if(position < 11) { |
|
return 16; |
|
} |
|
|
|
} |
|
|
|
void collisionCleanUp(int x, int y) { |
|
setHaveAlienDeathSound(1); |
|
blankTankBullet(framePointer); |
|
setTankBulletPositionY(0); |
|
setTankBulletState(0); |
|
delayDying(); |
|
dyingAlienHelper(framePointer, x, y); |
|
int guise = getGuise(); |
|
if(guise == 0) { |
|
renderAlien2(framePointer); |
|
} |
|
else { |
|
renderAlien1(framePointer); |
|
} |
|
alienSpeed(); |
|
} |
|
|
|
void alienCollision() { |
|
int curTankY = ((getTankBulletPositionY()-2)*640); |
|
int curTankX = getTankBulletPositionX()+3; |
|
int curAlienX = getAlienBlockPositionX(); |
|
int curAlienY = getAlienBlockPositionY(); |
|
int ufoscore = 0; |
|
int updatescore = 0; |
|
|
|
if(framePointer[((getTankBulletPositionY()-2)*640) + getTankBulletPositionX()+3] == 0x00FF0000) { |
|
setHaveSpaceShipDeathSound(1); |
|
blankUfo(framePointer, getUfoPositionX(), getUfoPositionY()); |
|
setUfoState(0); |
|
blankTankBullet(framePointer); |
|
setTankBulletPositionY(0); |
|
setTankBulletState(0); |
|
// ufo score operation |
|
ufoscore = rand()%7; |
|
updatescore = selectingUfoscore(framePointer, ufoscore); |
|
updateMyscore(updatescore); |
|
updateNumber(framePointer); |
|
} |
|
if(framePointer[((getTankBulletPositionY()-2)*640) + getTankBulletPositionX()+3] == 0x00FFFFFF || \ |
|
framePointer[((getTankBulletPositionY()-2)*640) + getTankBulletPositionX()+5] == 0x00FFFFFF ||\ |
|
framePointer[((getTankBulletPositionY()-2)*640) + getTankBulletPositionX()] == 0x00FFFFFF){ |
|
curTankY = curTankY/640; |
|
if(curAlienX > 1000) { |
|
curAlienX -= 65535; |
|
} |
|
xil_printf("curX: %d\r\n", curAlienX); |
|
if(curAlienY < curTankY && curTankY < curAlienY + 16 ) { |
|
if(curAlienX < curTankX && curTankX < (curAlienX + 32)) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY())); |
|
setAliens(0, 0); |
|
collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY())); |
|
setAliens(0, 1); |
|
collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY())); |
|
setAliens(0, 2); |
|
collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY())); |
|
setAliens(0, 3); |
|
collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY())); |
|
setAliens(0, 4); |
|
collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY())); |
|
setAliens(0, 5); |
|
collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY())); |
|
setAliens(0, 6); |
|
collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+ 224), (getAlienBlockPositionY())); |
|
setAliens(0, 7); |
|
collisionCleanUp((getAlienBlockPositionX()+ 224), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+ 256), (getAlienBlockPositionY())); |
|
setAliens(0, 8); |
|
collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY())); |
|
setAliens(0, 9); |
|
collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY())); |
|
} |
|
if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY())); |
|
setAliens(0, 10); |
|
collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY())); |
|
} |
|
updateMyscore(40); |
|
updateNumber(framePointer); |
|
|
|
} |
|
if(curAlienY + 26 < curTankY && curTankY < curAlienY + 42) { |
|
if(curAlienX < curTankX && curTankX < (curAlienX + 32)) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 11); |
|
collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 12); |
|
collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 13); |
|
collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 14); |
|
collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 15); |
|
collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 16); |
|
collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 17); |
|
collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+224), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 18); |
|
collisionCleanUp((getAlienBlockPositionX()+224), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+256), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 19); |
|
collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 20); |
|
collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY()+26)); |
|
} |
|
if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY()+26)); |
|
setAliens(0, 21); |
|
collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY()+26)); |
|
} |
|
updateMyscore(20); |
|
updateNumber(framePointer); |
|
} |
|
if(curAlienY + 52 < curTankY && curTankY < curAlienY + 68) { |
|
if(curAlienX < curTankX && curTankX < (curAlienX + 32)) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 22); |
|
collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 23); |
|
collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 24); |
|
collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 25); |
|
collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 26); |
|
collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 27); |
|
collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 28); |
|
collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+224), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 29); |
|
collisionCleanUp((getAlienBlockPositionX()+224), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+256), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 30); |
|
collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 31); |
|
collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY()+52)); |
|
} |
|
if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY()+52)); |
|
setAliens(0, 32); |
|
collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY()+52)); |
|
} |
|
updateMyscore(20); |
|
updateNumber(framePointer); |
|
} |
|
if(curAlienY + 78 < curTankY && curTankY < curAlienY + 94) { |
|
if(curAlienX < curTankX && curTankX < (curAlienX + 32)) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 33); |
|
collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 34); |
|
collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 35); |
|
collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 36); |
|
collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 37); |
|
collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 38); |
|
collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 39); |
|
collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+224), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 40); |
|
collisionCleanUp((getAlienBlockPositionX()+224), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+256), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 41); |
|
collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 42); |
|
collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY()+78)); |
|
} |
|
if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY()+78)); |
|
setAliens(0, 43); |
|
collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY()+78)); |
|
} |
|
updateMyscore(10); |
|
updateNumber(framePointer); |
|
} |
|
if(curAlienY + 104 < curTankY && curTankY < curAlienY +120){ |
|
if(curAlienX < curTankX && curTankX < (curAlienX + 32)) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 44); |
|
collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY()+104)); |
|
setAliens(0,45); |
|
collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 46); |
|
collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 47); |
|
collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 48); |
|
collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 49); |
|
collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 50); |
|
collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+224), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 51); |
|
collisionCleanUp((getAlienBlockPositionX()+224), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+256), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 52); |
|
collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 53); |
|
collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY()+104)); |
|
} |
|
if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) { |
|
dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY()+104)); |
|
setAliens(0, 54); |
|
collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY()+104)); |
|
} |
|
updateMyscore(10); |
|
updateNumber(framePointer); |
|
} |
|
} |
|
} |
|
|
|
void alienSpeed() { |
|
short* aliens = getAliens(); |
|
int i; |
|
int total = 0; |
|
for(i = 0; i < 55; i++) { |
|
if(aliens[i] == 1) { |
|
total++; |
|
} |
|
} |
|
if(total < 55) { |
|
speed = 30; |
|
} |
|
if(total < 44) { |
|
speed = 28; |
|
} |
|
if(total < 33) { |
|
speed = 26; |
|
} |
|
if(total < 22) { |
|
speed = 24; |
|
} |
|
if(total < 11) { |
|
speed = 20; |
|
} |
|
if(total == 0) { |
|
gameOver(framePointer); |
|
} |
|
} |
|
|
|
void timer_interrupt_handler() { |
|
onesec++; |
|
fifteenms++; |
|
fivems++; |
|
tenms++; |
|
mytimer++; |
|
|
|
if(mytimer == 5000){ |
|
mytimer = 0; |
|
xil_printf("my counter value: %d\r\n", mycounter); |
|
} |
|
|
|
if(onesec == 100) { |
|
onesec = 0; |
|
} |
|
if(fifteenms == speed) { |
|
fifteenms = 0; |
|
incrementAlienSoundCadence(); |
|
moveAlien(framePointer); |
|
renderAlien(framePointer); |
|
if(getAlienBlockPositionY() > 240){ |
|
int col; |
|
for(col=0; col<640; col++) { |
|
if(framePointer[360*640 + col] == 0x00FFFFFF) { |
|
gameOver(framePointer); |
|
} |
|
|
|
} |
|
} |
|
|
|
} |
|
if(tenms == 2){ |
|
tenms = 0; |
|
if(getUfoState() == 1){ |
|
moveUfo(framePointer, getUfoDirection()); |
|
renderUfo(framePointer); |
|
|
|
} |
|
|
|
} |
|
if(fivems == 1) { |
|
fivems = 0; |
|
if(getTankBulletState() == 1 || getAlien1BulletState() == 1 || getAlien2BulletState() == 1 || \ |
|
getAlien3BulletState() == 1 || getAlien4BulletState() == 1) { |
|
int i; |
|
for(i = 0; i < 3; i++) { |
|
moveBullets(framePointer); |
|
renderBullet(framePointer); |
|
} |
|
if(getAlien1BulletState()){ |
|
selectBlock(framePointer, 1); |
|
} |
|
if(getAlien2BulletState()){ |
|
selectBlock(framePointer, 2); |
|
} |
|
if(getAlien3BulletState()){ |
|
selectBlock(framePointer, 3); |
|
} |
|
if(getAlien4BulletState()){ |
|
selectBlock(framePointer, 4); |
|
} |
|
if(getTankBulletState()){ |
|
selectBlock(framePointer, 5); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// This is invoked each time there is a change in the button state (result of a push or a bounce). |
|
void pb_interrupt_handler() { |
|
// Clear the GPIO interrupt. |
|
XGpio_InterruptGlobalDisable(&gpPB); // Turn off all PB interrupts for now. |
|
currentButtonState = XGpio_DiscreteRead(&gpPB, 1); // Get the current state of the buttons. |
|
if(currentButtonState == 16) { |
|
increaseVolume(); |
|
} |
|
if(currentButtonState == 4) { |
|
decreaseVolume(); |
|
} |
|
XGpio_InterruptClear(&gpPB, 0xFFFFFFFF); // Ack the PB interrupt. |
|
XGpio_InterruptGlobalEnable(&gpPB); // Re-enable PB interrupts. |
|
} |
|
|
|
// Main interrupt handler |
|
void interrupt_handler_dispatcher(void* ptr) { |
|
int intc_status = XIntc_GetIntrStatus(XPAR_INTC_0_BASEADDR); |
|
|
|
// Check the AC97. Just one method - no need for a separate handler |
|
if (intc_status & XPAR_AXI_AC97_0_INTERRUPT_MASK) { |
|
XIntc_AckIntr(XPAR_INTC_0_BASEADDR, XPAR_AXI_AC97_0_INTERRUPT_MASK); |
|
fillSound(); |
|
} |
|
// Check the FIT interrupt first. |
|
if (intc_status & XPAR_FIT_TIMER_0_INTERRUPT_MASK){ |
|
XIntc_AckIntr(XPAR_INTC_0_BASEADDR, XPAR_FIT_TIMER_0_INTERRUPT_MASK); |
|
timer_interrupt_handler(); |
|
} |
|
// Check the push buttons. |
|
if (intc_status & XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK){ |
|
XIntc_AckIntr(XPAR_INTC_0_BASEADDR, XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK); |
|
pb_interrupt_handler(); |
|
} |
|
} |
|
|
|
int main() { |
|
init_platform(); // Necessary for all programs. |
|
// Initialize the GPIO peripherals. |
|
XAC97_HardReset(XPAR_AXI_AC97_0_BASEADDR); //Reset XAC97 |
|
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_MasterVol, AC97_VOL_ATTN_23_5_DB); // Set default volume |
|
|
|
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_ExtendedAudioStat, 1); |
|
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR,AC97_PCM_DAC_Rate,AC97_PCM_RATE_11025_HZ); |
|
|
|
XAC97_mSetControl(XPAR_AXI_AC97_0_BASEADDR, AC97_ENABLE_IN_FIFO_INTERRUPT); //Enable AC97 Interrupts |
|
|
|
//interrupt code from clock lab |
|
int success; |
|
success = XGpio_Initialize(&gpPB, XPAR_PUSH_BUTTONS_5BITS_DEVICE_ID); |
|
// Set the push button peripheral to be inputs. |
|
XGpio_SetDataDirection(&gpPB, 1, 0x0000001F); |
|
// Enable the global GPIO interrupt for push buttons. |
|
XGpio_InterruptGlobalEnable(&gpPB); |
|
// Enable all interrupts in the push button peripheral. |
|
XGpio_InterruptEnable(&gpPB, 0xFFFFFFFF); |
|
|
|
microblaze_register_handler(interrupt_handler_dispatcher, NULL); |
|
XIntc_EnableIntr(XPAR_INTC_0_BASEADDR, |
|
(XPAR_FIT_TIMER_0_INTERRUPT_MASK | XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK |XPAR_AXI_AC97_0_INTERRUPT_MASK )); |
|
XIntc_MasterEnable(XPAR_INTC_0_BASEADDR); |
|
microblaze_enable_interrupts(); |
|
//end of interrupt code from clock lab |
|
|
|
|
|
int Status; // Keep track of success/failure of system function calls. |
|
XAxiVdma videoDMAController; |
|
// There are 3 steps to initializing the vdma driver and IP. |
|
// Step 1: lookup the memory structure that is used to access the vdma driver. |
|
XAxiVdma_Config * VideoDMAConfig = XAxiVdma_LookupConfig(XPAR_AXI_VDMA_0_DEVICE_ID); |
|
// Step 2: Initialize the memory structure and the hardware. |
|
if(XST_FAILURE == XAxiVdma_CfgInitialize(&videoDMAController, VideoDMAConfig, XPAR_AXI_VDMA_0_BASEADDR)) { |
|
xil_printf("VideoDMA Did not initialize.\r\n"); |
|
} |
|
// Step 3: (optional) set the frame store number. |
|
if(XST_FAILURE == XAxiVdma_SetFrmStore(&videoDMAController, 2, XAXIVDMA_READ)) { |
|
xil_printf("Set Frame Store Failed."); |
|
} |
|
// Initialization is complete at this point. |
|
|
|
// Setup the frame counter. We want two read frames. We don't need any write frames but the |
|
// function generates an error if you set the write frame count to 0. We set it to 2 |
|
// but ignore it because we don't need a write channel at all. |
|
XAxiVdma_FrameCounter myFrameConfig; |
|
myFrameConfig.ReadFrameCount = 2; |
|
myFrameConfig.ReadDelayTimerCount = 10; |
|
myFrameConfig.WriteFrameCount =2; |
|
myFrameConfig.WriteDelayTimerCount = 10; |
|
Status = XAxiVdma_SetFrameCounter(&videoDMAController, &myFrameConfig); |
|
if (Status != XST_SUCCESS) { |
|
xil_printf("Set frame counter failed %d\r\n", Status); |
|
if(Status == XST_VDMA_MISMATCH_ERROR) |
|
xil_printf("DMA Mismatch Error\r\n"); |
|
} |
|
// Now we tell the driver about the geometry of our frame buffer and a few other things. |
|
// Our image is 480 x 640. |
|
XAxiVdma_DmaSetup myFrameBuffer; |
|
myFrameBuffer.VertSizeInput = 480; // 480 vertical pixels. |
|
myFrameBuffer.HoriSizeInput = 640*4; // 640 horizontal (32-bit pixels). |
|
myFrameBuffer.Stride = 640*4; // Dont' worry about the rest of the values. |
|
myFrameBuffer.FrameDelay = 0; |
|
myFrameBuffer.EnableCircularBuf=1; |
|
myFrameBuffer.EnableSync = 0; |
|
myFrameBuffer.PointNum = 0; |
|
myFrameBuffer.EnableFrameCounter = 0; |
|
myFrameBuffer.FixedFrameStoreAddr = 0; |
|
if(XST_FAILURE == XAxiVdma_DmaConfig(&videoDMAController, XAXIVDMA_READ, &myFrameBuffer)) { |
|
xil_printf("DMA Config Failed\r\n"); |
|
} |
|
// We need to give the frame buffer pointers to the memory that it will use. This memory |
|
// is where you will write your video data. The vdma IP/driver then streams it to the HDMI |
|
// IP. |
|
myFrameBuffer.FrameStoreStartAddr[0] = FRAME_BUFFER_0_ADDR; |
|
|
|
if(XST_FAILURE == XAxiVdma_DmaSetBufferAddr(&videoDMAController, XAXIVDMA_READ, |
|
myFrameBuffer.FrameStoreStartAddr)) { |
|
xil_printf("DMA Set Address Failed Failed\r\n"); |
|
} |
|
// Print a sanity message if you get this far. |
|
xil_printf("Woohoo! I made it through initialization.\n\r"); |
|
// Now, let's get ready to start displaying some stuff on the screen. |
|
// The variables framePointer and framePointer1 are just pointers to the base address |
|
// of frame 0 and frame 1. |
|
//unsigned int * framePointer = (unsigned int *) FRAME_BUFFER_0_ADDR; |
|
int row = 0; |
|
int col = 0; |
|
for(row=0; row<480; row++) { |
|
for(col=0; col<640; col++) { |
|
if(row > 460 && row < 464) { |
|
framePointer[row*640 + col] = 0x0000FF00; |
|
} |
|
else { |
|
framePointer[row*640 + col] = 0x00000000; |
|
} |
|
} |
|
} |
|
|
|
// This tells the HDMI controller the resolution of your display (there must be a better way to do this). |
|
XIo_Out32(XPAR_AXI_HDMI_0_BASEADDR, 640*480); |
|
|
|
// Start the DMA for the read channel only. |
|
if(XST_FAILURE == XAxiVdma_DmaStart(&videoDMAController, XAXIVDMA_READ)){ |
|
xil_printf("DMA START FAILED\r\n"); |
|
} |
|
int frameIndex = 0; |
|
// We have two frames, let's park on frame 0. Use frameIndex to index them. |
|
// Note that you have to start the DMA process before parking on a frame. |
|
if (XST_FAILURE == XAxiVdma_StartParking(&videoDMAController, frameIndex, XAXIVDMA_READ)) { |
|
xil_printf("vdma parking failed\n\r"); |
|
} |
|
|
|
setAlienBlockPosition(0, 120); |
|
setTankPosition(300, 420); |
|
renderTank(framePointer); |
|
renderAlien(framePointer); |
|
renderBunker(framePointer); |
|
renderScore(framePointer); |
|
renderNumber(framePointer); |
|
renderTanks(framePointer); |
|
alienSpeed(); |
|
|
|
while (gameState) { |
|
|
|
mycounter++; |
|
|
|
alienCollision(); |
|
int nesButtonState = NES_mReadReg(XPAR_NES_0_BASEADDR, 0); |
|
if(nesButtonState == 2) { |
|
xil_printf("we are in left\r\n"); |
|
moveTankL(framePointer); |
|
renderTank(framePointer); |
|
} |
|
if(nesButtonState == 1) { |
|
xil_printf("we are in right\r\n"); |
|
moveTankR(framePointer); |
|
renderTank(framePointer); |
|
} |
|
if(nesButtonState == 4) { |
|
xil_printf("we are in mid\r\n"); |
|
if(getTankBulletState() == 1) { |
|
continue; |
|
} |
|
else { |
|
setHaveTankBulletSound(1); |
|
setTankBulletState(1); |
|
initialTankBulletPosition(); |
|
renderBullet(framePointer); |
|
} |
|
} |
|
if(nesButtonState == 6) { |
|
xil_printf("we are in mid\r\n"); |
|
moveTankL(framePointer); |
|
renderTank(framePointer); |
|
if(getTankBulletState() == 1) { |
|
continue; |
|
} |
|
else { |
|
setHaveTankBulletSound(1); |
|
setTankBulletState(1); |
|
initialTankBulletPosition(); |
|
renderBullet(framePointer); |
|
} |
|
} |
|
if(nesButtonState == 5) { |
|
xil_printf("we are in mid\r\n"); |
|
moveTankR(framePointer); |
|
renderTank(framePointer); |
|
if(getTankBulletState() == 1) { |
|
continue; |
|
} |
|
else { |
|
setHaveTankBulletSound(1); |
|
setTankBulletState(1); |
|
initialTankBulletPosition(); |
|
renderBullet(framePointer); |
|
} |
|
} |
|
|
|
int ufo_show = rand() % 3000; |
|
if(ufo_show == 100){ |
|
if(getUfoState() == 0){ |
|
setHaveSpaceShipSound(1); |
|
setUfoState(1); |
|
setUfoDirection(); |
|
if(getUfoDirection()){ // getUfoDirection = 1 means ufo going left |
|
setUfoPositionX(610); |
|
setUfoPositionY(45); |
|
renderUfo(framePointer); |
|
} |
|
else{ // getUfoDirection = 0 means ufo going right |
|
setUfoPositionX(0); |
|
setUfoPositionY(45); |
|
renderUfo(framePointer); |
|
} |
|
} |
|
} |
|
|
|
int alienShot = rand() % 100000; // this controls how frequent bullets are fired by aliens |
|
if(alienShot == 50) { //key 3 |
|
int i = 0; |
|
int j = rand() % 4; |
|
int k[4] = {getAlien1BulletState(), getAlien2BulletState(), getAlien3BulletState(), getAlien4BulletState()}; |
|
for(i = 0; i < 16; i ++) { |
|
if(k[j] == 0) { |
|
break; |
|
} |
|
else { |
|
j = rand()%4; |
|
} |
|
} |
|
int bottomAlien = 0; |
|
short* aliens = getAliens(); |
|
int a; |
|
while(bottomAlien == 0) { |
|
a = rand () % 54; |
|
if(aliens[a] == 1 && isBottom(a)) { |
|
bottomAlien = 1; |
|
} |
|
} |
|
int position = whatRow(a); |
|
int x = a % 11; |
|
|
|
switch(j){ |
|
case 0: |
|
if(getAlien1BulletState() == 0) { |
|
setAlien1BulletState(1); |
|
setAlien1BulletPosition(((getAlienBlockPositionX()+10) + 32 * x), getAlienBlockPositionY()+position); |
|
renderBullet(framePointer); |
|
} |
|
break; |
|
case 1: |
|
if(getAlien2BulletState() == 0) { |
|
setAlien2BulletState(1); |
|
setAlien2BulletPosition(((getAlienBlockPositionX()+10) + 32 * x), getAlienBlockPositionY()+position); |
|
renderBullet(framePointer); |
|
} |
|
break; |
|
case 2: |
|
if(getAlien3BulletState() == 0) { |
|
setAlien3BulletState(1); |
|
setAlien3BulletPosition(((getAlienBlockPositionX()+10) + 32 * x), getAlienBlockPositionY()+position); |
|
renderBullet(framePointer); |
|
} |
|
break; |
|
case 3: |
|
if(getAlien4BulletState() == 0) { |
|
setAlien4BulletState(1); |
|
setAlien4BulletPosition(((getAlienBlockPositionX()+10) + 32 * x), getAlienBlockPositionY()+position); |
|
renderBullet(framePointer); |
|
} |
|
break; |
|
default : |
|
break; |
|
} |
|
} |
|
} |
|
cleanup_platform(); |
|
|
|
return 0; |
|
}
|
|
|