/* Advance the simulation by one time-step. */
static void
tick (void)
{
int i;
for (i = 0; i < num_particles; ++i)
put_particle (i, black);
update_state ();
for (i = 0; i < num_particles; ++i)
put_particle (i, white);
}
static void
buffer_delete_range (GtkTextBuffer *buffer,
GtkTextIter *start,
GtkTextIter *end,
gpointer user_data)
{
update_state (buffer, E_BUFFER_TAGGER_STATE_INSDEL, TRUE);
remove_tag_if_present (buffer, start);
remove_tag_if_present (buffer, end);
}
static void
buffer_insert_text (GtkTextBuffer *buffer,
GtkTextIter *location,
gchar *text,
gint len,
gpointer user_data)
{
update_state (buffer, E_BUFFER_TAGGER_STATE_INSDEL, TRUE);
remove_tag_if_present (buffer, location);
}
void run(SDL_Renderer *rend, State &s) {
int time_prev = 0;
int time = SDL_GetTicks();
// main loop
bool keep_running = true;
while (keep_running) {
time_prev = time;
time = SDL_GetTicks();
double dt = (time - time_prev) * 0.001; // in seconds
// Process input
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT)
keep_running = false;
else if (event.type == SDL_KEYDOWN) {
switch ( event.key.keysym.sym ) {
case SDLK_ESCAPE:
keep_running = false;
break;
}
}
}
const Uint8 *keyboard_state = SDL_GetKeyboardState(NULL);
// Move right
if (keyboard_state[SDL_SCANCODE_RIGHT]) {
s.player.b.x += dt * 200.0;
if (s.player.b.x > s.w-1) s.player.b.x = s.w-1;
}
// Move left
if (keyboard_state[SDL_SCANCODE_LEFT]) {
s.player.b.x -= dt * 200.0;
if (s.player.b.x < 0) s.player.b.x = 0;
}
// Shoot
if (keyboard_state[SDL_SCANCODE_SPACE] && s.can_shoot) {
s.can_shoot = false;
s.bullet.x = s.player.b.x;
s.bullet.y = s.player.b.y - s.player.b.size;
}
// Update the state
update_state(s, dt);
// Draw
render(rend, s);
SDL_Delay(2);
} // end of the main loop
}
void SliderViewImpl::on_pointer_thumb_press(PointerEvent &e)
{
if (_state_disabled)
return;
_state_pressed = true;
update_state();
mouse_down_mode = mouse_down_thumb_drag;
thumb_move_start_position = _position;
mouse_drag_start_pos = e.pos(track.get());
}
/* Stride Prefetcher */
void stride_prefetcher(struct cache_t *cp, md_addr_t addr) {
#if 0
int counter = 0;
while (pc) {
if (pc & 1)
printf("1");
else
printf("0");
if (counter == 0 && pc&1 != 0 || counter == 1 && pc&1 != 0 || counter == 2 && pc&1 != 0) assert(0);
pc >>= 1;
counter++;
}
printf("\n");
#endif
#if 1
md_addr_t pc = get_PC();
// The last three bits do not change
unsigned int index = (pc >> 3) & (cp->prefetch_type - 1);
unsigned int tag = (pc >> (log_base2(cp->prefetch_type) + 3));
#endif
// Scenario 1
if (cp->rpt[index].tag != tag) {
cp->rpt[index].tag = tag;
cp->rpt[index].prev_addr = addr;
cp->rpt[index].stride = 0;
cp->rpt[index].state = initial;
cp->rpt[index].is_neg = 0;
} else {
// Scenario 2
md_addr_t prev_addr = cp->rpt[index].prev_addr;
md_addr_t new_stride = MAX(addr, prev_addr) - MIN(addr, prev_addr);
int new_is_neg = prev_addr > addr ? 1 : 0;
int stride_condition = new_stride == cp->rpt[index].stride && new_is_neg == cp->rpt[index].is_neg;
assert(stride_condition == 1 || stride_condition == 0);
cp->rpt[index].state = update_state(cp->rpt[index].state, stride_condition);
if (!stride_condition && (cp->rpt[index].state == transient || cp->rpt[index].state== no_prediction)) {
cp->rpt[index].stride = new_stride;
cp->rpt[index].is_neg = new_is_neg;
}
cp->rpt[index].prev_addr = addr;
if (cp->rpt[index].state != no_prediction) {
if (cp->rpt[index].is_neg) {
prefetch(cp, addr - cp->rpt[index].stride);
} else {
prefetch(cp, addr + cp->rpt[index].stride);
}
}
}
}
void EDF_READEROBJ::session_stop(void)
{
if (edffile!=INVALID_HANDLE_VALUE) state=1;
else state=0;
if (hDlg==ghWndToolbox)
{
update_state(hDlg,state);
add_to_listbox(hDlg,IDC_LIST, "File-Read paused");
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
}
}
void ahrs_update_accel(void) {
struct FloatVect3 imu_g;
ACCELS_FLOAT_OF_BFP(imu_g, imu.accel);
const float alpha = 0.92;
ahrs_impl.lp_accel = alpha * ahrs_impl.lp_accel +
(1. - alpha) *(FLOAT_VECT3_NORM(imu_g) - 9.81);
const struct FloatVect3 earth_g = {0., 0., -9.81 };
const float dn = 250*fabs( ahrs_impl.lp_accel );
struct FloatVect3 g_noise = {1.+dn, 1.+dn, 1.+dn};
update_state(&earth_g, &imu_g, &g_noise);
reset_state();
}
void mqttclient_init(void) {
_mqttclient_mqtt_init();
timer_set(&_keep_alive_timer, CLOCK_SECOND * MQTT_KEEP_ALIVE / 2);
timer_set(&_dht_timer, CLOCK_SECOND * MQTT_PUBLISH_PERIOD);
timer_set(&_disconnected_wait_timer, CLOCK_SECOND);
actsig_init(&_broker_signal,
CONFIG_SIGNAL_LED_PIN,
&CONFIG_SIGNAL_LED_DDR,
&CONFIG_SIGNAL_LED_PORT,
CONFIG_SIGNAL_LED_INTERVAL);
update_state(MQTTCLIENT_BROKER_DISCONNECTED);
}
void mp_nav_destroy(struct MPContext *mpctx)
{
osd_set_nav_highlight(mpctx->osd, NULL);
if (!mpctx->nav_state)
return;
mp_input_disable_section(mpctx->input, "discnav");
mp_input_disable_section(mpctx->input, "discnav-menu");
pthread_mutex_destroy(&mpctx->nav_state->osd_lock);
talloc_free(mpctx->nav_state);
mpctx->nav_state = NULL;
update_state(mpctx);
}
void AP_Gimbal::receive_feedback(mavlink_channel_t chan, mavlink_message_t *msg)
{
mavlink_gimbal_report_t report_msg;
mavlink_msg_gimbal_report_decode(msg, &report_msg);
_gimbalParams.set_channel(chan);
if(report_msg.target_system != 1) {
// gimbal must have been power cycled or reconnected
_gimbalParams.reset();
_gimbalParams.set_param(GMB_PARAM_GMB_SYSID, 1);
return;
}
_gimbalParams.update();
if(!_gimbalParams.initialized()){
return;
}
_last_report_msg_ms = hal.scheduler->millis();
extract_feedback(report_msg);
update_mode();
update_state();
switch(_mode) {
case GIMBAL_MODE_IDLE:
_gimbalParams.set_param(GMB_PARAM_GMB_POS_HOLD, 0);
break;
case GIMBAL_MODE_POS_HOLD:
_gimbalParams.set_param(GMB_PARAM_GMB_POS_HOLD, 1);
break;
case GIMBAL_MODE_POS_HOLD_FF:
case GIMBAL_MODE_STABILIZE:
send_control(chan);
_gimbalParams.set_param(GMB_PARAM_GMB_POS_HOLD, 0);
default:
break;
}
float max_torque;
_gimbalParams.get_param(GMB_PARAM_GMB_MAX_TORQUE, max_torque, 0);
if (max_torque != _max_torque && max_torque != 0) {
_max_torque = max_torque;
}
if (!hal.util->get_soft_armed() || joints_near_limits()) {
_gimbalParams.set_param(GMB_PARAM_GMB_MAX_TORQUE, _max_torque);
} else {
_gimbalParams.set_param(GMB_PARAM_GMB_MAX_TORQUE, 0);
}
}
void ButtonViewImpl::on_pointer_release(PointerEvent &e)
{
_state_pressed = false;
if (_state_disabled)
return;
update_state();
if (_func_clicked)
{
if (button->geometry().border_box().contains(e.local_pos())) // Only allow click when mouse released over component
_func_clicked();
}
}
ButtonState Button::update(touchPosition stylus) {
if (state != BUTTON_DISABLED) {
ButtonState old_state = state;
update_state(stylus);
if (state != old_state) {
draw();
}
}
return state;
}
void CheckBoxView_Impl::on_pointer_release(PointerEvent &e)
{
_state_pressed = false;
if (_state_disabled)
return;
if (checkbox->geometry().border_box().contains(e.local_pos())) // Only allow click when mouse released over component
{
_checked_state = !_checked_state;
if (_func_state_changed)
_func_state_changed();
}
update_state();
}
void EDF_READEROBJ::session_start(void)
{
if ((edffile!=INVALID_HANDLE_VALUE)&&(outports>0))
{
state=2;
if (hDlg==ghWndToolbox)
{
update_state(hDlg,state);
add_to_listbox(hDlg,IDC_LIST, "File-Read started.");
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), FALSE);
}
}
}
bool AircraftSim::Update() {
update_state();
integrate();
update_mode();
task_manager.update(state, state_last);
task_manager.update_idle(state);
task_manager.update_auto_mc(state, fixed_zero);
state_last = state;
state.flying_state_moving(state.Time);
if (!far()) {
wait_prompt(time());
awp++;
if (awp>= w.size()) {
return false;
}
task_manager.setActiveTaskPoint(awp);
}
if (goto_target) {
if (task_manager.getActiveTaskPointIndex() < awp) {
// manual advance
task_manager.setActiveTaskPoint(awp);
if (verbose>1) {
printf("# manual advance to %d\n",awp);
}
}
}
if (task_manager.getActiveTaskPointIndex() > awp) {
awp = task_manager.getActiveTaskPointIndex();
}
if (awp>= w.size()) {
return false;
}
if (short_flight && awp>=1) {
return false;
}
if (task_manager.get_common_stats().task_finished) {
return false;
}
return true;
}
static void on_cbs_put_token_complete_callback(void* context, CBS_OPERATION_RESULT operation_result, unsigned int status_code, const char* status_description)
{
#ifdef NO_LOGGING
UNUSED(status_code);
UNUSED(status_description);
#endif
AUTHENTICATION_INSTANCE* instance = (AUTHENTICATION_INSTANCE*)context;
// Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_095: [`instance->is_sas_token_refresh_in_progress` and `instance->is_cbs_put_token_in_progress` shall be set to FALSE]
instance->is_cbs_put_token_in_progress = false;
// Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_091: [If `result` is CBS_OPERATION_RESULT_OK `instance->state` shall be set to AUTHENTICATION_STATE_STARTED and `instance->on_state_changed_callback` invoked]
if (operation_result == CBS_OPERATION_RESULT_OK)
{
update_state(instance, AUTHENTICATION_STATE_STARTED);
}
else
{
LogError("CBS reported status code %u, error: '%s' for put-token operation for device '%s'", status_code, status_description, instance->device_id);
// Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_092: [If `result` is not CBS_OPERATION_RESULT_OK `instance->state` shall be set to AUTHENTICATION_STATE_ERROR and `instance->on_state_changed_callback` invoked]
update_state(instance, AUTHENTICATION_STATE_ERROR);
// Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_094: [If `result` is not CBS_OPERATION_RESULT_OK and `instance->is_sas_token_refresh_in_progress` is TRUE, `instance->on_error_callback`shall be invoked with AUTHENTICATION_ERROR_SAS_REFRESH_FAILED]
if (instance->is_sas_token_refresh_in_progress)
{
notify_error(instance, AUTHENTICATION_ERROR_SAS_REFRESH_FAILED);
}
// Codes_SRS_IOTHUBTRANSPORT_AMQP_AUTH_09_093: [If `result` is not CBS_OPERATION_RESULT_OK and `instance->is_sas_token_refresh_in_progress` is FALSE, `instance->on_error_callback`shall be invoked with AUTHENTICATION_ERROR_AUTH_FAILED]
else
{
notify_error(instance, AUTHENTICATION_ERROR_AUTH_FAILED);
}
}
instance->is_sas_token_refresh_in_progress = false;
}
bool_t search_cntn_unit(mem_state_t *ptr_state,size_t nbytes,size_t ncount)
{
size_t temp_ncount = 1;/*连续单元数量*/
size_t unit_size = 0;
bool_t find_unit = false;/*是否找到连续内存单元标志*/
obj **my_free_list = NULL;
obj *p = NULL;/*当前节点*/
obj *pre_p = NULL; /*p节点前面的一个节点*/
my_free_list = free_list + freelist_index(nbytes);
pre_p = p = *my_free_list;
unit_size = round_up(nbytes);
while (p && p->free_list_link != NULL)
{
size_t i = 1;/*扫描计数，q为基准，已经扫描的元素计数*/
int temp_byte = 0;
/*找到第一个连续的内存空间*/
obj* q = p->free_list_link;
i++;
temp_byte = (q - p)*SIZE_OF_POINTER;/*计算两个地址相差的字节数*/
/*找到连续空间的最后一个内存单元*/
while ((temp_byte == unit_size*(i-1)) && q != NULL)
{
if (q->free_list_link != NULL)
{
q = q->free_list_link;
i++;
/*计算两个地址相差的字节数*/
temp_byte = (q - p)*SIZE_OF_POINTER;
}
temp_ncount++;
}
/*不是连续内存单元*/
if (1 == temp_ncount)
{
pre_p = p;
p = p->free_list_link;
}
/*找到连续单元长度大于等于ncount*/
if (temp_ncount >= ncount)
{
update_state(ptr_state,p,pre_p,temp_ncount);
find_unit = true;
break;
}
}
return find_unit;
}
void EDF_READEROBJ::session_reset(void)
{
if (edffile!=INVALID_HANDLE_VALUE)
{
state=1;
SetFilePointer(edffile,256+header.channels*256,NULL,FILE_BEGIN);
if (hDlg==ghWndToolbox)
{
update_state(hDlg,state);
add_to_listbox(hDlg,IDC_LIST, "File-Read stopped");
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
}
} else state=0;
}
void m6809_base_device::device_reset()
{
m_int_state = 0;
m_nmi_state = CLEAR_LINE;
m_irq_state[0] = CLEAR_LINE;
m_irq_state[1] = CLEAR_LINE;
DPD = 0; /* Reset direct page register */
CC |= CC_II; /* IRQ disabled */
CC |= CC_IF; /* FIRQ disabled */
PCD = RM16(0xfffe);
update_state();
}
void
Snes9xNetplayDialog::settings_to_dialog ()
{
set_entry_text ("rom_image", config->netplay_last_rom);
set_entry_text ("ip_entry", config->netplay_last_host);
set_check ("sync_reset", config->netplay_sync_reset);
set_check ("send_image", config->netplay_send_rom);
set_spin ("port", config->netplay_last_port);
set_spin ("default_port", config->netplay_default_port);
set_spin ("frames_behind", config->netplay_max_frame_loss);
set_check ("connect_radio", !config->netplay_is_server);
set_check ("host_radio", config->netplay_is_server);
update_state ();
}
void Pitch::save_game()
{
if(game->get_game_state() == Game::INCORRECT)
{
QMessageBox msgBox;
msgBox.setWindowTitle(M_DEF_TITLE);
msgBox.setText(tr("Odmawiam zapisania niepoprawnego układu planszy."));
msgBox.exec();
return;
}
saving = true;
blocked = true;
QString file_name = QFileDialog::getSaveFileName(this, tr("Zapisz grę"),
"", tr("Pliki zapisu gry (*.sav)"));
QFile file(file_name);
if(!file.open(QIODevice::WriteOnly))
{
QMessageBox msgBox;
msgBox.setWindowTitle(M_DEF_TITLE);
msgBox.setText(tr("Nie udało się dokonać zapisu do pliku."));
msgBox.exec();
blocked = false;
saving = false;
return;
}
QList<quint8> pos_list;
QDataStream stream(&file);
for(int i = 0; i < 14; i++)
{
pos_list.append(game->get_elem_pos(i));
}
pos_list.append(game->get_ball_owner(Game::WHITE));
pos_list.append(game->get_ball_owner(Game::BLACK));
QList<QPair<quint8, quint8> > move_list;
for(int i = 0; i < game->moves_back_stored(); i++)
{
Game::move m = game->get_move(i);
QPair<quint8, quint8> p(m.first, m.second);
move_list.append(p);
}
stream << (quint8) mode << pos_list << move_list << (quint8) game->get_act_player();
stream << (bool) game->get_white_made_move() << (quint16) game->get_turn();
stream << (bool) game->get_passed() << (quint8) game->get_moves_made();
file.close();
blocked = false;
saving = false;
update_state();
}
static void
nm_connectivity_check_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
NMConnectivity *self;
NMConnectivityPrivate *priv;
NMConnectivityState new_state;
const char *nm_header;
self = NM_CONNECTIVITY (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
g_object_unref (self);
priv = NM_CONNECTIVITY_GET_PRIVATE (self);
if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) {
nm_log_info (LOGD_CONCHECK, "Connectivity check for uri '%s' failed with '%s'.",
priv->uri, msg->reason_phrase);
new_state = NM_CONNECTIVITY_LIMITED;
goto done;
}
/* Check headers; if we find the NM-specific one we're done */
nm_header = soup_message_headers_get_one (msg->response_headers, "X-NetworkManager-Status");
if (g_strcmp0 (nm_header, "online") == 0) {
nm_log_dbg (LOGD_CONCHECK, "Connectivity check for uri '%s' with Status header successful.", priv->uri);
new_state = NM_CONNECTIVITY_FULL;
} else if (msg->status_code == SOUP_STATUS_OK) {
/* check response */
if (msg->response_body->data && (g_str_has_prefix (msg->response_body->data, priv->response))) {
nm_log_dbg (LOGD_CONCHECK, "Connectivity check for uri '%s' successful.",
priv->uri);
new_state = NM_CONNECTIVITY_FULL;
} else {
nm_log_info (LOGD_CONCHECK, "Connectivity check for uri '%s' did not match expected response '%s'; assuming captive portal.",
priv->uri, priv->response);
new_state = NM_CONNECTIVITY_PORTAL;
}
} else {
nm_log_info (LOGD_CONCHECK, "Connectivity check for uri '%s' returned status '%d %s'; assuming captive portal.",
priv->uri, msg->status_code, msg->reason_phrase);
new_state = NM_CONNECTIVITY_PORTAL;
}
done:
g_simple_async_result_set_op_res_gssize (simple, new_state);
g_simple_async_result_complete (simple);
update_state (self, new_state);
}
double GSLOptimizer::optimize(unsigned int iter,
const gsl_multimin_fminimizer_type*t,
double ms, double mxs) {
fis_= get_optimized_attributes();
best_score_=std::numeric_limits<double>::max();
unsigned int n= get_dimension();
if (n ==0) {
IMP_LOG(TERSE, "Nothing to optimize" << std::endl);
return get_scoring_function()->evaluate(false);
}
gsl_multimin_fminimizer *s=gsl_multimin_fminimizer_alloc (t, n);
gsl_vector *x= gsl_vector_alloc(get_dimension());
update_state(x);
gsl_vector *ss= gsl_vector_alloc(get_dimension());
gsl_vector_set_all(ss, mxs);
gsl_multimin_function f= internal::create_f_function_data(this);
gsl_multimin_fminimizer_set (s, &f, x, ss);
try {
int status;
do {
--iter;
//update_state(x);
status = gsl_multimin_fminimizer_iterate(s);
if (status) {
IMP_LOG(TERSE, "Ending optimization because of state " << s
<< std::endl);
break;
}
double sz= gsl_multimin_fminimizer_size(s);
status= gsl_multimin_test_size(sz, ms);
update_states();
if (status == GSL_SUCCESS) {
IMP_LOG(TERSE, "Ending optimization because of small size " << sz
<< std::endl);
break;
}
} while (status == GSL_CONTINUE && iter >0);
} catch (AllDone){
}
gsl_vector *ret=gsl_multimin_fminimizer_x (s);
best_score_=gsl_multimin_fminimizer_minimum (s);
write_state(ret);
gsl_multimin_fminimizer_free (s);
gsl_vector_free (x);
return best_score_;
}
void Pitch::end_turn()
{
if(blocked)
return;
if(game->get_edit_mode() || !game->can_end_turn())
{
QMessageBox msgBox;
msgBox.setWindowTitle(M_DEF_TITLE);
msgBox.setText(tr("Nie można zakończyć tury."));
msgBox.exec();
return;
}
clear_shadows();
game->end_turn();
update_state();
}
static void _mqttclient_broker_connect(void) {
struct uip_conn *uc;
uip_ipaddr_t ip;
uip_ipaddr(&ip,
MQTT_BROKER_IP_ADDR0,
MQTT_BROKER_IP_ADDR1,
MQTT_BROKER_IP_ADDR2,
MQTT_BROKER_IP_ADDR3);
uc = uip_connect(&ip, htons(MQTT_BROKER_PORT));
if (uc == NULL) {
return;
}
uc->appstate.conn = &_mqtt;
update_state(MQTTCLIENT_BROKER_CONNECTING);
}
void
ACA_AI::update_ten_hz(int milliseconds)
{
ACA_time_curr = milliseconds;
update_state();
if(mode_curr == ACA_Avoid)
{
apply_avoid();
ACA_time_stamp2 = ACA_time_curr; //keep the unrelated stamp to be updated
}
else
{
ACA_time_stamp = ACA_time_curr; //keep the unrelated stamp to be updated
}
update_rc();
}
static void gdb_exit_cb(G_GNUC_UNUSED GPid pid, gint status, G_GNUC_UNUSED gpointer gdata)
{
GdbState saved_state = gdb_state;
gdb_finalize();
gdb_state = INACTIVE;
if (saved_state == ACTIVE)
show_error(_("GDB died unexpectedly with status %d."), status);
else if (thread_count)
ui_set_statusbar(FALSE, _("Program terminated."));
views_clear();
utils_lock_all(FALSE);
update_state(DS_INACTIVE);
}
void mp_nav_reset(struct MPContext *mpctx)
{
struct mp_nav_state *nav = mpctx->nav_state;
if (!nav)
return;
struct mp_nav_cmd inp = {MP_NAV_CMD_RESUME};
run_stream_control(mpctx, STREAM_CTRL_NAV_CMD, &inp);
osd_set_nav_highlight(mpctx->osd, NULL);
nav->hi_visible = 0;
nav->nav_menu = false;
nav->nav_draining = false;
nav->nav_still_frame = 0;
mp_input_disable_section(mpctx->input, "discnav-menu");
run_stream_control(mpctx, STREAM_CTRL_RESUME_CACHE, NULL);
update_state(mpctx);
}
static char *iftag_else (int argc, char *argv[])
{
/* if we not yet pass for any if-block */
if (token[0] != TOK_IF_OUTSIDE) {
/* if all previous `if' and `elif' give false */
if (token[0] == TOK_IF_NOTYET)
/* now, is time to pass for the `else' */
token[0] = TOK_IF_INSIDE;
/* if some previous `if' or `elif' give true */
else
/* we need to jump the `else' block */
token[0] = TOK_IF_OUTSIDE;
}
/* update parser state */
update_state ();
return NULL;
}
