pvvmud/gos/gos.C

/*
 * PVVMUD a 3D MUD
 * Copyright (C) 1998-1999  Programvareverkstedet (pvv@pvv.org)
 *
 * 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 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#include "pvvmud.H"
#include <iostream.h>
#include "socket.H"
#include "gos.H"
#include "gosmanager.H"
#include "gossrvmanager.H"

CGOS::CGOS(COption *option){

  char *gosLibPath;

  gosLibPath=option->getString("goslib");

  printf("goslibpath:%s\n",gosLibPath);

  m_timeKeeper = new CTimeKeeper();
  m_cliManagerList = new CObjectList();
  m_srvManager = NULL;
  m_srvSocket = NULL;

  m_geoCache = new CGeoCache(gosLibPath);
  m_matCache = new CMatCache(gosLibPath);
  m_texCache = new CTexCache(gosLibPath);

  CClientSocket * socket = NULL; 
  try {
    CInetAddress server(option->getString("server"),SERVER_GOS_PORT);

    socket = new CClientSocket(server.getAddress(),server.getPort());
    socket->setNonBlocking();
    cout << "GOS Server manager connected\n";
    addSrvManager( new CGOSSrvManager(this, new CGOSSrvProtocol(socket,m_timeKeeper)));
  } catch (CSocketException * e){
    cout << "Failed to connect to server!\n";
    delete e;
    startSrvSocket();
  }

  try {
    m_cliSocket = new CGOSCliSrvSocket(this,option->getString("address"),
          option->getInt("port"),m_timeKeeper);
  } catch (CSocketException * e){
    cout << "Failed to create client SrvSocket!\n";
    delete e;
    exit(1);
  }

  m_timeKeeper->addHeartBeat(4*1024,this);
  
}

CGOS::~CGOS(){

  m_timeKeeper->rmHeartBeat(this);

  m_cliManagerList->deleteAll();
  delete m_cliManagerList;
  
  if (m_srvManager != NULL) delete m_srvManager;

  m_cliSocket->close();
  delete m_cliSocket;

  stopSrvSocket();

  delete m_timeKeeper;

  delete m_geoCache;
  delete m_matCache;
  delete m_texCache;

}

CInetAddress &CGOS::getAddress(){
  return m_cliSocket->getLocalAddress();
}

int CGOS::timeKeeperHB(){
//  cout << "Heart beat\n";
  CObjectListItem * item = m_cliManagerList->getFirst();
  while (item != NULL){
    CGOSCliManager * cliManager = (CGOSCliManager*)item->getObject();
    item = item->getNext();

    if (cliManager->getQuit()){
      cout << "Client " << cliManager->getId() << " deleted\n";
      removeCliManager(cliManager);
    }

  }

  if ((m_srvSocket != NULL) && (m_srvSocket->getQuit())){
    stopSrvSocket();
  }

  if ((m_srvManager != NULL) && (m_srvManager->getQuit())){
    cout << "GOS Server manager deleted\n";
    removeSrvManager(m_srvManager);
  }

  return TRUE;
}

void CGOS::addCliManager(CGOSCliManager * cliManager){
  m_cliManagerList->addLast((CObject*)cliManager);
}

void CGOS::removeCliManager(CGOSCliManager * cliManager){
  m_cliManagerList->remove((CObject*)cliManager);
  delete cliManager;
}

void CGOS::addSrvManager(CGOSSrvManager * srvManager){
  if (m_srvManager != NULL){
    cout << "WARNING: Multiple servers connected!!\nDeleting old server\n";
    delete m_srvManager;
  }
  m_srvManager = srvManager;
}

void CGOS::removeSrvManager(CGOSSrvManager * srvManager){
  if (srvManager != m_srvManager){
    cout << "WARNING:  Removing a not assigned server!\n";
    delete srvManager;
  } else {
    delete m_srvManager;
    m_srvManager = NULL;
    startSrvSocket();
  }
}

void CGOS::startSrvSocket(){
  if (m_srvSocket != NULL){
    cout << "WARNING: Server SrvSocket started!\n";
  }
  try {
    m_srvSocket = new CGOSSrvSrvSocket(this,GOS_SERVER_PORT,m_timeKeeper);
    cout << "Server SrvSocket started\n";
  } catch (CSocketException * e){
    cout << "Failed to create server SrvSocket!\n";
    delete e;
  }
}

void CGOS::stopSrvSocket(){
  if (m_srvSocket != NULL){
    m_srvSocket->close();
    delete m_srvSocket;
    m_srvSocket = NULL;
    cout << "Server SrvSocket stoped\n";
  }
}

void CGOS::quit(){
  m_timeKeeper->stopLoop();
}

void CGOS::restart(){
  m_geoCache->clear();
  m_matCache->clear();
  m_texCache->clear();
}

void CGOS::run(){
  m_timeKeeper->mainLoop();
}

CMsgGeometry * CGOS::getGeometry(int id){
  return (CMsgGeometry*)m_geoCache->get(id);
}

CMsgMaterial * CGOS::getMaterial(int id){
  return (CMsgMaterial*)m_matCache->get(id);
}

CMsgTexture * CGOS::getTexture(int id){
  return (CMsgTexture*)m_texCache->get(id);
}