void as_netstream::advance(float delta_time) { stream_event ev; while(m_event.pop(&ev)) { // printf("pop status: %s %s\n", ev.level.c_str(), ev.code.c_str()); // keep this alive during execution! gc_ptr<as_object> this_ptr(this); as_value function; if (get_member("onStatus", &function)) { gc_ptr<as_object> infoObject = new as_object(get_player()); infoObject->set_member("level", s_netstream_event_level[ev.level].c_str()); infoObject->set_member("code", s_netstream_event_code[ev.code].c_str()); as_environment env(get_player()); env.push(infoObject.get_ptr()); call_method(function, &env, this, 1, env.get_top_index()); } if (ev.code == playStop || ev.code == playStreamNotFound) { get_root()->remove_listener(this); } } }
void players::on_player_private_msg(int player_id, int reciever_id, std::string const& text) { if (player::ptr player_ptr = get_player(player_id)) { if (player::ptr reciever_ptr = get_player(reciever_id)) { container_execute_handlers(player_ptr, &player_events::on_private_msg_i::on_private_msg, reciever_ptr, text); } } }
// called from root // To check up presence of data which have come from a network void as_xmlsock::advance(float delta_time) { assert(m_ns); if (m_ns->is_readable()) { gameswf::tu_string str; m_ns->read_line(&str, XML_MAXDATASIZE, XML_TIMEOUT); // If the connection has been gracefully closed, // the size of return value is zero if (str.size() == 0) { close(); as_value function; if (get_member("onClose", &function)) { as_environment env(get_player()); call_method(function, &env, as_value(), 0, env.get_top_index()); } } else { as_value function; if (get_member("onData", &function)) { as_environment env(get_player()); env.push(str); call_method(function, &env, as_value(), 1, env.get_top_index()); } } } }
void players::on_player_click_player(int player_id, int clicked_player_id, samp::click_source source) { if (player::ptr player_ptr = get_player(player_id)) { if (player::ptr clicked_player_ptr = get_player(clicked_player_id)) { container_execute_handlers(player_ptr, &player_events::on_click_player_i::on_click_player, clicked_player_ptr, source); } } }
void on_pause_activate(GtkToggleAction * action, gpointer user_data) { gboolean pause = gtk_toggle_action_get_active(action); if (player_is_paused(get_player(app)) == pause) return; player_pause(get_player(app)); }
//int move_player() int main() { for(i=0; i<64; i++) { field[i] = 0; } while(1){ fgets(c, 2, stdin); //scanf("%c",&c); if(strstr(c,"w")!=NULL){ setplayer(get_player(field)-8); print_field(field); } if(strstr(c,"s")!=NULL){ setplayer(get_player(field)+8); print_field(field); } if(strstr(c,"a")!=NULL){ setplayer(get_player(field)-1); print_field(field); } if(strstr(c,"d")!=NULL){ setplayer(get_player(field)+1); print_field(field); } } setplayer(9); print_field(field); //printf("Hello world!\n"); return 0; }
void print() { // Column names. cout << "\t a b c d e f g h" << endl; for (int i = BOARD_SIZE - 1; i >= 0; --i) { cout << "\t" << i + 1 << " "; for (int j = 0; j < BOARD_SIZE; ++j) { if (board[i][j] != NULL) { board[i][j]->print(); } else { wcout << L" "; } } // Black Player turn if (i == 6 && get_player()) { cout << " Black"; } // White Plyer turn else if (i == 1 && !get_player()) { cout << " White"; } cout << endl; } cout << endl; }
void render_player(SDL_Surface* surface) { SDL_Surface *image = IMG_Load("img/character1.png"); if(image == NULL) { fprintf(stderr, "Unable to load image - reason: %s\n", SDL_GetError()); return; } /* * Palettized screen modes will have a default palette (a standard * 8*8*4 colour cube), but if the image is palettized as well we can * use that palette for a nicer colour matching */ if (image->format->palette && surface->format->palette) { SDL_SetColors(surface, image->format->palette->colors, 0, image->format->palette->ncolors); } SDL_Rect dest; dest.x = get_player()->x; dest.y = get_player()->y; dest.w = image->w; dest.h = image->h; if(SDL_BlitSurface(image,NULL, surface, &dest) < 0) { fprintf(stderr, "%s\n", SDL_GetError()); } SDL_UpdateRect(surface, dest.x,dest.y,dest.w, dest.h); SDL_FreeSurface(image); }
void instance::start() { log_->debugStream() << "players are ready, starting turn"; // start the first player's turn, and track them active_puppet_ = puppets_.front(); active_player_ = get_player(active_puppet_); waiting_puppet_ = puppets_.back(); waiting_player_ = get_player(waiting_puppet_); log_->debugStream() << "it's now " << active_player_->get_username() << "'s turn"; { Event evt(EventUID::StartTurn); send(active_player_, evt); } { Event evt(EventUID::TurnStarted); evt.setProperty("P", active_puppet_->getUID()); send(waiting_player_, evt); } for (auto puppet : puppets_) { puppet->live(); draw_spells(puppet, 4); } started_ = true; }
/** * \brief The fonction called when the the oxygen gauge changes. * \param level The level of the gauge. */ void ptb::cold_gauge_component::on_cold_gauge_changed(double level) { if ( get_player() != NULL ) get_gauge().set_level ( s_bar_length * level / get_player().get_cold_gauge().get_max_value() ); } // cold_gauge_component::on_cold_gauge_changed()
void players::on_player_death(int player_id, int killer_id, int reason) { if (player::ptr player_ptr = get_player(player_id)) { if (player_ptr->block_get()) return; container_execute_handlers(player_ptr, &player_events::on_death_i::on_death, get_player(killer_id), reason); container_execute_handlers(player_ptr, &player_events::on_death_post_i::on_death_post, get_player(killer_id), reason); } }
character *sprite_instance::add_empty_movieclip ( const char *name, int depth ) { cxform color_transform; matrix matrix; // empty_sprite_def will be deleted during deliting sprite sprite_definition *empty_sprite_def = new sprite_definition ( get_player(), NULL ); sprite_instance *sprite = new sprite_instance ( get_player(), empty_sprite_def, m_root, this, 0 ); sprite->set_name ( name ); m_display_list.add_display_object ( sprite, depth, true, color_transform, matrix, 0.0f, 0, 0 ); return sprite; }
void process_armageddon(void) { struct PlayerInfo *player; struct Dungeon *dungeon; struct Thing *heartng; long i; SYNCDBG(6,"Starting"); //_DK_process_armageddon(); return; if (game.armageddon_cast_turn == 0) return; if (game.armageddon.count_down+game.armageddon_cast_turn > game.play_gameturn) { if (player_cannot_win(game.armageddon_caster_idx)) { // Stop the armageddon if its originator is just losing game.armageddon_cast_turn = 0; } } else if (game.armageddon.count_down+game.armageddon_cast_turn == game.play_gameturn) { for (i=0; i < PLAYERS_COUNT; i++) { player = get_player(i); if (player_exists(player)) { if (player->field_2C == 1) reveal_whole_map(player); } } } else if (game.armageddon.count_down+game.armageddon_cast_turn < game.play_gameturn) { for (i=0; i < PLAYERS_COUNT; i++) { player = get_player(i); if ( (player_exists(player)) && (player->field_2C == 1) ) { dungeon = get_dungeon(player->id_number); if ((player->victory_state == VicS_Undecided) && (dungeon->num_active_creatrs == 0)) { event_kill_all_players_events(i); set_player_as_lost_level(player); if (is_my_player_number(i)) LbPaletteSet(engine_palette); heartng = get_player_soul_container(player->id_number); if (thing_exists(heartng)) { heartng->health = -1; } } } } } }
/** * \brief Initialize the component. */ void ptb::score_component::build() { if ( get_player() != NULL ) { std::ostringstream oss; oss << game_variables::get_score(get_player().get_index()); m_score.create(m_font, oss.str()); m_score->set_intensity(1, 0.8, 0); } super::build(); } // score_component::build()
DungeonMap::DungeonMap(Map* map) : m_map(map), m_minimap( POS_X, POS_Y, WIDTH, HEIGHT ), m_centerX(get_player()->player()->x), m_centerY(get_player()->player()->y), m_arrowTexture(cache::loadTexture("UI/Arrow_Big.png")), m_mapTexture(cache::loadTexture("UI/Map.png")) { m_minimap.updatePosition(m_map, m_centerX, m_centerY, m_centerX, m_centerY); }
bool FBVLC_Win::onWindowAttached( FB::AttachedEvent* evt, FB::PluginWindowlessWin* w ) { vlcOpen(); if( get_player().is_open() ) { vlc::vmem::open( &get_player().basic_player() ); } onWindowResized( 0, w ); applyPlayerOptions(); return true; }
void Chimera::vlcClose() { get_player().stop(); if ( get_player().is_open() ) { get_player().unregister_callback( this ); get_player().close(); } if ( m_libvlc ) { QmlVlcConfig::instance().releaseLibvlcInstance( m_libvlc ); m_libvlc = 0; } }
/** * \brief Set all signals to listen. */ void ptb::cold_gauge_component::init_signals() { add_signal ( get_player().get_signals().enters_cold_zone.connect ( boost::bind(&ptb::gauge_component::on_enters_zone, this) )); add_signal ( get_player().get_signals().leaves_cold_zone.connect ( boost::bind(&ptb::gauge_component::on_leaves_zone, this) )); add_signal ( get_player().get_signals().cold_gauge_changed.connect ( boost::bind (&ptb::cold_gauge_component::on_cold_gauge_changed, this,_1) ) ); } // cold_gauge_component::init_signals()
/** * Informs if players plyr1_idx and plyr2_idx creatures are tolerating each other. * This is similar to mutual alliance, but differs in conditions on nonexisting and neutral player. * @param plyr1_idx Index of the first player. * @param plyr2_idx Index of the second player. * @return True if the players creatures are tolerating each other; false otherwise. */ TbBool players_creatures_tolerate_each_other(PlayerNumber plyr1_idx, PlayerNumber plyr2_idx) { struct PlayerInfo *player1,*player2; // Player is always tolerating fellow creatures if (plyr1_idx == plyr2_idx) return true; // And neutral player creatures are like fellow creatures if ((plyr1_idx == game.neutral_player_num) || (plyr2_idx == game.neutral_player_num)) return true; player1 = get_player(plyr1_idx); player2 = get_player(plyr2_idx); // Check if we're allied return ((player1->allied_players & (1<<plyr2_idx)) != 0) && ((player2->allied_players & (1<<plyr1_idx)) != 0); }
int Cnew_tug::on_card_act(sprite_t* p, int type, int pos) { Cplayer* p_player = NULL; p_player = get_player(p); if (p_player == NULL) { return 0; } card_t card_info1 = {}; card_info1.id = -1; card_info1.type = type; card_info1.value = 0; p_player->act_bout_card(pos); int cardid = p_player->get_bout_cardid(); card_t card_info2 = (*cards_info)[cardid]; int result = compare(card_info1, card_info2); if (result != WIN) { p_player->update_life_dec(1); } notify_act_card(p->id, type, pos); process_game_result(); return 0; }
int is_player(char c) { char player; player = get_player(NULL); return (c == player || c == player - 32); }
void BallSpawnTower::spawn(){ Minion* ball=MinionCreator::get_cur_object()->create("Ball"); math::vec3<double> recruit_pos(x*Map::CUBE_SIZE-0.15*size, y*Map::CUBE_SIZE+0.093*size, z*Map::CUBE_SIZE+0.5*size); math::vec3<double> relative_pos=recruit_pos-math::vec3<double>(pos.get_pos().x, pos.get_pos().y,pos.get_pos().z); relative_pos.rotate_by_y(90.0*get_rotate_int()); ball->set_pos(math::vec3<double>(pos.get_pos().x+relative_pos.x, pos.get_pos().y+relative_pos.y, pos.get_pos().z+relative_pos.z)); ball->set_vel((200.0/loop_time)*0.02*size* math::vec3<double>::normalize( math::vec3<double>(relative_pos.x,0,relative_pos.z))); ball->max_hp_alter(loop_count*10); ball->upgrade("fire",loop_count); double ball_size=0.16f*size*sqrt(ball->get_hp()/100.0); if(ball_size>0.9)ball_size=0.9; ball->set_size(ball_size); ball->set_player(get_player()); ball->create_minion(); }
bool players::on_player_request_spawn(int player_id) { if (player::ptr player_ptr = get_player(player_id)) { return container_execute_handlers(player_ptr, &player_events::on_request_spawn_i::on_request_spawn); } // Может быть ботом return true; }
TbBool attempt_anger_job_join_enemy(struct Thing *creatng) { struct Thing *heartng; int i, n; n = ACTION_RANDOM(PLAYERS_COUNT); for (i=0; i < PLAYERS_COUNT; i++, n=(n+1)%PLAYERS_COUNT) { if ((n == game.neutral_player_num) || (n == creatng->owner)) continue; struct PlayerInfo *player; player = get_player(n); if (!player_exists(player) || (player->field_2C != 1)) continue; heartng = get_player_soul_container(n); if (thing_exists(heartng) && (heartng->active_state != 3)) { TRACE_THING(heartng); if (creature_can_navigate_to(creatng, &heartng->mappos, NavRtF_Default)) { change_creature_owner(creatng, n); anger_set_creature_anger_all_types(creatng, 0); } } } return false; }
void setup_exchange_player_number(void) { struct PlayerInfo *player; struct Packet *pckt; int i,k; SYNCDBG(6,"Starting"); clear_packets(); player = get_my_player(); pckt = get_packet_direct(my_player_number); set_packet_action(pckt, PckA_InitPlayerNum, player->field_2C, settings.video_rotate_mode, 0, 0); if (LbNetwork_Exchange(pckt)) ERRORLOG("Network Exchange failed"); k = 0; for (i=0; i<NET_PLAYERS_COUNT; i++) { pckt = get_packet_direct(i); if ((net_player_info[i].active) && (pckt->action == PckA_InitPlayerNum)) { player = get_player(k); player->id_number = k; player->field_0 |= 0x01; if (pckt->field_8 < 1) player->field_4B5 = 2; else player->field_4B5 = 5; player->field_2C = pckt->field_6; init_player(player, 0); strncpy(player->field_15,net_player[i].name,sizeof(struct TbNetworkPlayerName)); k++; } } }
int FBVLC::add_playlist_item( const std::string& mrl, const std::vector<std::string>& options ) { const std::string proxy_str = detectHttpProxy( mrl ); //trusted options std::vector<const char*> trusted_opts; if( !proxy_str.empty() ) { trusted_opts.push_back( proxy_str.c_str() ); } //untrusted options std::vector<const char*> untrusted_opts; for( unsigned i = 0; i < options.size(); ++i ) { if( isTrustedOption( options[i] ) ) trusted_opts.push_back( options[i].c_str() ); else untrusted_opts.push_back( options[i].c_str() ); } /*another trusted and untrusted options could be added here*/ const char** untrusted_optv = untrusted_opts.empty() ? 0 : &untrusted_opts[0]; const char** trusted_optv = trusted_opts.empty() ? 0 : &trusted_opts[0]; return get_player().add_media( mrl.c_str(), untrusted_opts.size(), untrusted_optv, trusted_opts.size(), trusted_optv ); }
static t_player *choose_target(void) { t_player *to_return; t_player *p; float min_dist; float player_dist; size_t i; i = 0; min_dist = 10000; while (i < get_shmem()->nb_user) { p = get_player(i); if (p->pid != getpid() && p->team != get_current_player()->team) { player_dist = dist_players(p, get_current_player()); if (player_dist < min_dist) { to_return = p; min_dist = player_dist; } } ++i; } return (to_return); }
void Client::check_need_update() { fvec3 player_pos = get_player()->get_viewpoint(); if (get_fvec3_distance(last_player_pos - player_pos) >= CHUNK_UPDATE_TRIGGER_DISTANCE) { get_world()->update_render(&player_pos); last_player_pos = player_pos; } }
int Cnew_tug::update_db_player_info_callback(sprite_t *p, uint32_t ret_code) { Cplayer* p_player = NULL; p_player = get_player(p); if (p_player == NULL) { DEBUG_LOG("%lu player uid=%d aready leave",m_grp->id, p->id); return 0; } if (ret_code != 0) { p_player->set_exp(0); p_player->set_xiaomee(0); p_player->set_medal(0); } recv_cnt++; DEBUG_LOG("%lu\tCnew_tug:: handle db return return_cnt: %d", m_grp->id, recv_cnt); if (recv_cnt == send_cnt) { notify_game_result(); send_cnt = 0; recv_cnt = 0; return GER_end_of_game; } return 0; }
void concater_rep::typeset_anim_repeat (tree t, path ip) { if (N(t) != 1) { typeset_error (t, ip); return; } player pl= get_player (env->get_animation_ip (ip)); box b= typeset_as_concat (env, t[0], descend (ip, 0)); print (anim_repeat_box (ip, b, pl)); }