playsingle_controller::playsingle_controller(const config& level,
game_state& state_of_game, hero_map& heros, hero_map& heros_start,
card_map& cards,
const int ticks, const int num_turns,
const config& game_config, CVideo& video, bool skip_replay) :
play_controller(level, state_of_game, heros, heros_start, cards,
ticks, num_turns, game_config, video, skip_replay, false),
cursor_setter(cursor::NORMAL),
data_backlog_(),
textbox_info_(),
replay_sender_(recorder),
end_turn_(false),
player_type_changed_(false),
turn_over_(false),
skip_next_turn_(false),
level_result_(NONE)
{
game_config::no_messagebox = false;
game_config::hide_tactic_slot = false;
// game may need to start in linger mode
if (state_of_game.classification().completion == "victory" || state_of_game.classification().completion == "defeat")
{
LOG_NG << "Setting linger mode.\n";
browse_ = linger_ = true;
}
ai::game_info ai_info(*gui_, map_, units_, heros_, teams_, tod_manager_, gamestate_);
ai::manager::set_ai_info(ai_info);
ai::manager::add_observer(this) ;
}
playsingle_controller::playsingle_controller(const config& level,
game_state& state_of_game, const int ticks, const int num_turns,
const config& game_config, CVideo& video, bool skip_replay) :
play_controller(level, state_of_game, ticks, num_turns, game_config, video, skip_replay),
cursor_setter(cursor::NORMAL),
data_backlog_(),
textbox_info_(),
replay_sender_(recorder),
end_turn_(false),
player_type_changed_(false),
replaying_(false),
turn_over_(false),
skip_next_turn_(false),
level_result_(NONE)
{
// game may need to start in linger mode
if (state_of_game.classification().completion == "victory" || state_of_game.classification().completion == "defeat")
{
LOG_NG << "Setting linger mode.\n";
browse_ = linger_ = true;
}
ai::game_info ai_info;
ai::manager::set_ai_info(ai_info);
ai::manager::add_observer(this) ;
}
int main()
{
sf::RenderWindow window(sf::VideoMode(800, 600), "Ping Pong");
coreState.SetWindow(&window);
coreState.SetState(new menu());
// run the program as long as the window is open
while (window.isOpen())
{
// check all the window's events that were triggered since the last iteration of the loop
sf::Event event;
while (window.pollEvent(event))
{
// "close requested" event: we close the window
if (event.type == sf::Event::Closed)
window.close();
}
window.clear(sf::Color::Black);
coreState.Update();
coreState.Render();
window.display();
if(quitGame){
window.close();
}
Sleep(5);
}
return 0;
}
pair<int, int> ai_move(game_state state) {
vector<pair<int, int> > all_moves = state.get_all_no_tipping_moves();
if (all_moves.size() == 0) {
// if all moves would tip, surrender
return pair<int, int>(-1, 16);
}
// find best solution
int alpha = -1000;
int beta = 1000;
int best_index = 0;
if (state.game_turn < 15) {
ai_depth = 3;
}
else {
ai_depth = 4 + (state.game_turn-15) / 3;
}
cout << "[[TURN:" << state.game_turn << "]]\n";
cout << "======= depth: " << ai_depth << " ==========\n";
time_t s_time = time(NULL);
for (int ii = 0; ii < all_moves.size(); ii ++) {
int i = ii;
if (ai_depth % 2 == 0) {
i = (int) all_moves.size() - ii - 1;
}
int this_value = alpha_beta(state.move_fast(all_moves[i]), ai_depth-1, alpha, beta);
// cout << all_moves[i].first << "," << all_moves[i].second << " : " << this_value << "\n";
if (ai_depth % 2 == 0) {
// minimax 2(2,3), 1(0), 3(1,4,1)->first
if (this_value > alpha) {
alpha = this_value;
best_index = i;
}
}
else {
// maxmini 2,1,3->second
if (this_value < beta) {
beta = this_value;
best_index = i;
}
}
if (alpha >= beta) {
break;
}
}
time_t e_time = time(NULL);
cout << "======used: " << e_time-s_time << " seconds=======\n";
return all_moves[best_index];
}
pair<int, int> ai_move(game_state state) {
vector<pair<int, int> > all_moves = state.get_all_no_tipping_moves();
if (all_moves.size() == 0) {
// if all moves would tip, surrender
return pair<int, int>(-1, 16);
}
return all_moves[rand() % all_moves.size()];
}
int main()
{
sf::RenderWindow window(sf::VideoMode(800, 600), "Ping");
coreState.SetWindow(&window);
coreState.SetState(new main_menu());
sf::Clock timer;
sf::Time elapsed;
// run the program as long as the window is open
while (window.isOpen())
{
// check all the window's events that were triggered since the last iteration of the loop
sf::Event event;
while (window.pollEvent(event))
{
// "close requested" event: we close the window
if (event.type == sf::Event::Closed)
window.close();
}
elapsed = timer.getElapsedTime();
if (elapsed.asMicroseconds() > 162)
{
window.clear(sf::Color::Black);
coreState.Update();
coreState.Render();
window.display();
if (quitGame)
{
window.close();
}
timer.restart();
}
}
return 0;
}
///well, more of an iterative balance. Should probably make it properly fully balance
///team data isn't reliable. Am I an idiot?
///this is not a good balance, we want to distribute players evenly between teams
void balance_ffa(game_state& state)
{
int number_of_players = state.player_list.size();
int max_players_per_team = (number_of_players / TEAM_NUMS) + 1;
//printf("Max num of players per team %i\ncurrentplayernum %i\n", max_players_per_team, number_of_players);;
std::vector<int32_t> too_big_teams;
too_big_teams.resize(TEAM_NUMS);
for(int i=0; i<TEAM_NUMS; i++)
{
if(state.number_of_team(i) > max_players_per_team)
{
too_big_teams[i] = 1;
}
}
for(auto& i : state.player_list)
{
if(i.team < 0 || i.team >= too_big_teams.size() || too_big_teams[i.team] == 1)
{
int old_team = i.team;
i.team = (i.team + 1) % TEAM_NUMS;
byte_vector vec;
vec.push_back(canary_start);
vec.push_back(message::TEAMASSIGNMENT);
vec.push_back<int32_t>(i.id);
vec.push_back<int32_t>(i.team);
vec.push_back(canary_end);
int no_player = -1;
state.broadcast(vec.ptr, no_player);
if(old_team >= 0 && old_team < too_big_teams.size())
too_big_teams[old_team] = 0;
}
}
}
int alpha_beta(game_state state, int depth, int alpha, int beta) {
if (alpha == beta) {
return alpha;
}
vector<pair<int, int> > children = state.get_all_no_tipping_moves();
if (depth == 0) {
return (int) children.size();
}
if (depth % 2 == 0) {
// get max, only alpha
// minimax 2(2,3), 1(0), 3(1,4,1)->first
for (int i = 0; i < children.size(); i ++) {
int value = alpha_beta(state.move_fast(children[i]), depth-1, alpha, beta);
if (value > alpha) {
alpha = value;
}
if (alpha >= beta) {
return alpha;
}
}
return alpha;
}
else {
// get min, only beta
// maxmini 2, 1, 3->second
for (int i = 0; i < children.size(); i ++) {
int value = alpha_beta(state.move_fast(children[i]), depth-1, alpha, beta);
if (value < beta) {
beta = value;
}
if (beta <= alpha) {
return beta;
}
}
return beta;
}
}
int main(int argc, char ** argv)
{
GameControls::createInstance(argc, argv);
sf::RenderWindow window(sf::VideoMode(800, 800), "DameUs");
coreState.SetWindow(&window);
coreState.SetState(new main_menu());
// run the program as long as the window is open
while (window.isOpen())
{
// check all the window's events that were triggered since the last iteration of the loop
sf::Event event;
while (window.pollEvent(event))
{
// "close requested" event: we close the window
if (event.type == sf::Event::Closed)
window.close();
}
window.clear(sf::Color::Black);
coreState.Update();
coreState.Render();
window.display();
if (quitGame)
{
window.close();
}
std::this_thread::sleep_for(std::chrono::milliseconds(17));
}
return 0;
}
void balance_first_to_x(game_state& state)
{
if(state.number_of_team(0) == state.number_of_team(1))
return;
///odd number of players, rest in peace
if(abs(state.number_of_team(1) - state.number_of_team(0)) == 1)
return;
int t0 = state.number_of_team(0);
int t1 = state.number_of_team(1);
int team_to_swap = t1 > t0 ? 1 : 0;
int team_to_swap_to = t1 < t0 ? 1 : 0;
int extra = abs(state.number_of_team(1) - state.number_of_team(0));
int num_to_swap = extra / 2;
int num_swapped = 0;
for(auto& i : state.player_list)
{
if(i.team == team_to_swap && num_swapped < num_to_swap)
{
i.team = team_to_swap_to;
///network
byte_vector vec;
vec.push_back(canary_start);
vec.push_back(message::TEAMASSIGNMENT);
vec.push_back<int32_t>(i.id);
vec.push_back<int32_t>(i.team);
vec.push_back(canary_end);
//udp_send_to(i.sock, vec.ptr, (const sockaddr*)&i.store);
int no_player = -1;
state.broadcast(vec.ptr, no_player);
num_swapped++;
}
}
}
replay_controller::replay_controller(const config& level,
game_state& state_of_game, const int ticks, const int num_turns,
const config& game_config, CVideo& video) :
play_controller(level, state_of_game, ticks, num_turns, game_config, video, false),
teams_start_(),
gamestate_start_(state_of_game),
units_start_(),
tod_manager_start_(level, num_turns, &state_of_game),
current_turn_(1),
delay_(0),
is_playing_(false),
show_everything_(false),
show_team_(state_of_game.classification().campaign_type == "multiplayer" ? 0 : 1)
{
init();
gamestate_start_ = gamestate_;
}
void play_replay(display& disp, game_state& gamestate, const config& game_config,
hero_map& heros, hero_map& heros_start, card_map& cards, CVideo& video)
{
std::string type = gamestate.classification().campaign_type;
if(type.empty())
type = "scenario";
// 'starting_pos' will contain the position we start the game from.
config starting_pos;
if (gamestate.starting_pos.empty()){
// Backwards compatibility code for 1.2 and 1.2.1
const config &scenario = game_config.find_child(type,"id",gamestate.classification().scenario);
assert(scenario);
gamestate.starting_pos = scenario;
}
starting_pos = gamestate.starting_pos;
//for replays, use the variables specified in starting_pos
if (const config &vars = starting_pos.child("variables")) {
gamestate.set_variables(vars);
}
try {
// Preserve old label eg. replay
if (gamestate.classification().label.empty())
gamestate.classification().label = starting_pos["name"].str();
//if (gamestate.abbrev.empty())
// gamestate.abbrev = (*scenario)["abbrev"];
play_replay_level(game_config, &starting_pos, video, gamestate, heros, heros_start, cards);
gamestate.snapshot = config();
recorder.clear();
gamestate.replay_data.clear();
gamestate.start_scenario_ss.str("");
// gamestate.start_hero_ss.str("");
gamestate.clear_start_hero_data();
} catch(game::load_game_failed& e) {
gui2::show_error_message(disp.video(), _("The game could not be loaded: ") + e.message);
} catch(game::game_error& e) {
gui2::show_error_message(disp.video(), _("Error while playing the game: ") + e.message);
} catch(incorrect_map_format_error& e) {
gui2::show_error_message(disp.video(), std::string(_("The game map could not be loaded: ")) + e.message);
} catch(twml_exception& e) {
e.show(disp);
}
}
direction random_ai_player::next_move(const game_state gs) {
player me = gs.player_by_id(get_player_id());
float rand = std::generate_canonical<float, 32>(gen);
if (rand < .30) {
return me.get_direction();
}
rand = std::generate_canonical<float, 32>(gen);
if (rand < .25) {
return LEFT;
} else if (rand < .50) {
return RIGHT;
} else if (rand < .75) {
return UP;
} else {
return DOWN;
}
}
replay_controller::replay_controller(const config& level,
game_state& state_of_game, const int ticks, const int num_turns,
const config& game_config, CVideo& video) :
play_controller(level, state_of_game, ticks, num_turns, game_config, video, false),
teams_start_(teams_),
gamestate_start_(gamestate_),
units_start_(units_),
tod_manager_start_(level, num_turns),
current_turn_(1),
is_playing_(false),
show_everything_(false),
show_team_(state_of_game.classification().campaign_type == game_classification::MULTIPLAYER ? 0 : 1)
{
tod_manager_start_ = tod_manager_;
// Our parent class correctly detects that we are loading a game. However,
// we are not loading mid-game, so from here on, treat this as not loading
// a game. (Allows turn_1 et al. events to fire at the correct time.)
loading_game_ = false;
init();
reset_replay();
}
scenariostart_savegame::scenariostart_savegame(hero_map& heros, hero_map& heros_start, game_state &gamestate)
: savegame(heros, heros_start, gamestate, dummy_snapshot)
{
memset(game_config::savegame_cache, 0, sizeof(unit_segment2));
set_filename(gamestate.classification().label);
}
void run(void)
{
gs.gs_run();
menu_pages.push(&lv);
}
void new_game(void)
{
gs.gs_run();
menu_pages.push(&lv);
lv.reset();
}
void gpause(void)
{
gs.gs_pause();
menu_pages.pop();
}
scenariostart_savegame::scenariostart_savegame(game_state &gamestate, const bool compress_saves)
: savegame(gamestate, compress_saves)
{
set_filename(gamestate.classification().label);
}
void sound_off(void)
{
gs.gs_sound_off();
}
void sound_on(void)
{
gs.gs_sound_on();
}
LEVEL_RESULT play_game(display& disp, game_state& gamestate, const config& game_config, hero_map& heros, hero_map& heros_start,
card_map& cards,
io_type_t io_type, bool skip_replay)
{
tent::io_type = io_type;
std::string type = gamestate.classification().campaign_type;
if (type.empty()) {
type = "scenario";
}
config const* scenario = NULL;
// 'starting_pos' will contain the position we start the game from.
config starting_pos;
// Do we have any snapshot data?
// yes => this must be a savegame
// no => we are starting a fresh scenario
if (!gamestate.snapshot["runtime"].to_bool() || !recorder.at_end()) {
gamestate.classification().completion = "running";
// Campaign or Multiplayer?
// If the gamestate already contains a starting_pos,
// then we are starting a fresh multiplayer game.
// Otherwise this is the start of a campaign scenario.
if (gamestate.starting_pos["id"].empty() == false) {
starting_pos = gamestate.starting_pos;
scenario = &starting_pos;
} else {
// reload of the scenario, as starting_pos contains carryover information only
scenario = &load_campagin_scenario(gamestate.classification().campaign, gamestate.classification().scenario, type);
VALIDATE(!scenario->empty(), std::string("play_game, cannot load scenario id = ") + gamestate.classification().scenario + " in game_config!");
gamestate.starting_pos = *scenario;
starting_pos = gamestate.starting_pos;
scenario = &starting_pos;
}
} else {
// This game was started from a savegame
starting_pos = gamestate.starting_pos;
scenario = &gamestate.snapshot;
// When starting wesnoth --multiplayer there might be
// no variables which leads to a segfault
if (const config &vars = gamestate.snapshot.child("variables")) {
gamestate.set_variables(vars);
}
gamestate.set_menu_items(gamestate.snapshot.child_range("menu_item"));
// Replace game label with that from snapshot
if (!gamestate.snapshot["label"].empty()){
gamestate.classification().label = gamestate.snapshot["label"].str();
}
}
bool fog = scenario->get("fog")->to_bool();
bool shroud = scenario->get("shroud")->to_bool();
while (scenario != NULL) {
// If we are a multiplayer client, tweak the controllers
if (io_type == IO_CLIENT) {
if (scenario != &starting_pos) {
starting_pos = *scenario;
scenario = &starting_pos;
}
}
config::const_child_itors story = scenario->child_range("story");
gamestate.classification().next_scenario = (*scenario)["next_scenario"].str();
bool save_game_after_scenario = true;
LEVEL_RESULT res = VICTORY;
end_level_data end_level;
try {
// Preserve old label eg. replay
if (gamestate.classification().label.empty()) {
t_string tstr = (*scenario)["name"];
if (gamestate.classification().abbrev.empty()) {
gamestate.classification().label = tstr;
gamestate.classification().original_label = tstr.base_str();
} else {
gamestate.classification().label = std::string(gamestate.classification().abbrev);
gamestate.classification().label.append("-");
gamestate.classification().original_label = gamestate.classification().label;
gamestate.classification().label.append(tstr);
gamestate.classification().original_label.append(tstr.base_str());
}
}
// If the entire scenario should be randomly generated
if ((*scenario)["scenario_generation"] != "") {
const cursor::setter cursor_setter(cursor::WAIT);
static config scenario2;
scenario2 = random_generate_scenario((*scenario)["scenario_generation"], scenario->child("generator"));
//level_ = scenario;
//merge carryover information into the newly generated scenario
config temp(scenario2);
gamestate.starting_pos = temp;
scenario = &scenario2;
}
std::string map_data = (*scenario)["map_data"];
if(map_data.empty() && (*scenario)["map"] != "") {
map_data = read_map((*scenario)["map"]);
}
// If the map should be randomly generated
if(map_data.empty() && (*scenario)["map_generation"] != "") {
const cursor::setter cursor_setter(cursor::WAIT);
map_data = random_generate_map((*scenario)["map_generation"],scenario->child("generator"));
// Since we've had to generate the map,
// make sure that when we save the game,
// it will not ask for the map to be generated again on reload
static config new_level;
new_level = *scenario;
new_level["map_data"] = map_data;
scenario = &new_level;
//merge carryover information into the scenario
config temp(new_level);
gamestate.starting_pos = temp;
}
sound::empty_playlist();
//add the variables to the starting_pos unless they are already there
const config &wmlvars = gamestate.starting_pos.child("variables");
if (!wmlvars || wmlvars.empty()){
gamestate.starting_pos.clear_children("variables");
gamestate.starting_pos.add_child("variables", gamestate.get_variables());
}
switch (io_type){
case IO_NONE:
res = playsingle_scenario(game_config, scenario, disp, gamestate, heros, heros_start, cards, story, skip_replay, end_level);
break;
case IO_SERVER:
case IO_CLIENT:
res = playmp_scenario(game_config, scenario, disp, gamestate, heros, heros_start, cards, story, skip_replay, io_type, end_level);
break;
}
} catch(game::load_game_failed& e) {
gui2::show_error_message(disp.video(), _("The game could not be loaded: ") + e.message);
return QUIT;
} catch(game::game_error& e) {
gui2::show_error_message(disp.video(), _("Error while playing the game: ") + e.message);
return QUIT;
} catch(incorrect_map_format_error& e) {
gui2::show_error_message(disp.video(), std::string(_("The game map could not be loaded: ")) + e.message);
return QUIT;
} catch(config::error& e) {
std::cerr << "caught config::error...\n";
gui2::show_error_message(disp.video(), _("Error while reading the WML: ") + e.message);
return QUIT;
} catch(twml_exception& e) {
e.show(disp);
return QUIT;
}
// Save-management options fire on game end.
// This means: (a) we have a victory, or
// or (b) we're multiplayer live, in which
// case defeat is also game end. Someday,
// if MP campaigns ever work again, we might
// need to change this test.
if (res == VICTORY || (io_type != IO_NONE && res == DEFEAT)) {
if (preferences::delete_saves()) {
savegame::manager::clean_saves(gamestate.classification().label);
}
}
recorder.clear();
gamestate.replay_data.clear();
gamestate.start_scenario_ss.str("");
gamestate.clear_start_hero_data();
// On DEFEAT, QUIT, or OBSERVER_END, we're done now
if (res != VICTORY) {
if (res != OBSERVER_END || gamestate.classification().next_scenario.empty()) {
gamestate.snapshot = config();
return res;
}
const int dlg_res = gui2::show_message(disp.video(), _("Game Over"),
_("This scenario has ended. Do you want to continue the campaign?"),
gui2::tmessage::yes_no_buttons);
if (dlg_res == gui2::twindow::CANCEL) {
gamestate.snapshot = config();
return res;
}
}
// Continue without saving is like a victory,
// but the save game dialog isn't displayed
if (!end_level.prescenario_save) {
save_game_after_scenario = false;
}
// Switch to the next scenario.
gamestate.classification().scenario = gamestate.classification().next_scenario;
gamestate.rng().rotate_random();
// gamestate.rng().seed_random(rand(), 0);
scenario = NULL;
if (io_type == IO_NONE) {
scenario = &load_campagin_scenario(gamestate.classification().campaign, gamestate.classification().scenario, type);
if (scenario->empty()) {
scenario = NULL;
} else{
starting_pos = *scenario;
starting_pos["fog"] = fog;
starting_pos["shroud"] = shroud;
scenario = &starting_pos;
}
}
if (scenario != NULL) {
// to single-player campaign, there are multi-secenario,
// set this result to next start hero data
heros.reset_to_unstage();
heros_start = heros;
loadscreen::global_loadscreen_manager* loadscreen_manager = loadscreen::global_loadscreen_manager::get();
if (loadscreen_manager) {
loadscreen_manager->reset();
}
// Update the label
// std::string oldlabel = gamestate.classification().label;
t_string scenario_name = (*scenario)["name"];
if (gamestate.classification().abbrev.empty()) {
gamestate.classification().label = scenario_name;
gamestate.classification().original_label = scenario_name.base_str();
} else {
gamestate.classification().label = std::string(gamestate.classification().abbrev);
gamestate.classification().label.append("-");
gamestate.classification().original_label = gamestate.classification().label;
gamestate.classification().label.append(scenario_name);
gamestate.classification().original_label.append(scenario_name.base_str());
}
// If this isn't the last scenario, then save the game
if (save_game_after_scenario) {
// For multiplayer, we want the save
// to contain the starting position.
// For campaigns however, this is the
// start-of-scenario save and the
// starting position needs to be empty,
// to force a reload of the scenario config.
if (gamestate.classification().campaign_type != "multiplayer"){
gamestate.starting_pos = config();
}
//add the variables to the starting position
gamestate.starting_pos.add_child("variables", gamestate.get_variables());
savegame::scenariostart_savegame save(heros, heros_start, gamestate);
save.save_game_automatic(disp.video());
}
if (gamestate.classification().campaign_type != "multiplayer"){
gamestate.starting_pos = *scenario;
//add the variables to the starting position
gamestate.starting_pos.add_child("variables", gamestate.get_variables());
}
gamestate.start_scenario_ss.str("");
}
gamestate.snapshot = config();
}
if (!gamestate.classification().scenario.empty() && gamestate.classification().scenario != "null") {
std::string message = _("Unknown scenario: '$scenario|'");
utils::string_map symbols;
symbols["scenario"] = gamestate.classification().scenario;
message = utils::interpolate_variables_into_string(message, &symbols);
gui2::show_error_message(disp.video(), message);
return QUIT;
}
if (gamestate.classification().campaign_type == "scenario"){
if (preferences::delete_saves()) {
savegame::manager::clean_saves(gamestate.classification().label);
}
}
return VICTORY;
}
