Uint16 BotManager::addBot() { PlayerState *p = PlayerInterface::allocateNewPlayer(); if ( p ) { Bot * b = new BotPlayer(p->getID()); bot_list.push_back(b); ResourceManagerSyncFlagMessage flagmsg; ResourceManager::getFlagData("bot.bmp",(Uint8*)&flagmsg.flagdata); flagmsg.setFlagID(ResourceManager::registerFlagFromData((Uint8*)&flagmsg.flagdata)); p->setName("Bot"); p->setFlag(flagmsg.getFlagID()); p->setStatus(_player_state_active); NetworkServer::broadcastMessage(&flagmsg, sizeof(flagmsg)); PlayerStateSync updatemsg(p->getNetworkPlayerState()); NetworkServer::broadcastMessage( &updatemsg, sizeof(updatemsg)); SystemConnectAlert connect_alert; connect_alert.set( p->getID(), _connect_alert_mesg_connect ); NetworkServer::broadcastMessage( &connect_alert, sizeof(SystemConnectAlert)); NetworkClient::sendMessage(&connect_alert, sizeof(SystemConnectAlert)); return p->getID(); } return 0xffff; }
virtual T message(const NetMessage* msg) { if ( msg->message_id == _net_message_id_connect_client_settings ) { ConnectClientSettings *client_setting; client_setting = (ConnectClientSettings *) msg; player->setName( client_setting->player_name ); ResourceManager::updateFlagData(player->getID(), client_setting->player_flag, sizeof(client_setting->player_flag) ); player->setStateConnecting(); // ** send server game setting map, units, player, etc. ConnectMesgServerGameSettings* server_game_setup = GameManager::getServerGameSetup(); connect_client->sendMessage( server_game_setup, sizeof(ConnectMesgServerGameSettings)); connect_client->sendRemaining(); delete server_game_setup; return connect_state_wait_for_client_game_setup_ack; } return State<T>::state; }
virtual T message(const NetMessage* msg) { T new_state = connect_state_drop_bad_connecting_client; if ( msg->message_id == _net_message_id_client_connect_request ) { ClientConnectResult connect_result; if ((GameConfig::game_allowmultiip == false) && (SERVER->isAlreadyConnected(connect_client) == true)) { connect_result.result_code = _connect_result_server_already_connected; LOGGER.warning("Client already connected!!!!, die"); } else { PlayerState * player = PlayerInterface::allocateNewPlayer(); if ( player == 0 ) { connect_result.result_code = _connect_result_server_full; } else { connect_result.result_code = _connect_result_success; connect_client->player_id = player->getID(); new_state = connect_state_wait_for_client_settings; } } connect_client->sendMessage( &connect_result, sizeof(ClientConnectResult)); connect_client->sendRemaining(); } return new_state; }
virtual T message(const NetMessage* msg) { if ( msg->message_id == _net_message_id_connect_client_game_setup_ack ) { PlayerConnectID player_connect_mesg(player->getID()); connect_client->sendMessage( &player_connect_mesg, sizeof(PlayerConnectID)); return connect_state_unit_profile_sync; } else if ( msg->message_id == _net_message_id_connect_client_game_setup_ping ) { time_out_timer.reset(); } return State<T>::state; }
void GameManager::netMessagePingRequest(const NetMessage* message) { const SystemPingRequest *ping_request = (const SystemPingRequest*) message; if(ping_request->getClientPlayerIndex() >= PlayerInterface::getMaxPlayers()) { LOGGER.warning("Invalid pingRequest message"); return; } PlayerState * player; player = PlayerInterface::getPlayer( ping_request->getClientPlayerIndex() ); SystemPingAcknowledge ping_ack; if ( player->getStatus() == _player_state_active && ping_request->getClientPlayerIndex() != MIN_PLAYER_ID ) { SERVER->sendMessage(player->getID(), &ping_ack, sizeof(SystemPingAcknowledge)); } }
//----------------------------------------------------------------- void DedicatedGameManager::inputLoop() { // handle server commands SDL_mutexP(commandqueue_mutex); while(!commandqueue.empty()) { const ServerCommand& command = commandqueue.front(); switch(command.type) { case ServerCommand::QUIT: { ActionManager::runAction("quit"); break; } case ServerCommand::CHAT: { ChatInterface::serversay(command.argument.c_str()); break; } case ServerCommand::STATUS: { //*Console::server std::cout << "Server " << *GameConfig::server_name << " version " << PACKAGE_VERSION << " port " << GameConfig::server_port << "\n" << "Map: " << *GameConfig::game_map << "\n" << std::setw(3) << "ID" << " " << std::setw(30) << "Name" << " " << std::setw(4) << "Kill" << " " << std::setw(4) << "Lost" << " " << std::setw(5) << "Score" << " " << std::setw(21) << "IP\n"; PlayerID i; for ( i = 0; i<PlayerInterface::getMaxPlayers(); ++i) { PlayerState* playerstate = PlayerInterface::getPlayer(i); if ( playerstate->isActive() ) { //*Console::server std::cout << std::setw(3) << static_cast<int>(i) << " " << std::setw(30) << playerstate->getName() << " " << std::setw(4) << playerstate->getKills() << " " << std::setw(4) << playerstate->getLosses() << " " << std::setw(5) << playerstate->getTotal() << " " << std::setw(21) << SERVER->getIP(playerstate->getID()) << "\n"; } } //*Console::server << std::flush; std::cout << std::flush; break; } case ServerCommand::MAPCHANGE: if(!MapsManager::existsMap(command.argument)) { std::cout << "map '" << command.argument << "' doesn't exist." << std::endl; break; } GameControlRulesDaemon::forceMapChange(command.argument); std::cout << "Preparing mapchange..." << std::endl; break; case ServerCommand::KICK: std::stringstream idstream(command.argument); PlayerID id = INVALID_PLAYER_ID; idstream >> (int&)id; // XXX KREMOVE if(id >= PlayerInterface::getMaxPlayers()) { std::cout << "Unknown player." << std::endl; break; } SERVER->kickClient(id); break; } commandqueue.pop(); } SDL_mutexV(commandqueue_mutex); BaseGameManager::inputLoop(); }
void NetworkServer::onClientDisconected(ClientSocket *s, const char * msg) { LOGGER.debug("NetworkServer::onClientDisconected( %d, '%s')", s->getId(), msg ? msg : "nice"); bool cleandisconnect = false; bool sendalert = true; if ( ServerConnectDaemon::inConnectQueue(s) ) { // player was connecting and dropped. ServerConnectDaemon::removeClientFromQueue(s); sendalert = false; LOGGER.debug("NetworkServer::onClientDisconected player was connecting"); } if ( NetworkInterface::receive_queue.isReady() ) { unsigned long frontsave = NetworkInterface::receive_queue.front; while ( NetworkInterface::receive_queue.isReady() ) { LOGGER.debug("NetworkServer::onClientDisconected there was a packet"); NetPacket packet; NetworkInterface::receive_queue.dequeue(&packet); if ( packet.fromClient == s ) { LOGGER.debug("NetworkServer::onClientDisconected the packet was from our friend"); const NetMessage * netmessage = packet.getNetMessage(); if ( netmessage->message_class == _net_message_class_connect && netmessage->message_id == _net_message_id_connect_netPanzer_client_disconnect ) { LOGGER.debug("NetworkServer::onClientDisconected so is a clean disconnect"); cleandisconnect = true; } } } NetworkInterface::receive_queue.front = frontsave; } PlayerID player_index = s->getPlayerIndex(); if ( player_index != INVALID_PLAYER_ID ) { PlayerState * player = PlayerInterface::getPlayer(player_index); bool kicked = player ? player->isKicked() : false; if ( player && sendalert && ! kicked) { if (GameConfig::game_teammode == true) ConsoleInterface::postMessage(Color::cyan, true, player->getFlag(), _("'%s' has left."), player->getName().c_str()); } ObjectiveInterface::disownPlayerObjectives( player_index ); UnitInterface::destroyPlayerUnits( player_index ); PlayerInterface::disconnectPlayerCleanup( player_index ); if ( sendalert ) { SystemConnectAlert scmsg; if ( cleandisconnect || ! msg ) { scmsg.set( player_index, _connect_alert_mesg_disconnect); } else if ( kicked ) { scmsg.set( player_index, _connect_alert_mesg_client_kicked); } else { scmsg.set( player_index, _connect_alert_mesg_client_drop ); } SERVER->broadcastMessage(&scmsg, sizeof(scmsg)); } if (GameConfig::game_teammode == true) { TeamManager::removePlayer(player->getID(), player->getTeamID()); TeamManager::BalancedTeam(); } } }