spawnmanager.h

Go to the documentation of this file.

/*
 * spawnmanager.h by Keith Fulton <[email protected]>
 *
 * Copyright (C) 2002 Atomic Blue ([email protected], 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 __SPAWNMANAGER_H__
#define __SPAWNMANAGER_H__

class gemObject;
class psCharacter;
class psDatabase;
class psScheduledItem;
class psSectorInfo;

#include <csgeom/vector3.h>
#include <csutil/hash.h>
#include "util/gameevent.h"
#include "msgmanager.h"
#include "lootrandomizer.h"


class SpawnRange
{
protected:
    csRandomGen* randomgen;

    int   id;

    char  type;  

    int   npcspawnruleid;

    csString spawnsector;

private:
    float x1;
    float y1;
    float z1;
    float x2;
    float y2;
    float z2;
    float radius;

    float area;

    csVector3 PickWithRadius(csVector3 pos, float radius);

public:
    SpawnRange();

    void Initialize(int idval,
                    int spawnruleid,
                    const char* type_code,
                    float rx1, float ry1, float rz1,
                    float rx2, float ry2, float rz2,
                    float radius,
                    const char* sectorname);

    void SetID(int idval)
    {
        id = idval;
    };
    int GetID()
    {
        return id;
    }

    float GetArea()
    {
        return area;
    };

    const csString &GetSector()
    {
        return spawnsector;
    }

    const csVector3 PickPos();
};

class LootEntrySet;

class SpawnRule
{
protected:

    csRandomGen* randomgen;

    int   id;

    int   minspawntime;

    int   maxspawntime;

    float substitutespawnodds;

    PID   substituteplayer;

    float    fixedspawnx;
    float    fixedspawny;
    float    fixedspawnz;
    float    fixedspawnrot;
    csString fixedspawnsector;
    InstanceID fixedinstance;
    float minSpawnSpacingDistance; 

    csHash<SpawnRange*> ranges;

    LootEntrySet* loot;

    int dead_remain_time;

public:

    SpawnRule();
    ~SpawnRule();

    void Initialize(int idval,
                    int minspawn,
                    int maxspawn,
                    float substodds,
                    int substplayer,
                    float x,float y,float z,float angle,
                    const char* sector,
                    LootEntrySet* loot_id,
                    int dead_time,
                    float minSpacing,
                    InstanceID instance);

    int  GetID()
    {
        return id;
    };
    void SetID(int idval)
    {
        id = idval;
    };

    int GetRespawnDelay();

    PID CheckSubstitution(PID originalplayer);

    bool DetermineSpawnLoc(psCharacter* ch, csVector3 &pos, float &angle, csString &sectorname, InstanceID &instance);

    void AddRange(SpawnRange* range);

    LootEntrySet* GetLootRules()
    {
        return loot;
    }

    int GetDeadRemainTime()
    {
        return dead_remain_time;
    }

    int GetMinSpawnSpacingDistance()
    {
        return minSpawnSpacingDistance;
    }

};

class psItemStats;
class psCharacter;

struct LootEntry
{
    psItemStats* item;
    int   min_item; 
    int   max_item; 
    float probability;
    int   min_money;
    int   max_money;
    bool  randomize;
    float randomizeProbability; 
};

class LootEntrySet
{
protected:
    int id;
    csArray<LootEntry*> entries;
    float total_prob;
    LootRandomizer* lootRandomizer;

    void CreateSingleLoot(psCharacter* chr);
    void CreateMultipleLoot(psCharacter* chr, size_t numModifiers = 0);

public:
    LootEntrySet(int idx, LootRandomizer* lr)
    {
        id=idx;
        total_prob=0;
        lootRandomizer=lr;
    }
    ~LootEntrySet();

    void AddLootEntry(LootEntry* entry);

    void CreateLoot(psCharacter* character, size_t numModifiers = 0);
};

class PendingLootPrompt;

class SpawnManager : public MessageManager<SpawnManager>
{
protected:
    psDatabase*             database;
    csHash<SpawnRule*>      rules;
    csHash<LootEntrySet*>   looting;
    LootRandomizer*         lootRandomizer;
    CacheManager*           cacheManager;
    EntityManager*          entityManager;
    GEMSupervisor*          gem;

    void HandleLootItem(MsgEntry* me,Client* client);
    void HandleDeathEvent(MsgEntry* me,Client* notused);

public:

    SpawnManager(psDatabase* db, CacheManager* cachemanager, EntityManager* entitymanager, GEMSupervisor* gemsupervisor);
    virtual ~SpawnManager();

    LootRandomizer* GetLootRandomizer()
    {
        return lootRandomizer;
    }

    void PreloadDatabase();

    void PreloadLootRules();

#if 0

    LoadWaypointsAsSpawnRanges(iDocumentNode* topNode);
#endif

    void LoadSpawnRanges(SpawnRule* rule);

    void LoadHuntLocations(psSectorInfo* sectorinfo = 0);

    void SpawnHuntLocations(Result &result, psSectorInfo* sectorinfo);

    void RepopulateLive(psSectorInfo* sectorinfo = 0);

    void Respawn(PID playerID, SpawnRule* spawnRule);

    void Respawn(psCharacter* chardata, InstanceID instance, csVector3 &where, float rot, const char* sector);

    void RepopulateItems(psSectorInfo* sectorinfo = 0);

    void KillNPC(gemActor* npc, gemActor* killer);

    void RemoveNPC(gemObject* obj);
};


class psRespawnGameEvent : public psGameEvent
{
protected:
    SpawnManager* spawnmanager;
    PID           playerID;    
    SpawnRule*    spawnRule;   

public:
    psRespawnGameEvent(SpawnManager* mgr,
                       int delayticks,
                       PID playerID,
                       SpawnRule* spawnRule);

    virtual void Trigger();  // Abstract event processing function
};

class psDespawnGameEvent : public psGameEvent
{
protected:
    SpawnManager* spawnmanager;
    GEMSupervisor* gem;
    EID entity;

public:
    psDespawnGameEvent(SpawnManager* mgr,
                       GEMSupervisor* gemSupervisor,
                       int delayticks,
                       gemObject* obj);

    virtual void Trigger();  // Abstract event processing function
};

class psItemSpawnEvent : public psGameEvent
{
public:
    psItemSpawnEvent(psScheduledItem* item);
    virtual ~psItemSpawnEvent();

    void Trigger();  // Abstract event processing function

protected:
    psScheduledItem* schedule;
};

void handleGroupLootItem(psItem* item, gemActor* obj, Client* client, CacheManager* cacheManager, GEMSupervisor* gem, uint8_t lootAction = 0);

#endif