Tomas Jankech
Game Ant Run - requires 8x8 LED RG shield - project MPOA (VUT v Brne)
Dependencies: MMA8451Q RGB mbed
main.cpp
- Committer:
- tomas_dca
- Date:
- 2015-01-08
- Revision:
- 0:56ca0aab95fc
- Child:
- 1:806df0da28dc
File content as of revision 0:56ca0aab95fc:
#include "mbed.h"
#include "MMA8451Q.h"
#include "MyColor.h"
// LED matrix states (pixel)
#define led_used 3 // color orange
#define led_lab 2 // color green
#define led_ant 1 // color red
#define led_free 0 // off
// brightness of LED matrix
#define brightness 0.0003f // 0.001f optimal, 0.0003f for night
// RGB states
#define color_red 1.0
#define color_orange 0.1
#define color_green 0.3
#define color_blue 0.5
// labyrint virtual LED matrix
uint8_t matrix[8][8];
// templates for labyrint
#define template_fill (~0) // fill all pixels
#define template_arrow 0x12244848241200
/*
* . . . . . . . .
* . . . x . . x .
* . . x . . x . .
* . x . . x . . .
* . . x . . x . .
* . . . x . . x .
* . . . . . . . .
* . . . . . . . .
*/
#define lab_turn_big 0x0D /*
* x x
* . x
*/
#define lab_turn_small 0x08 /*
* x .
* . .
*/
#define lab_straight 0x0A /*
* x .
* x .
*/
#define one 0xF248
//000000001111001001001000
#define two 0x3D2B8
//000000111101001010111000
#define three 0x39678
//000000111001011001111000
#define four 0x25E48
//000000100101111001001000
#define five 0x3CE78
//000000111100111001111000
#define six 0x3CF78
//000000111100111101111000
#define seven 0x39248
//000000111001001001001000
#define eight 0x3DF78
//000000111101111101111000
#define nine 0x3DE78
//000000111101111001111000
#define zero 0x3DB78
//000000111101101101111000
// init LED 8x8 matrix -> port
DigitalOut ROW0(PTB0);
DigitalOut ROW1(PTB1);
DigitalOut ROW2(PTB2);
DigitalOut COLG0(PTC0);
DigitalOut COLG1(PTC1);
DigitalOut COLG2(PTC2);
DigitalOut COLG3(PTC3);
DigitalOut COLG4(PTC4);
DigitalOut COLG5(PTC5);
DigitalOut COLG6(PTC6);
// DigitalOut COLG7(PTC7); TODO
DigitalOut COLG7(PTA1);
DigitalOut COLR0(PTC8);
DigitalOut COLR1(PTC9);
DigitalOut COLR2(PTC10);
DigitalOut COLR3(PTC11);
DigitalOut COLR4(PTC12);
DigitalOut COLR5(PTC13);
DigitalOut COLR6(PTC16);
DigitalOut COLR7(PTC17);
// init LED 8x8 matrix -> port
// state table TEST | GAME | PAUSE
// ----------------------------------------
DigitalIn BTN_L(PTD7); // ->new game | ->pause | ->game
DigitalIn BTN_R(PTD6); // new 0 state | rotate | ->new game
// define accelerometer stuffs
#define MMA8451_I2C_ADDRESS (0x1d<<1)
#define MOVE_ANGLE 25 // > degrees for move
#define IDLE_ANGLE 10 // < degrees for idle state
MMA8451Q acc(PTE25, PTE24, MMA8451_I2C_ADDRESS);
// index for actual block of control
uint8_t row = 2;
uint8_t column = 2;
// index for ant position
uint8_t ant_row = 5;
uint8_t ant_column = 3;
// score counter
uint32_t score_cnt = 0;
// Timer ticker
Ticker display; // display matrix of pixels
Ticker acc_scan; // scan accelerometer move
Ticker ant_run; // ant move
// periodic func. prototypes (Tickers)
void show_matrix(void); // Ticker display
void accelerometer(void); // Ticker acc_scan
void ant_move(void); // Ticker ant_run
// func. prototypes
void fill_matrix(uint64_t temp,uint8_t color);
void rotate_matrix(void);
void rotate_lab(uint8_t lab_row, uint8_t lab_col);
void prepare_matrix(void); // prepare matrix for new labyrint and set initial conditions
void reload_matrix(void); // generate new labyrint blocks (only instead of used)
uint32_t translate(uint8_t); // number to symbol
// func. under accelerometer()
void confirm_dir(void);
void move_cursor(void);
// states of game
typedef enum {ready, pause, game, test, save, learn, score} state_t;
state_t game_state = ready;
/*
* ready - ready for game (idle)
* test - test controls
* save - save accelerator offset
*
* game - ant run game
* learn - special type of the game (without score and game over)
* pause - pause game
*
* score - game over - show score
*/
// directions
typedef enum {idle, left, up, right, down} direction_t;
direction_t acc_dir = idle; // enum for move direction -> control
direction_t ant_dir = down; // enum for move direction -> ant
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main(void)
{
// init RGB backlight
DigitalOut rled(LED_RED, 1);
DigitalOut gled(LED_GREEN, 1);
DigitalOut bled(LED_BLUE, 1);
PwmOut r (LED_RED);
PwmOut g (LED_GREEN);
PwmOut b (LED_BLUE);
MyColor color(LED_RED, LED_GREEN, LED_BLUE);
uint8_t learning = 0;
Timer timer;
timer.start();
// display turn on
display.attach(&show_matrix, 0.01); // the address of the function to be attached (show_matrix) and the interval (0.01 seconds)
acc_scan.attach(&accelerometer, 0.1); // accelerometer 0.1 s
ant_run.attach(&ant_move, 1.2); // ant_move 1.2 s
// learn mode
if(!BTN_L && !BTN_R)
{
color = color_blue;
learning = 1;
while(!BTN_L || !BTN_R); //debounce
}
//control test
game_state = test;
color = color_orange;
// init rand() seed
srand(timer.read_ms());
// init time for debounce
int time = timer.read_ms();
while (true)
{
switch(game_state)
{
case score:
{
// SHOW SCORE
static uint8_t go = 0; // go and show score
static uint8_t sym_col = 100; // state of showing score
if((timer.read_ms() % 600 ) > 300)
{
color = color_red;
if(go == 5)
go = 1;
else
go = 6;
}
else
{
if(go == 6)
go = 1;
else
go = 5;
color = color_blue;
}
if( go == 1 )
{
static uint32_t sym_act = 0;
static uint32_t sym_clr = led_ant;
static uint32_t score_cnt_temp = 0;
switch(sym_col)
{
case 0:
case 1:
sym_col++;
break;
case 2:
score_cnt_temp -= score_cnt_temp % 10;
score_cnt_temp /=10;
if(score_cnt_temp == 0)
{
// empty block
sym_act = 0;
// close ceremony
sym_col++;
}
else
{
// next number
sym_act = translate(score_cnt_temp % 10);
sym_col = 0;
}
if(sym_clr == led_ant)
sym_clr = led_lab;
else
sym_clr = led_ant;
break;
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
// close loop
sym_col++;
break;
case 11:
sym_col = 100;
// show score again
break;
default:
// erase old symbol
fill_matrix(template_fill, led_free);
// load score
score_cnt_temp = score_cnt;
// init new char;
sym_act = translate(score_cnt_temp % 10);
sym_col = 0;
}
// shift matrix
if((sym_col < 12))
{
for(uint8_t j = 5; j > 0;j--) // rows
{
for(uint8_t i = 0; i < 7;i++) // columns
{
matrix[j][7-i] = matrix[j][6-i];
}
// add new column to matrix
// find actual bit sym_col, assign color
matrix[j][0] = sym_clr * ((((0x1 << sym_col) << (3*j)) & sym_act) > 0);
}
}
}
// buttons
if( BTN_R && !BTN_L && (time < timer.read_ms()))
{
game_state = pause;
color = color_orange;
// reset score show
sym_col = 100;
// RESET LABYRINT
game_state = ready;
time = timer.read_ms() + 200; //debounce
}
break;
}
case pause:
{
// PAUSE
if( BTN_L && !BTN_R && (time < timer.read_ms()))
{
// RESET LABYRINT
color = color_orange;
// prepare matrix for labyrint
prepare_matrix();
wait(0.4f);
// generate new playground
reload_matrix();
wait(0.2f);
color = color_red;
}
else
// RETURN
if( BTN_R && !BTN_L && (time < timer.read_ms()))
{
color = color_green;
if(!learning)
{
game_state = game;
// haaahaaaa :D
score_cnt = 0;
}
else
{
game_state = learn;
}
time = timer.read_ms() + 200; //debounce
}
break;
}
case game:
case learn:
{
// GAME
if( BTN_L && !BTN_R && (time < timer.read_ms()))
{
// rotate block
time = timer.read_ms() + 200; // debounce
rotate_lab(row, column);
}
else
if( BTN_R && !BTN_L && (time < timer.read_ms()))
{
// pause
color = color_red;
game_state = pause;
time = timer.read_ms() + 200; // debounce
// wait for action
// RETURN or RESET
}
break;
}
case ready:
{
// RESET LAB
color = color_orange;
// prepare matrix for labyrint
prepare_matrix();
wait(0.4f);
// generate new playground
reload_matrix();
wait(0.2f);
game_state = pause;
color = color_red;
break;
}
default:
{
// TEST
// arrows
// set new 0 point (offset)
if( BTN_R && !BTN_L && (time < timer.read_ms()))
{
color = color_green;
game_state = save;
wait(0.4f);
game_state = test;
color = color_orange;
time = timer.read_ms() + 200; // debounce
}
if( BTN_L && !BTN_R && (time < timer.read_ms()))
{
// generate new playground
game_state = ready;
time = timer.read_ms() + 200; // debounce
}
}
}
}
}
void accelerometer()
{
// offset
static float xAngle_offset = 0;
static float yAngle_offset = 0;
if((game_state == test) || (game_state == game) || (game_state == save) || (game_state == learn))
{
float ax, ay, az;
float xAngle, yAngle;
ax = acc.getAccX();
ay = acc.getAccY();
az = acc.getAccZ();
xAngle = atan( ax / (sqrt((ay)*(ay) + (az)*(az)))) * 60;
yAngle = atan( ay / (sqrt((ax)*(ax) + (az)*(az)))) * 60;
if(game_state == save)
{
xAngle_offset = xAngle;
yAngle_offset = yAngle;
}
else
{
xAngle -= xAngle_offset;
yAngle -= yAngle_offset;
}
// find maximum
if(abs(xAngle) >= abs(yAngle))
{
if(xAngle >= MOVE_ANGLE)
{
// +X
acc_dir = up;
}
else
if(xAngle <= -MOVE_ANGLE)
{
// -X
acc_dir = down;
}
else
if(abs(xAngle) <= IDLE_ANGLE)
{
if(game_state == test)
confirm_dir();
else
move_cursor();
}
}
else
{
if(yAngle >= MOVE_ANGLE)
{
// +Y
acc_dir = left;
}
else
if(yAngle <= -MOVE_ANGLE)
{
// -Y
acc_dir = right;
}
else
if(abs(yAngle) <= IDLE_ANGLE)
{
if(game_state == test)
confirm_dir();
else
move_cursor();
}
}
if(acc_dir != idle)
{
if(game_state == test)
{
fill_matrix(template_arrow, led_ant);
switch(acc_dir)
{
case down:
rotate_matrix();
case right:
rotate_matrix();
case up:
rotate_matrix();
case left:
break;
default:
fill_matrix(template_fill, led_free);
}
}
}
}
}
void move_cursor(void)
{
switch(acc_dir)
{
case up:
if(row == 6)
row = 0;
else
row +=2;
break;
case right:
if(column == 6)
column = 0;
else
column +=2;
break;
case down:
if(row == 0)
row = 6;
else
row -=2;
break;
case left:
if(column == 0)
column = 6;
else
column -=2;
break;
default:
break;
}
acc_dir = idle;
}
void confirm_dir(void)
{
fill_matrix(template_arrow, led_lab);
switch(acc_dir)
{
case down:
rotate_matrix();
case right:
rotate_matrix();
case up:
rotate_matrix();
case left:
break;
default:
fill_matrix(template_fill, led_free);
}
acc_dir = idle;
}
void show_matrix(void)
{
// labyrint block selection
static uint8_t mask = 0; // on/off -> blink
mask++;
for(uint8_t j = 0; j < 8;j++)
{
ROW0 = 0x0001 & j;
ROW1 = 0x0002 & j;
ROW2 = 0x0004 & j;
COLG0 = ~matrix[j][0] & led_lab;
COLG1 = ~matrix[j][1] & led_lab;
COLG2 = ~matrix[j][2] & led_lab;
COLG3 = ~matrix[j][3] & led_lab;
COLG4 = ~matrix[j][4] & led_lab;
COLG5 = ~matrix[j][5] & led_lab;
COLG6 = ~matrix[j][6] & led_lab;
COLG7 = ~matrix[j][7] & led_lab;
COLR0 = ~matrix[j][0] & led_ant;
COLR1 = ~matrix[j][1] & led_ant;
COLR2 = ~matrix[j][2] & led_ant;
COLR3 = ~matrix[j][3] & led_ant;
COLR4 = ~matrix[j][4] & led_ant;
COLR5 = ~matrix[j][5] & led_ant;
COLR6 = ~matrix[j][6] & led_ant;
COLR7 = ~matrix[j][7] & led_ant;
// blik cursor (block)
if(((row == j) || ((row+1) == j)) && ((mask % 0x17) < 0xD) && ((game_state == game || (game_state == learn))))
{
switch(column)
{
case 0:
COLG0 = ~led_free;
COLR0 = ~led_free;
COLG1 = ~led_free;
COLR1 = ~led_free;
break;
case 2:
COLG2 = ~led_free;
COLR2 = ~led_free;
COLG3 = ~led_free;
COLR3 = ~led_free;
break;
case 4:
COLG4 = ~led_free;
COLR4 = ~led_free;
COLG5 = ~led_free;
COLR5 = ~led_free;
break;
case 6:
COLG6 = ~led_free;
COLR6 = ~led_free;
COLG7 = ~led_free;
COLR7 = ~led_free;
break;
default:
break;
}
}
wait(brightness);
COLG0 = ~led_free;
COLG1 = ~led_free;
COLG2 = ~led_free;
COLG3 = ~led_free;
COLG4 = ~led_free;
COLG5 = ~led_free;
COLG6 = ~led_free;
COLG7 = ~led_free;
COLR0 = ~led_free;
COLR1 = ~led_free;
COLR2 = ~led_free;
COLR3 = ~led_free;
COLR4 = ~led_free;
COLR5 = ~led_free;
COLR6 = ~led_free;
COLR7 = ~led_free;
}
}
void fill_matrix(uint64_t temp, uint8_t color)
{
for(uint8_t j = 0; j < 8;j++)
{
for(uint8_t i = 0; i < 8;i++)
{
matrix[j][i] = color * ( 0 < (temp & (0x8000000000000000>>((8*j)+i)))); // print template to the matrix
}
}
}
void rotate_matrix(void)
{
uint8_t temp[8][8];
for(uint8_t j = 0; j < 8;j++)
{
for(uint8_t i = 0; i < 8;i++)
{
temp[7-i][j] = matrix[j][i];
}
}
for(uint8_t j = 0; j < 8;j++)
{
for(uint8_t i = 0; i < 8;i++)
{
matrix[j][i] = temp[j][i];
}
}
}
void rotate_lab(uint8_t lab_row, uint8_t lab_col)
{
// if block is labyrint only
if(((matrix[lab_row][lab_col]%2) == 0) && ((matrix[lab_row+1][lab_col]%2) == 0) && ((matrix[lab_row][lab_col+1]%2) == 0) && ((matrix[lab_row+1][lab_col+1]%2) == 0))
{
uint8_t temp;
temp = matrix[lab_row][lab_col];
matrix[lab_row][lab_col] = matrix[lab_row][lab_col+1];
matrix[lab_row][lab_col+1] = matrix[lab_row+1][lab_col+1];
matrix[lab_row+1][lab_col+1] = matrix[lab_row+1][lab_col];
matrix[lab_row+1][lab_col] = temp;
// change block type (because of turn clockwise and Anticlockwise too)
if(matrix[lab_row][lab_col+1] == led_lab)
{
if((matrix[lab_row][lab_col] == led_lab) && (matrix[lab_row+1][lab_col] == led_lab))
{
matrix[lab_row][lab_col] = led_free;
matrix[lab_row][lab_col+1] = led_lab;
matrix[lab_row+1][lab_col+1] = led_free;
matrix[lab_row+1][lab_col] = led_free;
}
else
if((matrix[lab_row][lab_col] == led_free) && (matrix[lab_row+1][lab_col] == led_free) && (matrix[lab_row+1][lab_col+1] == led_free))
{
matrix[lab_row][lab_col] = led_lab;
matrix[lab_row+1][lab_col] = led_lab;
matrix[lab_row+1][lab_col+1] = led_free;
}
}
}
}
void prepare_matrix(void)
{
// only used blocks are re-generate
fill_matrix(template_fill, led_used);
// reset counter
if(game_state != game)
score_cnt = 0;
// start marker position
row = 2;
column = 2;
// start symbol (home)
matrix[4][2] = led_free;
matrix[5][2] = led_free;
matrix[4][3] = led_lab;
matrix[5][3] = led_ant;
// start ant position
ant_row = 5;
ant_column = 3;
// new direction
ant_dir = down;
}
void reload_matrix(void)
{
for(uint8_t j = 0; j < 4;j++)
{
for(uint8_t i = 0; i < 4;i++)
{
int8_t block;
int8_t shift;
// if labyrint part == used => generate new part
if((matrix[j*2][i*2] == led_used) && (matrix[(j*2) + 1][i*2] == led_used) && (matrix[(j*2) + 1][(i*2) + 1] == led_used) && (matrix[j*2][(i*2) + 1] == led_used))
{
switch( rand() % 3 )
{
case 0:
block = lab_turn_big;
break;
case 1:
block = lab_turn_small;
break;
case 2:
block = lab_straight;
break;
default:
block = 0x0f;
}
shift = rand() % 4;
matrix[2*j][2*i] = led_lab * ( 1 & block >> (shift % 4)); // 0
matrix[2*j][(2*i)+1] = led_lab * ( 1 & (block >> (++shift % 4))); // 1
matrix[(2*j)+1][2*i] = led_lab * ( 1 & (block >> (++shift % 4))); // 2
matrix[(2*j)+1][(2*i)+1] = led_lab * ( 1 & (block >> (++shift % 4))); // 3
// one block == one point
if(game_state == game)
score_cnt++;
}
}
}
}
void ant_move(void)
{
// ant_dir
// enum left(1), up(2), right(3), down(4)
if((game_state == game) || (game_state == learn))
{
// old pixel
matrix[ant_row][ant_column] = led_used;
// find new pixel
if((ant_dir % 2) == 0)
{
// up, down
if(((ant_row + (ant_dir == down)) % 2) == 0)
{
// 1. type move
/* | str in */ if(matrix[ant_row + 1 - (2 * (ant_dir == down))][ant_column] == led_lab)
{
// go straight (in block)
// ant_dir = ant_dir;
ant_row += 1 - (2 * (ant_dir == down));
}
else
{
/* | turn out */ if((matrix[ant_row][ant_column - 1 + (2 * (ant_dir == down))] == led_lab ) && (matrix[ant_row + 1 - (2 * (ant_row % 2))][ant_column - 1 + (2 * (ant_dir == down))] == led_free ))
{
// mark used block
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column] = led_used;
matrix[ant_row][ant_column + 1 - (2* (ant_column % 2))] = led_used;
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column + 1 - (2* (ant_column % 2))] = led_used;
if((ant_column % 2) == 0)
{
ant_dir = left;
}
else
{
ant_dir = right;
}
// turn (out block)
ant_column += -1 + (2 * (ant_column % 2));
}
else
// reload matrix
if((ant_column == 7) || (ant_column == 0))
{
if((matrix[ant_row][7 * (ant_column != 7)] == led_lab) && (matrix[ant_row + 1 - (2 * (ant_row % 2))][7 * (ant_column != 7)] == led_free))
{
// mark used block
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column] = led_used;
matrix[ant_row][ant_column + 1 - (2* (ant_column % 2))] = led_used;
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column + 1 - (2* (ant_column % 2))] = led_used;
reload_matrix();
if(ant_column == 0)
{
ant_column = 7;
ant_dir = left;
}
else
{
ant_column = 0;
ant_dir = right;
}
}
else
{
// GAME OVER
if(game_state == game)
game_state = score;
}
}
else
{
// GAME OVER
if(game_state == game)
game_state = score;
}
}
}
else
if(((ant_row + (ant_dir == down)) % 2) == 1)
{
// 2. type move
/* | turn in */ if(matrix[ant_row][ant_column + 1 - (2 * (ant_column % 2))] == led_lab)
{
if((ant_column % 2) == 0)
{
ant_dir = right;
}
else
{
ant_dir = left;
}
// turn (in block)
ant_column += 1 - (2 * (ant_column % 2));
}
else
{
// go straight (out block)
/* | str out */
if((matrix[ant_row + 1 - (2 * (ant_dir == down))][ant_column] == led_lab) && (matrix[ant_row + 1 - (2 * (ant_dir == down))][ant_column + 1 - (2 * (ant_column % 2))] == led_free))
{
// mark used block
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column] = led_used;
matrix[ant_row][ant_column + 1 - (2* (ant_column % 2))] = led_used;
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column + 1 - (2* (ant_column % 2))] = led_used;
// ant_dir = ant_dir;
ant_row += 1 - (2 * (ant_dir == down));
}
else
// reload matrix
if((ant_row == 7) || (ant_row == 0))
{
if((matrix[7 * (ant_row != 7)][ant_column] == led_lab) && (matrix[7 * (ant_row != 7)][ant_column + 1 - (2 * (ant_column % 2))] == led_free))
{
// mark used block
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column] = led_used;
matrix[ant_row][ant_column + 1 - (2* (ant_column % 2))] = led_used;
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column + 1 - (2* (ant_column % 2))] = led_used;
reload_matrix();
if(ant_dir == down)
ant_row = 7;
else
ant_row = 0;
}
else
{
// GAME OVER
if(game_state == game)
game_state = score;
}
}
else
{
// GAME OVER
if(game_state == game)
game_state = score;
}
}
}
}
// right, left
else
{
if(((ant_column + (ant_dir == right)) % 2) == 1)
{
// 1. type move
/* - str in */
if(matrix[ant_row][ant_column - 1 + (2 * ( ant_dir == right))] == led_lab )
{
// go straight (in block)
// ant_dir = ant_dir;
ant_column += - 1 + (2 * ( ant_dir == right));
}
else
/* - turn out */
if((matrix[ant_row - 1 + (2 * (ant_row % 2 ))][ant_column] == led_lab ) && (matrix[ant_row - 1 + (2 * (ant_row % 2 ))][ant_column - 1 + (2 * (ant_dir == right))] == led_free ))
{
// mark used block
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column] = led_used;
matrix[ant_row][ant_column + 1 - (2* (ant_column % 2))] = led_used;
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column + 1 - (2* (ant_column % 2))] = led_used;
if((ant_row % 2) == 0)
{
ant_dir = down;
}
else
{
ant_dir = up;
}
// turn (out block)
ant_row += -1 + (2 * (ant_row % 2));
}
else
// reload matrix
if((ant_row == 7) || (ant_row == 0))
{
if((matrix[7 * (ant_row != 7)][ant_column] == led_lab) && (matrix[7 * (ant_row != 7)][ant_column + 1 - (2 * (ant_column % 2))] == led_free))
{
// mark used block
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column] = led_used;
matrix[ant_row][ant_column + 1 - (2* (ant_column % 2))] = led_used;
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column + 1 - (2* (ant_column % 2))] = led_used;
reload_matrix();
if(ant_row == 0)
{
ant_row = 7;
ant_dir = down;
}
else
{
ant_row = 0;
ant_dir = up;
}
}
else
{
// GAME OVER
if(game_state == game)
game_state = score;
}
}
else
{
// GAME OVER
if(game_state == game)
game_state = score;
}
}
else
{
// 2. type move
/* - turn in */ if(matrix[ant_row + 1 - (2 * (ant_dir == right))][ant_column] == led_lab)
{
if((ant_row % 2) == 0)
{
ant_dir = up;
}
else
{
ant_dir = down;
}
// turn (in block)
ant_row += 1 - (2 * (ant_row % 2));
}
/* - str out */
else
if((matrix[ant_row][ant_column - 1 + (2 * ( ant_dir == right))] == led_lab) && (matrix[ant_row + 1 - (2 * (ant_row % 2))][ant_column - 1 + (2 * ( ant_dir == right))] == led_free))
{
// mark used block
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column] = led_used;
matrix[ant_row][ant_column + 1 - (2* (ant_column % 2))] = led_used;
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column + 1 - (2* (ant_column % 2))] = led_used;
// go straight (out block)
ant_column += -1 + (2 * ( ant_dir == right));
// ant_dir = ant_dir;
}
else
// reload matrix
if((ant_column == 7) || (ant_column == 0))
{
if((matrix[ant_row][7 * (ant_column != 7)] == led_lab) && (matrix[ant_row + 1 - (2 * (ant_row % 2))][7 * (ant_column != 7)] == led_free))
{
// mark used block
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column] = led_used;
matrix[ant_row][ant_column + 1 - (2* (ant_column % 2))] = led_used;
matrix[ant_row + 1 - (2* (ant_row % 2))][ant_column + 1 - (2* (ant_column % 2))] = led_used;
reload_matrix();
if(ant_dir == left)
ant_column = 7;
else
ant_column = 0;
}
else
{
// GAME OVER
if(game_state == game)
game_state = score;
}
}
else
{
// GAME OVER
if(game_state == game)
game_state = score;
}
}
}
matrix[ant_row][ant_column] = led_ant;
}
}
uint32_t translate(uint8_t number)
{
uint32_t ret;
// translate numbers to symbols
for(uint8_t j = 0; j < 5;j++)
{
switch(number)
{
case 0:
ret = zero;
break;
case 1:
ret = one;
break;
case 2:
ret = two;
break;
case 3:
ret = three;
break;
case 4:
ret = four;
break;
case 5:
ret = five;
break;
case 6:
ret = six;
break;
case 7:
ret = seven;
break;
case 8:
ret = eight;
break;
default:
ret = nine;
break;
}
}
return(ret);
}