pstrade.h

Go to the documentation of this file.

/*
 * pstrade.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.
 *
 * Defines crafting transformations, combinations, processes and patterns.
 */

#ifndef __PSTRADE_H__
#define __PSTRADE_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/csstring.h>

//=============================================================================
// Project Includes
//=============================================================================
#include <idal.h>
#include "util/mathscript.h"

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


class psTradeCombinations;

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

class psTradeCombinations
{
public:
    psTradeCombinations();
    ~psTradeCombinations();

    bool Load(iResultRow &row);

    uint32 GetId() const
    {
        return id;
    }
    uint32 GetPatternId() const
    {
        return patternId;
    }
    uint32 GetResultId() const
    {
        return resultId;
    }
    int GetResultQty() const
    {
        return resultQty;
    }
    uint32 GetItemId() const
    {
        return itemId;
    }
    int GetMinQty() const
    {
        return minQty;
    }
    int GetMaxQty() const
    {
        return maxQty;
    }

protected:
    uint32 id;
    uint32 patternId;
    uint32 resultId;
    int resultQty;
    uint32 itemId;
    int minQty;
    int maxQty;
};

class psTradeTransformations : public iScriptableVar
{
public:
    psTradeTransformations();
    psTradeTransformations(uint32 rId, int rQty, uint32 iId, int iQty, char* tPoints);
    ~psTradeTransformations();

    bool Load(iResultRow &row);

    uint32 GetId() const
    {
        return id;
    }
    uint32 GetPatternId() const
    {
        return patternId;
    }
    uint32 GetProcessId() const
    {
        return processId;
    }
    uint32 GetResultId() const
    {
        return resultId;
    }

    int GetResultQty() const
    {
        return resultQty;
    }

    uint32 GetItemId() const
    {
        return itemId;
    }
    void SetItemId(uint32 newItemId)
    {
        itemId = newItemId;
    }

    int GetItemQty() const
    {
        return itemQty;
    }
    void SetItemQty(int newItemQty)
    {
        itemQty = newItemQty;
    }

    float GetItemQualityPenaltyPercent() const
    {
        return penaltyPct;
    }

    int GetTransPoints() const
    {
        MathEnvironment env;
        return transPoints->Evaluate(&env);
    }

    int GetTransformationCacheFlag()
    {
        return transCached;
    }


    const char* ToString();

    double CalcFunction(MathEnvironment* env, const char* functionName, const double* params);

    double GetProperty(MathEnvironment* env, const char* ptr);

protected:
    uint32 id;
    uint32 patternId;
    uint32 processId;
    uint32 resultId;
    int resultQty;
    uint32 itemId;
    int itemQty;
    float penaltyPct;
    MathExpression* transPoints;

private:
    bool transCached;
};

class psTradeProcesses : public iScriptableVar
{
public:
    psTradeProcesses();
    ~psTradeProcesses();

    bool Load(iResultRow &row);

    uint32 GetProcessId() const
    {
        return processId;
    }

    csString GetName() const
    {
        return name;
    }
    csString GetAnimation() const
    {
        return animation;
    }
    uint32 GetWorkItemId() const
    {
        return workItemId;
    }
    uint32 GetEquipementId() const
    {
        return equipmentId;
    }
    const char* GetConstraintString() const
    {
        return constraints;
    }
    uint32 GetGarbageId() const
    {
        return garbageId;
    }
    int GetGarbageQty() const
    {
        return garbageQty;
    }
    int GetPrimarySkillId() const
    {
        return priSkillId;
    }
    int GetSubprocessId() const
    {
        return subprocess;
    }
    unsigned int GetMinPrimarySkill() const
    {
        return minPriSkill;
    }
    unsigned int GetMaxPrimarySkill() const
    {
        return maxPriSkill;
    }
    int GetPrimaryPracticePts() const
    {
        return priPracticePts;
    }    int GetPrimaryQualFactor() const
    {
        return priQualFactor;
    }
    int GetSecondarySkillId() const
    {
        return secSkillId;
    }
    unsigned int GetMinSecondarySkill() const
    {
        return minSecSkill;
    }
    unsigned int GetMaxSecondarySkill() const
    {
        return maxSecSkill;
    }
    int GetSecondaryPracticePts() const
    {
        return secPracticePts;
    }
    int GetSecondaryQualFactor() const
    {
        return secQualFactor;
    }
    csString &GetRenderEffect()
    {
        return renderEffect;
    }

    MathScript* GetScript()
    {
        return script;
    }

    csString GetScriptName() const
    {
        return scriptName;
    }


    const char* ToString();

    double CalcFunction(MathEnvironment* env, const char* functionName, const double* params);

    double GetProperty(MathEnvironment* env, const char* ptr);

protected:
    uint32 processId;
    int subprocess;
    csString name;
    csString animation;
    uint32 workItemId;
    uint32 equipmentId;
    csString constraints;
    uint32 garbageId;
    int garbageQty;
    int priSkillId;
    int minPriSkill;
    int maxPriSkill;
    int priPracticePts;
    int priQualFactor;
    int secSkillId;
    int minSecSkill;
    int maxSecSkill;
    int secPracticePts;
    int secQualFactor;
    csString renderEffect;
    csString scriptName;
    MathScript* script;
};

class psTradePatterns
{
public:
    psTradePatterns();
    ~psTradePatterns();
    bool Load(iResultRow &row);

    uint32 GetId() const
    {
        return id;
    }
    uint32 GetGroupPatternId() const
    {
        return groupPatternId;
    }
    const char* GetPatternString() const
    {
        return patternName;
    }
    uint32 GetDesignItemId() const
    {
        return designItemId;
    }
    float GetKFactor() const
    {
        return KFactor;
    }

protected:
    uint32 id;
    uint32 groupPatternId;
    csString patternName;
    uint32 designItemId;
    float KFactor;
};

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

struct CombinationConstruction
{
    uint32 resultItem;
    int resultQuantity;
    csPDelArray<psTradeCombinations> combinations;
};

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

struct CraftSkills
{
    int priSkillId;
    int minPriSkill;
    int secSkillId;
    int minSecSkill;
};

struct CraftTransInfo
{
    int priSkillId;
    int minPriSkill;
    int secSkillId;
    int minSecSkill;
    csString craftStepDescription;
};

struct CraftComboInfo
{
    csArray<CraftSkills*>* skillArray;
    csString craftCombDescription;
};

#endif