Browse Source

Space Invaders is both flicker free and resolution aware, now.

feature/2015
Christian Kroll 12 years ago
parent
commit
77545ffb94
  1. 112
      games/space_invaders/invader_draw.c
  2. 39
      games/space_invaders/invader_init.c
  3. 123
      games/space_invaders/invader_proc.c
  4. 72
      games/space_invaders/invaders2.c
  5. 86
      games/space_invaders/invaders2.h

112
games/space_invaders/invader_draw.c

@ -1,10 +1,45 @@
#include <assert.h>
#include "invaders2.h"
/*--------------------double buffered graphics-------------------*/
static void setOffScreenPixel(offScreen_t offScreen, unsigned char x,
unsigned char y, unsigned char color)
{
assert(offScreen != 0);
assert(x < NUM_COLS);
assert(y < NUM_ROWS);
assert(color <= NUMPLANE);
offScreen[color][y][x / 8u] |= shl_table[x % 8u];
}
static void flushOffScreenBuffer(offScreen_t offScreen)
{
assert(offScreen != 0);
/* off-screen blitting borrowed from fixed point math patterns animation,
see fpmath_patterns.c (fixDrawPattern(...) for details */
unsigned char *pPixmap =
(&pixmap[NUMPLANE - 1][NUM_ROWS - 1][LINEBYTES - 1]) + 1;
unsigned char *pOffScreenDistHigh =
(&offScreen[NUMPLANE][NUM_ROWS - 1][LINEBYTES - 1]) + 1;
unsigned char *pOffScreenDistLow =
(&offScreen[NUMPLANE - 1][NUM_ROWS - 1][LINEBYTES - 1]) + 1;
while (pPixmap != &pixmap[0][0][0]) // stop at the beginning
{
*(--pPixmap) = *(--pOffScreenDistHigh);
*(--pOffScreenDistLow) |= *pOffScreenDistHigh;
*pOffScreenDistHigh = 0;
}
}
/*----------------------getter/setter----------------------------*/
unsigned char getInvaderPixel(Invaders * iv, unsigned char x, unsigned char y)
{
if (((x - iv->pos.x) < MAX_INVADER_WIDTH) && ((x - iv->pos.x) >= 0) && ((y
- iv->pos.y) < MAX_INVADER_HEIGHT) && ((y - iv->pos.y) >= 0))
if (((x - iv->pos.x) < MAX_INVADER_WIDTH) && ((x - iv->pos.x) >= 0) &&
((y - iv->pos.y) < MAX_INVADER_HEIGHT) && ((y - iv->pos.y) >= 0))
{
return iv->map[x - iv->pos.x][y - iv->pos.y];
}
@ -14,96 +49,91 @@ unsigned char getInvaderPixel(Invaders * iv, unsigned char x, unsigned char y)
void setInvaderPixel(Invaders * iv, unsigned char x, unsigned char y,
unsigned char val)
{
if (((x - iv->pos.x) < MAX_INVADER_WIDTH) && ((x - iv->pos.x) >= 0) && ((y
- iv->pos.y) < MAX_INVADER_HEIGHT) && ((y - iv->pos.y) >= 0))
if (((x - iv->pos.x) < MAX_INVADER_WIDTH) && ((x - iv->pos.x) >= 0) &&
((y - iv->pos.y) < MAX_INVADER_HEIGHT) && ((y - iv->pos.y) >= 0))
{
iv->map[x - iv->pos.x][y - iv->pos.y] = val;
}
}
void setGuardPixel(unsigned char *guards, unsigned char x,
unsigned char y, unsigned char val)
void setGuardPixel(unsigned char *guards, unsigned char x, unsigned char y,
unsigned char val)
{
assert(val <= NUMPLANE);
if (x < NUM_COLS && y == GUARD_LINE)
{
if (x < BORG_WIDTH && y == GUARD_LINE && val <= 3)
guards[x] = val;
}
}
/*----------------------drawing Method---------------------------*/
void draw(Invaders * iv, Spaceship * sc, Player * pl, Cannon * cn,
unsigned char *guards, uPixel *st, uPixel * shot)
void draw(offScreen_t offScreen, Invaders * iv, Spaceship * sc, Player * pl,
Cannon * cn, unsigned char *guards, pixel *st, pixel * shot)
{
clearScreen ();
unsigned char x, y;
/*---SPACESHIP---*/
if (sc->pos < RIGHT_BORDER)
if (sc->pos < NUM_COLS)
{
setPixel (sc->pos, SPACESHIP_LINE, sc->lives);
setOffScreenPixel(offScreen, sc->pos, SPACESHIP_LINE, sc->lives);
}
if (sc->pos - 1 < RIGHT_BORDER)
if ((sc->pos > 0) && ((sc->pos - 1) < NUM_COLS))
{
setPixel (sc->pos + 1, SPACESHIP_LINE, sc->lives);
setOffScreenPixel(offScreen, sc->pos - 1, SPACESHIP_LINE, sc->lives);
}
/*---INVADERS--*/
// for (y = 0; y < MAX_INVADER_HEIGHT; y++)
for (y = MAX_INVADER_HEIGHT; y--;)
{
// for (x = 0; x < MAX_INVADER_WIDTH; x++)
for (x = MAX_INVADER_WIDTH; x--;)
{
//mal in oder statement umwandeln ;-)
if (iv->map[x][y] == 0)
continue;
if (x + iv->pos.x > RIGHT_BORDER)
continue;
if (x + iv->pos.x < 0)
continue;
setPixel (x + iv->pos.x, y + iv->pos.y, iv->map[x][y]);
if ((x + iv->pos.x >= 0) && (x + iv->pos.x < NUM_COLS) &&
(y + iv->pos.y < NUM_ROWS))
{
setOffScreenPixel(offScreen, x + iv->pos.x, y + iv->pos.y,
iv->map[x][y]);
}
}
}
/*---GUARDS---*/
for (x = BORG_WIDTH; x--;)
for (x = NUM_COLS; x--;)
{
if (guards[x] != 0)
{
setPixel (x, GUARD_LINE, guards[x]);
}
setOffScreenPixel(offScreen, x, GUARD_LINE, guards[x]);
}
/*---SHOTS--*/
unsigned char i;
for (i = MAX_SHOTS; i--;)
{
if (st[i].x < BORG_WIDTH && st[i].y < BORG_HEIGHT)
if (st[i].x < NUM_COLS && st[i].y < NUM_ROWS)
{
setPixel (st[i].x, st[i].y, 3);
setOffScreenPixel(offScreen, st[i].x, st[i].y, 3);
}
}
/*draw player shot*/
if (!(cn->ready))
{
setPixel (shot->x, shot->y, 3);
setOffScreenPixel(offScreen, shot->x, shot->y, 3);
}
/*-- CANNON --*/
if (cn->pos >= LEFT_BORDER + 1)
if (cn->pos > 0) /* right border */
{
setPixel (cn->pos - 1, 15, pl->lives);
setOffScreenPixel(offScreen, cn->pos - 1, NUM_ROWS - 1, pl->lives);
}
if (cn->pos < BORG_WIDTH)
if (cn->pos < NUM_COLS)
{
setPixel (cn->pos, 15, pl->lives);
setPixel (cn->pos, 14, pl->lives);
setOffScreenPixel(offScreen, cn->pos, NUM_ROWS - 2, pl->lives);
setOffScreenPixel(offScreen, cn->pos, NUM_ROWS - 1, pl->lives);
}
if (cn->pos < RIGHT_BORDER)
if (cn->pos < (NUM_COLS - 1)) /* left border */
{
setPixel (cn->pos + 1, 15, pl->lives);
setOffScreenPixel(offScreen, cn->pos + 1, NUM_ROWS - 1, pl->lives);
}
flushOffScreenBuffer(offScreen);
}

39
games/space_invaders/invader_init.c

@ -11,12 +11,25 @@ uint16_t const hans[7] PROGMEM =
void initGuards(unsigned char *guards)
{
memset(guards, 0, BORG_WIDTH);
memset(guards, 0, NUM_COLS);
guards[3] = 3;
guards[6] = 3;
#if NUM_COLS == 16
guards[2] = 3;
guards[5] = 3;
guards[10] = 3;
guards[13] = 3;
#else
unsigned const guard_min_distance = 3;
unsigned char pos;
for (pos = 0; pos <= ((NUM_COLS - (guard_min_distance - 1)) / 2); ++pos)
{
if (((pos % guard_min_distance) == 0) && (pos != 0))
{
guards[pos - 1] = 3;
guards[NUM_COLS - pos] = 3;
}
}
#endif
}
void initInvaders(Invaders * iv, unsigned char lv)
@ -32,16 +45,16 @@ void initInvaders(Invaders * iv, unsigned char lv)
switch (lv)
{
case 0:
default:
for (x = 0; x < 8; ++x)
{
iv->map[x][0] = 2;
iv->map[x][1] = 2;
iv->map[x][2] = 2;
iv->map[x][3] = 1;
// iv->map[x][4] = 1;
}
iv->pos.x = 4;
iv->pos.x = (NUM_COLS - 8) / 2;
iv->pos.y = SPACESHIP_LINE + 1;
iv->speed = MIN_SPEED - 3;
iv->direction = 1;
@ -50,16 +63,13 @@ void initInvaders(Invaders * iv, unsigned char lv)
case 1:
for (x = 0; x < 8; ++x)
{
//for(y = 0; y < MAX_INVADER_HEIGHT; ++y) {
iv->map[x][0] = 3;
iv->map[x][1] = 3;
iv->map[x][2] = 2;
iv->map[x][3] = 2;
// iv->map[x][4] = 1;
//}
}
iv->pos.x = 4;
iv->pos.x = (NUM_COLS - 8) / 2;
iv->pos.y = SPACESHIP_LINE + 1;
iv->speed = MIN_SPEED - 2;
@ -69,16 +79,14 @@ void initInvaders(Invaders * iv, unsigned char lv)
case 2:
for (x = 0; x < 8; ++x)
{
//for(y = 0; y < MAX_INVADER_HEIGHT; ++y) {
iv->map[x][0] = 3;
iv->map[x][1] = 3;
iv->map[x][2] = 2;
iv->map[x][3] = 2;
iv->map[x][4] = 1;
//}
}
iv->pos.x = 4;
iv->pos.x = (NUM_COLS - 8) / 2;
iv->pos.y = SPACESHIP_LINE + 1;
iv->speed = MIN_SPEED - 1;
@ -97,12 +105,11 @@ void initInvaders(Invaders * iv, unsigned char lv)
}
}
iv->pos.x = 3;
iv->pos.x = (NUM_COLS - 11) / 2;
iv->pos.y = SPACESHIP_LINE + 1;
iv->speed = MIN_SPEED + 2;
iv->direction = 1;
break;
case 4:
@ -120,13 +127,11 @@ void initInvaders(Invaders * iv, unsigned char lv)
}
}
iv->pos.x = 3;
iv->pos.x = (NUM_COLS - 11) / 2;
iv->pos.y = SPACESHIP_LINE + 1;
iv->speed = MIN_SPEED + 3;
iv->direction = 1;
break;
}
}

123
games/space_invaders/invader_proc.c

@ -4,43 +4,36 @@
#include "../../random/prng.h"
#include "invaders2.h"
void procCannon(Cannon * cn, uPixel * shot)
void procCannon(Cannon * cn, pixel * shot)
{
static unsigned char mv = 0;
if (mv >= CANNON_SPEED)
if (mv++ >= CANNON_SPEED)
{
mv = 0;
if (JOYISLEFT)
{
if (cn->pos != RIGHT_BORDER)
if (cn->pos < (NUM_COLS - 1))
{
cn->pos++;
}
}
else if (JOYISRIGHT)
{
if (cn->pos != LEFT_BORDER)
if (cn->pos > 0)
{
cn->pos--;
--cn->pos;
}
}
else if (JOYISFIRE)
{
if (cn->ready)
{
shot->x = cn->pos;
shot->y = 14;
shot->y = NUM_ROWS - 3;
cn->ready = 0;
}
}
}
else
{
mv++;
}
}
static unsigned char areAtBorder(Invaders * iv)
@ -48,21 +41,19 @@ static unsigned char areAtBorder(Invaders * iv)
unsigned char y;
for (y = SPACESHIP_LINE + 1; y <= GUARD_LINE; ++y)
{
if (getInvaderPixel(iv, LEFT_BORDER, y) || getInvaderPixel(iv,
RIGHT_BORDER, y))
if (getInvaderPixel(iv, NUM_COLS - 1, y) || getInvaderPixel(iv, 0, y))
{
return 1;
}
}
return 0;
}
void procInvaders(Invaders * iv, uPixel *st)
void procInvaders(Invaders * iv, pixel *st)
{
static unsigned char mv = 0;
if (mv >= iv->speed)
if (mv++ >= iv->speed)
{
mv = 0;
if (areAtBorder(iv) && !(iv->isEdged))
@ -76,29 +67,21 @@ void procInvaders(Invaders * iv, uPixel *st)
iv->pos.x += iv->direction;
iv->isEdged = 0;
}
}
mv++;
unsigned char i, y;
unsigned char spos = random8() % 16;
if (spos >= BORG_WIDTH)
return;
unsigned char spos = random8() % UNUM_COLS;
unsigned char shoot = random8();
if (shoot < SHOOTING_RATE)
if (random8() < SHOOTING_RATE)
{
for (i = 0; i < MAX_SHOTS; ++i)
{
if (st[i].x > BORG_WIDTH || st[i].y > BORG_HEIGHT)
if (st[i].y >= NUM_ROWS)
{
for (y = GUARD_LINE; y > SPACESHIP_LINE; --y)
{
if (getInvaderPixel(iv, spos, y) != 0)
{
st[i].x = spos;
st[i].y = y + 1;
return;
@ -107,29 +90,29 @@ void procInvaders(Invaders * iv, uPixel *st)
}
} //for SHOTS
}
}
void procShots(Invaders * iv, Player * pl, Cannon * cn, Spaceship * sc,
unsigned char *guards, uPixel *st, uPixel * shot)
unsigned char *guards, pixel *st, pixel * shot)
{
unsigned char i;
static unsigned char cmv = 0, imv = 0;
// shuß mit einen struct mit dem shuß!!
if (cmv >= CANNON_SHOOTING_SPEED)
{
cmv = 0;
if (!(cn->ready))
{
if (shot->y > 0)
{
shot->y--;
}
if (shot->y > BORG_HEIGHT)
else
{
cn->ready = 1;
}
}
}
if (imv >= INVADER_SHOOTING_SPEED)
{
@ -137,7 +120,7 @@ void procShots(Invaders * iv, Player * pl, Cannon * cn, Spaceship * sc,
for (i = MAX_SHOTS; i--;)
{
if ( /*st[i].x < BORG_WIDTH && */st[i].y < BORG_HEIGHT)
if (st[i].y < NUM_ROWS)
{
st[i].y++;
}
@ -152,7 +135,6 @@ void procShots(Invaders * iv, Player * pl, Cannon * cn, Spaceship * sc,
/****************************************************************/
// USER CANNON
unsigned char tmp;
if (!(cn->ready))
{
@ -163,6 +145,7 @@ void procShots(Invaders * iv, Player * pl, Cannon * cn, Spaceship * sc,
st[i].x = 255;
st[i].y = 255;
cn->ready = 1;
goto invader_shots;
}
}
@ -200,21 +183,20 @@ void procShots(Invaders * iv, Player * pl, Cannon * cn, Spaceship * sc,
}
//SPACESHIP
if (shot->y == SPACESHIP_LINE)
{
if (shot->x == sc->pos || shot->x == sc->pos + 1)
if ((shot->x <= sc->pos) && (shot->x >= sc->pos - 1))
{
sc->pos = 255;
sc->pos = NO_SPACESHIP;
pl->points += POINTS_FOR_SPACESHIP;
cn->ready = 1;
goto invader_shots;
}
}
} // !(cn->ready)
}
invader_shots: for (i = 0; i < MAX_SHOTS; ++i)
invader_shots:
for (i = 0; i < MAX_SHOTS; ++i)
{
if ((tmp = getGuardPixel(guards, st[i].x, st[i].y)))
{
@ -224,7 +206,7 @@ void procShots(Invaders * iv, Player * pl, Cannon * cn, Spaceship * sc,
st[i].y = 255;
}
if (st[i].y == BORG_HEIGHT - 1)
if (st[i].y == (NUM_ROWS - 2))
{
if (st[i].x == cn->pos)
{
@ -240,66 +222,61 @@ void procShots(Invaders * iv, Player * pl, Cannon * cn, Spaceship * sc,
void procSpaceship(Spaceship * sc)
{
unsigned char rnd1 = random8();
unsigned char rnd2 = random8();
unsigned char const rnd1 = random8();
unsigned char const rnd2 = random8();
static unsigned char sct = 0;
if (sc->pos > RIGHT_BORDER)
if (sc->pos == NO_SPACESHIP)
{
if (rnd1 == 73)
{
if (rnd2 >= 200)
if ((rnd1 == 73) && (rnd2 >= 200))
{
sc->pos = RIGHT_BORDER;
sc->pos = NUM_COLS;
sct = 0;
}
}
}
else
{
if (sct == SPACESHIP_SPEED)
if (sct++ == SPACESHIP_SPEED)
{
sct = 0;
if (sc->pos == 0)
if (sc->pos > 0)
{
sc->pos = 255;
sc->pos--;
}
else
{
sc->pos--;
sc->pos = NO_SPACESHIP;
}
}
}
sct++;
}
unsigned char getStatus(Invaders * iv)
{
unsigned char x, y;
//count Invader!
unsigned char x, y, inv = 0;
for (x = MAX_INVADER_WIDTH; x--;)
// did invaders reached earth?
for (x = NUM_COLS; x--;)
{
for (y = MAX_INVADER_HEIGHT; y--;)
if (getInvaderPixel(iv, x, GUARD_LINE + 1))
{
if (iv->map[x][y] != 0)
inv++;
return 2;
}
}
//LEVEL BEREINIGT
if (inv == 0)
return 1;
//INVADERS REACHED EARTH
for (x = BORG_WIDTH; x--;)
// any invaders left?
for (x = MAX_INVADER_WIDTH; x--;)
{
if (getInvaderPixel(iv, x, GUARD_LINE + 1))
return 2;
for (y = MAX_INVADER_HEIGHT; y--;)
{
if (iv->map[x][y])
{
return 0; // yes
}
}
}
return 0;
// if we reach here, level was cleared \o/
return 1;
}

72
games/space_invaders/invaders2.c

@ -6,8 +6,6 @@
#include "../../scrolltext/scrolltext.h"
#include "invaders2.h"
//#include <stdio.h>
void borg_invaders();
#ifdef MENU_SUPPORT
@ -23,45 +21,36 @@ game_descriptor_t invaders_game_descriptor __attribute__((section(".game_descrip
void borg_invaders()
{
// waitForFire = 0;
/****************************************************************/
/* INITIALIZE */
/****************************************************************/
offScreen_t offScreen = {{{0}}};
Invaders iv;
Cannon cn;
Player pl;
Spaceship sc;
unsigned char guards[BORG_WIDTH];
unsigned char guards[NUM_COLS];
unsigned char level = 0;
unsigned char ivStatus = 0;
uPixel st[MAX_SHOTS] =
pixel st[MAX_SHOTS] =
{
{255, 255},
{255, 255},
{255, 255},
{255, 255},
{255, 255},
{255, 255},
{255, 255}
};
uPixel shot;
// = {0,0};
pixel shot;
pl.points = 0;
pl.lives = 3;
//--------Init Cannon-------//
//cn.pos = 4;
//cn.ready = 1;
/****************************************************************/
/* INTRO */
/****************************************************************/
//drawIntroScreen(2000);
/****************************************************************/
/* GAME LOOP */
@ -74,77 +63,50 @@ void borg_invaders()
//Spaceship
sc.lives = 1;
sc.pos = 255;
sc.pos = NO_SPACESHIP;
//Cannon
cn.pos = 7;
cn.pos = (NUM_COLS - 3) / 2;
cn.ready = 1;
draw(&iv, &sc, &pl, &cn, guards, st, &shot);
while (1)
while (pl.lives != 0)
{
procInvaders(&iv, st);
procSpaceship(&sc);
procShots(&iv, &pl, &cn, &sc, guards, st, &shot);
procCannon(&cn, &shot);
draw(&iv, &sc, &pl, &cn, guards, st, &shot);
draw(offScreen, &iv, &sc, &pl, &cn, guards, st, &shot);
ivStatus = getStatus(&iv);
if (ivStatus == 2) //LOST
{
//pl.lives--;
pl.lives = 0;
break;
}
else if (ivStatus == 1) //WON
{
unsigned int bonus = POINTS_FOR_LEVEL * (level + 1u) *
(unsigned int)(12 - iv.pos.y);
(unsigned int)(NUM_ROWS - 4 - iv.pos.y);
pl.points += bonus;
//printf("cleared l: %d , y: %d bonus: %d \n",
// level, iv.pos.y, bonus);
if (level == MAX_LEVEL - 1)
{
level = 0;
}
else
{
level = (level + 1);
}
break;
}
if (pl.lives <= 0)
{
//scrolltext("GAME OVER",0,80);
level = (level + 1) % MAX_LEVEL;
break;
}
wait (WAIT_MS);
} //IN LEVEL LOOP
} while (pl.lives > 0); //GAME LOOP
} while (pl.lives != 0); //GAME LOOP
clearScreen ();
//wait(5000);
/****************************************************************/
/* PLAYER STAT */
/* HIGH SCORES */
/****************************************************************/
#ifdef SCROLLTEXT_SUPPORT
char text[64];
snprintf(text, 64, "</#points: %u", pl.points);
scrolltext(text);
#endif
//printf("scores: %d\n", pl.points);
/****************************************************************/
/* PLAYER STAT */
/* HIGH SCORES */
/****************************************************************/
// waitForFire = 1;
}

86
games/space_invaders/invaders2.h

@ -9,44 +9,11 @@
#ifndef INVADERS2_H
#define INVADERS2_H
/* TEST PARTS NEW API */
#include <stdint.h>
#include "../../config.h"
#include "../../pixel.h"
typedef struct
{
signed char x;
signed char y;
} sPixel;
typedef struct
{
unsigned char x;
unsigned char y;
} uPixel;
#define USE_ORIGINAL_PIXEL_API
//for compatibility to pixel.h api!
#ifdef USE_ORIGINAL_PIXEL_API
//typedef uPixel pixel;
#define uPixel pixel
//#define getPixel(_X, _Y) get_pixel( (pixel){_X, _Y})
#define clearScreen() clear_screen(0)
//#define
//#ifdef SIMULATOR
#define setPixel(_X, _Y, _V) setpixel( (pixel){_X, _Y}, _V)
//#else //if defined (AVR)
//#define setPixel(_X, _Y, _V) reverseSetPixel( (pixel){_X, _Y}, _V)
//#endif
#endif
/****************************************************************/
/* GLOBALE VAR */
/****************************************************************/
@ -60,22 +27,8 @@ extern uint16_t const hans[7];
#define START_LIVES 3
#define SPACESHIP_LINE 1
//#define SPACESHIP_TRIGGER_POINTS 250
//#define SPACESHIP_TRIGGER_RATE 333
#define GUARD_LINE 13
#define BORG_WIDTH 16
#define BORG_HEIGHT 16
#ifdef SWITCHED_SIDE
#define RIGHT_BORDER 0
#define LEFT_BORDER (BORG_WIDTH -1 )
#else
#define RIGHT_BORDER (BORG_WIDTH -1 )
#define LEFT_BORDER 0
#endif
#define GUARD_LINE (NUM_ROWS - 3)
#define MAX_INVADER_HEIGHT 8
#define MAX_INVADER_WIDTH 12
@ -96,17 +49,22 @@ extern uint16_t const hans[7];
#define INVADER_SHOOTING_SPEED 10
#define CANNON_SHOOTING_SPEED 4
#define SPACESHIP_SPEED 30
#define NO_SPACESHIP 255
#define CANNON_SPEED 2
#define WAIT_MS 15
//#define WAIT_MS 20
typedef struct
{
signed char x;
signed char y;
} spixel;
typedef struct
{
unsigned char map[MAX_INVADER_WIDTH][MAX_INVADER_HEIGHT];
sPixel pos;
spixel pos;
unsigned char speed;
unsigned char speedinc;
@ -114,21 +72,20 @@ typedef struct
unsigned char isEdged;
} Invaders;
typedef struct
{
unsigned char pos;
unsigned char lives;
} Spaceship;
typedef struct
{
unsigned char pos;
unsigned char ready;
} Cannon;
//typedef struct {
// unsigned char guards[numGards];
//}
typedef struct
{
@ -136,6 +93,9 @@ typedef struct
unsigned int points;
} Player;
typedef unsigned char offScreen_t[NUMPLANE + 1][NUM_ROWS][LINEBYTES];
/****************************************************************/
/* FUNCTIONS */
/****************************************************************/
@ -144,19 +104,18 @@ void borg_invaders();
/*----------------------main_level_funcs-------------------------*/
void procSpaceship(Spaceship * sp);
void procCannon(Cannon * cn, uPixel * shot);
void procCannon(Cannon * cn, pixel * shot);
void procInvaders(Invaders * iv, uPixel st[MAX_SHOTS]);
void procInvaders(Invaders * iv, pixel st[MAX_SHOTS]);
void procShots(Invaders * iv, Player * pl, Cannon * cn, Spaceship * sc,
unsigned char guards[BORG_WIDTH], uPixel st[MAX_SHOTS], uPixel * shot);
unsigned char guards[NUM_COLS], pixel st[MAX_SHOTS], pixel * shot);
unsigned char getStatus(Invaders * iv);
/*----------------------Initialization---------------------------*/
void initGuards(unsigned char guards[BORG_WIDTH]);
void initGuards(unsigned char guards[NUM_COLS]);
void initInvaders(Invaders * iv, unsigned char lv);
//void initSpaceship(Spaceship* sc);
//void initPlayer(Player* pl);
/*----------------------getter/setter----------------------------*/
@ -171,15 +130,14 @@ void setGuardPixel(unsigned char *guards, unsigned char x,
inline static unsigned char getGuardPixel(unsigned char *guards,
unsigned char x, unsigned char y)
{
if (x < BORG_WIDTH && y == GUARD_LINE)
if (x < NUM_COLS && y == GUARD_LINE)
return guards[x];
return 0;
}
/*----------------------drawing Method---------------------------*/
void draw(Invaders * iv, Spaceship * sc, Player * pl, Cannon * cn,
unsigned char *guards, uPixel *ishots,
uPixel * shot);
void draw(offScreen_t offscreen, Invaders * iv, Spaceship * sc, Player * pl,
Cannon * cn, unsigned char *guards, pixel *st, pixel * shot);
#endif
#endif /* INVADERS2_H */

Loading…
Cancel
Save