C++ game_state类代码示例

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

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

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

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

scenariostart_savegame::scenariostart_savegame(game_state &gamestate, const bool compress_saves)
	: savegame(gamestate, compress_saves)
{
	set_filename(gamestate.classification().label);
}

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

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