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));
}
