static void run_penalty_kick_shootout() {
show_message("PENALTY KICK SHOOT-OUT!");
step();
// power off robots and move them out of the field
int i;
for (i = 0; i < NUM_ROBOTS; i++) {
// keep RED_PLAYER_1 and BLUE_GOAL_KEEPER for the shootout
if (i != ATTACKER && i != GOALIE) {
// make them zombies
set_controller(i, "void");
if (robot_translation[i]) {
// move them out of the field but preserve elevation
double elevation = wb_supervisor_field_get_sf_vec3f(robot_translation[i])[Y];
double out_of_field[3] = { 1.0 * i, elevation, 5.0 };
wb_supervisor_field_set_sf_vec3f(robot_translation[i], out_of_field);
}
}
}
// inform robots of the penalty kick shootout
control_data.secondaryState = STATE2_PENALTYSHOOT;
// five penalty shots per team
for (i = 0; i < 5; i++) {
run_penalty_kick(60);
if (check_victory(5 - i)) return;
run_finished_state();
swap_teams_and_scores();
run_penalty_kick(60);
if (check_victory(4 - i)) return;
run_finished_state();
swap_teams_and_scores();
}
if (match_type == FINAL) {
show_message("SUDDEN DEATH SHOOT-OUT!");
// sudden death shots
while (1) {
run_penalty_kick(120);
run_finished_state();
swap_teams_and_scores();
run_penalty_kick(120);
if (check_victory(0)) return;
run_finished_state();
swap_teams_and_scores();
}
}
}
void playsingle_controller::check_time_over(){
bool time_left = gamestate_.tod_manager_.next_turn(gamestate_.gamedata_);
it_is_a_new_turn_ = true;
if(!time_left) {
LOG_NG << "firing time over event...\n";
set_scontext_synced_base sync;
pump().fire("time over");
LOG_NG << "done firing time over event...\n";
//if turns are added while handling 'time over' event
if (gamestate_.tod_manager_.is_time_left()) {
return;
}
if(non_interactive()) {
LOG_AIT << "time over (draw)\n";
ai_testing::log_draw();
}
check_victory();
if (is_regular_game_end()) {
return;
}
end_level_data e;
e.proceed_to_next_level = false;
e.is_victory = false;
set_end_level_data(e);
}
}
possible_end_play_signal playsingle_controller::check_time_over() {
bool b = gamestate_.tod_manager_.next_turn(*resources::gamedata);
it_is_a_new_turn_ = true;
if(!b) {
LOG_NG << "firing time over event...\n";
game_events::fire("time over");
LOG_NG << "done firing time over event...\n";
//if turns are added while handling 'time over' event
if (gamestate_.tod_manager_.is_time_left()) {
return boost::none;
}
if(non_interactive()) {
LOG_AIT << "time over (draw)\n";
ai_testing::log_draw();
}
HANDLE_END_PLAY_SIGNAL( check_victory() );
get_end_level_data().proceed_to_next_level = false;
end_level_struct els = {DEFEAT};
return possible_end_play_signal (els);
//throw end_level_exception(DEFEAT);
}
return boost::none;
}
void play_controller::finish_side_turn()
{
whiteboard_manager_->on_finish_side_turn(current_side());
{ //Block for set_scontext_synced
set_scontext_synced sync(1);
// Ending the turn commits all moves.
undo_stack().clear();
gamestate().board_.end_turn(current_side());
const std::string turn_num = std::to_string(turn());
const std::string side_num = std::to_string(current_side());
// Clear shroud, in case units had been slowed for the turn.
actions::clear_shroud(current_side());
pump().fire("side_turn_end");
pump().fire("side_"+ side_num + "_turn_end");
pump().fire("side_turn_" + turn_num + "_end");
pump().fire("side_" + side_num + "_turn_" + turn_num + "_end");
// This is where we refog, after all of a side's events are done.
actions::recalculate_fog(current_side());
check_victory();
sync.do_final_checkup();
}
mouse_handler_.deselect_hex();
resources::gameboard->unit_id_manager().reset_fake();
gamestate_->init_side_done() = false;
}
void my_init_serveur(t_server *s_info) {
fd_set readfds;
int i = 0;
time_t *t;
struct timeval *time;
create_socket_s(s_info);
s_info->graph = 0;
my_prompt_welc(s_info);
s_info->list = NULL;
s_info->egg = NULL;
create_ele_fct(s_info);
while (check_victory(s_info) != 1) {
time->tv_sec= 1;
FD_ZERO(&readfds);
FD_SET(socket_s, &readfds);
parc_sock(s_info);
s_info->list = parse_list(s_info);
i = 0;
while (socket_com[i].socket != -2) {
if (socket_com[i].socket != -1)
FD_SET(socket_com[i].socket, &readfds);
i++;
}
select_s(s_info, &readfds, time);
}
}
void playsingle_controller::play_human_turn() {
show_turn_dialog();
execute_gotos();
end_turn_enable(true);
while(!end_turn_) {
play_slice();
check_victory();
gui_->draw();
}
}
int incantation(char **av, t_client *cl, t_kernel *kernel)
{
int check;
t_case *c;
(void)av;
check = 0;
c = get_case(kernel, cl->player->pos.y, cl->player->pos.x);
if (check_case_for_incantation(c, cl->player->level))
check = 1;
finish_elevation(c, cl->player->level + check);
send_finish_elevation_to_graphic(kernel, c, cl->player, check);
return (check_victory(kernel));
}
// @save: It isn't mean this is loaded game. it mean whether execute auto-save.
// false: this is first turn of loaded game, true: this isn't first turn or this isn't loaded game.
void playsingle_controller::play_turn(bool save)
{
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
play_side();
check_victory();
// Time has run out
check_time_over();
finish_turn();
}
int main(int argc, char **argv)
{
t_env e;
if ((e.key = ftok(argv[0], 'a')) < 0)
{
perror("ftok");
exit(1);
}
// printf("e.key : %d\n", e.key);
if (argc == 2)
{
init_env(&e, argv[1]);
while (1)
{
printf("ICI\n");
op_sem_proberen(&e);
printf("LA\n");
// printf("heya\n");
if ((*((int*)(e.addr + sizeof(int)))) == 0)
{
check_start(&e);
op_sem_verhogen(&e);
continue ;
}
printf("hey0\n");
test_print(&e);
if (check_elim(&e))
player_lost(&e);
msg_read(&e);
printf("hey1\n");
begin_turn(&e);
op_sem_verhogen(&e);
if ((*((int*)(e.addr + sizeof(int)))) == 1 && check_victory(&e))
{
printf("VICTOIRRRRRRRRE team : %d\n", e.team);
kill_player(&e);
}
printf("leader : %d\n", e.leader);
usleep(500000);
}
}
else
printf("Usage : %s [team]\n", argv[0]);
return (0);
}
// @save: It isn't mean this is loaded game. it mean whether execute auto-save.
// false: this is first turn of loaded game, true: this isn't first turn or this isn't loaded game.
void playsingle_controller::play_turn(bool save)
{
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
for (player_number_ = first_player_; player_number_ <= int(teams_.size()); ++player_number_) {
unit_display::player_number_ = player_number_;
// If a side is empty skip over it.
if (current_team().is_empty()) continue;
try {
save_blocker blocker;
init_side(player_number_ - 1, false, save || (player_number_ != first_player_));
} catch (end_turn_exception) {
if (current_team().is_network() == false) {
turn_info turn_data(player_number_, replay_sender_, undo_stack_);
recorder.end_turn();
turn_data.sync_network();
}
continue;
}
// If a side is dead end the turn.
if (current_team().is_human() && side_units(player_number_) == 0) {
turn_info turn_data(player_number_, replay_sender_, undo_stack_);
recorder.end_turn();
turn_data.sync_network();
continue;
}
play_side(player_number_, save);
finish_side_turn();
check_victory();
//if loading a savegame, network turns might not have reset this yet
loading_game_ = false;
}
// Time has run out
check_time_over();
finish_turn();
}
void playsingle_controller::check_time_over(){
bool b = tod_manager_.next_turn();
it_is_a_new_turn_ = true;
if(!b) {
LOG_NG << "firing time over event...\n";
game_events::fire("time over");
LOG_NG << "done firing time over event...\n";
//if turns are added while handling 'time over' event
if (tod_manager_.is_time_left()) {
return;
}
if(non_interactive()) {
LOG_AIT << "time over (draw)\n";
ai_testing::log_draw();
}
check_victory();
throw end_level_exception(DEFEAT);
}
}
void playsingle_controller::play_turn(bool save)
{
resources::whiteboard->on_gamestate_change();
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
LOG_NG << "turn: " << turn() << "\n";
if(non_interactive())
std::cout << "Turn " << turn() << ":" << std::endl;
for (player_number_ = first_player_; player_number_ <= int(teams_.size()); ++player_number_)
{
// If a side is empty skip over it.
if (current_team().is_empty()) continue;
try {
save_blocker blocker;
init_side(player_number_ - 1);
} catch (end_turn_exception) {
if (current_team().is_network() == false) {
turn_info turn_data(player_number_, replay_sender_);
recorder.end_turn();
turn_data.sync_network();
}
continue;
}
if (replaying_) {
LOG_NG << "doing replay " << player_number_ << "\n";
replaying_ = ::do_replay(player_number_);
LOG_NG << "result of replay: " << (replaying_?"true":"false") << "\n";
} else {
// If a side is dead end the turn, but play at least side=1's
// turn in case all sides are dead
if (current_team().is_human() && side_units(player_number_) == 0
&& (resources::units->size() != 0 || player_number_ != 1))
{
turn_info turn_data(player_number_, replay_sender_);
recorder.end_turn();
turn_data.sync_network();
continue;
}
ai_testing::log_turn_start(player_number_);
play_side(player_number_, save);
}
finish_side_turn();
if(non_interactive()) {
std::cout << " Player " << player_number_ << ": " <<
current_team().villages().size() << " Villages" <<
std::endl;
ai_testing::log_turn_end(player_number_);
}
check_victory();
//if loading a savegame, network turns might not have reset this yet
loading_game_ = false;
}
finish_turn();
// Time has run out
check_time_over();
}
possible_end_play_signal playsingle_controller::play_turn()
{
whiteboard_manager_->on_gamestate_change();
gui_->new_turn();
gui_->invalidate_game_status();
events::raise_draw_event();
LOG_NG << "turn: " << turn() << "\n";
if(non_interactive()) {
LOG_AIT << "Turn " << turn() << ":" << std::endl;
}
for (player_number_ = first_player_; player_number_ <= int(gamestate_.board_.teams().size()); ++player_number_)
{
// If a side is empty skip over it.
if (current_team().is_empty()) continue;
possible_end_play_signal signal;
{
save_blocker blocker;
signal = init_side();
}
if (signal) {
switch (boost::apply_visitor(get_signal_type(), *signal)) {
case END_TURN:
if (current_team().is_network() == false) {
turn_data_.send_data();
recorder.end_turn();
turn_data_.sync_network();
}
continue;
case END_LEVEL:
return signal;
}
}
if (replaying_) {
LOG_NG << "doing replay " << player_number_ << "\n";
HANDLE_END_PLAY_SIGNAL ( replaying_ = ::do_replay() == REPLAY_FOUND_END_TURN );
LOG_NG << "result of replay: " << (replaying_?"true":"false") << "\n";
} else {
ai_testing::log_turn_start(player_number_);
PROPOGATE_END_PLAY_SIGNAL ( play_side() );
}
finish_side_turn();
if(non_interactive()) {
LOG_AIT << " Player " << player_number_ << ": " <<
current_team().villages().size() << " Villages" <<
std::endl;
ai_testing::log_turn_end(player_number_);
}
HANDLE_END_PLAY_SIGNAL ( check_victory() );
//if loading a savegame, network turns might not have reset this yet
loading_game_ = false;
}
//If the loop exits due to the last team having been processed,
//player_number_ will be 1 too high
if(player_number_ > static_cast<int>(gamestate_.board_.teams().size()))
player_number_ = gamestate_.board_.teams().size();
finish_turn();
// Time has run out
PROPOGATE_END_PLAY_SIGNAL ( check_time_over() );
return boost::none;
}
void play_controller::do_init_side()
{
set_scontext_synced sync;
log_scope("player turn");
// In case we might end up calling sync:network during the side turn events,
// and we don't want do_init_side to be called when a player drops.
gamestate_->init_side_done() = true;
init_side_done_now_ = true;
const std::string turn_num = std::to_string(turn());
const std::string side_num = std::to_string(current_side());
gamestate().gamedata_.get_variable("side_number") = current_side();
// We might have skipped some sides because they were empty so it is not enough to check for side_num==1
if(!gamestate().tod_manager_.has_turn_event_fired())
{
pump().fire("turn_" + turn_num);
pump().fire("new_turn");
gamestate().tod_manager_.turn_event_fired();
}
pump().fire("side_turn");
pump().fire("side_" + side_num + "_turn");
pump().fire("side_turn_" + turn_num);
pump().fire("side_" + side_num + "_turn_" + turn_num);
// We want to work out if units for this player should get healed,
// and the player should get income now.
// Healing/income happen if it's not the first turn of processing,
// or if we are loading a game.
if (turn() > 1) {
gamestate().board_.new_turn(current_side());
current_team().new_turn();
// If the expense is less than the number of villages owned
// times the village support capacity,
// then we don't have to pay anything at all
int expense = gamestate().board_.side_upkeep(current_side()) -
current_team().support();
if(expense > 0) {
current_team().spend_gold(expense);
}
calculate_healing(current_side(), !is_skipping_replay());
}
// Prepare the undo stack.
undo_stack().new_side_turn(current_side());
pump().fire("turn_refresh");
pump().fire("side_" + side_num + "_turn_refresh");
pump().fire("turn_" + turn_num + "_refresh");
pump().fire("side_" + side_num + "_turn_" + turn_num + "_refresh");
// Make sure vision is accurate.
actions::clear_shroud(current_side(), true);
init_side_end();
check_victory();
sync.do_final_checkup();
}
int check_end(int **grid)
{
return (check_victory(grid) || check_lose(grid));
}