psserver.h

Go to the documentation of this file.

/*
 * psserver.h
 *
 * Copyright (C) 2001 Atomic Blue (info@planeshift.it, http://www.atomicblue.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 (version 2 of the License)
 * 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.
 *
 */

#ifndef __PSSERVER_H__
#define __PSSERVER_H__
#include "psstdint.h"

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/ref.h>
#include <csutil/randomgen.h>
#include <csutil/csstring.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "util/psconst.h"

//=============================================================================
// Local Includes
//=============================================================================


struct iObjectRegistry;
struct iConfigManager;
class  NetManager;
struct iChat;
class  EntityManager;
class  MsgHandler;          // Receive and distributes incoming messages.
class  AuthenticationServer;
class  ChatManager;
class  GuildManager;
class  GroupManager;
class  AdminManager;
class  UserManager;
class  WeatherManager;
class  psTimerThread;
class  psDatabase;
class  ServerCharManager;
class  SpawnManager;
class  EventManager;
class  TutorialManager;
class  ServerStatus;
class  psMarriageManager;
class  CombatManager;
class  SpellManager;
class  ExchangeManager;
class  ProgressionManager;
class  NPCManager;
class  CacheManager;
class  psCharacterLoader;
class  csRandomGen;
class  CharCreationManager;
class  QuestManager;
class  EconomyManager;
class  WorkManager;
class  QuestionManager;
class  ClientConnectionSet;
class  Client;
class  MathScriptEngine;
class  AdviceManager;
class  ActionManager;
class  IntroductionManager;
class  ServerSongManager;
class  MiniGameManager;
class  LogCSV;
class  iResultSet;
class  csVector3;
struct iVFS;
class  GMEventManager;
class  BankManager;
class  HireManager;
class  ServerConsole;
class  psQuitEvent;

class psServer
{
public:

    psServer();

    ~psServer();

    bool Initialize(iObjectRegistry* objreg);

    void MainLoop();

    bool IsMapLoaded()
    {
        return MapLoaded;
    }

    bool LoadMap(const char* mapname);

    bool IsReady();

    bool HasBeenReady();

    bool IsFull(size_t numclients, Client* client);

    void RemovePlayer(uint32_t clientnum,const char* reason);

    void MutePlayer(uint32_t clientnum,const char* reason);

    void UnmutePlayer(uint32_t clientnum,const char* reason);

    const char* GetMOTD()
    {
        return (const char*)motd.GetData();
    }

    void SetMOTD(const char* str)
    {
        motd=str;
    }

    NetManager* GetNetManager()
    {
        return netmanager;
    }

    ChatManager* GetChatManager()
    {
        return chatmanager;
    }

    AdviceManager* GetAdviceManager()
    {
        return advicemanager;
    }

    ActionManager* GetActionManager()
    {
        return actionmanager;
    }

    NPCManager* GetNPCManager()
    {
        return npcmanager;
    }

    psDatabase* GetDatabase()
    {
        return database;
    }

    iConfigManager* GetConfig()
    {
        return configmanager;
    }

    iObjectRegistry* GetObjectReg()
    {
        return objreg;
    }

    SpawnManager* GetSpawnManager()
    {
        return spawnmanager;
    }

    EventManager* GetEventManager()
    {
        return eventmanager;
    }

    WeatherManager*  GetWeatherManager()
    {
        return weathermanager;
    }

    MathScriptEngine*  GetMathScriptEngine()
    {
        return mathscriptengine;
    }

    AdminManager* GetAdminManager()
    {
        return adminmanager;
    }

    ServerCharManager* GetCharManager()
    {
        return charmanager;
    }

    ProgressionManager* GetProgressionManager()
    {
        return progression;
    }

    psMarriageManager* GetMarriageManager()
    {
        return marriageManager;
    }

    ExchangeManager* GetExchangeManager()
    {
        return exchangemanager;
    }

    CombatManager* GetCombatManager()
    {
        return combatmanager;
    }

    SpellManager* GetSpellManager()
    {
        return spellmanager;
    }

    WorkManager* GetWorkManager()
    {
        return workmanager;
    }

    GuildManager* GetGuildManager()
    {
        return guildmanager;
    }

    EconomyManager* GetEconomyManager()
    {
        return economymanager;
    }

    MiniGameManager* GetMiniGameManager()
    {
        return minigamemanager;
    }

    GMEventManager* GetGMEventManager()
    {
        return gmeventManager;
    }

    BankManager* GetBankManager()
    {
        return bankmanager;
    }

    HireManager* GetHireManager()
    {
        return hiremanager;
    }

    UserManager* GetUserManager()
    {
        return usermanager;
    }

    CacheManager* GetCacheManager()
    {
        return cachemanager;
    }

    IntroductionManager* GetIntroductionManager()
    {
        return intromanager;
    }

    ServerSongManager* GetSongManager()
    {
        return songManager;
    }

    TutorialManager* GetTutorialManager()
    {
        return tutorialmanager;
    }

    AuthenticationServer* GetAuthServer()
    {
        return authserver;
    }

    ClientConnectionSet* GetConnections();

    float GetRandom()
    {
        return rng->Get();
    }

    float GetRandomRange(const float pos, const float range)
    {
        return (pos - range + GetRandom()*range*2);
    }

    uint32 GetRandom(uint32 limit)
    {
        return rng->Get(limit);
    }

    void SendSystemInfo(int clientnum, const char* fmt, ...);

    void SendSystemBaseInfo(int clientnum, const char* fmt, ...);

    void SendSystemResult(int clientnum,const char* fmt, ...);

    void SendSystemOK(int clientnum,const char* fmt, ...);

    void SendSystemError(int clientnum, const char* fmt, ...);

    LogCSV* GetLogCSV()
    {
        return logcsv;
    }

    void LoadLogSettings();

    void SaveLogSettings();

    bool AddBuddy(PID self, PID buddy);

    bool RemoveBuddy(PID self, PID buddy);

    void UpdateDialog(const char* area, const char* trigger,
                      const char* response, int num);

    void UpdateDialog(const char* area, const char* trigger,
                      const char* prohim, const char* proher,
                      const char* it,     const char* them);

    iResultSet* GetAllTriggersInArea(csString data);

    iResultSet* GetSuperclientNPCs(int superclientID);

    bool GetServerOption(const char* option_name,csString &value);

    bool SetServerOption(const char* option_name,const csString &value);

    iResultSet* GetAllResponses(csString &trigger);

    bool CheckAccess(Client* client, const char* command, bool returnError=true);

    void QuitServer(int time, Client* client);

    PID GetUnusedPID()
    {
        return --unused_pid;
    }

    QuestManager* GetQuestManager()
    {
        return questmanager;
    }


    static psCharacterLoader        CharacterLoader;

    NPCManager*                     npcmanager;
    psMarriageManager*              marriageManager;
    CombatManager*                  combatmanager;
    csRandomGen*                    rng;
    QuestManager*                   questmanager;
    CharCreationManager*            charCreationManager;
    csRef<GuildManager>             guildmanager;
    csRef<QuestionManager>          questionmanager;
    csRef<GroupManager>             groupmanager;
    UserManager*                    usermanager;
    ExchangeManager*                exchangemanager;
    EntityManager*                  entitymanager;
    CacheManager*                   cachemanager;
    csRef<iVFS>                     vfs;

protected:

    ServerConsole*                  serverconsole;
    NetManager*                     netmanager;
    AdminManager*                   adminmanager;
    psDatabase*                     database;
    ServerCharManager*              charmanager;
    SpawnManager*                   spawnmanager;
    csRef<EventManager>             eventmanager;
    WeatherManager*                 weathermanager;
    SpellManager*                   spellmanager;
    ProgressionManager*             progression;
    WorkManager*                    workmanager;
    EconomyManager*                 economymanager;
    TutorialManager*                tutorialmanager;
    MiniGameManager*                minigamemanager;
    IntroductionManager*            intromanager;
    ServerSongManager*              songManager;
    MathScriptEngine*               mathscriptengine;
    iObjectRegistry*                objreg;
    csRef<iConfigManager>           configmanager;
    csRef<ChatManager>              chatmanager;
    csRef<AdviceManager>            advicemanager;
    csRef<ActionManager>            actionmanager;
    csRef<AuthenticationServer>   authserver;
    LogCSV*                         logcsv;
    bool                            MapLoaded;
    csString                        motd;
    GMEventManager*                 gmeventManager;
    BankManager*                    bankmanager;
    HireManager*                    hiremanager;

    psQuitEvent* server_quit_event; 

    uint32_t unused_pid;
};

#endif