psactionlocationinfo.h

Go to the documentation of this file.

/*
* psactionlocationinfo.h
*
* Copyright (C) 2005 Atomic Blue (info@planeshift.it, http://www.atomicblue.org)
*
* Credits :
*            Michael Cummings <cummings.michael@gmail.com>
*
* 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.
*
* Creation Date: 1/20/2005
* Description : Container for the action_locations db table.
*
*/
#ifndef __PSACTIONLOCATION_H__
#define __PSACTIONLOCATION_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/parray.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "util/poolallocator.h"
#include "util/psconst.h"

#include <idal.h>

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

class CacheManager;
class gemActionLocation;
class gemItem;
struct iDocumentNode;
class MathExpression;

class psActionLocation
{
public:
    typedef enum
    {
        TRIGGERTYPE_NONE,   
        TRIGGERTYPE_SELECT,
        TRIGGERTYPE_PROXIMITY
    } TriggerType;

    static const char* TriggerTypeStr[];

    psActionLocation();
    ~psActionLocation();

    bool Load(iResultRow &row);
    bool Load(csRef<iDocumentNode> root);
    bool Save();
    bool Delete();
    csString ToXML() const;

    int IsMatch(psActionLocation* compare);

    void SetGemObject(gemActionLocation* gemAction);
    gemActionLocation* GetGemObject(void);

    gemItem* GetRealItem();

    const csVector3 &GetPosition()
    {
        return position;
    }
    const csString &GetSectorName()
    {
        return sectorname;
    }
    //void SetLocationInWorld(psSectorInfo *sectorinfo,float loc_x,float loc_y,float loc_z,float loc_yrot);
    void Send(int clientnum);

    // Returns the result of the XML parsing of the action lcoation reponse string and
    //  the setting of the action location member variables
    bool ParseResponse();

    InstanceID GetInstanceID() const
    {
        return instanceID;
    }
    void SetInstanceID(InstanceID newID)
    {
        instanceID = newID;
    }

    MathExpression* GetEnterScript() const
    {
        return enterScript;
    }

    const csString &GetEntranceType() const
    {
        return entranceType;
    }
    void SetEntranceType(const csString &newType)
    {
        entranceType = newType;
    }

    bool IsGameBoard() const
    {
        return isGameBoard;
    }

    bool IsExamineScript() const
    {
        return isExamineScript;
    }

    bool IsEntrance() const
    {
        return isEntrance;
    }
    void SetIsEntrance(bool flag)
    {
        isEntrance = flag;
    }

    bool IsLockable() const
    {
        return isLockable;
    }
    void SetIsLockable(bool flag)
    {
        isLockable = flag;
    }

    bool IsContainer() const
    {
        return isContainer;
    }

    bool IsReturn() const
    {
        return isReturn;
    }

    bool IsActive() const
    {
        return isActive;
    }
    void SetActive(bool flag)
    {
        isActive = flag;
    }

    const csString &GetDescription() const
    {
        return description;
    }
    void SetDescription(const csString &newDescription)
    {
        description = newDescription;
    }

    csVector3 GetEntrancePosition() const
    {
        return entrancePosition;
    }
    void SetEntrancePosition(csVector3 newPosition)
    {
        entrancePosition = newPosition;
    }
    float GetEntranceRotation() const
    {
        return entranceRot;
    }
    void SetEntranceRotation(float newRot)
    {
        entranceRot = newRot;
    }
    const csString &GetEntranceSector() const
    {
        return entranceSector;
    }
    void SetEntranceSector(const csString &newSector)
    {
        entranceSector = newSector;
    }
    const InstanceID GetEntranceInstance() const
    {
        return entranceInstance;
    }
    void SetEntranceInstance(const InstanceID newInstance)
    {
        entranceInstance = newInstance;
    }

    csVector3 GetReturnPosition() const
    {
        return returnPosition;
    }
    void SetReturnPosition(csVector3 newPosition)
    {
        returnPosition = newPosition;
    }
    float GetReturnRotation() const
    {
        return returnRot;
    }
    void SetReturnRotation(float newRot)
    {
        returnRot = newRot;
    }
    const csString &GetReturnSector() const
    {
        return returnSector;
    }
    void SetReturnSector(const csString &newSector)
    {
        returnSector = newSector;
    }
    const InstanceID GetReturnInstance() const
    {
        return returnInstance;
    }
    void SetReturnInstance(const InstanceID newInstance)
    {
        returnInstance = newInstance;
    }

    void SetName(const csString &newname)
    {
        name = newname;
    }
    void SetSectorName(const csString &newsector)
    {
        sectorname = newsector;
    }
    void SetMeshName(const csString &newmeshname)
    {
        meshname = newmeshname;
    }
    void SetTriggerType(const TriggerType &newtrigger)
    {
        triggertype = newtrigger;
    }
    TriggerType GetTriggerType() const
    {
        return triggertype;
    }
    const char* GetTriggerTypeAsString() const
    {
        return TriggerTypeStr[triggertype];
    }
    void SetResponseType(const csString &newresponsetype)
    {
        responsetype = newresponsetype;
    }
    void SetResponse(const csString &newresponse)
    {
        response = newresponse;
    }
    void SetPosition(csVector3 newposition)
    {
        position = newposition;
    }

    void SetInstance(const InstanceID instance)
    {
        pos_instance = instance;
    }
    InstanceID GetInstance()
    {
        return pos_instance;
    }
    void SetRadius(float newradius)
    {
        radius = newradius;
    }

    void* operator new(size_t);
    void operator delete(void*);

    csString GetScriptToRun()
    {
        return scriptToRun;
    }
    csString GetScriptParameters()
    {
        return scriptParameters;
    }

    uint32 id;
    size_t master_id;

    csString name;
    csString sectorname; 
    csString meshname; 
    csString polygon; 
    csVector3 position; 
    InstanceID pos_instance; 
    float radius;
    TriggerType triggertype;
    csString responsetype;
    csString response;

    gemActionLocation* gemAction;

private:
    static PoolAllocator<psActionLocation> actionpool;

    void SetupEntrance(csRef<iDocumentNode> entranceNode);
    void SetupReturn(csRef<iDocumentNode> returnNode);
    void SetupContainer(csRef<iDocumentNode> containerNode);
    void SetupGameboard(csRef<iDocumentNode> boardNode);
    void SetupScript(csRef<iDocumentNode> scriptNode);
    void SetupDescription(csRef<iDocumentNode> descriptionNode);

    bool isContainer;

    bool isGameBoard;

    bool isEntrance;

    bool isLockable;

    bool isActive;

    bool isReturn;

    bool isExamineScript;

    csString scriptToRun;
    csString scriptParameters;

    InstanceID instanceID;

    csString entranceType;

    // Position stuff for entrances
    csVector3 entrancePosition;
    float entranceRot;
    csString entranceSector;
    InstanceID entranceInstance;

    MathExpression* enterScript;

    // Possition stuff for returns
    csVector3 returnPosition;
    float returnRot;
    csString returnSector;
    InstanceID returnInstance;


    csString description;


    //DB Helper Functions
    unsigned int Insert(const char* table, const char** fieldnames, psStringArray &fieldvalues);
    bool         UpdateByKey(const char* table, const char* idname, const char* idvalue, const char** fieldnames, psStringArray &fieldvalues);
    bool         DeleteByKey(const char* table, const char* idname, const char* idvalue);
};

#endif