root/deus/structures.h

/**
 * structures.h
 *
 * DEUS Director data structures
 */
#pragma warning(disable: 4786)
#pragma once

#include <windows.h>

#include "GraphIcon.h"
#include "mysql.h"

#include <vector>
#include <list>
#include <string>
#include <map>

using std::vector;
using std::string;
using std::list;
using std::map;


/************************************************
 * Game Objects
 ************************************************/
enum GOType {GO_NPC = 0x0, GO_LOCATION, GO_ITEM, GO_LAST};

/// parent class for anything that can be manipulated in the world
class GameObject        // parent class
{
public:
        GOType type;
};

class NPC : public GameObject {
public:
        string name;

        int xcoord, ycoord;

        NPC() {type = GO_NPC;}

        map<string, int> attributes;
        map<std::pair<string, int>, int> relationships;
};

/// All possible types go in this enum.  LOC_LAST must always be the last element
enum LocType {LOC_TOWN = 0x0, LOC_FARM, LOC_MARKET, LOC_BAR, LOC_GENERIC, LOC_LAST};

/// rectangular region of the map
class Location : public GameObject
{
public:
        string name;
        /// type of location
    LocType loc_type;

        Location() {type = GO_LOCATION;}

        /// bounding rectangle
        int ur_x, ur_y, ll_x, ll_y;
};

class Item : public GameObject
{
public:
        Item() {type = GO_ITEM;}

        /// there are currently no items =)
};



/************************************************
 * Operators and Conditions
 ************************************************/
// mapping from operator to unique index, starting with 0
enum OpCode {OP_CHANGEATTRIBUTE=0x0, OP_MOVENPC, OP_CHANGERELATIONSHIP, OP_NOOP, OP_LAST};

const int NUM_COND = 10;        // conditions are NUM_COND x num_COND

/// A condition defines the constraints that the author or some operator needs
/// to be satisfied in order to progress.  It may also be used to define the effects
/// of an operator.
class Condition
{
public:
        Condition() {
                satisfied = 0;
                conditions = new string*[NUM_COND];
                for (int i = 0; i < NUM_COND; i++)
                        conditions[i] = new string[NUM_COND];
        }

        int satisfied;
    /// possible bindings for the set of variables.  Each column defines an object,
    /// while each row defines a possible set of bindings.
        vector<vector<GameObject *> > vars;
        /// in custom condition language
        string ** conditions;
};

/// An Operator object provides the director's means of taking action in the world.
/// All reasoning about actions, their effects and conditions that must be satisfied
/// to perform those actions is done through use of these objects.
class Operator
{
public:
        Operator() {code = OP_NOOP;}

    /// defines the type of operator the instance represents
        OpCode code;

    /// Conjunction that defines the conditions that must be met before this action may be performed
        Condition PreConds;
    /// Conjunction that defines the effects this action will have on the world
        Condition PostConds;
};

/// All known information about the last observed state of the world is found in the World class
class World
{
public:
        int map_height, map_width;
        /// regions of the map
    vector<Location> Locations;

    /// non-player characters
        vector<NPC> NPCs;
        vector<Item> Items;
};




/************************************************
 * Story and Keyframes
 ************************************************/
enum NodeType {NODE_STORY = 0x0, NODE_KEYFRAME, NODE_LAST};

/// parent class for author defined nodes
class AuthorNode {
public:
        NodeType type;
        string name;

        GraphIcon *icon;

        virtual int save(int story_id, int parent_id) = 0;
        virtual void del_node() = 0;
};

/// A node in the detailed storyline the author specifies
/// This type of node defines conditions that must be met for the story to progress on the larger path.
/// The conditions may themselves have preconditions
/// As currently implemented, this node is part of a tree defining alternate types of and ways to satisfy preconditions
class KeyFrameNode : public AuthorNode
{
public:
        KeyFrameNode() {type = NODE_KEYFRAME; name = "NONE"; parent = NULL; icon = new GraphIcon(this); attempted = 0;}

        /// next frame
    KeyFrameNode* parent;                               
        /// frames that must be reached before this one
    vector<KeyFrameNode*> preconds;             
        /// conditions for current keyframe
    Condition conditions;                               

    /// number of times the director has tried to achieve this node
        int attempted;
    
    /// impl in AuthorInterface_impl.cpp, returns node_id
        virtual int save(int story_id, int parent_id);          
        /// impl in AuthorIntarface_impl.cpp also
    virtual void del_node();                                                    
};

/// A node in the high level storyline the author specifies
/// Each of these breaks down into ministories made up of KeyFrameNodes
/// As currectly implemented, this node is to be part of a tree defining possible paths in the story
class StoryNode : public AuthorNode
{
public:
        StoryNode() {type = NODE_STORY; name = "NONE"; frame = NULL; visited = false;  icon = new GraphIcon(this); parent = NULL;}

        StoryNode* parent;
        KeyFrameNode* frame;
        bool visited;
        
        vector<StoryNode*> next;

        /// impl in AuthorInterface_impl.cpp, returns node_id
    virtual int save(int story_id, int parent_id);              
        /// impl in AuthorIntarface_impl.cpp also
    virtual void del_node();                                                    
};

/// node in a partial order plan that defines the actions that
/// the director intends to execute to achieve some desired goal
/// The partial order plan is modeled as an acyclic directed graph
class PlanNode
{
public:
        PlanNode(const Operator& op, int depth = -1) : Op(op) 
                {this->depth = depth; icon = new GraphIcon();}

        inline bool isLeaf() {return branches.empty();}

        /// next nodes in the plan
    vector<PlanNode*> branches;
    /// previous nodes in the plan
        vector<PlanNode*> prevs;
        /// the action that should be executed at this point in the plan
    Operator Op;

        GraphIcon *icon;

    /// always useful for graph algorithms
        int num;        
        /// used for drawing, maybe more
    int depth;  
};



/************************************************
 * Misc declarations
 ************************************************/
int CheckValidOps(string str, int x, int y);
int IsInt(string s);
std::pair<int,int> GetMapSize();
vector<Location> MapGenerator();
list<Operator>* GetGregOperators(World* W);
void DoOps(World* W, Operator* O);
void initRegressionPanes();
vector<list<Operator> > GetMeOperators(Condition C, int index);
vector<vector<GameObject *> > GetList(string** conds, World* W);
vector<vector<GameObject *> > BindList(vector<vector<GameObject*> > Obs, World* W, string** conds, int level);
Condition CheckWorldState(World* W, Condition C);
int recievedata();


/************************************************
 * Global Data declarations - definition in director_main.cpp
 ************************************************/
extern StoryNode*                       story_root;
extern World*                           real_world;
extern MYSQL*                           conn;                   // database connection
extern list<Operator>           Ops;

extern PlanNode*                        forward_root;
extern PlanNode*                        regression_root;
extern PlanNode*                        current_plan_root;
extern list<vector<PlanNode*> > pending_execution;