psengine.h

Go to the documentation of this file.

/*
 * psengine.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 __ENGINE_H__
#define __ENGINE_H__

#include <csutil/csstring.h>
#include <csutil/strhashr.h>
#include <csutil/randomgen.h>
#include <csutil/refarr.h>
#include <csutil/sysfunc.h>
#include <csutil/leakguard.h>
#include <csutil/eventhandlers.h>
#include <csutil/weakrefarr.h>
#include <csutil/weakreferenced.h>
#include <ivaria/profile.h>
#include <ivideo/graph3d.h>
#include <iutil/eventh.h>

#include "psnetmanager.h"
#include "isoundmngr.h"

#include "util/slots.h"

class psCelClient;
class ClientMsgHandler;
class psClientCharManager;
struct iBgLoader;
struct iConfigManager;
struct iDialogManager;
struct iDocumentSystem;
struct iEngine;
struct iEvent;
struct iEventQueue;
struct iFont;
struct iGraphics2D;
struct iGraphics3D;
struct iSceneManipulate;
struct iTextureManager;
struct iThreadReturn;
struct iVFS;
struct iVirtualClock;
class ModeHandler;
class ActionHandler;
class ZoneHandler;
class psCharController;
class psCamera;
class psEffectManager;
class psChatBubbles;
class psCal3DCallbackLoader;
class psMainWidget;
class psQuestionClient;
class psOptions;
class psCSSetup;
class psMouseBinds;
class psInventoryCache;
class PawsManager;
class Autoexec;

// Networking classes
class ClientMsgHandler;
class psNetManager;
class psSlotManager;
class ClientSongManager;

class GUIHandler;

struct DelayedLoader : public CS::Utility::WeakReferenced
{
    virtual bool CheckLoadStatus() = 0;
    virtual ~DelayedLoader() { };
};

class psEngine
{
public:
    enum LoadState
    {
        LS_NONE,
        LS_LOAD_SCREEN,
        LS_INIT_ENGINE,
        LS_REQUEST_WORLD,
        LS_SETTING_CHARACTERS,
        LS_CREATE_GUI,
        LS_DONE,
        LS_ERROR
    };

    psEngine(iObjectRegistry* object_reg, psCSSetup* CSSetup);

    virtual ~psEngine();

    bool Initialize(int level);

    void Cleanup();

    void ResetEngine();

    void UpdatePerFrame();

    void FinishFrame()
    {
        g3d->FinishDraw();
        g3d->Print(NULL);
    }

    bool ProcessLogic(iEvent &Event);
    bool Process2D(iEvent &Event);
    bool Process3D(iEvent &Event);
    bool ProcessFrame(iEvent &Event);

    void LoadGame();

    bool IsGameLoaded()
    {
        return gameLoaded;
    };

    // References to plugins
    iObjectRegistry*      GetObjectRegistry()
    {
        return object_reg;
    }
    iEventNameRegistry*   GetEventNameRegistry()
    {
        return nameRegistry;
    }
    iEngine*              GetEngine()
    {
        return engine;
    }
    iGraphics3D*          GetG3D()
    {
        return g3d;
    }
    iGraphics2D*          GetG2D()
    {
        return g2d;
    }
    iTextureManager*      GetTextureManager()
    {
        return txtmgr;
    }
    iVFS*                 GetVFS()
    {
        return vfs;
    }
    iVirtualClock*        GetVirtualClock()
    {
        return vc;
    }
    iDocumentSystem*      GetXMLParser()
    {
        return xmlparser;
    }
    iConfigManager*       GetConfig()
    {
        return cfgmgr;    
    }
    iBgLoader*            GetLoader()
    {
        return loader;
    }
    iSceneManipulate*     GetSceneManipulator()
    {
        return scenemanipulator;
    }
    iSoundManager*        GetSoundManager()
    {
        return SoundManager;
    }

    csRandomGen &GetRandomGen()
    {
        return random;
    }
    float GetRandom()
    {
        return random.Get();
    }

    ClientMsgHandler*    GetMsgHandler()
    {
        return netmanager->GetMsgHandler();
    }
    CmdHandler*            GetCmdHandler()
    {
        return netmanager->GetCmdHandler();
    }
    psSlotManager*         GetSlotManager()
    {
        return slotManager;
    }
    ClientSongManager*     GetSongManager()
    {
        return songManager;
    }
    psClientCharManager*   GetCharManager()
    {
        return charmanager;
    }
    psCelClient*           GetCelClient()
    {
        return celclient;
    };
    psMainWidget*          GetMainWidget()
    {
        return mainWidget;
    }
    psEffectManager*       GetEffectManager()
    {
        return effectManager;
    }
    psChatBubbles*         GetChatBubbles()
    {
        return chatBubbles;
    }
    psOptions*             GetOptions()
    {
        return options;
    }
    ModeHandler*           GetModeHandler()
    {
        return modehandler;
    }
    ActionHandler*         GetActionHandler()
    {
        return actionhandler;
    }
    psCharController*      GetCharControl()
    {
        return charController;
    }
    psMouseBinds*          GetMouseBinds();
    psCamera*              GetPSCamera()
    {
        return camera;
    }
    psNetManager*          GetNetManager()
    {
        return netmanager;
    }
    psCSSetup*             GetCSSetup()
    {
        return CS_Setup;
    }
    ZoneHandler*           GetZoneHandler()
    {
        return zonehandler;
    }
    Autoexec*              GetAutoexec()
    {
        return autoexec;
    }

    void SetTargetPetitioner(const char* pet)
    {
        targetPetitioner = pet;
    }
    
    const char* GetTargetPetitioner()
    {
        return targetPetitioner;
    }

    void QuitClient();

    void Disconnect();

    void StartLoad()
    {
        loadstate = LS_LOAD_SCREEN;
    }
    LoadState loadstate;

    size_t GetTime();

    float GetBrightnessCorrection()
    {
        return BrightnessCorrection;
    }
    
    void SetBrightnessCorrection(float B);

    void AdjustBrightnessCorrectionUp();

    void AdjustBrightnessCorrectionDown();

    void ResetBrightnessCorrection();
    
    void UpdateLights();

    float GetKFactor()
    {
        return KFactor;
    }
    void SetKFactor(float K)
    {
        KFactor = K;
    }

    iEvent* GetLastEvent()
    {
        return lastEvent;
    }

    // Functions to set and get frameLimit converted into a value of FPS for users
    void setLimitFPS(int);
    int getLimitFPS()
    {
        return maxFPS;
    }
    float getFPS()
    {
        return currFPS;
    }

    bool toggleFPS()
    {
        showFPS = !showFPS;
        return showFPS;
    }

    inline void SetDuelConfirm(int confirmType)
    {
        duelConfirmation = confirmType;
        WriteConfirmationSettings();
    }
    inline int GetDuelConfirm() const
    {
        return duelConfirmation;
    }
    inline void SetMarriageProposal(bool ignore)
    {
        marriageProposal = ignore;
        WriteConfirmationSettings();
    }
    inline bool GetMarriageProposal() const
    {
        return marriageProposal;
    }
    
    void WriteConfirmationSettings();
    
    bool LoadConfirmationSettings();

    bool LoadSoundSettings(bool forceDef);

    inline bool HasLoadedMap() const
    {
        return loadedMap;
    }

    void SetLoadedMap(bool value)
    {
        loadedMap = value;
    }

    bool LoadingError()
    {
        return loadError;
    }

    void LoadError(bool value)
    {
        loadError = value;
    }

    bool LoadPawsWidget(const char* title, const char* filename);

    bool LoadCustomPawsWidgets(const char* filename);

    SlotNameHash slotName;

    void AddLoadingWindowMsg(const csString &msg);

    void FatalError(const char* msg);

    bool IsLoggedIn()
    {
        return loggedIn;
    }
    void SetLoggedIn(bool v)
    {
        loggedIn = v;
    }

    void SetNumChars(int chars)
    {
        numOfChars = chars;
    }

    int GetNumChars()
    {
        return numOfChars;
    }

    const char* GetMainPlayerName();

    bool UpdateWindowTitleInformations();

    void ForceRefresh()
    {
        elapsed = 0;
    }

    void SetGuildName(const char* name)
    {
        guildname = name;
    }

    const char* GetGuildName()
    {
        return guildname;
    }

    bool GetMuteSoundsOnFocusLoss(void) const
    {
        return muteSoundsOnFocusLoss;
    }
    void SetMuteSoundsOnFocusLoss(bool value)
    {
        muteSoundsOnFocusLoss = value;
    }

    void MuteAllSounds(void);
    void UnmuteAllSounds(void);

    const char* FindCommonString(unsigned int cstr_id);

    csStringID FindCommonStringId(const char* str);

    csStringHashReversible* GetMsgStrings();

    bool GetSoundStatus()
    {
        return soundOn;
    }

    psInventoryCache* GetInventoryCache(void)
    {
        return inventoryCache;
    }

    bool BackgroundWorldLoading()
    {
        return backgroundWorldLoading;
    }

    void RegisterDelayedLoader(DelayedLoader* obj)
    {
        delayedLoaders.PushSmart(obj);
    }
    void UnregisterDelayedLoader(DelayedLoader* obj)
    {
        delayedLoaders.Delete(obj);
    }

    static csString hwRenderer;
    static csString hwVersion;
    static csString playerName;
#ifdef WIN32
    static HWND hwnd;
#endif

private:
    void LoadLogSettings();

    bool QueryPlugins();

    void DeclareExtraFactories();

    void HideWindow(const csString &widgetName);

    void FrameLimit();

    /* plugins we're using... */
    iObjectRegistry*          object_reg;     
    csRef<iEventNameRegistry> nameRegistry;   
    csRef<iEngine>            engine;         
    csRef<iConfigManager>     cfgmgr;         
    csRef<iTextureManager>    txtmgr;         
    csRef<iVFS>               vfs;            
    csRef<iGraphics2D>        g2d;            
    csRef<iGraphics3D>        g3d;            
    csRef<iEventQueue>        queue;          
    csRef<iVirtualClock>      vc;             
    csRef<iDocumentSystem>    xmlparser;      
    csRef<iSoundManager>      SoundManager;   
    csRef<iStringSet>         stringset;
    csRandomGen               random;

    csRef<psNetManager>       netmanager;   
    csRef<psCelClient>        celclient;    
    csRef<ModeHandler>        modehandler;  
    csRef<ActionHandler>      actionhandler;
    csRef<ZoneHandler>        zonehandler;  
    csRef<psCal3DCallbackLoader> cal3DCallbackLoader;
    psClientCharManager*      charmanager;  
    GUIHandler*               guiHandler;
    psCharController*         charController;
    psMouseBinds*             mouseBinds;
    psCamera*                 camera;
    csRef<psEffectManager>    effectManager;
    psChatBubbles*            chatBubbles;
    psOptions*                options;
    psSlotManager*            slotManager;
    ClientSongManager*        songManager;
    psQuestionClient*         questionclient;
    PawsManager*              paws;          
    psMainWidget*             mainWidget;    
    psInventoryCache*         inventoryCache;
    psCSSetup*                CS_Setup;
    csRef<iBgLoader>          loader;
    csRef<iSceneManipulate>   scenemanipulator;
    Autoexec*                 autoexec;

    /* status, misc. vars */
    bool gameLoaded; 
    bool modalMenu;
    bool loggedIn;

    csTicks loadtimeout;

    csString lasterror;

    csString guildname;

    bool drawScreen;

    // For splash progress.
    csRefArray<iThreadReturn> precaches;
    csRef<iStringArray> meshes;
    csRef<iStringArray> maps;
    size_t lastLoadingCount;

    // True if we've requested the main actor.
    bool actorRequested;

private:

    csString targetPetitioner;

    float BrightnessCorrection;

    float KFactor;           

    iEvent* lastEvent;

    int duelConfirmation;
    bool marriageProposal; 

    bool loadedMap;
    bool loadError; 
    csArray<csString> wdgProblems; 

    int numOfChars;

    csTicks elapsed;

    csTicks frameLimit;

    int maxFPS;

    float currFPS;
    unsigned int countFPS;
    unsigned int timeFPS;

    bool showFPS;

    csRef<iFont> font;

    bool muteSoundsOnFocusLoss;

    bool soundOn;

    bool backgroundWorldLoading;

    // Event ID cache
    csEventID event_frame;
    csEventID event_canvashidden;
    csEventID event_canvasexposed;
    csEventID event_focusgained;
    csEventID event_focuslost;
    csEventID event_mouse;
    csEventID event_keyboard;
    csEventID event_joystick;
    csEventID event_quit;

#if defined(CS_PLATFORM_UNIX) && defined(INCLUDE_CLIPBOARD)
    csEventID event_selectionnotify;
#endif

    class LogicEventHandler : public scfImplementation1<LogicEventHandler, iEventHandler>
    {
    public:
        LogicEventHandler(psEngine* parent) : scfImplementationType(this), parent(parent)
        {
        }

        virtual ~LogicEventHandler()
        {
        }

        virtual bool HandleEvent(iEvent &ev)
        {
            return parent->ProcessLogic(ev);
        }

        virtual const csHandlerID* GenericPrec(csRef<iEventHandlerRegistry> &,
                                               csRef<iEventNameRegistry> &, csEventID) const;
        virtual const csHandlerID* GenericSucc(csRef<iEventHandlerRegistry> &,
                                               csRef<iEventNameRegistry> &, csEventID) const;

        CS_EVENTHANDLER_NAMES("planeshift.client.frame.logic")
        CS_EVENTHANDLER_DEFAULT_INSTANCE_CONSTRAINTS

    private:
        psEngine* parent;
    };

    class EventHandler3D : public scfImplementation1<EventHandler3D, iEventHandler>
    {
    public:
        EventHandler3D(psEngine* parent) : scfImplementationType(this), parent(parent)
        {
        }

        virtual ~EventHandler3D()
        {
        }

        virtual bool HandleEvent(iEvent &ev)
        {
            return parent->Process3D(ev);
        }

        CS_EVENTHANDLER_PHASE_3D("planeshift.client.frame.3d");

    private:
        psEngine* parent;
    };

    class EventHandler2D : public scfImplementation1<EventHandler2D, iEventHandler>
    {
    public:
        EventHandler2D(psEngine* parent) : scfImplementationType(this), parent(parent)
        {
        }

        virtual ~EventHandler2D()
        {
        }

        virtual bool HandleEvent(iEvent &ev)
        {
            return parent->Process2D(ev);
        }

        CS_EVENTHANDLER_PHASE_2D("planeshift.client.frame.2d");

    private:
        psEngine* parent;
    };

    class FrameEventHandler : public scfImplementation1<FrameEventHandler, iEventHandler>
    {
    public:
        FrameEventHandler(psEngine* parent) : scfImplementationType(this), parent(parent)
        {
        }

        virtual ~FrameEventHandler()
        {
        }

        virtual bool HandleEvent(iEvent &ev)
        {
            return parent->ProcessFrame(ev);
        }

        CS_EVENTHANDLER_PHASE_FRAME("planeshift.client.frame");

    private:
        psEngine* parent;
    };

    csRef<LogicEventHandler> eventHandlerLogic;
    csRef<EventHandler3D> eventHandler3D;
    csRef<EventHandler2D> eventHandler2D;
    csRef<FrameEventHandler> eventHandlerFrame;

    csWeakRefArray<DelayedLoader> delayedLoaders;
};

#endif