source: orxonox.OLD/trunk/src/lib/network/network_game_manager.cc @ 9729

/*
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

### File Specific:
   main-programmer: Christoph Renner rennerc@ee.ethz.ch
   co-programmer:   Patrick Boenzli  boenzlip@orxonox.ethz.ch

     June 2006: finishing work on the network stream for pps presentation (rennerc@ee.ethz.ch)
     July 2006: some code rearangement and integration of the proxy server mechanism (boenzlip@ee.ethz.ch)
*/



#define DEBUG_MODULE_NETWORK

#include "util/loading/factory.h"
#include "state.h"
#include "class_list.h"
#include "debug.h"

#include "network_stream.h"
#include "shared_network_data.h"
#include "converter.h"
#include "message_manager.h"

#include "playable.h"
#include "player.h"

#include "game_world.h"

#include "game_rules.h"
#include "network_game_rules.h"

#include "network_game_manager.h"

#include "multiplayer_team_deathmatch.h"

#include "preferences.h"




NetworkGameManager* NetworkGameManager::singletonRef = NULL;

/*!
 * Standard constructor
 */
NetworkGameManager::NetworkGameManager()
  : Synchronizeable()
{
  PRINTF(0)("START\n");

  /* set the class id for the base object */
  this->setClassID(CL_NETWORK_GAME_MANAGER, "NetworkGameManager");

  this->setSynchronized(true);

  MessageManager::getInstance()->registerMessageHandler( MSGID_DELETESYNCHRONIZEABLE, delSynchronizeableHandler, NULL );
  MessageManager::getInstance()->registerMessageHandler( MSGID_PREFEREDTEAM, preferedTeamHandler, NULL );
  MessageManager::getInstance()->registerMessageHandler( MSGID_CHATMESSAGE, chatMessageHandler, NULL );

  this->gameState = 0;
  registerVar( new SynchronizeableInt( &gameState, &gameState, "gameState", PERMISSION_MASTER_SERVER ) );
}

/*!
 * Standard destructor
 */
NetworkGameManager::~NetworkGameManager()
{
  delete MessageManager::getInstance();

  PlayerStats::deleteAllPlayerStats();

  NetworkGameManager::singletonRef = NULL;
}


/**
 * insert new player into game
 * @param userId
 * @return
 */
bool NetworkGameManager::signalNewPlayer( int userId )
{
  assert( SharedNetworkData::getInstance()->isMasterServer());
  assert( State::getGameRules() );
  assert( State::getGameRules()->isA( CL_NETWORK_GAME_RULES ) );

  NetworkGameRules & rules = *(dynamic_cast<NetworkGameRules*>(State::getGameRules()));

  int          team = rules.getTeamForNewUser();
  ClassID      playableClassId = rules.getPlayableClassId( userId, team );
  std::string  playableModel = rules.getPlayableModelFileName( userId, team, playableClassId );
  std::string  playableTexture = rules.getPlayableModelFileName( userId, team, playableClassId );
  float        playableScale = rules.getPlayableScale( userId, team, playableClassId );

  BaseObject * bo = Factory::fabricate( playableClassId );

  assert( bo != NULL );
  assert( bo->isA( CL_PLAYABLE ) );

  Playable & playable = *(dynamic_cast<Playable*>(bo));

  playable.loadMD2Texture( playableTexture );
  playable.setTeam(team);
  playable.loadModel( playableModel, 100.0f );
  playable.setOwner( userId );
  playable.setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
  playable.setSynchronized( true );

  PlayerStats * stats = rules.getNewPlayerStats( userId );

  stats->setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
  stats->setSynchronized( true );
  stats->setOwner( SharedNetworkData::getInstance()->getHostID() );

  stats->setTeamId( team );
  stats->setPlayableClassId( playableClassId );
  stats->setPlayableUniqueId( playable.getUniqueID() );
  stats->setModelFileName( playableModel );

  if ( userId == 0 )
    stats->setNickName( Preferences::getInstance()->getString( "multiplayer", "nickname", "Server" ) );

  if ( rules.isA( CL_MULTIPLAYER_TEAM_DEATHMATCH ) )
    dynamic_cast<MultiplayerTeamDeathmatch*>(&rules)->respawnPlayable( &playable, team, 0.0f );

  return true;
}


/**
 * remove player from game
 * @param userID
 * @return
 */
bool NetworkGameManager::signalLeftPlayer(int userID)
{
  if ( PlayerStats::getStats( userID ) )
  {
    if ( PlayerStats::getStats( userID )->getPlayable() )
      delete PlayerStats::getStats( userID )->getPlayable();
    delete PlayerStats::getStats( userID );
  }

  return true;
}



/**
 * handler for remove synchronizeable messages
 * @param messageType
 * @param data
 * @param dataLength
 * @param someData
 * @param userId
 * @return true on successfull handling else handler will be called again
 */
bool NetworkGameManager::delSynchronizeableHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  )
{

  PRINTF(0)(" del synchronizeable\n");

  if ( SharedNetworkData::getInstance()->isMasterServer() ||
       SharedNetworkData::getInstance()->isProxyServerActive() && SharedNetworkData::getInstance()->isUserClient(senderId))
  {
    PRINTF(0)("Recieved DeleteSynchronizeable message from client %d!\n", senderId);
    return true;
  }

  int uniqueId = 0;
  int len = Converter::byteArrayToInt( data, &uniqueId );

  if ( len != dataLength )
  {
    PRINTF(2)("Recieved DeleteSynchronizeable message with incorrect size (%d) from client %d!\n", dataLength, senderId);
    return true;
  }

  const std::list<BaseObject*> * list = ClassList::getList( CL_SYNCHRONIZEABLE );

  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
  {
    if ( dynamic_cast<Synchronizeable*>(*it)->getUniqueID() == uniqueId )
    {
      if ( (*it)->isA(CL_PLAYABLE) )
      {
        getInstance()->playablesToDelete.push_back( dynamic_cast<Playable*>(*it) );
        return true;
      }

      delete dynamic_cast<Synchronizeable*>(*it);
      return true;
    }
  }

  return true;
}

/**
 * removes synchronizeable (also on clients)
 * @param uniqueId uniqueid to delete
 */
void NetworkGameManager::removeSynchronizeable( int uniqueId )
{
  byte buf[INTSIZE];

  assert( Converter::intToByteArray( uniqueId, buf, INTSIZE ) == INTSIZE );

  MessageManager::getInstance()->sendMessage( MSGID_DELETESYNCHRONIZEABLE, buf, INTSIZE, RT_ALL_BUT_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );
}



/**
 * handler for MSGID_PREFEREDTEAM message
 * @param messageType
 * @param data
 * @param dataLength
 * @param someData
 * @param userId
 * @return
 */
bool NetworkGameManager::preferedTeamHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  )
{
  assert( SharedNetworkData::getInstance()->isMasterServer() );

  int teamId = 0;
  int len = Converter::byteArrayToInt( data, &teamId );

  if ( len != dataLength )
  {
    PRINTF(2)("Recieved DeleteSynchronizeable message with incorrect size (%d) from client %d!\n", dataLength, senderId);
    return true;
  }

  PRINTF(0)("Client %i wishes to play in team %i\n", senderId, teamId);
  NetworkGameManager::getInstance()->setPreferedTeam( senderId, teamId );

  return true;
}


/**
 * this actualy sets the new prefered team id
 * @param userId: the user that changes team
 * @param teamId: the new team id for the user
 */
void NetworkGameManager::setPreferedTeam( int userId, int teamId )
{
  if ( !PlayerStats::getStats( userId ) )
    return;

  PlayerStats & stats = *(PlayerStats::getStats( userId ));

  stats.setPreferedTeamId( teamId );
}


/**
 * set prefered team for this host
 * @param teamId
 */
void NetworkGameManager::prefereTeam( int teamId )
{
  if ( SharedNetworkData::getInstance()->isMasterServer() )
    this->setPreferedTeam( SharedNetworkData::getInstance()->getHostID(), teamId );
  else
  {
    byte buf[INTSIZE];

    assert( Converter::intToByteArray( teamId, buf, INTSIZE) == INTSIZE );

    // send this message to the master server
    MessageManager::getInstance()->sendMessage( MSGID_PREFEREDTEAM, buf, INTSIZE, RT_USER, NET_ID_MASTER_SERVER, MP_HIGHBANDWIDTH );
  }
}

/**
 * this function will be called periodically by networkManager
 * @param ds time elapsed since last call of tick
 */
void NetworkGameManager::tick( float ds )
{
  //delete playables if they are not assigned to local player anymore
  for ( std::list<Playable*>::iterator it = playablesToDelete.begin(); it != playablesToDelete.end();  )
  {
    if ( State::getPlayer()->getPlayable() != *it )
    {
      const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYABLE );

      if ( list && std::find( list->begin(), list->end(), *it ) != list->end() )
      {
        PRINTF(0)("Delete unused playable: %s owner: %d\n", (*it)->getClassCName(), (*it)->getOwner() );
        std::list<Playable*>::iterator delit = it;
        it++;
        delete *delit;
        playablesToDelete.erase( delit );
        continue;
      }
    }
    it++;
  }
}



bool NetworkGameManager::chatMessageHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  )
{
  PRINTF(0)("NetworkGameManager::chatMessageHandler %d %d\n", senderId, SharedNetworkData::getInstance()->getHostID() );
  if ( (SharedNetworkData::getInstance()->isMasterServer() /*|| SharedNetworkData::getInstance()->isProxyServerActive()*/) && senderId !=  SharedNetworkData::getInstance()->getHostID() )
  {
    MessageManager::getInstance()->sendMessage( messageType, data, dataLength, RT_ALL_BUT_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );
  }

  assert( State::getGameRules() );
  assert( State::getGameRules()->isA( CL_NETWORK_GAME_RULES ) );

  NetworkGameRules & rules = *(dynamic_cast<NetworkGameRules*>(State::getGameRules()));

  if ( dataLength < 3*INTSIZE )
  {
    PRINTF(2)("got too small chatmessage from client %d\n", senderId);

    return true;
  }

  int chatType = 0;
  Converter::byteArrayToInt( data, &chatType);
  int senderUserId = 0;
  Converter::byteArrayToInt( data+INTSIZE, &senderUserId );
  std::string message;
  Converter::byteArrayToString( data+2*INTSIZE, message, dataLength-2*INTSIZE );

  rules.handleChatMessage( senderUserId, message, chatType);

  return true;
}

/**
 * send chat message
 * @param message message text
 * @param messageType some int
 */
void NetworkGameManager::sendChatMessage( const std::string & message, int messageType )
{
  byte * buf = new byte[message.length()+3*INTSIZE];

  assert( Converter::intToByteArray( messageType, buf, INTSIZE ) == INTSIZE );
  assert( Converter::intToByteArray( SharedNetworkData::getInstance()->getHostID(), buf+INTSIZE, INTSIZE ) == INTSIZE );
  assert( Converter::stringToByteArray(message, buf+2*INTSIZE, message.length()+INTSIZE) == message.length()+INTSIZE );

  if ( SharedNetworkData::getInstance()->isMasterServer() /*|| SharedNetworkData::getInstance()->isProxyServerActive()*/)
    MessageManager::getInstance()->sendMessage( MSGID_CHATMESSAGE, buf, message.length()+3*INTSIZE, RT_ALL_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );
  else
    MessageManager::getInstance()->sendMessage( MSGID_CHATMESSAGE, buf, message.length()+3*INTSIZE, RT_ALL_BUT_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );


  delete [] buf;
}