networkmgr.h

Go to the documentation of this file.

/*
 * networkmgr.h
 *
 * Copyright (C) 2003 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 __NETWORKMGR_H__
#define __NETWORKMGR_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/csstring.h>

//=============================================================================
// Library Includes
//=============================================================================
#include "net/cmdbase.h"            // Subscriber class
#include "net/npcmessages.h"
#include "util/serverconsole.h"     // iCommandCatcher

class MsgHandler;
class EventManager;
class psLinearMovement;

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

class psNPCCommandsMessage;
class psNetConnection;
class psGameEvent;
class NPC;
class gemNPCActor;
class gemNPCObject;
class gemNPCItem;

class NetworkManager : public psClientNetSubscriber
{
protected:
    MsgHandler* msghandler;
    psNetConnection* connection;
    bool ready;
    bool connected;

    // Command Message Queue
    psNPCCommandsMessage* outbound;
    csHash<NPC*,PID>      cmd_dr_outbound; 
    int                   cmd_count;       

    void RequestAllObjects();

    bool HandleMapList(MsgEntry* msg);

    bool HandleNPCList(MsgEntry* msg);

    void HandlePositionUpdates(MsgEntry* msg);

    void HandlePersistMessage(MsgEntry* msg);

    void HandlePerceptions(MsgEntry* msg);

    void HandleDisconnect(MsgEntry* msg);

    void HandleHiredNPCScript(MsgEntry* me);

    void HandleTimeUpdate(MsgEntry* msg);

    void HandleNPCWorkDone(MsgEntry* msg);

    void HandleNewNpc(MsgEntry* msg);

    void HandleNpcDeleted(MsgEntry* msg);

    void HandleConsoleCommand(MsgEntry* me);

    void HandleRaceList(MsgEntry* me);

    void HandleAllEntities(MsgEntry* message);

    void HandleActor(MsgEntry* msg);

    void HandleItem(MsgEntry* me);

    void HandleObjectRemoval(MsgEntry* me);

    void HandlePathNetwork(MsgEntry* me);

    void HandleLocation(MsgEntry* me);

    csString host,password,user;
    int port;

public:

    NetworkManager(MsgHandler* mh,psNetConnection* conn, iEngine* engine);

    virtual ~NetworkManager();

    virtual void HandleMessage(MsgEntry* pMsg);

    void Authenticate(csString &host,int port,csString &user,csString &pass);
    bool IsReady()
    {
        return ready;
    }
    void Disconnect();

    void CheckCommandsOverrun(size_t neededSize);

private:

    void QueueDRDataCommand(NPC* npc);

public:
    void PrepareCommandMessage();

    void SendAllCommands(bool final = false);

    void QueueDRData(NPC* npc);

    void QueueDRData2(NPC* npc);

    void DequeueDRData(NPC* npc);

    void QueueAttackCommand(gemNPCActor* attacker, gemNPCActor* target, const char* stance, const char* attack_type);

    void QueueScriptCommand(gemNPCActor* npc, gemNPCObject* target, const csString &scriptName);

    void QueueSitCommand(gemNPCActor* npc, gemNPCObject* target, bool sit);

    void QueueSpawnCommand(gemNPCActor* mother, gemNPCActor* father, const csString &tribeMemberType);

    void QueueSpawnBuildingCommand(gemNPCActor* spawner, csVector3 where, iSector* sector, const char* buildingName, int tribeID, bool pickupable);

    void QueueUnbuildCommand(gemNPCActor* unbuilder, gemNPCItem* building);

    void QueueTalkCommand(gemNPCActor* speaker, gemNPCActor* target, psNPCCommandsMessage::PerceptionTalkType talkType, bool publicTalk, const char* text);

    void QueueVisibilityCommand(gemNPCActor* entity, bool status);

    void QueuePickupCommand(gemNPCActor* entity, gemNPCObject* item, int count);

    void QueueEmoteCommand(gemNPCActor* npc, gemNPCObject* target, const csString &cmd);

    void QueueAnimationCommand(gemNPCActor* npc, const csString &cmd);

    void QueueEquipCommand(gemNPCActor* entity, csString item, csString slot, int count);

    void QueueDequipCommand(gemNPCActor* entity, csString slot);

    void QueueWorkCommand(gemNPCActor* entity, const csString &type, const csString &resource);

    void QueueTransferCommand(gemNPCActor* entity, csString item, int count, csString target);

    void QueueDeleteNPCCommand(NPC* npcx);

    void QueueDropCommand(gemNPCActor* entity, csString slot);

    void QueueResurrectCommand(csVector3 where, float rot, iSector* sector, PID character_id);

    void QueueSequenceCommand(csString name, int cmd, int count);

    void QueueTemporarilyImperviousCommand(gemNPCActor* entity, bool impervious);

    void QueueSystemInfoCommand(uint32_t clientNum, const char* reply, ...);

    void QueueAssessCommand(gemNPCActor* entity, gemNPCObject* target, const csString &physicalAssessmentPerception,
                            const csString &magicalAssessmentPerception,  const csString &overallAssessmentPerception);

    void QueueCastCommand(gemNPCActor* entity, gemNPCObject* target, const csString &spell, float kFactor);

    void QueueBusyCommand(gemNPCActor* entity, bool busy);

    void QueueControlCommand(gemNPCActor* controllingEntity, gemNPCActor* controlledEntity);

    void QueueLootCommand(gemNPCActor* entity, EID targetEID, const csString &type);

    void SendConsoleCommand(const char* cmd);

    csStringHashReversible* GetMsgStrings();

    const char* GetCommonString(uint32_t cstr_id);

    uint32_t GetCommonStringID(const char* string);

    void ReAuthenticate();

    void ReConnect();

    bool reconnect; 

private:
    iEngine* engine;
};

class psNPCReconnect : public psGameEvent
{
protected:
    NetworkManager* networkMgr;
    bool authent;

public:
    psNPCReconnect(int offsetticks, NetworkManager* mgr, bool authent);
    virtual void Trigger();  // Abstract event processing function
};

#endif