void BackupDevice::reset()
{
reset_hardware();
data_autodetect.resize(0);
//if the user has requested a manual choice for backup type, and we havent imported a raw save file, then apply it now
if(state == DETECTING && CommonSettings.manualBackupType != MC_TYPE_AUTODETECT)
{
state = RUNNING;
int savetype = save_types[CommonSettings.manualBackupType].media_type;
int savesize = save_types[CommonSettings.manualBackupType].size;
ensure((u32)savesize); //expand properly if necessary
addr_size = addr_size_for_old_save_type(savetype);
}
}
void BackupDevice::reset()
{
memset(&info, 0, sizeof(info));
reset_hardware();
resize(0);
data_autodetect.resize(0);
addr_size = 0;
loadfile();
//if the user has requested a manual choice for backup type, and we havent imported a raw save file, then apply it now
if(state == DETECTING && CommonSettings.manualBackupType != MC_TYPE_AUTODETECT)
{
state = RUNNING;
int savetype = save_types[CommonSettings.manualBackupType][0];
int savesize = save_types[CommonSettings.manualBackupType][1];
ensure((u32)savesize); //expand properly if necessary
resize(savesize); //truncate if necessary
addr_size = addr_size_for_old_save_type(savetype);
flush();
}
}
int main(){
//printf("Press start to begin the game\n");
int set = 1;
while(1) {
/* Reset display */
reset_hardware();
reset_software();
//initBorder();
if(set){
fancy_splash();
enable_splash_screen();
}
play_splash_sound();
play_sound();
//printf("Press any button to start!\n");
if(set){
wait_for_continue();
disable_splash_screen();
}
/* init border */
//initPowBoard(board, seed);
/* Reset snakes and display them */
//PLAYER1 = 1;
//PLAYER2 = 2;
struct Snake snake_player1[SNAKE_SIZE];
struct SnakeInfo info1;
initSnake(snake_player1, 256/16, 256/16, PLAYER1, &info1);
struct Snake snake_player2[SNAKE_SIZE];
struct SnakeInfo info2;
initSnake(snake_player2, 256/16, 320/16, PLAYER2, &info2);
PLAYER1_SLEEP_CYCLES = DEFAULT_SLEEP_CYCLE / SLEEP_TIME;
PLAYER2_SLEEP_CYCLES = DEFAULT_SLEEP_CYCLE / SLEEP_TIME;
//printf("Game is starting");
int player1_dir[4];
int player2_dir[4];
player1_dir[right_dir] = 1;
player1_dir[left_dir] = 0;
player1_dir[up_dir] = 0;
player1_dir[down_dir] = 0;
player2_dir[right_dir] = 1;
player2_dir[left_dir] = 0;
player2_dir[up_dir] = 0;
player2_dir[down_dir] = 0;
initBorder();
initPowUps();
drawStartPowUps(snake_player1, snake_player2);
if(!set){
wait_for_continue();
}
set = 0;
int paused = 0;
unsigned char code;
int count_player1 = 0;
int count_player2 = 0;
int pressed_player1 = getPlayer1Controller();
int pressed_player2 = getPlayer2Controller();
int potential_pressed1;
int potential_pressed2;
int old_potential1;
int old_potential2;
int game = 1;
int collision = 0;
int p1_move_collision = 0;
int p2_move_collision = 0;
int moved = 0;
while(1) {
/*Check if paused button pushed*/
if( (count_player1 >= PLAYER1_SLEEP_CYCLES && (check_paused(pressed_player1) != 0) ) ||
(count_player2 >= PLAYER2_SLEEP_CYCLES && (check_paused(pressed_player2) != 0) ) ){
pressed_player1 = 0;
pressed_player2 = 0;
count_player1 = 0;
count_player2 = 0;
paused = !paused;
//printf("Paused is now %d\n", paused);
}
/* Move player 1 */
if(count_player1 >= PLAYER1_SLEEP_CYCLES && !paused ){
p1_move_collision = movement(code, snake_player1, player1_dir, pressed_player1, PLAYER1, &info1);
if(p1_move_collision)
game_winner = 2;
check_powerup_col(snake_player1, snake_player2, player1_dir, PLAYER1, &info1);
//movement(code, snake_player2, player2_dir, food, pressed_player1, PLAYER2);
check_powerup_buttons(pressed_player1, snake_player1, snake_player2, freeze, PLAYER1, &info1);
count_player1 = 0;
pressed_player1 = 0;
moved = 1;
//printf("Moving player1");
}
/* Move player 2 */
if(count_player2 >= PLAYER2_SLEEP_CYCLES && !paused){
p2_move_collision = movement(code, snake_player2, player2_dir, pressed_player2, PLAYER2, &info2);
if(p2_move_collision)
game_winner = 1;
check_powerup_col(snake_player2, snake_player1, player2_dir, PLAYER2, &info2);
check_powerup_buttons(pressed_player2, snake_player2, snake_player1,freeze, PLAYER2, &info2);
count_player2 = 0;
pressed_player2 = 0;
moved = 1;
}
/* Get controls from player1 everytime and store control for later if pressed */
old_potential1 = potential_pressed1;
potential_pressed1 = getPlayer1Controller();
if( potential_pressed1 != 0 && old_potential1 != potential_pressed1){
pressed_player1 = potential_pressed1;
//printf("pressed player1: %d\n", pressed_player1);
}
/* Get controls from player2 everytime and store control for later if pressed */
old_potential2 = potential_pressed2;
potential_pressed2 = getPlayer2Controller();
if( potential_pressed2 != 0 && old_potential2 != potential_pressed2){
pressed_player2 = potential_pressed2;
}
if( moved ){
collision = snakeCol(snake_player1, snake_player2);
play_move_sound();
}
if (collision || p1_move_collision || p2_move_collision){
//printf("breaking");
play_gameover_sound();
play_sound();
draw_winner(game_winner);
usleep(SLEEP_TIME*250000);
//wait_for_continue();
break;
}
play_sound();
//printf("Random: %d", PRNG(40));
moved = 0;
count_player1++;
count_player2++;
usleep(SLEEP_TIME*1000);
}
//printf("New Game starting\n");
}
//printf("GAME OVER\n");
return 0;
}
int main(void){
configure_nvic();
initialize_i2c(I2C_BASE_ADDRESS + read_i2c_address());
// Configure all of the hardware and internal state
initialize_motion_queue();
initialize_parser();
reset_parameters();
initialize_stepper_state();
set_microstepping(DEFAULT_MICROSTEPPING);
reset_hardware();
float_sync_line();
while(1){
if(parser.status == PARSER_ERR){
send_response(IMC_RSP_UNKNOWN,0);
initialize_parser();
continue;
}
if(parser.status == PARSER_NEW_EVENT){
switch(parser.packet_type){
case IMC_MSG_INITIALIZE:
initialize_motion_queue();
initialize_parser();
// Unlike out first initialization round, don't reset parameters
initialize_stepper_state();
float_sync_line();
response.init.slave_hw_ver = 0;
response.init.slave_fw_ver = 0;
response.init.queue_depth = MOTION_QUEUE_LENGTH;
send_response(IMC_RSP_OK,sizeof(rsp_initialize_t));
break;
case IMC_MSG_GETPARAM:
handle_get_parameter(&parser.packet.get_param, &response.param);
send_response(IMC_RSP_OK,sizeof(rsp_get_param_t));
break;
case IMC_MSG_SETPARAM:
handle_set_parameter(&parser.packet.set_param);
send_response(IMC_RSP_OK,0);
break;
case IMC_MSG_QUEUEMOVE:
{
int space = enqueue_block(&parser.packet.move);
send_response(space < 0 ? IMC_RSP_QUEUEFULL : IMC_RSP_OK,0);
// If we're adding moves in idle state, make sure that the sync interface is listening
if(st.state == STATE_IDLE)
enable_sync_interrupt();
}
break;
case IMC_MSG_STATUS:
response.status.queued_moves = queue_length();
if(st.state == STATE_ERROR){
response.status.status = parameters.error_low;
}else{
response.status.status = IMC_ERR_NONE;
}
send_response(IMC_RSP_OK,sizeof(rsp_status_t));
break;
case IMC_MSG_HOME:
send_response(IMC_RSP_OK,0);
enter_homing_routine();
break;
case IMC_MSG_QUICKSTOP:
send_response(IMC_RSP_ERROR,0);
break;
}
initialize_parser();
}
}
}
