int main(void) {
REG_DISPCNT = MODE3 | BG2_ENABLE;
while(1){
if(start == -1)
{
waitForVblank();
bricksSet(Bricks);
cleanScreen();
startscreen();
waitForVblank();
start = 1;
cleanScreen();
bricksDraw();
barSet();
ballSet();
}
CollisionDetect_BRICKS();
barControl();
ballControl();
waitForVblank();
if(KEY_DOWN_NOW(BUTTON_SELECT))
{
Reset();
continue;
}
if(score == 600 || life == 0){
cleanScreen();
overscreen();
Reset();
}
}
}
/*
* Press Left or Right to change pages.
* Press Start to begin
*/
void instructions() {
waitForVblank();
fillScreen(BLACK);
waitForVblank();
drawString(30, 10, "D-Pad to move blocks.", YELLOW);
drawString(50, 10, "If two blocks with the same", YELLOW);
drawString(70, 10, "number hit, they will merge!", YELLOW);
drawString(130, 10, "Press Start to begin.", YELLOW);
while (!KEY_DOWN_NOW(BUTTON_START));
while (KEY_DOWN_NOW(BUTTON_START));
}
void resetCursor()
{
int i;
sprites[0].row = 8;
sprites[0].col = 0;
shadowOAM[0].attr0 = ATTR0_HIDE;
waitForVblank();
for(i=0; i<NUMSPRITES; i++)
{
SPRITEMEM[i] = shadowOAM[i];
}
waitForVblank();
}
void drawMovingBlocks(int row, int col, Direction d, int spaces) {
int r = TOP_MARGIN + (BLOCK_SIZE + 1)*row + 1;
int c = LEFT_MARGIN + (BLOCK_SIZE + 1)*col + 1;
int length = 0;
switch (d) {
case UP:
length = (size - row)*(BLOCK_SIZE + 1) - 1;
for (int i = 0; i < spaces; i++) {
for (int j = 0; j < BLOCK_NUM_MOVES; j++) {
shiftRectVertical(r + BLOCK_SPEED, c, BLOCK_SIZE, length, -BLOCK_SPEED);
}
waitForVblank();
drawHorizontalLine(r + length, c, BLOCK_SIZE, WHITE);
}
break;
case DOWN:
r = TOP_MARGIN + 1;
length = (row + 1)*(BLOCK_SIZE + 1) - 1;
for (int i = 0; i < spaces; i++) {
for (int j = 0; j < BLOCK_NUM_MOVES; j++) {
shiftRectVertical(r, c, BLOCK_SIZE, length - BLOCK_SPEED, BLOCK_SPEED);
}
waitForVblank();
drawHorizontalLine(r + BLOCK_SIZE, c, BLOCK_SIZE, WHITE);
}
break;
case LEFT:
length = (size - col)*(BLOCK_SIZE + 1) - 1;
for (int i = 0; i < spaces; i++) {
for (int j = 0; j < BLOCK_NUM_MOVES; j++) {
shiftRectHorizontal(r, c + BLOCK_SPEED, length, BLOCK_SIZE, -BLOCK_SPEED);
}
waitForVblank();
drawVerticalLine(r, c + length, BLOCK_SIZE, WHITE);
}
break;
case RIGHT:
c = LEFT_MARGIN + 1;
length = (col + 1)*(BLOCK_SIZE + 1) - 1;
for (int i = 0; i < spaces; i++) {
for (int j = 0; j < BLOCK_NUM_MOVES; j++) {
shiftRectHorizontal(r, c, length - BLOCK_SPEED, BLOCK_SIZE, BLOCK_SPEED);
}
waitForVblank();
drawVerticalLine(r, c + BLOCK_SIZE, BLOCK_SIZE, WHITE);
}
break;
}
}
void barControl(){
ballControl();
if(KEY_DOWN_NOW(BUTTON_RIGHT))
{
cur_bar->CL = cur_bar->CL + cur_bar->CD;
}
if(KEY_DOWN_NOW(BUTTON_LEFT))
{
cur_bar->CL = cur_bar->CL - (cur_bar->CD);
}
cur_bar = &bar;
oldcur_bar = &bar_old;
if(cur_bar->CL < 0)
{
cur_bar->CL = 0;
}
if(cur_bar->CL > 239-BAR_Width+1)
{
cur_bar->CL = 239-BAR_Width+1;
}
waitForVblank();
oldcur_bar = &bar_old;
drawImage3(oldcur_bar->RW, oldcur_bar->CL, BAR_Width, BAR_Height, 0x0000);
bar_old = bar;
cur_bar = &bar;
drawImage3(cur_bar->RW, cur_bar->CL, BAR_Width, BAR_Height, BAR);
}
void runInstructions(){
buttonsIns = BUTTONS;
if(BUTTON_PRESSED_INS(BUTTON_SELECT)){
setupSplash();
stateFunction = runSplash;
}else if(BUTTON_PRESSED_INS(BUTTON_START)){
waitForVblank();
nbr = (nbr +1) %6;
switch(nbr){
case 0: drawImage3(ins1Bitmap,0,0,160,240);
drawString3(140,20,"To return press SELECT", WHITE);
drawString3(150,20,"To continue press START", WHITE);
break;
case 1: drawImage3(ins2Bitmap,0,0,160,240); break;
case 2: drawImage3(ins3Bitmap,0,0,160,240); break;
case 3: drawImage3(ins4Bitmap,0,0,160,240); break;
case 4: drawImage3(ins5Bitmap,0,0,160,240); break;
case 5: drawRect3(0,0,160,240, BLACK); drawString3(40,20,"To PAUSE at any time press SELECT",WHITE);
drawString3(50,20,"To return from PAUSE press START",WHITE);
drawString3(60,20,"To turn cheat ON/OFF press R",WHITE);
break;
}
}
oldButtonsIns = buttonsIns;
}
void drawSplash() {
drawImage(KongouSisters);
waitForVblank();
drawString(70, 10, "2048+", YELLOW);
drawString(90, 10, "Press Start to begin.", YELLOW);
drawString(110, 10, "Press Select to change settings.", YELLOW);
drawString(130, 10, "Press A for how to play.", YELLOW);
}
int rollDice(int row, int col, int duration) //Rolls and Animates Dice
{
int n;
int d1;
int d2;
for(n = 0; n < duration; n++)
{
drawDice(row, col, rand()%6+1);
drawDice(row, col+3, rand()%6+1);
waitForVblank();
}
d1 = rand()%6+1;
d2 = rand()%6+1;
drawDice(row, col, d1);
drawDice(row, col+3, d2);
waitForVblank();
return d1 + d2;
}
int main()
{
REG_DISPCTL = MODE4 | BG2_ENABLE | BUFFER1FLAG;
loadPalette(pics_palette, PICS_PALETTE_SIZE, 0);
int state = BEGIN;
while(1)
{
switch(state)
{
case BEGIN:
// loadPalette(pics_palette, PICS_PALETTE_SIZE, 0);
drawImage4(0, 0, 240, 160, (u16*)screen);
waitForVblank();
FlipPage();
while(!KEY_DOWN_NOW(BUTTON_START));
state = GAME;
break;
case GAME:
state = play();
break;
case WIN:
loadPalette(pics_palette, PICS_PALETTE_SIZE, 0);
drawImage4(0, 0, 240, 160, (u16*)win);
drawString4(5, 8, "Press Select", PALETTE[0]);
waitForVblank();
FlipPage();
while(!KEY_DOWN_NOW(BUTTON_SELECT));
state = BEGIN;
break;
case LOSE:
// loadPalette(pics_palette, PICS_PALETTE_SIZE, 0);
drawImage4(0, 0, 240, 160, (u16*)die);
waitForVblank();
FlipPage();
while(!KEY_DOWN_NOW(BUTTON_SELECT));
state = BEGIN;
break;
default:
break;
}
}
return 0;
}
//Begins Text Input
void getText(char *buffer)
{
int FINISHED = 0;
clearScreen();
setupInterrupts();
initializeSprites();
drawKeyboard();
playBG = TRUE;
while(!FINISHED)
{
if(playBG && !BGplaying)
{
// play the bg music
DMA[2].cnt |= DMA_ON;
REG_TM1CNT |= TM_ON;
startBG = vblankcount;
BGplaying = TRUE;
DMA[2].src = flute;
}
checkMovement();
//Check Input and End Function if finished
if(!endInput)
{
checkSelection(buffer);
copyShadow();
waitForVblank();
moveSpriteToMem();
}
else
{
DMA[2].cnt &= ~DMA_ON;
REG_TM1CNT &= ~TM_ON;
playBG = FALSE;
waitForVblank();
FINISHED = 1;
resetVariables();
endInput = 0;
resetCursor();
}
}
clearScreen();
}
Result game(int seed) {
Result result = {LOSE, 0};
srand(seed);
Block blocks[size*size];
int blocksLeft = 0;
resetGame(blocks, &blocksLeft, &result);
int index = 0;
int spawn = FALSE;
int quit = FALSE;
while (!quit) {
if (KEY_DOWN_NOW(BUTTON_UP)) {
if (moveBlocks(blocks, UP, &result.score, &blocksLeft, &result.outcome) && blocksLeft) {
spawn = TRUE;
}
while (KEY_DOWN_NOW(BUTTON_UP));
}
if (KEY_DOWN_NOW(BUTTON_DOWN)) {
if (moveBlocks(blocks, DOWN, &result.score, &blocksLeft, &result.outcome) && blocksLeft) {
spawn = TRUE;
}
while (KEY_DOWN_NOW(BUTTON_DOWN));
}
if (KEY_DOWN_NOW(BUTTON_LEFT)) {
if (moveBlocks(blocks, LEFT, &result.score, &blocksLeft, &result.outcome) && blocksLeft) {
spawn = TRUE;
}
while (KEY_DOWN_NOW(BUTTON_LEFT));
}
if (KEY_DOWN_NOW(BUTTON_RIGHT)) {
if (moveBlocks(blocks, RIGHT, &result.score, &blocksLeft, &result.outcome) && blocksLeft) {
spawn = TRUE;
}
while (KEY_DOWN_NOW(BUTTON_RIGHT));
}
if (spawn) {
index = spawnBlock(blocks, blocksLeft--);
result.score += 1<<blocks[index].num;
waitForVblank();
drawBlock(blocks, index);
updateScoreDisplay(result.score);
quit = !hasMoves(blocks);
spawn = FALSE;
}
if (KEY_DOWN_NOW(BUTTON_B)) {
quit = TRUE;
while (KEY_DOWN_NOW(BUTTON_B));
}
if (KEY_DOWN_NOW(BUTTON_SELECT)) {
resetGame(blocks, &blocksLeft, &result);
while (KEY_DOWN_NOW(BUTTON_SELECT));
}
}
//put a while loop here to check if game ends properly
return result;
}
int main() {
REG_DISPCNT = MODE4 | BG2_ENABLE;
initialize();
while (1) {
waitForVblank();
flipPage();
clear();
update();
draw();
}
}
void drawEverything()
{
waitForVblank();
//min functions for width prevent ball from drawing over the info panel
//since the ball can go a bit off the screen before it changes directions
repaintColorsUnderBall();
drawRect(ball.x, ball.y, min(BALL_SIZE, GAME_WIDTH - ball.x), BALL_SIZE, BALL_COLOR);
drawRect(oldPaddle.x, PADDLE_Y, PADDLE_WIDTH, PADDLE_HEIGHT, BLACK);
drawRect(paddle.x, PADDLE_Y, PADDLE_WIDTH, PADDLE_HEIGHT, PADDLE_COLOR);
}
void resetGame(Block *blocks, int *blocksLeft, Result *result) {
result->outcome = LOSE;
result->score = 0;
initializeBlocks(blocks);
*blocksLeft = size*size;
int index[2];
index[0] = spawnBlock(blocks, *blocksLeft);
(*blocksLeft)--;
index[1] = spawnBlock(blocks, *blocksLeft);
(*blocksLeft)--;
result->score += 1<<blocks[index[0]].num;
result->score += 1<<blocks[index[1]].num;
waitForVblank();
fillScreen(BLACK);
waitForVblank();
drawBoard();
drawGameText();
updateScoreDisplay(result->score);
drawBlock(blocks, index[0]);
drawBlock(blocks, index[1]);
}
void gameOver(Outcome outcome, int score) {
char* s = "";
char buffer[39];
switch (outcome) {
case WIN:
s = "You win! :D";
break;
case LOSE:
s = "You lost. :(";
break;
}
sprintf(buffer, "Score: %d", score);
waitForVblank();
drawImage(EnemyFleet);
waitForVblank();
drawString(30, 10, "GAME OVER", RED);
drawString(50, 10, s, YELLOW);
drawString(70, 10, buffer, YELLOW);
drawString(90, 10, "Press Start to play again.", YELLOW);
while (!KEY_DOWN_NOW(BUTTON_START));
while (KEY_DOWN_NOW(BUTTON_START));
}
int main() {
setMode(MODE_4 | BG2_ENABLE);
startGame();
while(1) {
if (KEY_DOWN_NOW(KEY_START) && state == 0) {
state = 1;
numOfLives = 3;
loadAvatar();
fillPalette(GPalette_palette, 0, GPALETTE_PALETTE_SIZE);
PALETTE[200] = BLACK;
PALETTE[201] = WHITE;
PALETTE[202] = RED;
PALETTE[203] = GREEN;
PALETTE[204] = BLUE;
for (int i = 0; i < 5; i++) {
homeFlags[i] = 0;
}
}
if (state == 1) {
drawBG();
char liveStr[7];
if (numOfLives >= 0) {
sprintf(liveStr, "%d", numOfLives);
drawString4(10, 147, "LIVES LEFT: ", PALETTE[1]);
drawString4(80, 147, liveStr, PALETTE[1]);
}
drawTrucks();
drawCars();
drawCrocodiles();
drawWoods();
drawFrog();
collision();
reset();
delay(2);
waitForVblank();
flipPage();
}
if (state == 2) {
while (1) {
if (KEY_DOWN_NOW(KEY_START)) {
state = 0;
break;
}
}
}
}
return 0;
}
//Begins Text Input
void getText(char *buffer)
{
setRegister();
setupInterrupts();
initializeTiles();
initializeSprites();
drawKeyboard();
playBG = TRUE;
while(1)
{
if(playBG && !BGplaying)
{
// play the bg music
DMA[2].cnt |= DMA_ON;
REG_TM1CNT |= TM_ON;
startBG = vblankcount;
BGplaying = TRUE;
DMA[2].src = flute;
}
checkMovement();
if(!endInput)
{
checkSelection(buffer);
}
else
{
DMA[2].cnt &= ~DMA_ON;
REG_TM1CNT &= ~TM_ON;
playBG = FALSE;
waitForVblank();
}
copyShadow();
waitForVblank();
moveSpriteToMem();
}
}
void startscreen() {
int i = 0;
DMA[3].src = StartScreen;
DMA[3].dst = videoBuffer;
DMA[3].cnt = (240*160) | DMA_ON;
while(!KEY_DOWN_NOW(BUTTON_START)){
waitForVblank();
if(i%30 > 0 && i%30 < 25) {
drawString(130, 55, "Press start to continue", WHITE);
}else{
drawString(130, 55, "Press start to continue", BLACK);
}
i++;
}
}
void overscreen() {
int i = 0;
DMA[3].src = OVER;
DMA[3].dst = videoBuffer;
DMA[3].cnt = (240*160) | DMA_ON;
while(!KEY_DOWN_NOW(BUTTON_SELECT)){
waitForVblank();
if(i%30 > 0 && i%30 < 25) {
drawString(130, 55, "Press Select to restart", WHITE);
}else{
drawString(130, 55, "Press Select to restart", BLACK);
}
i++;
}
}
/*
* Draw the splash screen and perform the appropriate logic.
* Pressing Start begins the game.
* Pressing Select opens the settings menu.
* Pressing A opens the instructions.
*
* @return the button pressed to exit the splash screen
*/
int splash(int *seed) {
int result = 0;
waitForVblank();
drawSplash();
while (!KEY_DOWN_NOW(BUTTON_START) && !KEY_DOWN_NOW(BUTTON_A)
&& !KEY_DOWN_NOW(BUTTON_SELECT)) {
(*seed)++;
}
if (KEY_DOWN_NOW(BUTTON_START)) {
result = BUTTON_START;
} else if (KEY_DOWN_NOW(BUTTON_A)) {
result = BUTTON_A;
} else if (KEY_DOWN_NOW(BUTTON_SELECT)) {
result = BUTTON_SELECT;
}
while (KEY_DOWN_NOW(BUTTON_START) || KEY_DOWN_NOW(BUTTON_A)
|| KEY_DOWN_NOW(BUTTON_SELECT));
return result;
}
void reset()
{
//Reset game variables
paddle[0].prow = PSTARTROW;
paddle[0].pcol = PSTARTCOL;
paddle[0].poldcol = 0;
paddle[0].poldrow = 0;
paddle[0].color = pcolor;
brickCount = 0;
ballCount = 0;
//Reset Ball Struct
for(i=0; i<NUM; i++)
{
theBalls[i].row = ROWSTART + rand()%20;
theBalls[i].col = COLSTART + rand()%20;
theBalls[i].size = SIZE;
theBalls[i].rdelta = RDELSTART+rand()%2;
theBalls[i].cdelta = CDELSTART+rand()%2;
theBalls[i].oldrow = 0;
theBalls[i].oldcol = 0;
theBalls[i].visible = 1;
theBalls[i].color = WHITE;
}
//Reset Brick Struct
for(k=0; k<NUMBRICKS; k++)
{
theBricks[k].row = BSTARTROW;
theBricks[k].col = BSTARTCOL + k*BWIDTH;
theBricks[k].size = SIZE;
theBricks[k].visible = 1;
theBricks[k].color = rand()%32767;
}
//Reset game environment
gameEnviroment(theBricks, paddle[0].color);
//Display game title
gameTitle();
waitForVblank();
}
//Sets Up Sprites
void initializeSprites()
{
int i;
// Load sprite palette
for(i=0; i<256; i++)
{
SPRITEPAL[i] = spritePalette[i];
}
// Load sprite images
for(i=0; i<64/2; i++)
{
CHARBLOCKBASE[4].tileimg[i] = spriteTiles[i];
}
for(i=0; i<NUMSPRITES; i++)
{
shadowOAM[i].attr0 = sprites[i].row | ATTR0_8BPP | sprites[i].shape;
shadowOAM[i].attr1 = sprites[i].col | sprites[i].size;
shadowOAM[i].attr2 = sprites[i].start | ATTR2_PALETTE_BANK(0);
}
//Hide Sprites
for(i=1; i<128; i++)
{
shadowOAM[i].attr0 = ATTR0_HIDE;
}
waitForVblank();
for(i=0; i<128; i++)
{
SPRITEMEM[i] = shadowOAM[i];
}
}
void firstLevel() {
int p = 1;
while (p <= 1) {
int size = 5;
int rwin, bwin, row, col, oldRow, oldCol, brow, bcol, boldRow, boldCol, ycol, yrow;
size++;
rwin = 0;
bwin = 0;
ycol = 65;
yrow = 65;
waitForVblank();
//draw the green background
drawRect(0,0, 240, 160, GREEN);
//draw the yellow goal state
drawRect(yrow, ycol, 10,10, YELLOW);
//draw the red and yellow players
drawRect(100, 10, 10, 10, RED);
drawRect(10, 20, 10, 10, BLUE);
oldCol = 0;
oldRow = 0;
row = 100;
col = 10;
boldCol = 0;
boldRow = 0;
brow = 10;
bcol = 20;
//looping to keep moving the red and blue players to reach the yellow goal
//drawRect(100, 10, 20, 50, RED);
//drawRect(row, col, size, size, color);
if(KEY_DOWN_NOW(BUTTON_RIGHT))
{
if (row <= 160 && col <= 240 && row >= 0 && col >= 0) {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(brow, bcol, 10, 10, BLUE);
col = col + 1;
drawRect(row, col, 10, 10, RED);
} else {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(brow, bcol, 10, 10, BLUE);
row = 50;
col = 50;
drawRect(row, col, 10, 10, RED);
}
}
if(KEY_DOWN_NOW(BUTTON_LEFT))
{
if (row <= 160 && col <= 240 && row >= 0 && col >= 0) {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(brow, bcol, 10, 10, BLUE);
col = col - 1;
drawRect(row, col-3, 10, 10, RED);
} else {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(brow, bcol, 10, 10, BLUE);
row = 50;
col = 50;
drawRect(row, col, 10, 10, RED);
}
}
if(KEY_DOWN_NOW(BUTTON_UP))
{
if (row <= 160 && col <= 240 && row >= 0 && col >= 0) {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(brow, bcol, 10, 10, BLUE);
row = row - 1;
drawRect(row, col, 10, 10, RED);
} else {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(brow, bcol, 10, 10, BLUE);
row = 50;
col = 50;
drawRect(row, col, 10, 10, RED);
}
}
if(KEY_DOWN_NOW(BUTTON_DOWN))
{
if (row <= 160 && col <= 240 && row >= 0 && col >= 0) {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(brow, bcol, 10, 10, BLUE);
row = row + 1;
drawRect(row, col, 10, 10, RED);
} else {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(brow, bcol, 10, 10, BLUE);
row = 50;
col = 50;
drawRect(row, col, 10, 10, RED);
}
}
if(KEY_DOWN_NOW(BUTTON_R))
{
if (brow <= 160 && bcol <= 240 && brow >= 0 && bcol >= 0) {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(row, col, 10, 10, RED);
bcol = bcol + 1;
drawRect(brow, bcol, 10, 10, BLUE);
} else {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(row, col, 10, 10, RED);
brow = 80;
bcol = 190;
drawRect(brow, bcol, 10, 10, BLUE);
}
}
if(KEY_DOWN_NOW(BUTTON_L))
{
if (brow <= 160 && bcol <= 240 && brow >= 0 && bcol >= 0) {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(row, col, 10, 10, RED);
bcol = bcol - 1;
drawRect(brow, bcol, 10, 10, BLUE);
} else {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(row, col, 10, 10, RED);
brow = 80;
bcol = 190;
drawRect(brow, bcol, 10, 10, BLUE);
}
}
if(KEY_DOWN_NOW(BUTTON_A))
{
if (brow <= 160 && bcol <= 240 && brow >= 0 && bcol >= 0) {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(row, col, 10, 10, RED);
brow = brow - 1;
drawRect(brow, bcol, 10, 10, BLUE);
} else {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(row, col, 10, 10, RED);
brow = 80;
bcol = 190;
drawRect(brow, bcol, 10, 10, BLUE);
}
}
if(KEY_DOWN_NOW(BUTTON_B))
{
if (brow <= 160 && bcol <= 240 && brow >= 0 && bcol >= 0) {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(row, col, 10, 10, RED);
brow = brow + 1;
drawRect(brow, bcol, 10, 10, BLUE);
} else {
drawRect(0,0, 240, 160, GREEN);
drawRect(yrow, ycol, 10,10, YELLOW);
drawRect(row, col, 10, 10, RED);
brow = 80;
bcol = 190;
drawRect(brow, bcol, 10, 10, BLUE);
}
}
if (brow == row && bcol == col && bcol != ycol && bcol != ycol) {
row = 190;
col = 100 ;
drawRect(0,0, 240, 160, GREEN);
drawRect(row, col, 10, 10, RED);
drawRect(yrow, ycol, 10,10, YELLOW);
brow = 10;
bcol = 20;
drawRect(brow, bcol, 10, 10, BLUE);
}
//checking if either of the entitites reachedthe yellow goal state, increment their win pts
//and then start the next level
if ((brow == yrow && bcol == ycol) || (row == yrow && col == ycol) ) {
//bwin = (brow == yrow && bcol == ycol) ? bwin++ : bwin;
//rwin = (brow == yrow && bcol == ycol) ? rwin : rwin++;
p = 2;
}
//waitForVblank();
}
}
void secondLevel() {
//draw the cyan background
drawRect(0,0, 240, 160, CYAN);
//drawing the goal state
drawRect(54, 189, 10, 10, YELLOW);
//draw the boxes for the "puzzle blocking thingies"
drawRect(10,110, 30, 10, BLUE);
drawRect(100,10, 30, 20, BLUE);
drawRect(20,50, 10, 20, BLUE);
drawRect(160,40, 30, 20, BLUE);
drawRect(20,100, 10, 20, BLUE);
drawRect(30,60, 40, 20, BLUE);
waitForVblank();
int p = 1;
while (p <= 1) {
int size = 5;
int row, col, ycol, yrow, rwin, bwin;
row = 100;
col = 10;
//int rwin, bwin, row, col, oldRow, oldCol, brow, bcol, boldRow, boldCol, ycol, yrow;
size++;
rwin = 0;
bwin = 0;
ycol = 65;
yrow = 65;
if(KEY_DOWN_NOW(BUTTON_RIGHT))
{
if (row <= 160 && col <= 240 && row >= 0 && col >= 0) {
drawRect(0,0, 240, 160, CYAN);
//drawing the goal state
drawRect(54, 189, 10, 10, YELLOW);
//draw the boxes for the "puzzle blocking thingies"
drawRect(10,110, 30, 10, BLUE);
drawRect(100,10, 30, 20, BLUE);
drawRect(20,50, 10, 20, BLUE);
drawRect(160,40, 30, 20, BLUE);
drawRect(20,100, 10, 20, BLUE);
drawRect(30,60, 40, 20, BLUE);
} else {
p++;
p--;
}
}
if(KEY_DOWN_NOW(BUTTON_LEFT))
{
if (row <= 160 && col <= 240 && row >= 0 && col >= 0) {
drawRect(0,0, 240, 160, CYAN);
//drawing the goal state
drawRect(54, 189, 10, 10, YELLOW);
//draw the boxes for the "puzzle blocking thingies"
drawRect(10,110, 30, 10, BLUE);
drawRect(100,10, 30, 20, BLUE);
drawRect(20,50, 10, 20, BLUE);
drawRect(160,40, 30, 20, BLUE);
drawRect(20,100, 10, 20, BLUE);
drawRect(30,60, 40, 20, BLUE);
} else {
p++;
p--;
}
}
if(KEY_DOWN_NOW(BUTTON_UP))
{
if (row <= 160 && col <= 240 && row >= 0 && col >= 0) {
drawRect(0,0, 240, 160, CYAN);
//drawing the goal state
drawRect(54, 189, 10, 10, YELLOW);
//draw the boxes for the "puzzle blocking thingies"
drawRect(10,110, 30, 10, BLUE);
drawRect(100,10, 30, 20, BLUE);
drawRect(20,50, 10, 20, BLUE);
drawRect(160,40, 30, 20, BLUE);
drawRect(20,100, 10, 20, BLUE);
drawRect(30,60, 40, 20, BLUE);
} else {
p++;
p--;
}
}
if(KEY_DOWN_NOW(BUTTON_DOWN))
{
if (row <= 160 && col <= 240 && row >= 0 && col >= 0) {
drawRect(0,0, 240, 160, CYAN);
//drawing the goal state
drawRect(54, 189, 10, 10, YELLOW);
//draw the boxes for the "puzzle blocking thingies"
drawRect(10,110, 30, 10, BLUE);
drawRect(100,10, 30, 20, BLUE);
drawRect(20,50, 10, 20, BLUE);
drawRect(160,40, 30, 20, BLUE);
drawRect(20,100, 10, 20, BLUE);
drawRect(30,60, 40, 20, BLUE);
} else {
p++;
p--;
}
}
}
}
void gameLoop()
{
// Set our game data
shipRow = 55;
shipCol = 0;
enemyCol = 225;
enemy_num = 0;
projectile_num = 0;
time_diff = 0;
kills = 0;
REG_DISPCNT = MODE3 | BG2_ENABLE;
EntityClass player_ship;
initialize_entity( &player_ship, SHIP_WIDTH, SHIP_HEIGHT, shipRow, shipCol );
EntityClass enemy;
initialize_entity( &enemy, 0, 0, 0, 0 );
enemies[max_enemies+1] = enemy;
while (lives != 0)
{
// Check if player won the level.
if( kills == 10 )
{
state = WIN;
break;
}
// Draw background
drawImage3( 0, 0, BACKGROUND_WIDTH, BACKGROUND_HEIGHT, background );
// Draw ship
draw_entity( &player_ship, ship );
// Generate enemy
if( time_diff <= 0 && enemy_num < 10 )
{
time_diff = 75;
int rand_row = ( rand() % (120+1-20) ) + 20;
generate_enemy( rand_row, enemyCol );
}
// Draw Enemy
update_enemies();
// Draw each projectile
update_projectiles();
// Check if player is dead.
if( is_player_dead( &player_ship ) == 1 )
{
lives--;
gameLoop();
}
check_collisions();
remove_old_projectiles();
remove_old_enemies();
// Draw lives
for( int i = 0; i < lives; i++ )
{
drawImage3( 140, 170 + ( i * 25 ), SHIP_WIDTH, SHIP_HEIGHT, ship );
}
waitForVblank();
// If player hits 'select' return to titleScreen and start game over.
if( KEY_DOWN_NOW( BUTTON_SELECT ) )
{
state = TITLE;
break;
}
// Player Actions
if( KEY_DOWN_NOW( BUTTON_DOWN ) )
{
if( get_row( &player_ship ) < 121 )
move_entity( &player_ship, 2, 0 );
}
if( KEY_DOWN_NOW( BUTTON_UP ) )
{
if( get_row( &player_ship ) > 20 )
move_entity( &player_ship, -2, 0 );
}
if( KEY_DOWN_NOW( BUTTON_A ) )
{
while( KEY_DOWN_NOW( BUTTON_A ) ) {
;
}
fire_weapon( &player_ship );
}
time_diff--;
}
if( lives == 0 )
{
state = GAME_OVER;
}
else if( state == WIN )
return;
}
int main()
{
REG_DISPCTL = MODE3 | BG2_ENABLE;
while(1) {
waitForVblank();
//handle different states
switch(state) {
//Enter Title Screen
case START:
drawImage3(0, 0, 240, 160, title);
state = LEVEL1;
//state = LEVEL4;
break;
//Enter Level 1
case LEVEL1:
if (KEY_DOWN_NOW(BUTTON_START)) {
drawLevel(state);
state = play(state);
}
if (KEY_DOWN_NOW(BUTTON_SELECT)) {
state = START;
}
break;
//Enter Pause Screen 1
case PAUSE1:
drawImage3(0, 0, 240, 160, dkvsmario);
if (KEY_DOWN_NOW(BUTTON_START)) {
state = LEVEL2;
drawLevel(state);
state = play(state);
}
if (KEY_DOWN_NOW(BUTTON_SELECT)) {
state = START;
}
break;
//Enter Level 2
case LEVEL2:
drawLevel(state);
state = play(state);
if (KEY_DOWN_NOW(BUTTON_SELECT)) {
state = START;
}
break;
//Enter Pause Screen 2
case PAUSE2:
drawImage3(0, 0, 240, 160, dkvsmario);
if (KEY_DOWN_NOW(BUTTON_START)) {
state = LEVEL3;
drawLevel(state);
state = play(state);
}
if (KEY_DOWN_NOW(BUTTON_SELECT)) {
state = START;
}
break;
//Enter Level 3
case LEVEL3:
drawLevel(state);
state = play(state);
if (KEY_DOWN_NOW(BUTTON_SELECT)) {
state = START;
}
break;
// //Enter Pause Screen 3
// case PAUSE3:
// drawImage3(0, 0, 240, 160, dkvsmario);
// if (KEY_DOWN_NOW(BUTTON_START)) {
// state = LEVEL4;
// drawLevel(state);
// state = play(state);
// }
// if (KEY_DOWN_NOW(BUTTON_SELECT)) {
// state = START;
// }
// break;
// //Enter Level 4
// case LEVEL4:
// drawLevel(state);
// state = play(state);
// if (KEY_DOWN_NOW(BUTTON_SELECT)) {
// state = START;
// }
// break;
// //Enter Pause Screen 4
// case PAUSE4:
// drawImage3(0, 0, 240, 160, dkvsmario);
// if (KEY_DOWN_NOW(BUTTON_START)) {
// state = LEVEL4;
// drawLevel(state);
// state = play(state);
// }
// if (KEY_DOWN_NOW(BUTTON_SELECT)) {
// state = START;
// }
// break;
//You lost... gameover.
case GAMEOVER:
drawImage3(0, 0, 240, 160, gameover);
if (KEY_DOWN_NOW(BUTTON_SELECT)) {
state = START;
}
break;
//You actually won...
case WIN:
drawImage3(0, 0, 240, 160, win);
if (KEY_DOWN_NOW(BUTTON_SELECT)) {
state = START;
}
break;
}
}
return 0;
}
int main() {
setupInterrupts();
setupSounds();
playSoundA(titleSong, TITLESONGLEN, TITLESONGFREQ, 1);
// Start game with splash screen
splash();
// Main Game Loop
while (1) {
oldButtons = buttons;
buttons = BUTTONS;
// Update player row and column
player.bigRow = player.row + vOff;
player.bigCol = player.col + hOff;
switch(state) {
case SPLASH:
// Displays splash screen
splash();
break;
case INSTRUCTIONS:
instructions();
break;
case GAME:
// Game Function holds all game logic
game();
break;
case SEASONCHANGE:
// Warp-like animation as player changes between seasons
warpAnimation();
// Change game to correct season, based on prevSeason and return to gameplay
if (vBlankCount < 1) {
seasonChange();
state = GAME;
}
break;
case PAUSE:
pause();
break;
case LOSE:
lose();
break;
case WINLEVEL:
winLevel();
break;
case GAMEEND:
gameEnd();
break;
}
// Shadow OAM Handling
// Player Sprite
shadowOAM[0].attr0 = (ROWMASK & player.row) | ATTR0_SQUARE;
shadowOAM[0].attr1 = (COLMASK & player.col) | ATTR1_SIZE16 | (ATTR1_HFLIP & (player.facing << 12));
shadowOAM[0].attr2 = (SPRITEOFFSET16(season * 2, player.currentFrame * 2)) | ATTR2_PRIORITY2;
// Season Icon Sprite
shadowOAM[1].attr0 = (ROWMASK & icon.row) | ATTR0_SQUARE;
shadowOAM[1].attr1 = (COLMASK & icon.col) | ATTR1_SIZE16;
shadowOAM[1].attr2 = (SPRITEOFFSET16(season * 2, 6)) | (1 << 10); // Priority 1
REG_BG2HOFS = hOff;
REG_BG2VOFS = vOff;
// Set BG1 offsets - used for snow and falling leaves
REG_BG1HOFS = bg1HOff;
REG_BG1VOFS = bg1VOff;
//Copy the shadowOAM into the OAM
DMANow(3, &shadowOAM, OAM, 512);
waitForVblank();
}
return 0;
}
void drawBoard(){
if(toReset){
int i;
mode=NORMAL;
playing=0;
for (i=0;i<2;i++){
PALETTE[i]=LifeGame_palette[i];
}
drawImage4(0,0,240,160,LifeGame);
FlipPage();
while(!(KEY_DOWN_NOW(BUTTON_START))){
}
FlipPage();
u16 colors[]={BLACK,LTGREY,RED,GREEN,BLUE,WHITE,DKGREY,YELLOW};
int numcolors = sizeof(colors)/sizeof(colors[0]);
for (i=0;i<numcolors;i++){
PALETTE[i]=colors[i];
}
clear();//Clear array to start game
mouse->r=UpperLeftRow-1;
mouse->c=UpperLeftCol-2;
toReset=0;
}
else{
drawRect4(0,0,240,160,LTGREYINDEX);
drawImage4(140,58,20,12,clearButton);
drawImage4(140,80,20,12,One);
drawImage4(140,110,20,12,Two);
drawImage4(140,145,20,12,next);
if(playing)drawImage4(140,30,12,12,pause);
else drawImage4(140,30,12,12,play);
if (mode==NORMAL){
drawImage4(2,5,50,12,normalModeButton);
drawImage4(140,177,50,12,nextModeButton);
}
else{
drawImage4(2,5,50,12,nextModeButton);
drawImage4(140,177,50,12,normalModeButton);
}
drawMouse(mouse->r,mouse->c,5,5,BLUEINDEX);
int i;
int j;
if (mode==NORMAL){
for (i=0;i<MAXR;i++){
for (j=0;j<MAXC;j++){
if (a[i][j])drawRect4(i*4+UpperLeftRow,j*4+UpperLeftCol,3,3,GREENINDEX);
else drawRect4(i*4+UpperLeftRow,j*4+UpperLeftCol,3,3,BLACKINDEX);
}
}
}
else{
int n;
int m;
for(n=0;n<MAXR;n++){
for(m=0;m<MAXC;m++){
oldA[n][m]=prevA[n][m];
}
}
nextArray();
for (i=0;i<MAXR;i++){
for (j=0;j<MAXC;j++){
if (a[i][j]==prevA[i][j]){
if(a[i][j])
drawRect4(i*4+UpperLeftRow,j*4+UpperLeftCol,3,3,GREENINDEX);
else drawRect4(i*4+UpperLeftRow,j*4+UpperLeftCol,3,3,BLACKINDEX);
}
else{
if(a[i][j])drawRect4(i*4+UpperLeftRow,j*4+UpperLeftCol,3,3,YELLOWINDEX);
else drawRect4(i*4+UpperLeftRow,j*4+UpperLeftCol,3,3,REDINDEX);
}
}
}
for(n=0;n<MAXR;n++){
for(m=0;m<MAXC;m++){
a[n][m]=prevA[n][m];
}
}
for(n=0;n<MAXR;n++){
for(m=0;m<MAXC;m++){
prevA[n][m]=oldA[n][m];
}
}
}
}
FlipPage();
waitForVblank();
}
int main()
{
REG_DISPCTL = MODE3 | BG2_ENABLE;
reset();
while(1) {
waitForVblank();
switch (state) {
case START:
drawImage3(0, 0, 240, 160, StartScreen); //The start screen
state = READY;
break;
case READY:
if (KEY_DOWN_NOW(BUTTON_B)) {
drawBg();
state = PLAY;
}
break;
case PLAY:
if(KEY_DOWN_NOW(BUTTON_A)) {
reset();
}
eraseImage3(150, 0, 240, 10);
sprintf(buffer, "%d bugs left", bugsNum);
drawString(150, 0, buffer, red);
sprintf(buffer, "%d lives left", lives);
drawString(150, 100, buffer, red);
sprintf(buffer, "level %d", level);
drawString(150, 190, buffer, red);
updateShip(&ship);
updateBugs(bugs, &ship, &state);
if (bugsNum == 0 && lives > 0) {
state = WON;
}
break;
case WON:
if (level == 1) {
drawString(100, 10, "Almost there! Press enter to continue!", red);
if(KEY_DOWN_NOW(BUTTON_A)) {
reset();
}
if (KEY_DOWN_NOW(BUTTON_START)) {
level++;
drawBg();
setShip(&ship);
setBugs(bugs);
state = PLAY;
}
} else {
drawImage3(0, 0, 240, 160, Win);
if (KEY_DOWN_NOW(BUTTON_START) || KEY_DOWN_NOW(BUTTON_A)) {
reset();
}
}
break;
case DIE:
drawBg();
sprintf(buffer, "%d lives left", lives);
drawString(50, 75, buffer, red);
if(KEY_DOWN_NOW(BUTTON_A)) {
reset();
}
if (KEY_DOWN_NOW(BUTTON_START)) {
drawBg();
state = PLAY;
ship.x = START_X;
ship.y = START_Y;
for (int i = 0; i < bugsNum; i++) {
bugs[i].y = bugs[i].startY;
bugs[i].charge = 0;
}
}
break;
case LOSE:
drawImage3(0, 0, 240, 160, Ending);
if(KEY_DOWN_NOW(BUTTON_A)) {
reset();
}
if (KEY_DOWN_NOW(BUTTON_START)) {
reset();
}
break;
}
}
return 0;
}
int game(int seed)
{
REG_DISPCTL = MODE3 | BG2_ENABLE;
int live = 5;
char buffer[41];
int speed = 1;
int num = 100;
int objx = 70;
int objy = 50;
drawPicture(black);
WALL wall0;
wall0.i = 80;
wall0.gate = 90;
wall0.gateSize = 10;
wall0.color = WHITE;
WALL wall1;
wall1.i = 100;
wall1.gate = 90;
wall1.gateSize = 10;
wall1.color = MAGENTA;
WALL wall2;
wall2.i = 120;
wall2.gate = 30;
wall2.gateSize = 30;
wall2.color = RED;
WALL wall3;
wall3.i = 140;
wall3.gate = 150;
wall3.gateSize = 30;
wall3.color = BLUE;
WALL wall4;
wall4.i = 160;
wall4.gate = 0;
wall4.gateSize = 20;
wall4.color = GREEN;
WALL wall5;
wall5.i = 180;
wall5.gate = 130;
wall5.gateSize = 20;
wall5.color = BLUE;
WALL wall6;
wall6.i = 200;
wall6.gate = 130;
wall6.gateSize = 15;
wall6.color = CYAN;
// Game Loop
while(1)
{
int oldx = objx;
int oldy = objy;
drawRect(oldx,oldy,1,1, BLACK);
if(KEY_DOWN_NOW(BUTTON_SELECT))
{
objx = 70;
objy = 50;
live = 5;
drawRect(150,0,60,30,BLACK);
drawString(150, 0, "Score: 0", YELLOW);
}
if(KEY_DOWN_NOW(BUTTON_UP))
{
objx-=speed;
if(objx < 0)
{
objx = 0;
}
}
if(KEY_DOWN_NOW(BUTTON_DOWN))
{
objx+=speed;
if(objx > 159)
{
objx = 159;
}
}
if(KEY_DOWN_NOW(BUTTON_A))
{
speed = 2;
}
if(KEY_DOWN_NOW(BUTTON_B))
{
speed = 1;
}
if(KEY_DOWN_NOW(BUTTON_RIGHT))
{
objy++;
}
if(KEY_DOWN_NOW(BUTTON_LEFT))
{
objy--;
if(objy <= 0)
{
objy= 0;
}
}
drawRect(objx,objy,1,1, RED);
drawWall(wall0.i, wall0.gate, wall0.gateSize, wall0.color);
if(num < 50)
{
if(num <= 0)
{
num = 100;
}
drawWall(wall1.i, wall1.gate++, wall1.gateSize, wall1.color);
drawWall(wall2.i, wall2.gate-=2, wall2.gateSize, wall2.color);
drawWall(wall3.i, wall3.gate+=3, wall3.gateSize, wall3.color);
drawWall(wall4.i, wall4.gate-=3, wall4.gateSize, wall4.color);
drawWall(wall5.i, wall5.gate+=3, wall5.gateSize, wall5.color);
drawWall(wall6.i, wall6.gate+=3, wall6.gateSize, wall6.color);
}
else
{
drawWall(wall1.i, wall1.gate--, wall1.gateSize, wall1.color);
drawWall(wall2.i, wall2.gate+=2, wall2.gateSize, wall2.color);
drawWall(wall3.i, wall3.gate-=3, wall3.gateSize, wall3.color);
drawWall(wall4.i, wall4.gate+=3, wall4.gateSize, wall4.color);
drawWall(wall5.i, wall5.gate-=3, wall5.gateSize, wall5.color);
drawWall(wall6.i, wall6.gate-=3, wall6.gateSize, wall6.color);
}
num--;
if(objy < wall0.i)
{
drawString(150, 0, "Score: 0", YELLOW);
}
if(objy == wall0.i)
{
if(objx < wall0.gate || objx > wall0.gate + wall0.gateSize)
{
live--;
objy-=10;
drawRect(objx,objy ,1,1, RED);
if (live == 0)
{
return LOSE;
}
}
drawRect(150,0,60,30,BLACK);
drawString(150, 0, "Score: 1", YELLOW);
}
if(objy == wall1.i)
{
if(objx < wall1.gate || objx > wall1.gate + wall1.gateSize)
{
live--;
objy-=10;
drawRect(objx,objy ,1,1, RED);
if (live == 0)
{
return LOSE;
}
}
drawRect(150,0,60,30,BLACK);
drawString(150, 0, "Score: 2", YELLOW);
}
if(objy == wall2.i)
{
if(objx < wall2.gate || objx > wall2.gate + wall2.gateSize)
{
live--;
objy-=10;
drawRect(objx,objy ,1,1, RED);
if (live == 0)
{
return LOSE;
}
}
drawRect(150,0,60,30,BLACK);
drawString(150, 0, "Score: 3", YELLOW);
}
if(objy == wall3.i)
{
if(objx < wall3.gate || objx > wall3.gate + wall3.gateSize)
{
live--;
objy-=10;
drawRect(objx,objy ,1,1, RED);
if (live == 0)
{
return LOSE;
}
}
drawRect(150,0,60,30,BLACK);
drawString(150, 0, "Score: 4", YELLOW);
}
if(objy == wall4.i)
{
if(objx < wall4.gate || objx > wall4.gate + wall4.gateSize)
{
live--;
objy-=10;
drawRect(objx,objy ,1,1, RED);
if (live == 0)
{
return LOSE;
}
}
drawRect(150,0,60,30,BLACK);
drawString(150, 0, "Score: 5", YELLOW);
}
if(objy == wall5.i)
{
if(objx < wall5.gate || objx > wall5.gate + wall5.gateSize)
{
live--;
objy-=10;
drawRect(objx,objy ,1,1, RED);
if (live == 0)
{
return LOSE;
}
}
drawRect(150,0,60,30,BLACK);
drawString(150, 0, "Score: 6", YELLOW);
}
if(objy == wall6.i)
{
if(objx < wall6.gate || objx > wall6.gate + wall6.gateSize)
{
live--;
objy-=10;
drawRect(objx,objy ,1,1, RED);
if (live == 0)
{
return LOSE;
}
}
drawRect(150,0,60,30,BLACK);
drawString(150, 0, "Score: 7", YELLOW);
}
if(objy > wall6.i +5)
{
return WIN;
}
drawRect(5,5,60,30,BLACK);
waitForVblank();
drawImage3(0,0,30,30,heart);
sprintf(buffer, " %d", live);
drawString(10, 30, buffer, YELLOW);
drawString(80,210, "EXIT", YELLOW);
}
}
