/* 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; }