void vectrex_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
switch (id)
{
case TIMER_VECTREX_IMAGER_CHANGE_COLOR:
vectrex_imager_change_color(ptr, param);
break;
case TIMER_UPDATE_LEVEL:
update_level(ptr, param);
break;
case TIMER_VECTREX_IMAGER_EYE:
vectrex_imager_eye(ptr, param);
break;
case TIMER_LIGHTPEN_TRIGGER:
lightpen_trigger(ptr, param);
break;
case TIMER_VECTREX_REFRESH:
vectrex_refresh(ptr, param);
break;
case TIMER_VECTREX_ZERO_INTEGRATORS:
vectrex_zero_integrators(ptr, param);
break;
case TIMER_UPDATE_SIGNAL:
update_signal(ptr, param);
break;
default:
assert_always(FALSE, "Unknown id in vectrex_state::device_timer");
}
}
void Game::send_new_wave()
{
EnemyList tmp = level_control->get_new_wave(this);
enemy_list.insert(enemy_list.end(), tmp.begin(), tmp.end());
tmp.clear();
update_level();
}
static GtkToolItem*
level_widget_new()
{
g_assert(level_widget == NULL);
level_widget = sugar_toolkit_tool_text_new();
update_level();
return GTK_TOOL_ITEM(level_widget);
}
static void
bar_set_level(GcomprisBoard *board)
{
if (board == NULL)
return;
if (level_widget == NULL) {
g_message("in bar_set_level, level_item uninitialized : should not happen\n");
return;
}
current_level = board->level;
update_level();
}
// If G1LogLevel has not been set up we will use the values of PrintGC
// and PrintGCDetails for the logging level.
void G1Log::init() {
if (!FLAG_IS_DEFAULT(G1LogLevel)) {
// PrintGC flags change won't have any affect, because G1LogLevel
// is set explicitly
if (G1LogLevel[0] == '\0' || strncmp("none", G1LogLevel, 4) == 0 && G1LogLevel[4] == '\0') {
_level = LevelNone;
} else if (strncmp("fine", G1LogLevel, 4) == 0 && G1LogLevel[4] == '\0') {
_level = LevelFine;
} else if (strncmp("finer", G1LogLevel, 5) == 0 && G1LogLevel[5] == '\0') {
_level = LevelFiner;
} else if (strncmp("finest", G1LogLevel, 6) == 0 && G1LogLevel[6] == '\0') {
_level = LevelFinest;
} else {
warning("Unknown logging level '%s', should be one of 'fine', 'finer' or 'finest'.", G1LogLevel);
}
} else {
update_level();
}
}
static void
level_clicked_cb(GtkToolButton *button, gpointer user_data)
{
beep();
GcomprisBoard *board = gc_board_get_current();
if (board == NULL)
return;
gint delta = GPOINTER_TO_INT(user_data);
current_level += delta;
if (current_level > board->maxlevel)
current_level = 1;
else if (current_level < 1)
current_level = board->maxlevel;
update_level();
if (board->plugin->set_level != NULL)
board->plugin->set_level(current_level);
gc_bar_play_level_voice(current_level);
}
static void update(Tetris *tetris)
{
if (tetris->key_quit) {
Tetris_destroy(tetris);
exit(0);
}
else if (tetris->key_pause) {
if (tetris->game_state == RUNNING) {
tetris->game_state = PAUSED;
Renderer_erase_panel_labels(tetris->renderer);
Renderer_erase_panel_line_counter(tetris->renderer);
Renderer_erase_panel_score(tetris->renderer);
Renderer_erase_panel_level(tetris->renderer);
Renderer_draw_pause_message(tetris->renderer);
}
else if (tetris->game_state == PAUSED) {
tetris->game_state = RUNNING;
Renderer_erase_pause_message(tetris->renderer);
Renderer_draw_panel_labels(tetris->renderer);
Renderer_draw_panel_line_counter(tetris->renderer,
tetris->lines_completed);
Renderer_draw_panel_score(tetris->renderer, tetris->score);
Renderer_draw_panel_level(tetris->renderer, tetris->level);
}
}
if (tetris->game_state != PAUSED) {
if (collision(COORDINATE_BOTTOM_COLLISION,
tetris->current_block,
tetris->renderer->buffer)
) {
++tetris->movement_frame_counter;
if (tetris->movement_frame_counter == tetris->movement_frame_delay) {
tetris->movement_frame_counter = 0;
Renderer_draw_block(tetris->renderer, tetris->current_block);
int complete_lines = check_complete_lines(tetris);
next_block(tetris);
check_game_over(tetris);
update_score(tetris, complete_lines);
update_level(tetris);
Renderer_draw_panel_score(tetris->renderer, tetris->score);
Renderer_draw_panel_level(tetris->renderer, tetris->level);
tetris->renderer->buffer->dirty = 1;
}
}
if (!collision(COORDINATE_BOTTOM_COLLISION,
tetris->current_block,
tetris->renderer->buffer)
) {
++tetris->gravity_frame_counter;
if (tetris->gravity_frame_counter == tetris->gravity_frame_delay) {
tetris->gravity_frame_counter = 0;
++tetris->current_block->y;
tetris->renderer->buffer->dirty = 1;
}
}
if (tetris->key_drop) {
while (!collision(COORDINATE_BOTTOM_COLLISION,
tetris->current_block,
tetris->renderer->buffer)
) {
++tetris->current_block->y;
tetris->score += 2;
}
tetris->renderer->buffer->dirty = 1;
}
else if (tetris->key_rotate
&& rotate_collision(tetris->current_block,
tetris->renderer->buffer) != 1
) {
Block_rotate(tetris->current_block);
if (tetris->enable_ghost_block == 1) {
set_ghost_block(tetris);
}
tetris->renderer->buffer->dirty = 1;
}
else if (tetris->key_ghost_block) {
if (tetris->enable_ghost_block) {
tetris->enable_ghost_block = 0;
}
else {
tetris->enable_ghost_block = 1;
set_ghost_block(tetris);
}
tetris->renderer->buffer->dirty = 1;
}
else if (tetris->key_left
&& !collision(COORDINATE_LEFT_COLLISION,
tetris->current_block,
tetris->renderer->buffer)
) {
--tetris->current_block->x;
if (tetris->enable_ghost_block == 1) {
set_ghost_block(tetris);
}
tetris->renderer->buffer->dirty = 1;
}
else if (tetris->key_right
&& !collision(COORDINATE_RIGHT_COLLISION,
tetris->current_block,
tetris->renderer->buffer)
) {
++tetris->current_block->x;
if (tetris->enable_ghost_block == 1) {
set_ghost_block(tetris);
}
tetris->renderer->buffer->dirty = 1;
}
else if (tetris->key_down
&& !collision(COORDINATE_BOTTOM_COLLISION,
tetris->current_block,
tetris->renderer->buffer)
) {
++tetris->current_block->y;
if (tetris->enable_ghost_block == 1) {
set_ghost_block(tetris);
}
++tetris->score;
Renderer_draw_panel_score(tetris->renderer, tetris->score);
tetris->renderer->buffer->dirty = 1;
}
}
}
/* ------------------------------------------------------------------------------------------------------
Creates a byte from the waveform
0..255 new byte
-1 continue
-2 error
-3 no more bytes
--------------------------------------------------------------------------------------------------------- */
int byte_decode(int restart, int new_file)
{
static int t,t_active,t_byte;
static int byte,n_bytes,c[6];
int i,j,k,d[7],sampleval;
double x;
// t = number of samples read
// t_byte = sample where byte starts
// t_active is > 0 when a signal has been detected
if(restart) {
t = t_active = 0;
update_progress(0.0);
update_status("Attente du signal...");
}
// process next sample
t++;
sampleval = next_sample(new_file);
if (sampleval == 40000) {
return -3;
}
x = (double)sampleval / 32768.0;
x = filter(x);
x = dilate(x);
x = median(x);
x = make_decision(x,d);
b_median(d);
update_level(x);
// print_deep_debug("t: %d, d6 %d, d5 %d, x %0.5f\n", t, d[6], d[5], x);
// activation test
if(d[6] && t_active == 0) {
print_deep_debug(" - act - ");
t_active = t;
t_byte = 0;
n_bytes = 0;
update_status("Analyse du signal...");
}
if(t_active == 0) return -1;
// deactivation test after a long period of inactivity
if(t > t_active + 10000) {
update_status("Désactivation pour cause d'inactivité");
return -2;
}
// new byte?
if(t_byte == 0 && d[5]) { // new byte
print_deep_debug(" -- new byte -- ");
t_active = t_byte = t;
n_bytes++;
byte = 0;
for(i = 0;i < 6;i++)
c[i] = 0;
}
// processing a byte?
if(t_byte > 0) {
j = (t - t_byte) / 88; // bit number; the duration of a bit is very close to 2ms=88.2 samples
if(j >= 10) { // end of the byte
print_deep_debug(" [b = %d ] ", byte);
if((byte & 1) == 0) { // first bit (lsb) must be a one
print_debug("Bad byte start");
return -2;
}
if(byte >= 512) { // last bit (msb) must be a zero
print_debug("Bad byte finish");
return -2;
}
byte >>= 1;
t_byte = 0;
if(n_bytes > 5) {
return byte;
}
if(byte != 0xAA) { // bad synchronization byte
print_debug("Bad synchronization byte.");
return -2;
}
print_debug("Found good synchronization byte.");
return -1; // discard synchronization byte
}
