workmanager.h

Go to the documentation of this file.

/*
* workmanager.h
*
* Copyright (C) 2001-2002 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 __WORKMANAGER_H__
#define __WORKMANAGER_H__

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/sysfunc.h>

//=============================================================================
// Project Includes
//=============================================================================

//=============================================================================
// Local Includes
//=============================================================================
#include "msgmanager.h"             // Parent class
#include "gem.h"

class psWorkGameEvent;
class WorkManager;
class psItem;
class Client;
struct CombinationConstruction;

// Define the work event types
#define MANUFACTURE 0                   
#define PRODUCTION  1                   
#define LOCKPICKING 2                   
#define CLEANUP     3                   
#define REPAIR      4                   

#define GARBAGE_PATTERNID   1           
#define CLEANUP_DELAY       600         
//#define CLEANUP_DELAY       10 


enum TradePatternMatch
{
    TRANSFORM_MATCH                 = 0x0000,       
    TRANSFORM_UNKNOWN_PATTERN       = 0x0001,       
    TRANSFORM_UNKNOWN_ITEM          = 0x0002,       
    TRANSFORM_MISSING_ITEM          = 0x0004,       
    TRANSFORM_UNKNOWN_WORKITEM      = 0x0008,       
    TRANSFORM_MISSING_EQUIPMENT     = 0x0010,       
    TRANSFORM_BAD_TRAINING          = 0x0020,       
    TRANSFORM_BAD_SKILLS            = 0x0040,       
    TRANSFORM_OVER_SKILLED          = 0x0080,       
    TRANSFORM_FAILED_CONSTRAINTS    = 0x0100,       
    TRANSFORM_BAD_QUANTITY          = 0x0200,       
    TRANSFORM_BAD_COMBINATION       = 0x0400,       
    TRANSFORM_TOO_MANY_ITEMS        = 0x0800,       
    TRANSFORM_BAD_USE               = 0x1000,       
    TRANSFORM_NO_STAMINA            = 0x2000,       
    TRANSFORM_GONE_WRONG            = 0x4000,       
    TRANSFORM_GARBAGE               = 0x8000        
};

enum TradeTransfomType
{
    TRANSFORMTYPE_UNKNOWN=0,        
    TRANSFORMTYPE_AUTO_CONTAINER,   
    TRANSFORMTYPE_SLOT,             
    TRANSFORMTYPE_CONTAINER,        
    TRANSFORMTYPE_SLOT_CONTAINER,   
    TRANSFORMTYPE_TARGETSLOT,       
    TRANSFORMTYPE_TARGET,           
    TRANSFORMTYPE_TARGET_TO_NPC,    
    TRANSFORMTYPE_SELF_CONTAINER    
};

//-----------------------------------------------------------------------------

struct NaturalResource
{
    int          sector;                
    csVector3    loc;                   
    float        radius;                
    float        visible_radius;        
    float        probability;           
    psSkillInfo* skill;                 
    int          skill_level;           
    unsigned int item_cat_id;           
    float        item_quality;          
    csString     anim;                  
    int          anim_duration_seconds; 
    int          reward;                
    csString     reward_nickname;       
    size_t       action;                
};


class NearNaturalResource
{
public:
    NearNaturalResource(NaturalResource* res, float distance) : resource(res), dist(distance) {}
    NaturalResource* resource;
    float dist;
    bool operator<(const NearNaturalResource &oth) const
    {
        if(oth.dist > dist)
            return true;
        if(oth.resource->probability > resource->probability)
            return true;
        if(oth.resource->skill_level > resource->skill_level)
            return true;
        return false;
    }
};

//-----------------------------------------------------------------------------

struct constraint
{
    bool (*constraintFunction)(WorkManager* that, char* param);
    const char* name;
    const char* message;
};

//-----------------------------------------------------------------------------

class WorkManager : public MessageManager<WorkManager>
{
public:

    WorkManager(CacheManager* cachemanager, EntityManager* entitymanager);
    virtual ~WorkManager();

//-----------------------------------------------------------------------------
// Entry points
//-----------------------------------------------------------------------------

    void HandleUse(Client* client);

    void HandleCombine(Client* client);

    void HandleConstruct(Client* client);

    void StartAutoWork(Client* client, gemContainer* container, psItem* autoItem, int count);

    bool StartScriptWork(Client* client, gemObject* target, csString pattern);

    void StopWork(Client* client, psItem* item);

    void HandleWorkEvent(psWorkGameEvent* workEvent);

    void HandleCleanupEvent(psWorkGameEvent* workEvent);

    void HandleProductionEvent(psWorkGameEvent* workEvent);

    void HandleRepairEvent(psWorkGameEvent* workEvent);
    void LockpickComplete(psWorkGameEvent* workEvent);

    static bool constraintTime(WorkManager* that, char* param);
    static bool constraintFriends(WorkManager* that,char* param);
    static bool constraintLocation(WorkManager* that,char* param);
    static bool constraintMode(WorkManager* that,char* param);
    static bool constraintGender(WorkManager* that,char* param);
    static bool constraintRace(WorkManager* that,char* param);
    void StartLockpick(Client* client,psItem* item);


    bool LoadLocalVars(Client* client, gemObject* target=NULL);

    /*
     * Send clear client view message to remove items from autocontainers.
     *
     * @param slotID The slot number to clear.
     * @param containerID The container ID that has item that needs to be cleared.
     *
     * @return False if there is a problem sending message.
     *
    bool SendClearUpdate( unsigned int slotID, unsigned int containerID ); */


    void HandleProduction(gemActor* actor,const char* type,const char* reward);

protected:
    csPDelArray<NaturalResource> resources;       

    csStringArray resourcesActions;
    MathScript* calc_repair_rank;                 
    MathScript* calc_repair_time;                 
    MathScript* calc_repair_result;               
    MathScript* calc_repair_quality;              
    MathScript* calc_repair_exp;                  
    MathScript* calc_lockpicking_exp;             
    MathScript* calc_mining_chance;               
    MathScript* calc_mining_exp;                  
    MathScript* calc_transform_exp;               
    MathScript* calc_transform_practice;          
    MathScript* calc_lockpick_time;               
    MathScript* calc_transform_apply_skill;       
    MathScript* calc_transform_time;              
    MathScript* calc_combine_quality;             


    void HandleLockPick(MsgEntry* me,Client* client);
    void HandleWorkCommand(MsgEntry* me,Client* client);

    void StopAutoWork(Client* client, psItem* autoItem);

    void StopUseWork(MsgEntry* me,Client* client);

    void StartUseWork(Client* client);

    void StopCombineWork(Client* client);

    void StartCombineWork(Client* client);

    void StartConstructWork(Client* client);

    void StopConstructWork(Client* client);

    void StopCleanupWork(Client* client, psItem* cleanItem);

    void SendTransformError(uint32_t clientNum, unsigned int result, uint32 curItemId = 0, int CurItemQty = 0);

    bool IsContainerCombinable(uint32 &resultId, int &resultQty);

    bool IsHandCombinable(uint32 &resultId, int &resultQty);

    bool ValidateCombination(csArray<psItem*> itemArray, uint32 &resultId, int &resultQty);

    bool AnyCombination(csArray<psItem*> itemArray, uint32 &resultId, int &resultQty);

    bool MatchCombinations(csArray<psItem*> itemArray, CombinationConstruction* current, int &multiplier);

    unsigned int AnyTransform(csArray<psTradePatterns*> &patterns, float &KFactor, uint32 targetId, int targetQty);

    unsigned int IsTransformable(uint32 patternId, uint32 targetId, int targetQty);

    bool ScriptNoTarget();
    bool ScriptActor(gemActor* gemAct);
    bool ScriptItem(gemItem* gemItm);
    bool ScriptAction(gemActionLocation* gemAction);

    bool CombineWork();
    bool IsIngredient(uint32 patternId, uint32 targetId);

    psItem* TransformSelfContainerItem(psItem* oldItem, uint32 newId, int newQty, float itemQuality, psTradeProcesses* process, psTradeTransformations* trans);

    psItem* TransformContainedItem(psItem* oldItem, uint32 newId, int newQty, float itemQuality, psTradeProcesses* process, psTradeTransformations* trans);

    psItem* CombineContainedItem(uint32 newId, int newQty, float itemQuality, psItem* containerItem);

    psItem* TransformSlotItem(INVENTORY_SLOT_NUMBER slot, uint32 newId, int newQty, float itemQuality, psTradeProcesses* process, psTradeTransformations* trans);

    psItem* TransformTargetSlotItem(INVENTORY_SLOT_NUMBER slot, uint32 newId, int newQty, float itemQuality, psTradeProcesses* process, psTradeTransformations* trans);

    psItem* TransformTargetItem(psItem* oldItem, uint32 newId, int newQty, float itemQuality, psTradeProcesses* process, psTradeTransformations* trans);

    void TransformTargetItemToNpc(psItem* workItem, Client* client);

    void ApplyProcessScript(psItem* oldItem, psItem* newItem, gemActor* worker, psTradeProcesses* process, psTradeTransformations* trans);
//    bool TransformHandItem(uint32 newId, int newQty, float itemQuality);
    //bool SendItemUpdate( INVENTORY_SLOT_NUMBER slotID, psItem *newItem );

    void StartTransformationEvent(int transType, INVENTORY_SLOT_NUMBER transSlot, int resultQty,
                                  float resultQuality, psItem* autoItem);
    void StartCleanupEvent(int transType, Client* client, psItem* item, gemActor* worker);

    bool ValidateTarget(Client* client);
    bool ValidateWork();
    bool ValidateMind();
    bool ValidateStamina(Client* client);
    bool IsOnHand(uint32 equipId);
    psItem* CreateTradeItem(uint32 newId, int newQty, float itemQuality, bool transient = false);
    bool ValidateTraining(psTradeTransformations* transCandidate, psTradeProcesses* processCandidate);
    bool ValidateSkills(psTradeTransformations* transCandidate, psTradeProcesses* processCandidate);
    bool ValidateNotOverSkilled(psTradeTransformations* transCandidate, psTradeProcesses* processCandidate);
    bool ValidateConstraints(psTradeTransformations* transCandidate, psTradeProcesses* processCandidate);

    int CalculateEventDuration(psTradeTransformations* trans, psTradeProcesses* process, psItem* transItem, gemActor* worker);

    bool CheckStamina(psCharacter* owner) const;

    void Initialize();

    bool CalculateQuality(float factor, psItem* transItem, gemActor* worker, bool amountModifier, float &currentQuality, psTradeProcesses* process, psTradeTransformations* trans, csTicks time);

    void HandleRepair(gemActor* actor, Client* client, const csString &repairSlotName);

    void HandleProduction(gemActor* actor, size_t type,const char* reward, Client* client = NULL);

    bool SameProductionPosition(gemActor* actor, const csVector3 &startPos);

    csArray<NearNaturalResource> FindNearestResource(iSector* sector, csVector3 &pos, const size_t action, const char* reward = NULL);

private:

    csWeakRef<gemActor> worker;     

    uint32_t clientNum;             
    psItem* workItem;               
    psItem* autoItem;               
    gemActor* owner;                
    gemObject* gemTarget;           
    csArray<psTradePatterns*> patterns; 
    uint32 groupPatternId;          
    float patternKFactor;           
    float currentQuality;           
    psTradeTransformations* trans;  
    psTradeProcesses* process;      
    const char* preworkModeString;  
    bool secure;                    

    CacheManager* cacheManager;
    EntityManager* entityManager;
};



//-----------------------------------------------------------------------------

class psWorkGameEvent : public psGameEvent, public iDeleteObjectCallback
{
public:
    psWorkGameEvent(WorkManager* mgr,
                    gemActor* worker,
                    int delayticks,
                    int cat,
                    csVector3 &pos,
                    csArray<NearNaturalResource>* natres=NULL,
                    Client* c=NULL,
                    psItem* object=NULL,
                    float repairAmount=0.0F);
    virtual ~psWorkGameEvent();

    void Interrupt();

    virtual void Trigger();  

    virtual void DeleteObjectCallback(iDeleteNotificationObject* object);

    void SetTransformation(psTradeTransformations* t)
    {
        transformation = t;
    }

    psTradeTransformations* GetTransformation()
    {
        return transformation;
    }

    void SetProcess(psTradeProcesses* p)
    {
        process = p;
    }

    psTradeProcesses* GetProcess()
    {
        return process;
    }

    int GetResultQuantity()
    {
        return resultQuantity;
    }
    void SetResultQuantity(int newQuantity)
    {
        resultQuantity = newQuantity;
    }

    float GetResultQuality()
    {
        return resultQuality;
    }
    void SetResultQuality(float newQuality)
    {
        resultQuality = newQuality;
    }

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

    INVENTORY_SLOT_NUMBER GetTransformationSlot()
    {
        return transSlot;
    }
    void SetTransformationSlot(INVENTORY_SLOT_NUMBER curSlot)
    {
        transSlot = curSlot;
    }

    psItem* GetTranformationItem()
    {
        return item;
    }
    void SetTransformationItem(psItem* i)
    {
        item = i;
    }

    psItem* GetWorkItem()
    {
        return workItem;
    }
    void SetWorkItem(psItem* w)
    {
        workItem = w;
    }

    gemObject* GetTargetGem()
    {
        return gemTarget;
    }
    void SetTargetGem(gemObject* g)
    {
        gemTarget = g;
    }

    int GetTransformationType()
    {
        return transType;
    }
    void SetTransformationType(int t)
    {
        transType = t;
    }

    WorkManager* workmanager;
    csWeakRef<gemActor> worker;
    csArray<NearNaturalResource> nrr;
    Client* client;
    gemObject* gemTarget;
    int category;
    csVector3 position;
    psItem*    object;
    psTradeTransformations* transformation;
    psTradeProcesses* process;
    float repairAmount;

    uint32_t effectID;      
    csArray<PublishDestination> multi;

private:
    int resultQuantity;
    float resultQuality;
    float KFactor;
    INVENTORY_SLOT_NUMBER transSlot;
    psItem* item;
    psItem* workItem;
    int transType;
};

#endif