void main(){
SET_BIT(DDRB, 0);
ini_lcd();
clr_lcd();
for(;;){
pos_lcd(0,0);
put_str_lcd("Press 1. Saria's...");
pos_lcd(1,0);
put_str_lcd("Press 2. Mary...");
if (get_key() == 16)
{
clr_lcd();
pos_lcd(0,2);
put_str_lcd("Saria's Song");
pos_lcd(1, 0);
put_str_lcd("Press B to stop.");
play_song(saria, 85);
clr_lcd();
}
else if (get_key() == 15)
{
clr_lcd();
pos_lcd(0,2);
put_str_lcd("Mary Had A");
pos_lcd(1, 2);
put_str_lcd("Little Lamb");
play_song(mary, 26);
clr_lcd();
}
wait_avr(50);
}
}
void updateCScreen(CScreen *cscreen, Hammer *hammer, int *numberPCs, int *score, double mili){
switch (cscreen->state) {
case WINDOWS:
if(cscreen->nextCrashTime == -1)
cscreen->nextCrashTime = rand() % crashTimeMax;
else {
cscreen->nextCrashTime -= mili;
if (cscreen->nextCrashTime <= 0) {
cscreen->nextCrashTime = -1;
cscreen->state = BSOD;
cscreen->deathTime = bsodTime;
cscreen->sprite->imgIndex++;
play_song(cscreen->crash);
}
}
// verificar colisoes com o cd
if (hammer->state == CD_HIT && collidesSprite(hammer->sprite, cscreen->sprite))
cscreen->state = REINSTALLED;
break;
case BSOD:
cscreen->deathTime -= mili;
if (cscreen->deathTime <= 0) {
cscreen->state = DEATH;
cscreen->sprite->imgIndex += 3;
*score -= scoreDeath;
}
else if (hammer->state == HIT
&& collidesSpriteRect(cscreen->sprite,
hammer->sprite->x, hammer->sprite->y + hammer->sprite->height/2,
hammer->sprite->width/2, hammer->sprite->height/2))
{
cscreen->state = WINDOWS;
cscreen->sprite->imgIndex--;
*score += scoreSaved;
countedSavesUntilCD--;
if (countedSavesUntilCD <= 0) {
countedSavesUntilCD = savesUntilCD;
hammer->state = GET_CD;
}
} else if (hammer->state == CD_HIT && collidesSprite(hammer->sprite, cscreen->sprite))
cscreen->state = REINSTALLED;
break;
case REINSTALLED:
cscreen->sprite->imgIndex = 2 + rand() % 2;
play_song(cscreen->reinstall);
hammer->state = GET_HAMMER;
case DEATH:
(*numberPCs)--;
// aumenta dificuldade
savesUntilCD++;
crashTimeMax -= crashTimeDecrease;
cscreen->state = INACTIVE;
break;
case INACTIVE:
break;
default:
break;
}
}
void super_dead_mode(){
uint16_t counter = 0;
while(!config.health){
handle_music();
// Manage base station comms
uint8_t b;
if(CHECK_CHAR()){
b=AVAIL_CHAR();
if(b == 0x10) {
control_transfer();
}
}
counter++;
delay_1_ms();
if(counter > config.death_period){
counter = 0;
led_off();
Send_Byte(config.id);
play_song((uint16_t*)dead_song,sizeof(dead_song)/sizeof(uint16_t),10000,0);
}
if(counter == config.death_period-50){
red_led_on();
}
}
}
/******************************************************************************
* Calls the Roomba interface function given some serialized function call
******************************************************************************/
void deserialize(uint8_t* function)
{
switch(function[0])
{
case INITIALIZE_ROOMBA:
initialize_roomba();
break;
case SET_MODE:
set_mode((roomba_mode_t)(function[1] - ASCII_OFFSET));
break;
case START_CLEAN:
start_clean((clean_mode_t)(function[1] - ASCII_OFFSET));
break;
case SEND_DOCK:
send_dock();
break;
case SET_WHEEL_SPEEDS:
{
/* high byte right, low byte right, high byte left, low byte left */
int16_t left, right;
right = (function[1] << 8) & function[2];
left = (function[3] << 8) & function[4];
set_wheel_speeds(right, left);
}
break;
case TEST_MOVE:
test_move();
break;
case PLAY_SONG:
play_song(function[1] - ASCII_OFFSET);
break;
}
}
static int select_plisttrack(struct menulist *ml)
{
atracks *at = ml->user;
struct track *t = (*at)[0];
play_song(ml, t);
return 0;
}
//handles the music/sfx playing for the sketch
void update_sound()
{
switch (music_state)
{
case SONG_PLAYING:
case SONG_PLAYING_ONCE:
case SONG_PLAYING_SFX:
static long next_note_start_time = 0;
if (millis() >= next_note_start_time)
{
if (current_note == song_end_pos)
{
switch (music_state)
{
//it's the end of the song, so we can contine
case SONG_PLAYING:
music_state = SONG_ENDED;
break;
case SONG_PLAYING_ONCE:
music_state = MUSIC_STOPPED;
break;
case SONG_PLAYING_SFX:
//restore the old state of the music and continue
song_note_len = old_song_note_len;
song_end_pos = old_song_end_pos;
current_note = old_current_note;
music_state = old_music_state;
current_song = old_current_song;
break;
}
}
//determine the current note duration
int note_duration = ( song_note_len / pgm_read_byte_near(duration + current_note));
next_note_start_time = millis()+note_duration;
//play the note
tone(9,pgm_read_word_near(melody + current_note), note_duration);
current_note++;
}
break;
case SONG_ENDED:
//start the same song over automatically
play_song(current_song);
break;
case MUSIC_STOPPED:
//we are idle, until a new play action is initiated
break;
}
}
void Controller::play_current_song(const std::string &playlist_name, bool update_playlist_first) {
if (playlist.songs.empty() || update_playlist_first) {
// Flag to let controller know to fetch current song after fetching playlist
should_fetch_playlist_single = true;
fetch_playlist(playlist_name);
return;
}
playlist.name = playlist_name;
fetching_playlist_single = true;
should_fetch_playlist_single = false;
requests.get(build_api("/playlists/" + playlist.name), [&](const std::string &response, bool success) -> void {
rapidjson::Document json;
fetching_playlist_single = false;
if (json.Parse(response.c_str()).HasParseError()) {
log_text("json error!");
return;
}
if (json.HasMember("current_song") && json.HasMember("song_start_time") && json.HasMember("requested_time")) {
int id = json["current_song"].GetInt();
if (playlist.songs.find(id) == playlist.songs.end()) {
add_message("Cant find song in playlist - recache?");
}
else {
int requested_time = json["requested_time"].GetInt();
int song_start_time = json["song_start_time"].GetInt();
int elapsed_seconds = requested_time - song_start_time;
int time_left = playlist.songs[id].duration - elapsed_seconds;
if (time_left < 3) {
// nearing end. call self again since probably will want next song instead.
should_fetch_playlist_single = true;
return;
}
// assume if only a bit of time has passed, that we're still at the start (?)
if (elapsed_seconds > 5) add_message("Seeking to %d seconds", elapsed_seconds);
timer.reset(time_left);
play_song(playlist.songs[id], elapsed_seconds);
}
}
});
}
//plays a sound effect
void play_sfx(char song)
{
//saves the current state of the song to be restored
//when the sound effect is finished playing
old_song_note_len = song_note_len;
old_song_end_pos = song_end_pos;
old_current_note = current_note;
old_music_state = music_state;
old_current_song = current_song;
play_song(song);
//override the state to a single time through
music_state = SONG_PLAYING_SFX;
}
/*
Wrapper function that will play the song and also accept an input
from the A3BU keyboard buttons
*/
static void play_song_with_input(struct SongNote song[], uint8_t song_length) {
struct keyboard_event key;
while(true) {
keyboard_get_key_state(&key);
if((key.keycode == KEYBOARD_ENTER)
&& (key.type == KEYBOARD_RELEASE))
{
break;
}
play_song(song, song_length);
}
}
/*
* Our main function we start of here...
* we should make sure that we never return from here, or vectrex will
* be surely bothered!
*/
int main(void)
{
unsigned char anim_state; /* our animation state counter */
signed char pacman_x; /* where is the pacman? */
signed char pacman_y;
pacman_x = 0;
pacman_y = 0;
anim_state = 0;
setup(); /* setup our program */
while (true) /* never to return... */
{
start_one_vectrex_round(); /* start 'de round */
intensity(MAX_BRIGHTNESS); /* set some brightness */
set_scale(MOVE_SCALE); /* set scale factor */
print_str(-128,100, "JOYTICK 1 TO MOVE PACMAN!"); /* a message! */
move_to(pacman_x, pacman_y); /* position pacman */
set_scale(PACMAN_SCALE); /* set scale factor for the sprite */
draw_vector_list(pacman[anim_state]); /* draw the current pacman */
anim_state++; /* next time the next animation */
if (anim_state == MAX_ANIM) /* could do a % MAXANIM, but this is */
anim_state = 0; /* more optimized */
if (!read_ram(Vec_Music_Flag)) /* music finished? */
play_song(SCRAMBLE_MUSIC); /* if so ... restart */
if (joystick1_x>0) /* check the joystick and */
{ /* update position */
pacman_x++;
}
else if (joystick1_x<0)
{
pacman_x--;
}
if (joystick1_y>0)
{
pacman_y++;
}
else if (joystick1_y<0)
{
pacman_y--;
}
if (pacman_x>=100) pacman_x = 100; /* make sure pacman is not */
if (pacman_x<=-100) pacman_x = -100; /* out of bounds */
if (pacman_y>=100) pacman_y = 100;
if (pacman_y<=-100) pacman_y = -100;
joy_digital(); /* call once per round, to insure */
} /* while (true) */ /* joystick information is up to date */
}
void reset_level_data()
{
// reload all data into RAM
if (load_game_data(data)) {
frame_handler = frame_error;
return;
}
sprites_reset();
player_reset();
interpret_spritetypes();
// apply mapper just once
uint8_t mapper = data[255*256];
switch (mapper) {
case 0 :
black_mapper();
break;
case TRANSPARENT :
// null mapper
break;
default:
message("Unknown mapper ! ");
frame_handler = frame_error;
return;
}
// interpret level after mapper
get_level_boundingbox();
get_level_start();
memcpy(hud,"B0 F0G0 C0 E000 D00 ",sizeof(hud));
hud[1]='0'+lives;
hud[6]='0'+level+1;
move_camera(); // avoid being negative
play_song(); // start playing song
vga_frame=0;
coins=0;
}
uint8_t handle_fire(){
static uint16_t timer = 0; // for holdoff
static uint16_t counter = 0; // for power
uint16_t a;
a=ADC_read();
if (a > config.fire_cheating){
cheat();
}
if (a > config.fire_threshold && a < config.fire_cheating)
{
while(!my_random_number){
my_random_number = TMR0;
}
if(timer < config.fire_holdoff)
{
timer ++;
}
else
{
if(!config.power || counter <= config.power)
{
if(!counter)
{
green_led_on();
play_song((uint16_t*)fire_song,sizeof(fire_song)/sizeof(uint16_t),3000,!(config.power));
}
Send_Byte(config.id);
counter++;
}
else
{
led_off();
}
}
}
else
{
led_off();
if(!config.power && counter) stop_song();
timer = 0;
counter = 0;
return 0;
}
return 1;
}
/**
* Compares two times and acts on match (deadline)
*/
static void check_for_deadline(Time* current_time_struct, Time* target_time_struct)
{
if ((current_time_struct->hours == target_time_struct->hours)
&& (current_time_struct->minutes == target_time_struct->minutes)
&& (current_time_struct->seconds == target_time_struct->seconds)) {
debug_printf (DEBUG_INFO, "* Alarm has been activated, decide what action to take!");
/* Decide what action to take from the selected item in the combo */
switch (cfg_get_single_value_as_int_with_default (config, "alarm-plugin", "action-id", 0)) {
case 0:
debug_printf (DEBUG_INFO, "* Attempting to play/pause");
play_song ();
break;
case 1:
debug_printf (DEBUG_INFO, "* Attempting to stop");
stop_song ();
break;
case 2:
debug_printf (DEBUG_INFO, "* Stopping and closing gmpc");
stop_song ();
main_quit ();
break;
case 3:
debug_printf (DEBUG_INFO, "* Closing gmpc only");
/* Friendly way of closing gmpc */
main_quit ();
break;
case 4:
debug_printf (DEBUG_INFO, "* Shutting down system");
/* TODO: Nice way of halting a system */
break;
case 5:
debug_printf (DEBUG_INFO, "* Toggling random");
random_toggle ();
break;
}
/* Disable timer, and thus the ticking timeout */
alarm_stop();
}
}
void hit_by(uint8_t who)
{
uint16_t respawn_timer;
add_to_hitlist(who);
Save(FLASH_HITLIST,(uint16_t*)&hitlist,HITLIST_SIZE);
config.health --;
Save(FLASH_CONFIG,(uint16_t*)&config, CONFIG_SIZE);
play_song((uint16_t*)death_song,sizeof(death_song)/sizeof(uint16_t),60000,0);
if(!config.health)
{
red_led_on();
super_dead_mode();
return;
}
respawn_timer = config.respawn_delay;
while(respawn_timer)
{
respawn_timer--;
red_led_on();
for(uint8_t i=0;i<50;i++)
{
handle_music();
delay_1_ms();
}
if(respawn_timer < 30)
{
led_off();
}
for(uint8_t i=0;i<50;i++)
{
handle_music();
delay_1_ms();
}
}
}
/* Text is an array of strings terminated by a NULL */
void scroller_sine( const struct about_text_type text[] )
{
bool ale = mt_rand() % 2;
int visible_lines = vga_height / LINE_HEIGHT + 1;
int current_line = -visible_lines;
int y = 0;
bool fade_in = true;
struct coin_type {
int x, y, vel, type, cur_frame;
bool backwards;
} coins[MAX_COINS];
struct {
int x, y, ay, vx, vy;
} beer[MAX_BEER];
if (ale)
{
memset(beer, 0, sizeof(beer));
} else {
for (int i = 0; i < MAX_COINS; i++)
{
coins[i].x = mt_rand() % (vga_width - 12);
coins[i].y = mt_rand() % (vga_height - 20 - 14);
coins[i].vel = (mt_rand() % 4) + 1;
coins[i].type = mt_rand() % COUNTOF(coin_defs);
coins[i].cur_frame = mt_rand() % coin_defs[coins[i].type].frame_count;
coins[i].backwards = false;
}
}
fade_black(10);
wait_noinput(true, true, true);
play_song(40); // BEER
while (!JE_anyButton())
{
setdelay(3);
JE_clr256(VGAScreen);
if (!ale)
{
for (int i = 0; i < MAX_COINS/2; i++)
{
struct coin_type *coin = &coins[i];
blit_sprite2(VGAScreen, coin->x, coin->y, eShapes5, coin_defs[coin->type].shape_num + coin->cur_frame);
}
}
for (int i = 0; i < visible_lines; i++)
{
if (current_line + i >= 0)
{
if (text[current_line + i].text == NULL)
{
break;
}
int line_x = VGAScreen->w / 2;
int line_y = i * LINE_HEIGHT - y;
// smooths edges on sine-wave text
if (text[i + current_line].effect & 0x20)
{
draw_font_hv(VGAScreen, line_x + 1, line_y, text[i + current_line].text, normal_font, centered, text[i + current_line].effect & 0x0f, -10);
draw_font_hv(VGAScreen, line_x - 1, line_y, text[i + current_line].text, normal_font, centered, text[i + current_line].effect & 0x0f, -10);
}
draw_font_hv(VGAScreen, line_x, line_y, text[i + current_line].text, normal_font, centered, text[i + current_line].effect & 0x0f, -4);
if (text[i + current_line].effect & 0x10)
{
for (int j = 0; j < LINE_HEIGHT; j++)
{
if (line_y + j >= 10 && line_y + j <= vga_height - 10)
{
int waver = sinf((((line_y + j) / 2) % 10) / 5.0f * M_PI) * 3;
memmove(&((Uint8 *)VGAScreen->pixels)[VGAScreen->pitch * (line_y + j) + waver],
&((Uint8 *)VGAScreen->pixels)[VGAScreen->pitch * (line_y + j)],
VGAScreen->pitch);
}
}
}
}
}
if (++y == LINE_HEIGHT)
{
y = 0;
if (current_line < 0 || text[current_line].text != NULL)
++current_line;
else
current_line = -visible_lines;
}
if (!ale)
{
for (int i = MAX_COINS/2; i < MAX_COINS; i++)
{
struct coin_type *coin = &coins[i];
blit_sprite2(VGAScreen, coin->x, coin->y, eShapes5, coin_defs[coin->type].shape_num + coin->cur_frame);
}
}
fill_rectangle_xy(VGAScreen, 0, 0, vga_width - 1, 14, 0);
fill_rectangle_xy(VGAScreen, 0, vga_height - 14, vga_width - 1, vga_height - 1, 0);
if (!ale)
{
for (int i = 0; i < MAX_COINS; i++)
{
struct coin_type *coin = &coins[i];
if (coin->backwards)
{
coin->cur_frame--;
} else {
coin->cur_frame++;
}
if (coin->cur_frame == coin_defs[coin->type].frame_count)
{
if (coin_defs[coin->type].reverse_anim)
{
coin->backwards = true;
coin->cur_frame -= 2;
} else {
coin->cur_frame = 0;
}
}
if (coin->cur_frame == -1)
{
coin->cur_frame = 1;
coin->backwards = false;
}
coin->y += coin->vel;
if (coin->y > vga_height - 14)
{
coin->x = mt_rand() % (vga_width - 12);
coin->y = 0;
coin->vel = (mt_rand() % 4) + 1;
coin->type = mt_rand() % COUNTOF(coin_defs);
coin->cur_frame = mt_rand() % coin_defs[coin->type].frame_count;
}
}
} else {
for (uint i = 0; i < COUNTOF(beer); i++)
{
while (beer[i].vx == 0)
{
beer[i].x = mt_rand() % (vga_width - 24);
beer[i].y = mt_rand() % (vga_height - 28 - 50);
beer[i].vx = (mt_rand() % 5) - 2;
}
beer[i].vy++;
if (beer[i].x + beer[i].vx > vga_width - 24 || beer[i].x + beer[i].vx < 0) // check if the beer hit the sides
{
beer[i].vx = -beer[i].vx;
}
beer[i].x += beer[i].vx;
if (beer[i].y + beer[i].vy > vga_height - 28) // check if the beer hit the bottom
{
if ((beer[i].vy) < 8) // make sure the beer bounces!
{
beer[i].vy += mt_rand() % 2;
} else if (beer[i].vy > 16) { // make sure the beer doesn't bounce too high
beer[i].vy = 16;
}
beer[i].vy = -beer[i].vy + (mt_rand() % 3 - 1);
beer[i].x += (beer[i].vx > 0 ? 1 : -1) * (i % 2 ? 1 : -1);
}
beer[i].y += beer[i].vy;
blit_sprite2x2(VGAScreen, beer[i].x, beer[i].y, eShapes5, BEER_SHAPE);
}
}
JE_showVGA();
if (fade_in)
{
fade_in = false;
fade_palette(colors, 10, 0, 255);
SDL_Color white = { 255, 255, 255 };
set_colors(white, 254, 254);
}
wait_delay();
}
fade_black(10);
}
int main(int argc, char **argv) {
char filename[BUFSIZ]="intro2.ym";
int result;
int c;
int next_song,first_song;
/* Setup control-C handler to quiet the music */
/* otherwise if you force quit it keeps playing */
/* the last tones */
signal(SIGINT, quiet_and_exit);
/* Set to have highest possible priority */
display_enable_realtime();
/* Parse command line arguments */
while ((c = getopt(argc, argv, "dDmhvmsnitr"))!=-1) {
switch (c) {
case 'd':
/* Debug messages */
printf("Debug enabled\n");
dump_info=1;
break;
case 'D':
/* diff mode */
printf("Diff mode\n");
diff_mode=1;
break;
case 'h':
/* help */
print_help(0,argv[0]);
break;
case 'v':
/* version */
print_help(1,argv[0]);
break;
case 'm':
/* mono sound */
shift_size=8;
break;
case 's':
/* stereo sound */
shift_size=16;
break;
case 'n':
/* no sound */
play_music=0;
break;
case 'i':
/* i2c visualization */
display_type=DISPLAY_I2C;
break;
case 't':
/* text visualization */
display_type=DISPLAY_TEXT;
break;
case 'r':
/* repeat */
music_repeat=1;
break;
default:
print_help(0,argv[0]);
break;
}
}
first_song=optind;
next_song=0;
/* Initialize the Chip interface */
if (play_music) {
result=initialize_ay_3_8910(0);
if (result<0) {
printf("Error initializing bcm2835!\n");
printf("Maybe try running as root?\n\n");
exit(0);
}
result=max98306_init();
if (result<0) {
printf("Error initializing max98306 amp\n");
exit(0);
}
printf("Headphone is: %d\n",
max98306_check_headphone());
if (amp_disable) {
result=max98306_disable();
}
else {
result=max98306_enable();
}
}
/* Initialize the displays */
if (visualize) {
result=display_init(display_type);
if (result<0) {
printf("Error initializing display!\n");
printf("Turning off display for now!\n");
display_type=0;
}
}
while(1) {
if (argv[first_song+next_song]!=NULL) {
strcpy(filename,argv[first_song+next_song]);
next_song++;
}
else {
break;
}
/* Play the song */
result=play_song(filename);
if (result==CMD_EXIT_PROGRAM) {
break;
}
if (result==CMD_BACK) {
next_song-=2;
if (next_song<0) next_song=0;
}
if (result==CMD_NEXT) {
/* already point to next song */
}
/* Quiet down the chips */
if (play_music) {
quiet_ay_3_8910(shift_size);
}
usleep(500000);
}
/* Get ready to shut down */
/* Quiet down the chips */
if (play_music) {
quiet_ay_3_8910(shift_size);
close_ay_3_8910();
max98306_free();
}
/* Clear out display */
if (visualize) {
display_shutdown(display_type);
}
return 0;
}
int main(void){
setup();
tone_length = 5;
while(1){
update_status();
if (sw == 0) {
if (btns & 0x1) {
tone = tone_frq[btn1_set1];
play_tone(tone, tone_length);
} if (btns & 0x2) {
tone = tone_frq[btn2_set1];
play_tone(tone, tone_length);
} if (btns & 0x4) {
tone = tone_frq[btn3_set1];
play_tone(tone, tone_length);
} if (btns & 0x8) {
tone = tone_frq[btn4_set1];
play_tone(tone, tone_length);
} if (btns & 0x10) {
tone = tone_frq[btn5_set1];
play_tone(tone, tone_length);
} if (btns & 0x20) {
tone = tone_frq[btn6_set1];
play_tone(tone, tone_length);
} if (btns & 0x40) {
tone = tone_frq[btn7_set1];
play_tone(tone, tone_length);
}
} else if (sw == 0x1) {
modify_pitch1(1);
} else if (sw == 0x3) {
modify_pitch1(-1);
} else if (sw == 0x8) {
if (btns & 0x1) {
tone = tone_frq[btn1_set2];
play_tone(tone, tone_length);
} if (btns & 0x2) {
tone = tone_frq[btn2_set2];
play_tone(tone, tone_length);
} if (btns & 0x4) {
tone = tone_frq[btn3_set2];
play_tone(tone, tone_length);
} if (btns & 0x8) {
tone = tone_frq[btn4_set2];
play_tone(tone, tone_length);
} if (btns & 0x10) {
tone = tone_frq[btn5_set2];
play_tone(tone, tone_length);
} if (btns & 0x20) {
tone = tone_frq[btn6_set2];
play_tone(tone, tone_length);
} if (btns & 0x40) {
tone = tone_frq[btn7_set2];
play_tone(tone, tone_length);
}
} else if (sw == 0x9) {
modify_pitch2(1);
} else if (sw == 0xb) {
modify_pitch2(-1);
} else if (sw == 0xc) {
if (btns & 0x1) {
melody_arabix();
} else if (btns & 0x2) {
melody_small();
} if (btns & 0x4) {
tone = tone_frq[btn3_set1];
play_tone(tone, tone_length);
} if (btns & 0x8) {
tone = tone_frq[btn4_set1];
play_tone(tone, tone_length);
} if (btns & 0x10) {
tone = tone_frq[btn5_set1];
play_tone(tone, tone_length);
} if (btns & 0x20) {
tone = tone_frq[btn6_set1];
play_tone(tone, tone_length);
} if (btns & 0x40) {
tone = tone_frq[btn7_set1];
play_tone(tone, tone_length);
}
} else if (sw == 0xd) {
if (btns & 0x1) {
tone = tone_frq[btn1_set1];
play_tone(tone, tone_length);
} else if (btns & 0x2) {
melody_happy();
} else if (btns & 0x4) {
melody_sad();
} else if (btns & 0x8) {
play_song();
} if (btns & 0x10) {
tone = tone_frq[btn5_set1];
play_tone(tone, tone_length);
} if (btns & 0x20) {
tone = tone_frq[btn6_set1];
play_tone(tone, tone_length);
} if (btns & 0x40) {
tone = tone_frq[btn7_set1];
play_tone(tone, tone_length);
}
} else if (sw == 0xa) {
if (btns & 0x1) {
melody_sad();
} if (btns & 0x2) {
tone = tone_frq[btn2_set1];
play_tone(tone, tone_length);
} if (btns & 0x4) {
tone = tone_frq[btn3_set1];
play_tone(tone, tone_length);
} if (btns & 0x8) {
tone = tone_frq[btn4_set1];
play_tone(tone, tone_length);
} if (btns & 0x10) {
tone = tone_frq[btn5_set1];
play_tone(tone, tone_length);
} if (btns & 0x20) {
tone = tone_frq[btn6_set1];
play_tone(tone, tone_length);
} if (btns & 0x40) {
tone = tone_frq[btn7_set1];
play_tone(tone, tone_length);
}
} else if (sw == 0xe) {
if (btns & 0x1) {
melody_slow();
} if (btns & 0x2) {
tone = tone_frq[btn2_set1];
play_tone(tone, tone_length);
} if (btns & 0x4) {
tone = tone_frq[btn3_set1];
play_tone(tone, tone_length);
} if (btns & 0x8) {
tone = tone_frq[btn4_set1];
play_tone(tone, tone_length);
} if (btns & 0x10) {
tone = tone_frq[btn5_set1];
play_tone(tone, tone_length);
} if (btns & 0x20) {
tone = tone_frq[btn6_set1];
play_tone(tone, tone_length);
} if (btns & 0x40) {
tone = tone_frq[btn7_set1];
play_tone(tone, tone_length);
}
} else if (sw == 0xf) {
if (btns & 0x1) {
melody_arabix();
} if (btns & 0x2) {
play_example(example_twinkle, twinkle_length);
} if (btns & 0x4) {
play_example(example_imperial, imperial_length);
} if (btns & 0x8) {
tone = tone_frq[btn4_set1];
play_tone(tone, tone_length);
} if (btns & 0x10) {
tone = tone_frq[btn5_set1];
play_tone(tone, tone_length);
} if (btns & 0x20) {
tone = tone_frq[btn6_set1];
play_tone(tone, tone_length);
} if (btns & 0x40) {
tone = tone_frq[btn7_set1];
play_tone(tone, tone_length);
}
} else {
if (btns & 0x1) {
tone = tone_frq[btn1_set1];
play_tone(tone, tone_length);
} if (btns & 0x2) {
tone = tone_frq[btn2_set1];
play_tone(tone, tone_length);
} if (btns & 0x4) {
tone = tone_frq[btn3_set1];
play_tone(tone, tone_length);
} if (btns & 0x8) {
tone = tone_frq[btn4_set1];
play_tone(tone, tone_length);
} if (btns & 0x10) {
tone = tone_frq[btn5_set1];
play_tone(tone, tone_length);
} if (btns & 0x20) {
tone = tone_frq[btn6_set1];
play_tone(tone, tone_length);
} if (btns & 0x40) {
tone = tone_frq[btn7_set1];
play_tone(tone, tone_length);
}
}
// Clear tones etc.
PORTECLR = 0xff;
}
return 0;
}
void restart_song( void )
{
unsigned int temp = song_playing;
song_playing = -1;
play_song(temp);
}
static int select_tracklist(struct menulist *ml)
{
play_song(ml, ((struct tracklist *)ml->user)->track);
return 0;
}
int main()
{
struct douban_radio* douban;
douban=(struct douban_radio*) malloc (sizeof(struct douban_radio));
memset(douban, 0, sizeof(struct douban_radio));
douban->channel=2;
douban_radio_playlist_load(douban);
int mp3_out = 0;
char com_temp[1];
init_dev(22050);
uart_fd = Uart_Init(uart_dev);
printf("douban channel %d \n", douban->channel);
while(1) //主消息循环
{
if(uart_read(uart_fd, protocol_buff, 1, 0) > 0)
//if((mp3_out == 1) || (uart_read(uart_fd, protocol_buff, 1, 0) > 0))
{
//mp3_out = 0;
//printf("get data\n");
switch(protocol_buff[0])
{
case COM_START:
com_temp[0] = COM_END;
write(uart_fd, com_temp, 1);
break;
case COM_TITLE:
printf("send title!\n");
send_title(uart_fd, douban);
break;
case COM_ARTIST:
printf("send artist!\n");
send_artist(uart_fd, douban);
break;
case COM_JPG:
printf("send jpg!\n");
send_jpg(uart_fd, douban);
break;
case COM_PLAY:
printf("douban channel %d \n", douban->channel);
play_song(uart_fd, douban);
//printf("play song1\n");
//ice_mp3("http://190.220.157.52:8000");
//mp3("/song1.mp3");
//mp3_out = 1;
break;
case NEW_LIST:
load_list(uart_fd, douban);
case COM_STOP:
stop(uart_fd);
printf("stop!\n");
break;
default:
break;
}
}
}
/*
int index;
struct douban_radio* douban;
douban=(struct douban_radio*) malloc (sizeof(struct douban_radio));
memset(douban, 0, sizeof(struct douban_radio));
douban->channel=2;
douban_radio_playlist_load(douban);
printf("items:\t%d\n",douban->size );
for (index = 0; index < douban->size; index ++)
{
printf("picture: \t%s\n", douban->items[index].picture);
printf("title : \t%s\n", douban->items[index].title);
printf("artist : \t%s\n", douban->items[index].artist);
printf("url : \t%s\n\n", douban->items[index].url);
printf("index %d \n", index);
}
free(douban);
printf("\n\n\n\n\n");
douban=(struct douban_radio*) malloc (sizeof(struct douban_radio));
memset(douban, 0, sizeof(struct douban_radio));
douban->channel=2;
douban_radio_playlist_load(douban);
//load_list(douban);
printf("items:\t%d\n",douban->size );
for (index = 0; index < douban->size; index ++)
{
printf("picture: \t%s\n", douban->items[index].picture);
printf("title : \t%s\n", douban->items[index].title);
printf("artist : \t%s\n", douban->items[index].artist);
printf("url : \t%s\n\n", douban->items[index].url);
printf("index %d \n", index);
}
*/
return 0;
}
int main()
{
WINDOW *menu_win;
int highlight = 1,nphighlight=1;
int choice = -1,npchoice = 0;
int c,z=0,i=0,j=0;
char *line;
char *buff;
char read;
bool pause_id = false;
char *pid;
char pause[20];
FILE *f;
/////////////////////////////////////////////////// FILE START ///////////////////////////////////////////////////////////
FILE *fp;
start:
z=0;
fp = fopen("currentplay.txt", "r");
while(!feof(fp))
{
buff = (char *)malloc(200*sizeof(char));
fgets(buff,80,fp);
choices[z]=buff;
z++;
}
n_choices = z;
fclose(fp);
/////////////////////////////////////////////////// FILE END /////////////////////////////////////////////////////////////
initscr();
clear();
noecho();
cbreak(); /* Line buffering disabled. pass on everything */
startx = (80 - WIDTH) / 2;
starty = (24 - HEIGHT) / 2;
getmaxyx(stdscr,row,col);
menu_win = newwin(HEIGHT, WIDTH, starty, startx);
keypad(menu_win, TRUE);
/////////////////////////////////////////////////////////// PAINT BLACK //////////////////////////////////////////////////
start_color();
init_pair(2,COLOR_WHITE,COLOR_BLACK);
////////////////////////////////////////////////////////// PAINT BLACK //////////////////////////////////////////////////
mvprintw(0, 0, "Use arrow keys to go up and down, left and right, Press enter to select a song and space to selct lower menu choice.");
// mvprintw(1, 0, "%d %d",row,col);
refresh();
p:
print_menu(menu_win, highlight, nphighlight);
/*************************************************************************************************************/
while(1)
{
c = wgetch(menu_win);
switch(c)
{
case KEY_UP:
if(highlight == 1)
highlight = n_choices-1;
else
--highlight;
break;
case KEY_DOWN:
if(highlight == n_choices-1)
highlight = 1;
else
++highlight;
break;
case KEY_RIGHT:
if (nphighlight == npn_choices)
nphighlight = 1;
else
nphighlight++;
break;
case KEY_LEFT:
if (nphighlight == 1)
nphighlight = npn_choices;
else
nphighlight--;
break;
case 10:
choice = highlight;
break;
case 32:
npchoice = nphighlight;
break;
default:
refresh();
break;
}
print_menu(menu_win, highlight, nphighlight);
if(choice != -1 || npchoice !=0) /* User did a choice come out of the infinite loop */
break;
}
/*************************************************************************************************************/
/*--------------------------------------- SONG PLAYING START------------------------------------------------------*/
if (choice != -1)
{
curr_song= choice-1;
play_song(menu_win);
choice=-1;
goto p;
}
/*--------------------------------------- SONG PLAYING ENDS------------------------------------------------------*/
else
{
if (npchoice == 1)
{
system("./AddSongs.sh");
npchoice =0;
goto start;
}
else if (npchoice == 2)
{
f = popen("pidof mpg123", "r");
if (f==NULL){
printf("No song to pause!");
}
else {
fgets(pid, 10, f);
if (!pause_id){
sprintf(pause, "kill -STOP %s", pid);
wprintw(menu_win,"%s",pause);
strcpy(npchoices[1], "Resume");
system(pause);
pause_id = true;
}
else {
sprintf(pause, "kill -CONT %s", pid);
strcpy(npchoices[1], "Pause ");
system(pause);
pause_id = false;
}
pclose(f);
npchoice = 0;
goto p;
}
}
else if (npchoice == 3)
{
system("killall mpg123 2>/dev/null");
npchoice=0;
curr_song = -1;
goto p;
}
else if (npchoice == 4)
{
if (curr_song == n_choices-2)
curr_song = 0;
else
curr_song++;
npchoice = 0;
play_song(menu_win);
goto p;
}
else if (npchoice == 5)
{
system("./SavePlaylist.sh");
npchoice =0;
goto p;
}
else if (npchoice == 7)
{
clear();
choice = -1;
echo();
return 0;
}
}
clrtoeol();
refresh();
endwin();
echo();
return 0;
}
RoomElement hitElf(RoomElement element)
{
//hit by a monster
if (element.type < 50)
{
//check the counter, so hearts are not
//removed unless the monster has not been 'hit'
//already
if (element.counter == 0)
{
element.counter = COUNTER_START;
elf.hearts--;
if (elf.hearts < 1)
{
//game over
elf.state = ELFSTATE_DEAD;
}
}
//when the elf and a monster 'bump,' move the monster
//in the opposite direction
switch (element.state)
{
case STATE_MOVE_UP:
element.state = STATE_MOVE_DOWN;
break;
case STATE_MOVE_DOWN:
element.state = STATE_MOVE_UP;
break;
case STATE_MOVE_LEFT:
element.state = STATE_MOVE_RIGHT;
break;
case STATE_MOVE_RIGHT:
element.state = STATE_MOVE_LEFT;
break;
}
} else {
switch (element.type)
{
case ITEM_HEART:
if (elf.hearts < MAX_HEARTS) elf.hearts++;
//handle the rest of the item hit
element = hitItem(element);
play_sfx(5);
break;
case ITEM_CRYSTAL:
case ITEM_ORB:
case ITEM_ARMOR:
case ITEM_STAFF:
addElfItem(element.type);
//handle the rest of the item hit
element = hitItem(element);
break;
case ITEM_PORTAL:
//handle the rest of the item hit
element = hitItem(element);
if (getMapCurrentRoom() > 63)
{
//go to the bottom half of the map (underworld)
setMapRoom(0);
play_song(0);
} else {
//back to top half of the map (overworld)
setMapRoom(64);
play_song(1);
}
elf.x = 36;
elf.y = 24;
elf.facing = FACING_DOWN;
showElf();
break;
}
}
//update the display
updateDisplay(elf);
return element;
}
//plays a song only once
void play_song_once(char song)
{
play_song(song);
//override the state to a single time through
music_state = SONG_PLAYING_ONCE;
}
void jukebox( void )
{
bool trigger_quit = false, // true when user wants to quit
quitting = false;
bool hide_text = false;
bool fade_looped_songs = true, fading_song = false;
bool stopped = false;
bool fx = false;
int fx_num = 0;
int palette_fade_steps = 15;
int diff[256][3];
init_step_fade_palette(diff, vga_palette, 0, 255);
JE_starlib_init();
int fade_volume = tyrMusicVolume;
for (; ; )
{
if (!stopped && !audio_disabled)
{
if (songlooped && fade_looped_songs)
fading_song = true;
if (fading_song)
{
if (fade_volume > 5)
{
fade_volume -= 2;
}
else
{
fade_volume = tyrMusicVolume;
fading_song = false;
}
set_volume(fade_volume, fxVolume);
}
if (!playing || (songlooped && fade_looped_songs && !fading_song))
play_song(mt_rand() % MUSIC_NUM);
}
setdelay(1);
SDL_FillRect(VGAScreenSeg, NULL, 0);
// starlib input needs to be rewritten
JE_starlib_main();
push_joysticks_as_keyboard();
service_SDL_events(true);
if (!hide_text)
{
char buffer[60];
if (fx)
snprintf(buffer, sizeof(buffer), "%d %s", fx_num + 1, soundTitle[fx_num]);
else
snprintf(buffer, sizeof(buffer), "%d %s", song_playing + 1, musicTitle[song_playing]);
const int x = VGAScreen->w / 2;
#ifdef ANDROID
draw_font_hv(VGAScreen, x, 170, "Press the Back button to quit the jukebox.", small_font, centered, 1, 0);
draw_font_hv(VGAScreen, x, 180, "Touch to change the song being played.", small_font, centered, 1, 0);
#else
draw_font_hv(VGAScreen, x, 170, "Press ESC to quit the jukebox.", small_font, centered, 1, 0);
draw_font_hv(VGAScreen, x, 180, "Arrow keys change the song being played.", small_font, centered, 1, 0);
#endif
draw_font_hv(VGAScreen, x, 190, buffer, small_font, centered, 1, 4);
}
if (palette_fade_steps > 0)
step_fade_palette(diff, palette_fade_steps--, 0, 255);
JE_showVGA();
wait_delay();
#ifdef ANDROID
if (mousedown)
{
wait_noinput(true, true, true);
newkey = true;
if (mouse_x < 160)
lastkey_sym = SDLK_LEFT;
else
lastkey_sym = SDLK_RIGHT;
}
#else
// quit on mouse click
Uint16 x, y;
if (JE_mousePosition(&x, &y) > 0)
trigger_quit = true;
#endif
if (newkey)
{
switch (lastkey_sym)
{
case SDLK_ESCAPE: // quit jukebox
case SDLK_q:
trigger_quit = true;
break;
case SDLK_SPACE:
hide_text = !hide_text;
break;
case SDLK_f:
fading_song = !fading_song;
break;
case SDLK_n:
fade_looped_songs = !fade_looped_songs;
break;
case SDLK_SLASH: // switch to sfx mode
fx = !fx;
break;
case SDLK_COMMA:
if (fx && --fx_num < 0)
fx_num = SAMPLE_COUNT - 1;
break;
case SDLK_PERIOD:
if (fx && ++fx_num >= SAMPLE_COUNT)
fx_num = 0;
break;
case SDLK_SEMICOLON:
if (fx)
JE_playSampleNum(fx_num + 1);
break;
case SDLK_LEFT:
case SDLK_UP:
case SDLK_LCTRL:
play_song((song_playing > 0 ? song_playing : MUSIC_NUM) - 1);
stopped = false;
break;
case SDLK_RETURN:
case SDLK_RIGHT:
case SDLK_DOWN:
case SDLK_LALT:
play_song((song_playing + 1) % MUSIC_NUM);
stopped = false;
break;
case SDLK_s: // stop song
stop_song();
stopped = true;
break;
case SDLK_r: // restart song
restart_song();
stopped = false;
break;
default:
break;
}
}
// user wants to quit, start fade-out
if (trigger_quit && !quitting)
{
palette_fade_steps = 15;
SDL_Color black = { 0, 0, 0 };
init_step_fade_solid(diff, black, 0, 255);
quitting = true;
}
// if fade-out finished, we can finally quit
if (quitting && palette_fade_steps == 0)
break;
}
set_volume(tyrMusicVolume, fxVolume);
}
int fm_play_song(char *song_url)
{
play_song(song_url);
}
void opentyrian_menu( void )
{
typedef enum
{
MENU_ABOUT = 0,
MENU_FULLSCREEN,
MENU_SCALER,
// MENU_DESTRUCT,
MENU_JUKEBOX,
MENU_RETURN,
MenuOptions_MAX
} MenuOptions;
static const char *menu_items[] =
{
"About OpenTyrian",
"Toggle Fullscreen",
"Scaler: None",
// "Play Destruct",
"Jukebox",
"Return to Main Menu",
};
bool menu_items_disabled[] =
{
false,
!can_init_any_scaler(false) || !can_init_any_scaler(true),
false,
// false,
false,
false,
};
assert(COUNTOF(menu_items) == MenuOptions_MAX);
assert(COUNTOF(menu_items_disabled) == MenuOptions_MAX);
fade_black(10);
JE_loadPic(VGAScreen, 13, false);
draw_font_hv(VGAScreen, VGAScreen->surf->w / 2, 5, opentyrian_str, large_font, centered, 15, -3);
memcpy(VGAScreen2->surf->pixels, VGAScreen->surf->pixels, VGAScreen2->surf->pitch * VGAScreen2->surf->h);
JE_showVGA();
play_song(36); // A Field for Mag
MenuOptions sel = 0;
uint temp_scaler = scaler;
bool fade_in = true, quit = false;
do
{
memcpy(VGAScreen->surf->pixels, VGAScreen2->surf->pixels, VGAScreen->surf->pitch * VGAScreen->surf->h);
for (MenuOptions i = 0; i < MenuOptions_MAX; i++)
{
const char *text = menu_items[i];
char buffer[100];
if (i == MENU_SCALER)
{
snprintf(buffer, sizeof(buffer), "Scaler: %s", scalers[temp_scaler].name);
text = buffer;
}
int y = i != MENU_RETURN ? i * 16 + 32 : 118;
draw_font_hv(VGAScreen, VGAScreen->surf->w / 2, y, text, normal_font, centered, 15, menu_items_disabled[i] ? -8 : i != sel ? -4 : -2);
}
JE_showVGA();
if (fade_in)
{
fade_in = false;
fade_palette(colors, 20, 0, 255);
wait_noinput(true, false, false);
}
tempW = 0;
JE_textMenuWait(&tempW, false);
if (newkey)
{
switch (lastkey_sym)
{
case SDLK_UP:
do
{
if (sel-- == 0)
sel = MenuOptions_MAX - 1;
}
while (menu_items_disabled[sel]);
JE_playSampleNum(S_CURSOR);
break;
case SDLK_DOWN:
do
{
if (++sel >= MenuOptions_MAX)
sel = 0;
}
while (menu_items_disabled[sel]);
JE_playSampleNum(S_CURSOR);
break;
case SDLK_LEFT:
if (sel == MENU_SCALER)
{
do
{
if (temp_scaler == 0)
temp_scaler = scalers_count;
temp_scaler--;
}
while (!can_init_scaler(temp_scaler, fullscreen_enabled));
JE_playSampleNum(S_CURSOR);
}
break;
case SDLK_RIGHT:
if (sel == MENU_SCALER)
{
do
{
temp_scaler++;
if (temp_scaler == scalers_count)
temp_scaler = 0;
}
while (!can_init_scaler(temp_scaler, fullscreen_enabled));
JE_playSampleNum(S_CURSOR);
}
break;
case SDLK_RETURN:
switch (sel)
{
case MENU_ABOUT:
JE_playSampleNum(S_SELECT);
scroller_sine(about_text);
memcpy(VGAScreen->surf->pixels, VGAScreen2->surf->pixels, VGAScreen->surf->pitch * VGAScreen->surf->h);
JE_showVGA();
fade_in = true;
break;
case MENU_FULLSCREEN:
JE_playSampleNum(S_SELECT);
if (!init_scaler(scaler, !fullscreen_enabled) && // try new fullscreen state
!init_any_scaler(!fullscreen_enabled) && // try any scaler in new fullscreen state
!init_scaler(scaler, fullscreen_enabled)) // revert on fail
{
exit(EXIT_FAILURE);
}
break;
case MENU_SCALER:
JE_playSampleNum(S_SELECT);
if (scaler != temp_scaler)
{
if (!init_scaler(temp_scaler, fullscreen_enabled) && // try new scaler
!init_scaler(temp_scaler, !fullscreen_enabled) && // try other fullscreen state
!init_scaler(scaler, fullscreen_enabled)) // revert on fail
{
exit(EXIT_FAILURE);
}
}
break;
case MENU_JUKEBOX:
JE_playSampleNum(S_SELECT);
fade_black(10);
jukebox();
memcpy(VGAScreen->surf->pixels, VGAScreen2->surf->pixels, VGAScreen->surf->pitch * VGAScreen->surf->h);
JE_showVGA();
fade_in = true;
break;
case MENU_RETURN:
quit = true;
JE_playSampleNum(S_SPRING);
break;
case MenuOptions_MAX:
assert(false);
break;
}
break;
case SDLK_ESCAPE:
quit = true;
JE_playSampleNum(S_SPRING);
break;
default:
break;
}
}
} while (!quit);
}
int main(int argc, char *argv[]) {
FILE *fp = fopen(argv[1], "r");
play_song(fp);
return 0;
}
void opentyrian_menu( void )
{
static const char *menu_items[] =
{
"About OpenTyrian",
"Toggle Fullscreen",
"Scaler: None",
// "Play Destruct",
"Jukebox",
"Return to Main Menu",
};
bool menu_items_disabled[] =
{
false,
!can_init_any_scaler(false) || !can_init_any_scaler(true),
false,
// false,
false,
false,
};
fade_black(10);
JE_loadPic(VGAScreen, 13, false);
draw_font_hv(VGAScreen, VGAScreen->w / 2, 5, opentyrian_str, large_font, centered, 15, -3);
memcpy(VGAScreen2->pixels, VGAScreen->pixels, VGAScreen2->pitch * VGAScreen2->h);
JE_showVGA();
play_song(36); // A Field for Mag
int sel = 0;
const int maxSel = COUNTOF(menu_items) - 1;
uint32_t temp_scaler = scaler;
bool fade_in = true, quit = false;
do
{
memcpy(VGAScreen->pixels, VGAScreen2->pixels, VGAScreen->pitch * VGAScreen->h);
for (int i = 0; i <= maxSel; i++)
{
const char *text = menu_items[i];
char buffer[100];
if (i == 2) /* Scaler */
{
snprintf(buffer, sizeof(buffer), "Scaler: %s", scalers[temp_scaler].name);
text = buffer;
}
int y = i != maxSel ? i * 16 + 32 : 118;
draw_font_hv(VGAScreen, VGAScreen->w / 2, y, text, normal_font, centered, 15, menu_items_disabled[i] ? -8 : i != sel ? -4 : -2);
}
JE_showVGA();
if (fade_in)
{
fade_in = false;
fade_palette(colors, 20, 0, 255);
wait_noinput(true, false, false);
}
tempW = 0;
JE_textMenuWait(&tempW, false);
if (newkey)
{
switch (lastkey_sym)
{
case SDLK_UP:
do
{
if (--sel < 0)
sel = maxSel;
}
while (menu_items_disabled[sel]);
JE_playSampleNum(S_CURSOR);
break;
case SDLK_DOWN:
do
{
if (++sel > maxSel)
sel = 0;
}
while (menu_items_disabled[sel]);
JE_playSampleNum(S_CURSOR);
break;
case SDLK_LEFT:
if (sel == 2)
{
do
{
if (temp_scaler == 0)
temp_scaler = scalers_count;
temp_scaler--;
}
while (!can_init_scaler(temp_scaler, fullscreen_enabled));
JE_playSampleNum(S_CURSOR);
}
break;
case SDLK_RIGHT:
if (sel == 2)
{
do
{
temp_scaler++;
if (temp_scaler == scalers_count)
temp_scaler = 0;
}
while (!can_init_scaler(temp_scaler, fullscreen_enabled));
JE_playSampleNum(S_CURSOR);
}
break;
case SDLK_RETURN:
switch (sel)
{
case 0: /* About */
JE_playSampleNum(S_SELECT);
scroller_sine(about_text);
memcpy(VGAScreen->pixels, VGAScreen2->pixels, VGAScreen->pitch * VGAScreen->h);
JE_showVGA();
fade_in = true;
break;
case 1: /* Fullscreen */
JE_playSampleNum(S_SELECT);
if (!init_scaler(scaler, !fullscreen_enabled) && // try new fullscreen state
!init_any_scaler(!fullscreen_enabled) && // try any scaler in new fullscreen state
!init_scaler(scaler, fullscreen_enabled)) // revert on fail
{
exit(EXIT_FAILURE);
}
set_palette(colors, 0, 255); // for switching between 8 bpp scalers
break;
case 2: /* Scaler */
JE_playSampleNum(S_SELECT);
if (scaler != temp_scaler)
{
if (!init_scaler(temp_scaler, fullscreen_enabled) && // try new scaler
!init_scaler(temp_scaler, !fullscreen_enabled) && // try other fullscreen state
!init_scaler(scaler, fullscreen_enabled)) // revert on fail
{
exit(EXIT_FAILURE);
}
set_palette(colors, 0, 255); // for switching between 8 bpp scalers
}
break;
case 3: /* Jukebox */
JE_playSampleNum(S_SELECT);
fade_black(10);
jukebox();
memcpy(VGAScreen->pixels, VGAScreen2->pixels, VGAScreen->pitch * VGAScreen->h);
JE_showVGA();
fade_in = true;
break;
case 4: /* Return to main menu */
quit = true;
JE_playSampleNum(S_SPRING);
break;
}
break;
case SDLK_ESCAPE:
quit = true;
JE_playSampleNum(S_SPRING);
break;
default:
break;
}
}
} while (!quit);
}
int main() {
int noteBuffer[SONG_SIZE];
int accidentals[SONG_SIZE];
int octaveBuffer[SONG_SIZE];
memcpy(noteBuffer, rom_notes, SONG_SIZE*sizeof(int));
memcpy(accidentals, rom_accidentals, SONG_SIZE*sizeof(int));
memcpy(octaveBuffer, rom_octaves, SONG_SIZE*sizeof(int));
const int buf_size = SONG_SIZE;
//uint8 selected;
initHardware();
int start = 0;
while (1) {
//glcd_clear();
glcd_tiny_set_font(Font5x7,5,7,32,127);
update_notes(noteBuffer, accidentals, octaveBuffer, start, buf_size);
if (start > 0) {
glcd_draw_string_xy(13*6,0,"^");
}
if (start+4 < buf_size) {
glcd_draw_string_xy(13*6,5*8,"v");
}
glcd_draw_char_xy(13*6,1*8,(start/4+1)/100%10+'0');
glcd_draw_char_xy(13*6,2*8,(start/4+1)/10%10+'0');
glcd_draw_char_xy(13*6,3*8,(start/4+1)%10+'0');
glcd_write();
/*
start+=4;
if (start > 24) start = 0;
*/
int reading = 0;
not_scroll:
reading = Keypad_1_GetButton();
switch (reading) {
case 7:
if (start+4 < buf_size) start+=4;
break;
case 15:
if (start > 0) start-=4;
break;
case 3:
play_song(noteBuffer, accidentals, octaveBuffer, buf_size);
break;
case 0:
for (int i = 0; i < 4; ++i) {
glcd_invert_area(i*18, 0, 6, 8);
glcd_write();
CyDelay(200);
int button = 7;
while (button > 6) {
button = keycode_to_note[Keypad_1_GetButton()];
}
noteBuffer[start+i] = button;
update_notes(noteBuffer, accidentals, octaveBuffer, start, buf_size);
glcd_invert_area(i*18+6, 0, 6, 8);
glcd_write();
CyDelay(200);
button = 2;
while (button > 1) {
button = keycode_to_accidental[Keypad_1_GetButton()];
if (button == 99) goto cancel_edit;
}
accidentals[start+i] = button;
update_notes(noteBuffer, accidentals, octaveBuffer, start, buf_size);
glcd_invert_area(i*18+12, 0, 6, 8);
glcd_write();
CyDelay(200);
button = 10;
while (button > 9) {
button = keycode_to_octave[Keypad_1_GetButton()];
if (button == 99) goto cancel_edit;
}
octaveBuffer[start+i] = button;
update_notes(noteBuffer, accidentals, octaveBuffer, start, buf_size);
}
cancel_edit:
break;
case 1:
glcd_clear();
glcd_draw_string_xy(0,0,"Saving...");
glcd_write();
int fail = 0;
fail += CYRET_SUCCESS!=Em_EEPROM_Write((void*)noteBuffer, (void*)rom_notes, SONG_SIZE*sizeof(int));
fail += CYRET_SUCCESS!=Em_EEPROM_Write((void*)accidentals, (void*)rom_accidentals, SONG_SIZE*sizeof(int));
fail += CYRET_SUCCESS!=Em_EEPROM_Write((void*)octaveBuffer, (void*)rom_octaves, SONG_SIZE*sizeof(int));
if (fail) {
glcd_draw_string_xy(0,8,"Failed!");
glcd_write();
CyDelay(1000);
}
else {
glcd_draw_string_xy(0,8,"Success!");
glcd_write();
CyDelay(300);
}
break;
default:
goto not_scroll;
}
CyDelay(50);
}
}
static int select_track(struct menulist *ml)
{
play_song(ml, (struct track *)ml->user);
return 0;
}
