std::pair< time_type , time_type > do_step( System system )
{
const size_t max_count = 1000;
if( !m_is_deriv_initialized )
{
typename odeint::unwrap_reference< System >::type &sys = system;
sys( get_current_state() , get_current_deriv() , m_t );
m_is_deriv_initialized = true;
}
controlled_step_result res = fail;
m_t_old = m_t;
size_t count = 0;
do
{
res = m_stepper.try_step( system , get_current_state() , get_current_deriv() , m_t ,
get_old_state() , get_old_deriv() , m_dt );
if( count++ == max_count )
throw std::overflow_error( "dense_output_controlled_explicit : too much iterations!");
}
while( res == fail );
toggle_current_state();
return std::make_pair( m_t_old , m_t );
}
static void game_click(int buttonID, bool longClick) {
if(buttonID == BUTTON_ID_SELECT) {
if(get_current_state() == STATE_RESULTS) {
// We really don't want to do anything with it...
} else if(get_current_state() == STATE_AFTERRESULTS) {
race_result_destroy_assets();
set_current_state(STATE_BEFORERACE);
} else if(get_current_state() == STATE_SPLASH) {
hide_splashscreen();
set_current_state(STATE_SHOWMAINMENU);
}
} else if(buttonID == BUTTON_ID_BACK) {
APP_LOG(APP_LOG_LEVEL_DEBUG, "!!! hello BACK pressed !!!! (%d)", get_current_state());
switch(get_current_state()) {
case STATE_SPLASH:
set_current_state(STATE_QUITTING);
break;
case STATE_RESULTS:
case STATE_QUITTING:
break;
case STATE_AFTERRESULTS:
race_result_destroy_assets();
main_menu_destroy();
set_current_state(STATE_SHOWMAINMENU);
break;
default:
set_current_state(STATE_SHOWMAINMENU);
break;
}
}
}
static void game_draw(GContext *ctx) {
graphics_context_set_compositing_mode(ctx, GCompOpSet);
// Per-frame game rendering here
if(get_current_state() == STATE_TUTORIAL) {
draw_track(ctx, car_get_camera_focus());
} else if(get_current_state() == STATE_RACING) {
draw_track(ctx, car_get_camera_focus());
race_draw_cars(ctx);
} else if(get_current_state() == STATE_RESULTS) {
// This actually only gets done once
race_result_populate_position_layers(ctx);
}
}
static void game_logic() {
// Per-frame game logic here
if(get_current_state() == STATE_SPLASH) {
psleep(MENUPSLEEPTIME); // Trying to save the battery!
} else if(get_current_state() == STATE_SHOWMAINMENU) {
main_menu_create();
} else if(get_current_state() == STATE_MARATHON) {
race_reset_cars();
race_set_difficulty(DIFFICULTY);
track_set_length(14000);
main_menu_destroy();
switch_on_light(50000);
set_current_state(STATE_BEFORERACE);
} else if(get_current_state() == STATE_SPRINT) {
race_reset_cars();
race_set_difficulty(DIFFICULTY);
track_set_length(7000);
main_menu_destroy();
switch_on_light(35000);
set_current_state(STATE_BEFORERACE);
} else if(get_current_state() == STATE_BEFORERACE) {
race_result_create_position_layers();
race_place_cars_on_grid();
race_set_start_time();
set_current_state(STATE_RACING);
} else if(get_current_state() == STATE_RACING) {
race_frame_update();
} else if(get_current_state() == STATE_AFTERRESULTS) {
psleep(MENUPSLEEPTIME); // Trying to save the battery!
} else if(get_current_state() == STATE_QUITTING) {
APP_LOG(APP_LOG_LEVEL_DEBUG, "!!! QUITTING from horizontalboost !!!!");
window_stack_pop(false);
}
}
static void
gpcap_conduits_enable (GtkWidget *widget, gpointer user_data)
{
GnomePilotCapplet *gpcap = GNOME_PILOT_CAPPLET (user_data);
GnomePilotCappletPrivate *priv;
ConduitState *state;
GtkTreeIter iter;
priv = gpcap->priv;
state = get_current_state (gpcap, &iter);
if (state->default_sync_type == GnomePilotConduitSyncTypeNotSet) {
/* nothing? */
} else if (state->default_sync_type == GnomePilotConduitSyncTypeCustom) {
state->changed=TRUE;
state->enabled=TRUE;
state->sync_type = GnomePilotConduitSyncTypeCustom;
} else {
state->changed = TRUE;
state->enabled = TRUE;
state->sync_type = state->default_sync_type;
}
gtk_list_store_set (GTK_LIST_STORE (priv->conduit_model), &iter,
0, state->name,
1, display_sync_type_name (state->enabled, state->sync_type),
-1);
check_conduits_buttons (gpcap);
gpcap_save_state (gpcap);
gpcap_conduits_settings (widget, user_data);
}
void initialize( const StateType &x0 , time_type t0 , time_type dt0 )
{
m_resizer.adjust_size( x0 , detail::bind( &dense_output_stepper_type::template resize_impl< StateType > , detail::ref( *this ) , detail::_1 ) );
get_current_state() = x0;
m_t = t0;
m_dt = dt0;
}
String Legs::get_current_state_name(){
/*
Return a String representing the current state.
*/
switch (get_current_state()) {
case FORWARD:
return "FORWARD";
break;
case BACKWARD:
return "BACKWARD";
break;
case LEFT:
return "LEFT";
break;
case RIGHT:
return "RIGHT";
break;
case BYELEFT:
return "BYELEFT";
break;
case BYERIGHT:
return "BYERIGHT";
break;
case STOP:
return "STOP";
break;
default:
return "STOP";
break;
}
}
void Legs::move_according_state(){
/*
Given the current state, update the moviment.
*/
switch (get_current_state()) {
case FORWARD:
move_forward();
break;
case BACKWARD:
move_backward();
break;
case LEFT:
turn_left();
break;
case RIGHT:
turn_right();
break;
case BYELEFT:
bye_bye_left();
break;
case BYERIGHT:
bye_bye_right();
break;
case STOP:
zero_pos();
break;
default:
zero_pos();
break;
}
}
void initialize( const StateType &x0 , time_type t0 , time_type dt0 )
{
m_resizer.adjust_size( x0 , detail::bind( &dense_output_stepper_type::template resize< StateType > , detail::ref( *this ) , detail::_1 ) );
boost::numeric::odeint::copy( x0 , get_current_state() );
m_t = t0;
m_dt = dt0;
m_is_deriv_initialized = false;
}
std::pair< time_type , time_type > do_step( System system )
{
m_stepper.do_step( system , get_current_state() , m_t , get_old_state() , m_dt );
m_t_old = m_t;
m_t += m_dt;
toggle_current_state();
return std::make_pair( m_t_old , m_dt );
}
int handle_immigration_request(struct nl_msg *req_msg) {
struct nl_msg *msg = NULL;
struct nlattr *nla;
int ret = 0;
int seq;
struct internal_state* state = get_current_state();
// In params
int uid;
int slot_index;
char* name;
// Out params
int accept = 1;
seq = nlmsg_hdr(req_msg)->nlmsg_seq;
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_UID);
if (nla == NULL)
return -EBADMSG;
uid = nla_get_u32(nla);
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_INDEX);
if (nla == NULL)
return -EBADMSG;
slot_index = nla_get_u32(nla);
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_NAME);
if (nla == NULL)
return -EBADMSG;
//name = nl_data_get(nla_get_data(nla));
name = nla_data(nla);
//printf("NPM CALLED FOR NAME: %s\n", name);
if ( immigration_request_callback )
immigration_request_callback(uid, slot_index, name, &accept);
if ( (ret=prepare_response_message(state->handle, DIRECTOR_IMMIGRATION_REQUEST_RESPONSE, state->gnl_fid, seq, &msg) ) != 0 ) {
goto done;
}
ret = nla_put_u32(msg,
DIRECTOR_A_DECISION,
accept);
if (ret != 0)
goto error_del_resp;
ret = send_request_message(state->handle, msg, 0);
goto done;
error_del_resp:
nlmsg_free(msg);
done:
return ret;
}
int handle_task_exitted(struct nl_msg *req_msg) {
struct nl_msg *msg = NULL;
struct nlattr *nla;
int ret = 0;
int seq;
struct internal_state* state = get_current_state();
struct rusage *rusage;
// In params
pid_t pid;
int exit_code;
seq = nlmsg_hdr(req_msg)->nlmsg_seq;
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_PID);
if (nla == NULL)
return -EBADMSG;
pid = nla_get_u32(nla);
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_EXIT_CODE);
if (nla == NULL)
return -EBADMSG;
exit_code = nla_get_u32(nla);
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_RUSAGE);
if (nla == NULL)
return -EBADMSG;
//rusage = nl_data_get(nla_get_data(nla));
rusage = nla_data(nla);
if ( task_exitted_callback )
task_exitted_callback(pid, exit_code, rusage);
if ( (ret=prepare_response_message(state->sk, DIRECTOR_ACK, state->gnl_fid, seq, &msg) ) != 0 ) {
goto done;
}
if (ret != 0)
goto error_del_resp;
ret = send_request_message(state->sk, msg, 0);
goto done;
error_del_resp:
nlmsg_free(msg);
done:
return ret;
}
static void
gpcap_conduits_selection_changed (GtkTreeSelection *selection, gpointer user_data)
{
GnomePilotCapplet *gpcap = GNOME_PILOT_CAPPLET (user_data);
GnomePilotCappletPrivate *priv;
ConduitState *state;
priv = gpcap->priv;
state = get_current_state (gpcap, NULL);
gtk_label_set_text (GTK_LABEL (priv->conduit_description), state ? state->description: "");
check_conduits_buttons (gpcap);
}
std::pair< time_type , time_type > do_step( System system )
{
failed_step_checker fail_checker; // to throw a runtime_error if step size adjustment fails
controlled_step_result res = fail;
m_t_old = m_t;
do
{
res = m_stepper.try_step( system , get_current_state() , m_t , get_old_state() , m_dt );
fail_checker(); // check for overflow of failed steps
}
while( res == fail );
m_stepper.stepper().prepare_dense_output();
this->toggle_current_state();
return std::make_pair( m_t_old , m_t );
}
static void
gpcap_conduits_settings (GtkWidget *widget, gpointer user_data)
{
GnomePilotCapplet *gpcap = GNOME_PILOT_CAPPLET (user_data);
GnomePilotCappletPrivate *priv;
ConduitState *state;
GtkTreeIter iter;
priv = gpcap->priv;
state = get_current_state (gpcap, &iter);
if (state->conduit == NULL) {
/* must allocate conduit */
if (gnome_pilot_conduit_management_instantiate_conduit (state->management,
state->pilot,
&state->conduit)
!= GNOME_PILOT_CONDUIT_MGMT_OK) {
gchar *msg = _("Unable to instantiate %s conduit.");
error_dialog (GTK_WINDOW (gpcap), msg, state->name);
return;
}
state->settings_widget2 = gnome_pilot_cdialog_new (state);
}
if (state->settings_widget2 != NULL) {
if (gnome_pilot_cdialog_run_and_close (GNOME_PILOT_CDIALOG (state->settings_widget2), GTK_WINDOW (gpcap))) {
/* pressed ok */
state->sync_type = gnome_pilot_cdialog_sync_type (GNOME_PILOT_CDIALOG (state->settings_widget2));
state->first_sync_type = gnome_pilot_cdialog_first_sync_type (GNOME_PILOT_CDIALOG (state->settings_widget2));
state->enabled = (state->sync_type != GnomePilotConduitSyncTypeNotSet);
state->changed=TRUE;
gtk_list_store_set (GTK_LIST_STORE (priv->conduit_model), &iter,
1, display_sync_type_name (state->enabled, state->sync_type),
-1);
gpcap_save_state (gpcap);
} else {
/* pressed cancel */
gnome_pilot_conduit_display_settings (state->conduit);
}
}
check_conduits_buttons (gpcap);
}
std::pair< time_type , time_type > do_step( System system )
{
const size_t max_count = 1000;
controlled_step_result res = fail;
m_t_old = m_t;
size_t count = 0;
do
{
res = m_stepper.try_step( system , get_current_state() , m_t , get_old_state() , m_dt );
if( count++ == max_count )
throw std::overflow_error( "rosenbrock4 : too much iterations!");
}
while( res == fail );
m_stepper.stepper().prepare_dense_output();
this->toggle_current_state();
return std::make_pair( m_t_old , m_t );
}
static void
gpcap_conduits_disable (GtkWidget *widget, gpointer user_data)
{
GnomePilotCapplet *gpcap = GNOME_PILOT_CAPPLET (user_data);
GnomePilotCappletPrivate *priv;
ConduitState *state;
GtkTreeIter iter;
priv = gpcap->priv;
state = get_current_state (gpcap, &iter);
state->enabled=FALSE;
state->changed=TRUE;
gtk_list_store_set (GTK_LIST_STORE (priv->conduit_model), &iter,
0, state->name,
1, display_sync_type_name (FALSE, GnomePilotConduitSyncTypeNotSet),
-1);
check_conduits_buttons (gpcap);
gpcap_save_state (gpcap);
}
void calc_state( time_type t , StateOut &x )
{
m_stepper.stepper().calc_state( t , x , get_old_state() , m_t_old , get_current_state() , m_t );
}
void calc_state( time_type t , const StateOut &x ) const
{
m_stepper.calc_state( x , t , get_old_state() , m_t_old , get_current_state() , m_t );
}
const state_type& current_state( void ) const
{
return get_current_state();
}
void calc_state( time_type t , const StateOut &x ) const
{
m_stepper.stepper().calc_state( t , x , get_old_state() , get_old_deriv() , m_t_old ,
get_current_state() , get_current_deriv() , m_t );
}
int handle_immigration_confirmed(struct nl_msg *req_msg) {
struct nl_msg *msg = NULL;
struct nlattr *nla;
int ret = 0;
int seq;
struct internal_state* state = get_current_state();
// In params
int uid;
int slot_index;
char* name;
pid_t local_pid;
pid_t remote_pid;
unsigned long jiffies;
seq = nlmsg_hdr(req_msg)->nlmsg_seq;
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_UID);
if (nla == NULL)
return -EBADMSG;
uid = nla_get_u32(nla);
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_INDEX);
if (nla == NULL)
return -EBADMSG;
slot_index = nla_get_u32(nla);
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_NAME);
if (nla == NULL)
return -EBADMSG;
//name = nl_data_get(nla_get_data(nla));
name = nla_data(nla);
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_JIFFIES);
if (nla == NULL)
return -EBADMSG;
jiffies = nla_get_u64(nla);
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_PID);
if (nla == NULL)
return -EBADMSG;
local_pid = nla_get_u32(nla);
nla = nlmsg_find_attr(nlmsg_hdr(req_msg), sizeof(struct genlmsghdr), DIRECTOR_A_REMOTE_PID);
if (nla == NULL)
return -EBADMSG;
remote_pid = nla_get_u32(nla);
//printf("NPM CALLED FOR NAME: %s\n", name);
if ( immigration_confirmed_callback )
immigration_confirmed_callback(uid, slot_index, name, jiffies, local_pid, remote_pid);
if ( (ret=prepare_response_message(state->sk, DIRECTOR_ACK, state->gnl_fid, seq, &msg) ) != 0 ) {
goto done;
}
ret = send_request_message(state->sk, msg, 0);
goto done;
error_del_resp:
nlmsg_free(msg);
done:
return ret;
}
