waypoint.h

Go to the documentation of this file.

/*
 * waypoint.h
 *
 * Copyright (C) 2004 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 __WAYPOINT_H__
#define __WAYPOINT_H__

#include <csutil/csstring.h>
#include <csgeom/vector3.h>
#include <iengine/sector.h>

#include "util/psdatabase.h"
#include "util/location.h"
#include "util/pspath.h"
#include "util/edge.h"

class WaypointAlias
{
public:
    WaypointAlias(Waypoint* wp, int id, const csString& alias, float rotationAngle);

    int GetID() const { return id; }
    
    const char* GetName() const { return alias.GetDataSafe(); }

    float GetRotationAngle() const { return rotationAngle; }

    bool CreateUpdate(iDataConnection* db);
        
    bool SetRotationAngle(iDataConnection* db, float rotationAngle);

    void SetRotationAngle(float rotationAngle) { this->rotationAngle = rotationAngle; }

    Waypoint* wp;              
    int       id;              
    csString  alias;           
    float     rotationAngle;   
};

class Waypoint
{
public:
    Location                   loc;            
    csString                   group;          
    csPDelArray<WaypointAlias> aliases;        

    csArray<Waypoint*>         links;          
    csArray<float>             dists;          
    csPDelArray<Edge>          edges;          
    csArray<psPath*>           paths;          
    
    bool                       allowReturn;    

    bool                       underground;    
    bool                       underwater;     
    bool                       priv;           
    bool                       pub;            
    bool                       city;           
    bool                       indoor;         
    bool                       path;           
    bool                       road;           
    bool                       ground;         

    uint32_t                   effectID;       

    Waypoint();
    Waypoint(const char *name);
    Waypoint(csString& name, csVector3& pos, csString& sectorName, float radius, csString& flags);
    
    
    bool operator==(Waypoint& other) const
    { return loc.name==other.loc.name; }
    bool operator<(Waypoint& other) const
    { return (strcmp(loc.name,other.loc.name)<0); }

    bool Load(iDocumentNode *node, iEngine *engine);
    bool Import(iDocumentNode *node, iEngine *engine, iDataConnection *db);
    bool Load(iResultRow& row, iEngine *engine); 

    void AddLink(psPath * path, Waypoint * wp, psPath::Direction direction, float distance);
    void RemoveLink(psPath * path);

    Edge* GetRandomEdge(const psPathNetwork::RouteFilter* routeFilter);


    WaypointAlias* AddAlias(int id, csString aliasName, float rotationAngle);
    
    void RemoveAlias(csString aliasName);

    int          GetID() const { return loc.id; }
    void SetID(int id);
    
    const char * GetName() const { return loc.name.GetDataSafe(); }

    bool Rename(iDataConnection * db,const char* name);
    void Rename(const char* name);

    const char* GetGroup(){ return group.GetDataSafe(); }
    
    csString GetAliases();

    const WaypointAlias* FindAlias(const csString& aliasName) const;

    WaypointAlias* FindAlias(const csString& aliasName);

    
    bool SetRotationAngle(const csString& aliasName, float rotationAngle);
    
    
    iSector*     GetSector(iEngine * engine) { return loc.GetSector(engine); }
    iSector*     GetSector(iEngine * engine) const { return loc.GetSector(engine); }
    
    csString     GetFlags() const;

    float GetRadius() const  { return loc.radius; }
    bool SetRadius(float radius);
    bool SetRadius(iDataConnection * db, float radius);
    void RecalculateEdges(psWorld * world, iEngine *engine);

    const csVector3& GetPosition() const { return loc.pos; }

    bool CheckWithin(iEngine * engine, const csVector3& pos, const iSector* sector);

    int Create(iDataConnection * db);
    WaypointAlias* CreateAlias(iDataConnection * db, csString alias, float rotationAngle);
    bool RemoveAlias(iDataConnection * db, csString alias);
    bool Adjust(iDataConnection * db, csVector3 & pos, csString sector);
    void Adjust(csVector3 & pos, csString sector);
    void Adjust(csVector3 & pos, iSector* sector);
    
    void SetFlags(const csString& flagStr);

    bool SetFlag(iDataConnection * db, const csString &flagstr, bool enable);

    bool SetFlag(const csString &flagstr, bool enable);    

    uint32_t GetEffectID(iEffectIDAllocator* allocator);

    float distance; 
    Waypoint * pi;  
    bool excluded;  

};

#endif