int main (void)
{
int tick;
boing_state_t balls[3];
system_init ();
tinygl_init (LOOP_RATE);
pacer_init (LOOP_RATE);
tick = 0;
balls[0] = boing_init (0, 1, DIR_NE);
balls[1] = boing_init (4, 5, DIR_SE);
balls[2] = boing_init (4, 5, DIR_SW);
/* Paced loop. */
while (1)
{
/* Wait for next tick. */
pacer_wait ();
tick++;
/* Flash the first two balls at different rates. */
tinygl_draw_point (balls[0].pos, tick % 2 < 1);
tinygl_draw_point (balls[1].pos, tick % 4 < 2);
if (tick >= 40)
{
int i;
tick = 0;
for (i = 0; i < 3; i++)
{
/* Erase previous position. */
tinygl_draw_point (balls[i].pos, 0);
/* Check for collision; if so reverse direction. */
balls[i] = boing_update (balls[i]);
/* Perhaps should make ball that is hit reverse as well? */
if (collision_detect (balls, 2, i) > 0)
{
balls[i] = boing_reverse (balls[i]);
}
/* Draw previous position. */
tinygl_draw_point (balls[i].pos, 1);
}
}
tinygl_update ();
}
}
/** Initialise pen for both player
use setPenP1 and setPenP2
Pen position for player1 is [top-left]
Pen position for player2 is [bottom-right]
@param player - which player are you? */
void initPen(int player){
paintP1 = 0;
paintP2 = 0;
initPenP1(player);
initPenP2(player);
tinygl_init (LOOP_RATE);
//light red led on both players origin
//player1 [top-left] player2 [bottom-right]
tinygl_draw_point (player1_pen.pos, player1_pen.state);
tinygl_draw_point (player2_pen.pos, player2_pen.state);
//turn blue led on to indicate game starts
led_set (LED1, player1_pen.state);
}
static void monster_move (monster_t *monsters, uint8_t num)
{
uint8_t x;
uint8_t y;
uint8_t this;
this = monster_choose (monsters, num);
tinygl_draw_point (monsters[this].pos, 0);
x = monsters[this].pos.x;
y = monsters[this].pos.y;
while (1)
{
int8_t dx[] = {
int8_t dx;
int8_t dy;
dx = (rand () % 3) - 1;
dy = (rand () % 3) - 1;
if ((dx || dy)
&& x + dx >= 0 && x + dx < TINYGL_WIDTH
&& y + dy >= 0 && y + dy < TINYGL_HEIGHT)
{
int8_t other;
other = monster_find (monsters, num, x + dx, y + dy);
if (other != -1)
monsters[other].alive = 0;
monsters[this].pos.x = x + dx;
monsters[this].pos.y = y + dy;
tinygl_draw_point (monsters[this].pos, 1);
return;
}
}
}
int main (void)
{
snake_t snake;
int tick = 0;
system_init ();
snake.dir = DIR_N;
snake.pos.x = TINYGL_WIDTH / 2;
snake.pos.y = TINYGL_HEIGHT - 1;
tinygl_init (LOOP_RATE);
navswitch_init ();
pacer_init (LOOP_RATE);
tinygl_draw_point (snake.pos, 1);
/* Paced loop. */
while (1)
{
/* Wait for next tick. */
pacer_wait ();
navswitch_update ();
tick = tick + 1;
if (tick > LOOP_RATE / SNAKE_SPEED)
{
tick = 0;
snake = snake_move (snake);
}
if (navswitch_push_event_p (NAVSWITCH_WEST))
{
snake = snake_turn_left (snake);
}
if (navswitch_push_event_p (NAVSWITCH_EAST))
{
snake = snake_turn_right (snake);
}
tinygl_update ();
}
return 0;
}
static void monsters_create (monster_t *monsters, uint8_t num)
{
uint8_t i;
for (i = 0; i < num; i++)
{
uint8_t x;
uint8_t y;
do
{
x = rand () % TINYGL_WIDTH;
y = rand () % TINYGL_HEIGHT;
} while (monster_find (monsters, i, x, y) != -1);
monsters[i].pos.x = x;
monsters[i].pos.y = y;
monsters[i].alive = 1;
tinygl_draw_point (tinygl_point (x, y), 1);
}
}
static snake_t snake_move (snake_t snake)
{
switch (snake.dir)
{
case DIR_N:
snake.pos.y = snake.pos.y - 1;
break;
case DIR_E:
snake.pos.x = snake.pos.x + 1;
break;
case DIR_S:
snake.pos.y = snake.pos.y + 1;
break;
case DIR_W:
snake.pos.x = snake.pos.x - 1;
break;
}
tinygl_draw_point (snake.pos, 1);
return snake;
}
int
main (void)
{
uint8_t game_ticks;
uint8_t game_over_ticks;
state_t state = STATE_INIT;
flasher_t flashers[SPACEY_PIX_TYPE_NUM];
uint8_t flasher_state[SPACEY_PIX_TYPE_NUM];
flasher_obj_t flashers_info[SPACEY_PIX_TYPE_NUM];
uint8_t display[TINYGL_WIDTH * TINYGL_HEIGHT];
uint8_t i;
uint8_t j;
game_data_t data;
char message[44];
ir_serial_ret_t ret;
uint8_t ir_data;
system_init ();
/* The first time EEPROM is read all the bytes are 0xFF so set to
sensible defaults. */
eeprom_read (0, &data, sizeof (data));
if (data.level == 0xff)
{
data.level = 0;
data.games = 0;
}
for (i = 0; i < ARRAY_SIZE (flashers); i++)
{
flashers[i] = flasher_init (&flashers_info[i]);
flasher_state[i] = 0;
}
for (i = 0; i < ARRAY_SIZE (display); i++)
display[i] = 0;
/* Set up flash patterns for different pixel types. */
flasher_pattern_set (flashers[SPACEY_PIX_GUN],
&flasher_patterns[FLASH_MODE_GUN]);
flasher_pattern_set (flashers[SPACEY_PIX_SHELL],
&flasher_patterns[FLASH_MODE_SHELL]);
flasher_pattern_set (flashers[SPACEY_PIX_ALIEN],
&flasher_patterns[FLASH_MODE_ALIEN]);
tinygl_init (LOOP_RATE);
tinygl_font_set (&font3x5_1);
tinygl_text_mode_set (TINYGL_TEXT_MODE_SCROLL);
tinygl_text_dir_set (TINYGL_TEXT_DIR_ROTATE);
tinygl_text_speed_set (10);
spacey_init (GAME_UPDATE_RATE, TINYGL_WIDTH, TINYGL_HEIGHT,
display_handler, display);
spacey_event_handler_set (game_event, 0);
game_ticks = 0;
game_over_ticks = 0;
pacer_init (LOOP_RATE);
while (1)
{
pacer_wait ();
if (state == STATE_PLAYING)
{
uint8_t *src;
/* Update flasher states. NB, the first flasher is always off. */
for (i = 1; i < ARRAY_SIZE (flashers); i++)
flasher_state[i] = flasher_update (flashers[i]);
/* Update display. */
src = display;
for (j = 0; j < TINYGL_HEIGHT; j++)
for (i = 0; i < TINYGL_WIDTH; i++)
{
tinygl_point_t point = {i, j};
tinygl_draw_point (point, flasher_state[*src++]);
}
}
/* Advance messages and refresh display. */
tinygl_update ();
game_ticks++;
if (game_ticks >= LOOP_RATE / GAME_UPDATE_RATE)
{
game_ticks = 0;
switch (state)
{
case STATE_PLAYING:
if (! spacey_update ())
{
game_over_display (message);
game_over_ticks = 0;
state = STATE_OVER;
}
break;
case STATE_INIT:
tinygl_text ("SPACEY READY V" VERSION " BY MPH ");
state = STATE_READY;
break;
case STATE_OVER:
game_over_ticks ++;
if (game_over_ticks >= GAME_UPDATE_RATE * GAME_OVER_PERIOD)
state = STATE_READY;
/* Fall through. */
case STATE_READY:
case STATE_MENU_LEVEL:
default:
break;
case STATE_START:
/* Turn that bloody blimey space invader off... */
game_start (&data);
state = STATE_PLAYING;
break;
}
}
ret = ir_serial_receive (&ir_data);
if (ret == IR_SERIAL_OK)
{
if (ir_data == 1)
{
switch (state)
{
case STATE_READY:
state = STATE_MENU_LEVEL;
game_level_display (data.level, message);
break;
case STATE_MENU_LEVEL:
state = STATE_INIT;
break;
case STATE_PLAYING:
spacey_gun_move_right ();
break;
default:
break;
}
}
if (ir_data == 2)
{
switch (state)
{
case STATE_READY:
state = STATE_START;
break;
case STATE_PLAYING:
spacey_gun_fire ();
break;
case STATE_MENU_LEVEL:
data.level++;
if (data.level > GAME_LEVEL_MAX)
data.level = 0;
game_level_display (data.level, message);
break;
default:
break;
}
}
}
}
}
int main (void)
{
uint16_t pulsate_tick = 0;
uint8_t pwm_tick = 0;
uint8_t x;
uint8_t y;
uint8_t update_col = 0;
uint8_t col;
uint8_t luminance = 0;
/* This controls the luminance levels. */
const uint8_t levels[] = {4, 8, 16, 32, 64, 100, 64, 32, 16, 4};
system_init ();
tinygl_init (LOOP_RATE);
led_init ();
pacer_init (LOOP_RATE);
while (1)
{
uint8_t state;
/* Refresh display. */
for (col = 0; col < TINYGL_WIDTH; col++)
{
pacer_wait ();
tinygl_update ();
if (update_col != col)
continue;
if (update_col == 0)
update_col = TINYGL_WIDTH;
update_col--;
pulsate_tick++;
if (pulsate_tick >= UPDATE_RATE / PULSATE_RATE)
{
pulsate_tick = 0;
if (luminance == 0)
luminance = ARRAY_SIZE (levels) - 1;
else
luminance--;
}
state = levels[luminance] > pwm_tick * 100 / LUMINANCE_STEPS;
/* Pulse width modulate pixels to control luminance. */
for (x = 0; x < TINYGL_WIDTH; x++)
{
for (y = 0; y < TINYGL_HEIGHT; y++)
{
tinygl_draw_point (tinygl_point (x, y), state);
}
}
led_set (LED1, state);
pwm_tick++;
if (pwm_tick >= UPDATE_RATE / PWM_RATE)
{
pwm_tick = 0;
}
}
}
return 0;
}
void painting(void){
//receive from other players
if (ir_uart_read_ready_p ()){
paintP2 = 1;
//get their position from the signal
player2_pen.pos.x = ir_uart_getc();
player2_pen.pos.y = ir_uart_getc();
/* update the information about other player territory. */
setTerritoryP2(player2_pen.pos.y, player2_pen.pos.x);
tinygl_update ();
}
if (navswitch_push_event_p (NAVSWITCH_NORTH) && player1_pen.pos.y > 0)
{
player1_pen.pos.y--;
paintP1= 1;
ir_uart_putc(player1_pen.pos.x);
ir_uart_putc(player1_pen.pos.y);
//check if the player lands on their own territory
if(!isTerritoryTakenP1(player1_pen.pos.y, player1_pen.pos.x)){
//check if the player lands on other player territory
if(isTerritoryTakenP2(player1_pen.pos.y, player1_pen.pos.x)){
specialScore();
}
//the player lands on territory that hasn't been painted
else{
incrementScore();
}
}
//update information about the player territory
setTerritoryP1(player1_pen.pos.y, player1_pen.pos.x);
}
if (navswitch_push_event_p (NAVSWITCH_SOUTH) && player1_pen.pos.y < TINYGL_HEIGHT - 1)
{
player1_pen.pos.y++;
paintP1= 1;
ir_uart_putc(player1_pen.pos.x);
ir_uart_putc(player1_pen.pos.y);
//check if the player lands on their own territory
if(!isTerritoryTakenP1(player1_pen.pos.y, player1_pen.pos.x)){
//check if the player lands on other player territory
if(isTerritoryTakenP2(player1_pen.pos.y, player1_pen.pos.x)){
specialScore();
}
//the player lands on territory that hasn't been painted
else{
incrementScore();
}
}
//update information about the player territory
setTerritoryP1(player1_pen.pos.y, player1_pen.pos.x);
}
if (navswitch_push_event_p (NAVSWITCH_EAST) && player1_pen.pos.x < TINYGL_WIDTH - 1)
{
player1_pen.pos.x++;
paintP1= 1;
ir_uart_putc(player1_pen.pos.x);
ir_uart_putc(player1_pen.pos.y);
//check if the player lands on their own territory
if(!isTerritoryTakenP1(player1_pen.pos.y, player1_pen.pos.x)){
//check if the player lands on other player territory
if(isTerritoryTakenP2(player1_pen.pos.y, player1_pen.pos.x)){
specialScore();
}
//the player lands on territory that hasn't been painted
else{
incrementScore();
}
}
//update information about the player territory
setTerritoryP1(player1_pen.pos.y, player1_pen.pos.x);
}
if(navswitch_push_event_p(NAVSWITCH_WEST) && player1_pen.pos.x > 0)
{
player1_pen.pos.x--;
paintP1= 1;
ir_uart_putc(player1_pen.pos.x);
ir_uart_putc(player1_pen.pos.y);
//check if the player lands on their own territory
if(!isTerritoryTakenP1(player1_pen.pos.y, player1_pen.pos.x)){
//check if the player lands on other player territory
if(isTerritoryTakenP2(player1_pen.pos.y, player1_pen.pos.x)){
specialScore();
}
//the player lands on territory that hasn't been painted
else{
incrementScore();
}
}
//update information about the player territory
setTerritoryP1(player1_pen.pos.y, player1_pen.pos.x);
}
if (paintP1)
tinygl_draw_point (player1_pen.pos, player1_pen.state);
tinygl_update();
if (paintP2)
tinygl_draw_point (player2_pen.pos, player2_pen.state);
tinygl_update();
}
