示例#1
0
// ----------------------------------------------------------------------------
void RaceManager::setPlayerKart(unsigned int player_id,
                                 const std::string &kart_name)
{
    const PlayerProfile* profile =
                    StateManager::get()->getActivePlayerProfile(player_id);
    RemoteKartInfo rki(player_id, kart_name, profile->getName(), 0, false);
    m_player_karts[player_id] = rki;
}   // setPlayerKart
void StartGameProtocol::update()
{
    if (m_state == NONE)
    {
        // if no synchronization protocol exists, create one
        m_listener->requestStart(new SynchronizationProtocol());
        Log::info("StartGameProtocol", "SynchronizationProtocol started.");
        // race startup sequence
        NetworkWorld::getInstance<NetworkWorld>()->start(); // builds it and starts
        race_manager->setNumKarts(m_game_setup->getPlayerCount());
        race_manager->setNumPlayers(m_game_setup->getPlayerCount());
        race_manager->setNumLocalPlayers(1);
        std::vector<NetworkPlayerProfile*> players = m_game_setup->getPlayers();
        std::sort(players.begin(), players.end(), sort_karts);
        // have to add self first
        for (unsigned int i = 0; i < players.size(); i++)
        {
            bool is_me = (players[i]->user_profile == Online::CurrentUser::get()->getProfile());
            if (is_me)
            {
                NetworkPlayerProfile* profile = players[i];
                RemoteKartInfo rki(profile->race_id, profile->kart_name,
                    profile->user_profile->getUserName(), profile->race_id, !is_me);
                rki.setGlobalPlayerId(profile->race_id);
                rki.setLocalPlayerId(is_me?0:1);
                rki.setHostId(profile->race_id);
                PlayerProfile* profileToUse = unlock_manager->getCurrentPlayer();
                assert(profileToUse);
                InputDevice* device = input_manager->getDeviceList()->getLatestUsedDevice();
                int new_player_id = 0;
                if (StateManager::get()->getActivePlayers().size() >= 1) // more than one player, we're the first
                    new_player_id = 0;
                else
                    new_player_id = StateManager::get()->createActivePlayer( profileToUse, device , players[i]->user_profile);
                device->setPlayer(StateManager::get()->getActivePlayer(new_player_id));
                input_manager->getDeviceList()->setSinglePlayer(StateManager::get()->getActivePlayer(new_player_id));

                race_manager->setPlayerKart(i, rki);
                race_manager->setLocalKartInfo(new_player_id, profile->kart_name);
                Log::info("StartGameProtocol", "Self player device added.");            // self config
                NetworkWorld::getInstance()->m_self_kart = profile->kart_name;
            }
        }
        for (unsigned int i = 0; i < players.size(); i++)
        {
            bool is_me = (players[i]->user_profile == Online::CurrentUser::get()->getProfile());
            NetworkPlayerProfile* profile = players[i];
            RemoteKartInfo rki(profile->race_id, profile->kart_name,
                profile->user_profile->getUserName(), profile->race_id, !is_me);
            rki.setGlobalPlayerId(profile->race_id);
            // on the server, the race id must be the local one.
            rki.setLocalPlayerId(m_listener->isServer()?profile->race_id:(is_me?0:1));
            rki.setHostId(profile->race_id);
            Log::info("StartGameProtocol", "Creating kart %s for Player#%d with race_id %d", profile->kart_name.c_str(), i, profile->race_id);

            if (!is_me)
            {
                StateManager::get()->createActivePlayer( NULL, NULL , players[i]->user_profile);

                race_manager->setPlayerKart(i, rki);
            }
        }
        race_manager->computeRandomKartList();
        Log::info("StartGameProtocol", "Player configuration ready.");
        m_state = SYNCHRONIZATION_WAIT;
/*
        KartSelectionScreen* s = KartSelectionScreen::getInstance();
        s->setMultiplayer(false);
        s->setFromOverworld(false);
        StateManager::get()->pushScreen( s );*/
    }
    else if (m_state == SYNCHRONIZATION_WAIT)
    {
        SynchronizationProtocol* protocol = static_cast<SynchronizationProtocol*>
            (m_listener->getProtocol(PROTOCOL_SYNCHRONIZATION));
        if (protocol)
        {
            // now the synchronization protocol exists.
            Log::info("StartGameProtocol", "Starting the race loading.");
            race_manager->startSingleRace("jungle", 1, false);
            World::getWorld()->setNetworkWorld(true);
            m_state = LOADING;
        }
    }
    else if (m_state == LOADING)
    {
        if (m_ready)
        {
            m_state = READY;
        }
    }
    else if (m_state == READY)
    {
        // set karts into the network game setup
        NetworkManager::getInstance()->getGameSetup()->bindKartsToProfiles();
        m_state = EXITING;
        m_listener->requestTerminate(this);
    }
}
Labirynt* TwórzLabirynt(BudowniczyLabiryntu& budowniczy)
{
	budowniczy.RozpocznijBudowę(15, 0, 14);

	budowniczy.WiążKomórki(0, 1, Wschód);
	budowniczy.WiążKomórki(1, 2, Wschód);	
	budowniczy.WiążKomórki(2, 3, Południe);	
	budowniczy.WiążKomórki(3, 4, Wschód);
	budowniczy.WiążKomórki(4, 5, Wschód);
	budowniczy.WiążKomórki(3, 6, Południe);
	budowniczy.WiążKomórki(4, 7, Południe);
	budowniczy.WiążKomórki(5, 8, Południe);
	budowniczy.WiążKomórki(6, 7, Wschód);
	budowniczy.WiążKomórki(7, 8, Wschód);

	budowniczy.WstawDrzwiMiędzyKomórki(6, 10, Południe);

	budowniczy.WiążKomórki(10, 9, Zachód);
	budowniczy.WiążKomórki(9, 11, Południe);
	budowniczy.WiążKomórki(11, 12, Wschód);
	budowniczy.WiążKomórki(12, 13, Wschód);
	budowniczy.WiążKomórki(13, 14, Wschód);

	budowniczy.ZakończBudowę();
	return budowniczy.PobierzLabirynt();
}
/** Setup the actual game. It first starts the SynchronisationProtocol,
 *  and then 
 */
void StartGameProtocol::setup()
{
    m_state       = NONE;
    m_ready_count = 0;
    m_ready       = false;
    Log::info("SynchronizationProtocol", "Ready !");

    Protocol *p = new SynchronizationProtocol();
    p->requestStart();
    Log::info("StartGameProtocol", "SynchronizationProtocol started.");

    // Race startup sequence
    // ---------------------
    // builds it and starts
    NetworkWorld::getInstance<NetworkWorld>()->start();
    race_manager->setNumKarts(m_game_setup->getPlayerCount());
    race_manager->setNumPlayers(m_game_setup->getPlayerCount());
    race_manager->setNumLocalPlayers(1);

    // Create the kart information for the race manager:
    // -------------------------------------------------
    std::vector<NetworkPlayerProfile*> players = m_game_setup->getPlayers();
    for (unsigned int i = 0; i < players.size(); i++)
    {
        NetworkPlayerProfile* profile = players[i];
        bool is_me =  profile->getGlobalPlayerId()
                   == STKHost::get()->getGameSetup()->getLocalMasterID();
        RemoteKartInfo rki(profile->getGlobalPlayerId(),
                           profile->getKartName(),
                           profile->getName(),
                           /*hostid*/profile->getGlobalPlayerId(),
                           !is_me);
        rki.setPerPlayerDifficulty(profile->getPerPlayerDifficulty());
        rki.setLocalPlayerId(0);
        // FIXME: for now (only one local player) the global player id
        // can be used as host id.
        rki.setHostId(profile->getGlobalPlayerId());

        // Inform the race manager about the data for this kart.
        race_manager->setPlayerKart(i, rki);

        if(is_me)
        {
            PlayerProfile* profile_to_use = PlayerManager::getCurrentPlayer();
            assert(profile_to_use);
            InputDevice* device = input_manager->getDeviceManager()
                                ->getLatestUsedDevice();
            int new_player_id = 0;

            // more than one player, we're the first
            if (StateManager::get()->getActivePlayers().size() >= 1)
                new_player_id = 0;
            else
                new_player_id = StateManager::get()
                              ->createActivePlayer(profile_to_use, device);
            StateManager::ActivePlayer *ap =
                           StateManager::get()->getActivePlayer(new_player_id);
            device->setPlayer(ap);
            input_manager->getDeviceManager()->setSinglePlayer(ap);
            race_manager->setLocalKartInfo(new_player_id,
                                           profile->getKartName());
            NetworkWorld::getInstance()->setSelfKart(profile->getKartName());
        }   // if is_me
        else
        {
            StateManager::get()->createActivePlayer( NULL, NULL );
            race_manager->setPlayerKart(i, rki);
        }
    }   // for i in players

    race_manager->computeRandomKartList();
    Log::info("StartGameProtocol", "Player configuration ready.");
    m_state = SYNCHRONIZATION_WAIT;

}   // setup