source: orxonox.OLD/branches/network/src/lib/network/network_game_manager.cc @ 6197

/*
   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: Benjamin Wuest
   co-programmer: ...
*/


/* this is for debug output. It just says, that all calls to PRINT() belong to the DEBUG_MODULE_NETWORK module
   For more information refere to https://www.orxonox.net/cgi-bin/trac.cgi/wiki/DebugOutput
*/
#define DEBUG_MODULE_NETWORK

#include "factory.h"
#include "network_stream.h"

/* include your own header */
#include "network_game_manager.h"


/* using namespace std is default, this needs to be here */
using namespace std;

/*!
 * Standard constructor
 */
NetworkGameManager::NetworkGameManager()
{
  /* set the class id for the base object */
  this->setClassID(CL_ENTITY_MANAGER, "EntityManager");
}

/*!
 * Standard destructor
 */
NetworkGameManager::~NetworkGameManager()
{
  for ( int i = 0; i<inBuffer.size(); i++)
  {
    if ( inBuffer[i].buffer )
      delete inBuffer[i].buffer;
    if ( outBuffer[i].buffer )
      delete outBuffer[i].buffer;
  }
}


void NetworkGameManager::writeBytes(const byte* data, int length, int sender)
{
}

int NetworkGameManager::readBytes(byte* data, int maxLength, int * reciever)
{
}

void NetworkGameManager::writeDebug() const
{
}

void NetworkGameManager::readDebug() const
{
}


/*!
 * Checks whether this is connected to a server or a client
 * and afterwards creates the needed entity if possible
 * @param classID: The ID of the class of which an entity should be created
 */
void NetworkGameManager::createEntity(int classID)
{
}

/*!
 * Checks whether this is connected to a server or a client
 * and afterwards removes the specified entity
 * @param uniqueID: The ID of the entity object which should be removed
 */
void NetworkGameManager::removeEntity(int uniqueID)
{
}



/*!
 * Creates the needed entity on the server if possible
 * @param classID: The ID of the class of which an entity should be created
 */
void NetworkGameManager::requestCreateEntity(int classID)
{
}

/*!
 * Removes the specified entity on the server
 * @param uniqueID: The ID of the entity object which should be removed
 */
void NetworkGameManager::requestRemoveEntity(int uniqueID)
{
}

/*!
 * Creates the needed entity if possible
 * This function is called if this is a server
 * @param classID: The ID of the class of which an entity should be created
 */
void NetworkGameManager::executeCreateEntity(int classID)
{
}

/*!
 * Removes the specified entity
 * This function is called if this is a server
 * @param uniqueID: The ID of the entity object which should be removed
 */
void NetworkGameManager::executeRemoveEntity(int uniqueID)
{
}

/*!
 * Checks whether it is possible to create an entity of a given class
 * @return: true if the entity can be created, false otherwise
 */
bool NetworkGameManager::canCreateEntity(int classID)
{
  return true;
}

/*!
 * Sends the Entities to the new connected client
 * @param userID: The ID of the user
 */
void NetworkGameManager::sendEntityList( int userID )
{
}

/**
 * Creates a buffer for user n
 * @param n The ID of the user
 */
void NetworkGameManager::resizeBufferVector( int n )
{
  for ( int i = inBuffer.size(); i<=n; i++)
  {
    clientBuffer inBuf;
    clientBuffer outBuf;

    inBuf.length = 0;
    outBuf.length = 0;

    inBuf.maxLength = 5*1014;
    outBuf.maxLength = 5*1024;

    inBuf.buffer = new byte[5*1014];
    outBuf.buffer = new byte[5*1014];

    inBuffer.push_back(inBuf);
    outBuffer.push_back(outBuf);
  }
}

/**
 * Creates the entity on this host
 * @param classID: ClassID of the entity to create
 * @param uniqueID: Unique ID to assign to the synchronizeable
 * @param owner: owner of this synchronizealbe
 */
void NetworkGameManager::doCreateEntity( ClassID classID, int uniqueID, int owner )
{
  //BaseObject * b = Factory::fabricate( classID );
  BaseObject * b = NULL;

  if ( b->isA(CL_SYNCHRONIZEABLE) )
  {
    Synchronizeable * s = dynamic_cast<Synchronizeable*>(b);
    s->setUniqueID( uniqueID );
    s->setOwner( owner );
    this->networkStream->connectSynchronizeable( *s );
  }
  else
  {
    PRINTF(1)("Class with ID %d is not a synchronizeable!", (int)classID);
    delete b;
  }
}

/**
 * Removes a entity on this host
 * @param uniqueID: unique ID assigned with the entity to remove
 */
void NetworkGameManager::doRemoveEntity( int uniqueID )
{
  SynchronizeableList::const_iterator it,e;
  it = this->networkStream->getSyncBegin();
  e = this->networkStream->getSyncEnd();

  while ( it != e )
  {
    if ( (*it)->getUniqueID() == uniqueID )
    {
      delete *it;
      break;
    }
  }
}

/**
 * Tell the synchronizeable that a user's synchronizeable is out of sync
 * @param uniqueID: unique ID assigned with the entity which is out of sync
 * @param userID: user ID who's synchronizeable is out of sync
 */
void NetworkGameManager::doRequestSync( int uniqueID, int userID )
{
  SynchronizeableList::const_iterator it,e;
  it = this->networkStream->getSyncBegin();
  e = this->networkStream->getSyncEnd();

  while ( it != e )
  {
    if ( (*it)->getUniqueID() == uniqueID )
    {
      (*it)->requestSync( userID );
      break;
    }
  }
}