static void display_task_init (void)
{
tinygl_init (DISPLAY_TASK_RATE);
tinygl_font_set (&font3x5_1);
tinygl_text_mode_set (TINYGL_TEXT_MODE_STEP);
tinygl_text_dir_set (TINYGL_TEXT_DIR_ROTATE);
}
int main (void)
{
uint16_t tick = 0;
uint8_t col;
monster_t monsters[NUM_MONSTERS];
system_init ();
tinygl_init (LOOP_RATE);
pacer_init (LOOP_RATE);
monsters_create (monsters, NUM_MONSTERS);
while (1)
{
/* Refresh monsters. */
for (col = 0; col < TINYGL_WIDTH; col++)
{
pacer_wait ();
tinygl_update ();
}
tick++;
if (tick >= LOOP_RATE / MOVE_RATE)
{
tick = 0;
monster_move (monsters, NUM_MONSTERS);
}
}
return 0;
}
int main (void)
{
int count = 5;
system_init ();
tinygl_init (LOOP_RATE);
tinygl_font_set (&font3x5_1);
tinygl_text_speed_set (MESSAGE_RATE);
tinygl_text_mode_set (TINYGL_TEXT_MODE_SCROLL);
tinygl_text_dir_set (TINYGL_TEXT_DIR_ROTATE);
navswitch_init ();
ir_serial_init ();
show_count (count);
pacer_init (LOOP_RATE);
/* Paced loop. */
while (1)
{
int ret;
uint8_t data;
/* Wait for next tick. */
pacer_wait ();
tinygl_update ();
navswitch_update ();
if (navswitch_push_event_p (NAVSWITCH_WEST))
ir_serial_transmit (1);
if (navswitch_push_event_p (NAVSWITCH_EAST))
ir_serial_transmit (2);
ret = ir_serial_receive (&data);
if (ret == IR_SERIAL_OK)
{
if (data == 1)
count--;
else if (data == 2)
count++;
else
count = 0;
show_count (count);
}
else if (ret < 0)
{
show_err (-ret);
}
}
return 0;
}
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 ();
}
}
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;
}
int main (void)
{
uint8_t size = 0;
code_t codeseq[CODESEQ_LEN_MAX];
uint8_t count = 0;
system_init ();
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 (MESSAGE_RATE);
navswitch_init ();
ir_init ();
pacer_init (LOOP_RATE);
show_num ('W', count);
/* Paced loop. */
while (1)
{
/* Wait for next tick. */
pacer_wait ();
tinygl_update ();
navswitch_update ();
if (navswitch_push_event_p (NAVSWITCH_PUSH))
{
transmit (codeseq, size);
show_char ('T');
}
if (ir_rx_get ())
{
size = capture (codeseq, CODESEQ_LEN_MAX);
show_num (size == 0 ? 'E' : 'R', size);
count++;
// size = capture (codeseq, 9);
// show_char ('0' + size);
}
}
return 0;
}
/** 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);
}
int main (void)
{
uint16_t navswitch_tick = 0;
uint16_t count = 0;
system_init ();
navswitch_init ();
tinygl_init (LOOP_RATE);
tinygl_font_set (&font5x7_1);
pacer_init (LOOP_RATE);
tinygl_draw_char ('*', tinygl_point (0, 0));
while (1)
{
pacer_wait ();
tinygl_update ();
count++;
navswitch_tick++;
if (navswitch_tick >= LOOP_RATE / NAVSWITCH_RATE)
{
navswitch_tick = 0;
navswitch_update ();
if (navswitch_push_event_p (NAVSWITCH_PUSH))
{
char c;
c = (rand () % 26) + 'A';
tinygl_draw_char (c, tinygl_point (0, 0));
/* Reseed the pseudorandom number generator based on the
number of iterations of the paced loop. */
srand (count);
}
}
}
return 0;
}
int main (void)
{
uint16_t things_move_tick = 0;
uint16_t navswitch_tick = 0;
uint16_t monster_flash_tick = 0;
bool running = 0;
bool game_over = 1;
int duration = 0;
system_init ();
navswitch_init ();
led_init ();
led_set (LED1, 0);
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);
pacer_init (LOOP_RATE);
tinygl_text ("GOBBLE6: PUSH TO START");
while (1)
{
uint8_t col;
/* Refresh things. */
for (col = 0; col < TINYGL_WIDTH; col++)
{
pacer_wait ();
tinygl_update ();
}
/* Poll the navswitch and update monster position. */
navswitch_tick++;
if (navswitch_tick >= LOOP_RATE / NAVSWITCH_RATE)
{
navswitch_tick = 0;
navswitch_update ();
if (navswitch_push_event_p (NAVSWITCH_NORTH))
things_monster_move (0, -1);
if (navswitch_push_event_p (NAVSWITCH_SOUTH))
things_monster_move (0, 1);
if (navswitch_push_event_p (NAVSWITCH_EAST))
things_monster_move (1, 0);
if (navswitch_push_event_p (NAVSWITCH_WEST))
things_monster_move (-1, 0);
/* Pause/resume things running around. */
if (navswitch_push_event_p (NAVSWITCH_PUSH))
{
if (! running && game_over)
{
srand (timer_get ());
tinygl_clear ();
things_create ();
duration = 0;
game_over = 0;
}
running = !running;
led_set (LED1, running);
}
if (running && things_killed_p ())
{
char buffer[6];
running = 0;
game_over = 1;
led_set (LED1, 0);
sprintf (buffer, "%d", duration);
tinygl_text (buffer);
}
}
/* Move the things. */
things_move_tick++;
if (things_move_tick >= LOOP_RATE / MOVE_RATE)
{
things_move_tick = 0;
if (running)
{
duration++;
things_move ();
}
}
/* Flash the monster. */
monster_flash_tick++;
if (monster_flash_tick >= LOOP_RATE / MONSTER_FLASH_RATE / 2)
{
monster_flash_tick = 0;
if (running)
things_monster_toggle ();
}
}
return 0;
}
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)
{
int count;
uint8_t data = 'M';
system_init ();
tinygl_init (LOOP_RATE);
tinygl_font_set (&font3x5_1);
tinygl_text_speed_set (MESSAGE_RATE);
tinygl_text_mode_set (TINYGL_TEXT_MODE_STEP);
tinygl_text_dir_set (TINYGL_TEXT_DIR_ROTATE);
navswitch_init ();
ir_uart_init ();
pacer_init (LOOP_RATE);
show_byte ('M');
count = 0;
/* Paced loop. */
while (1)
{
/* Wait for next tick. */
pacer_wait ();
tinygl_update ();
if (ir_uart_read_ready_p ())
{
uint8_t data;
data = ir_uart_getc ();
/* Note, if messages come in too fast, say due to IR
inteference from fluorescent lights, then the display
will not keep up and will appear to freeze. */
show_byte (data);
}
count++;
if (count > LOOP_RATE / SWITCH_POLL_RATE)
{
count = 0;
navswitch_update ();
if (navswitch_push_event_p (NAVSWITCH_WEST))
{
ir_uart_putc (--data);
/* Gobble echoed character. */
ir_uart_getc ();
}
if (navswitch_push_event_p (NAVSWITCH_EAST))
{
ir_uart_putc (++data);
/* Gobble echoed character. */
ir_uart_getc ();
}
}
}
return 0;
}
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;
}
