root/ggpa/GameWorld.h

/*
 * GameWorld.h
 * Header file for GameWorld class
 */

#ifndef GAME_WORLD_H
#define GAME_WORLD_H

#include <string>
#include <vector>
#include <map>
#include <utility>
using namespace std;

#include "SentenceStructure.h"
#include "Sentence.h"
#include "State.h"
#include "Utils.h"
#include "Action.h"

/*
 * Class that represents the rules and states of a game
 */
class GameWorld {

private:
    
    string matchID;  // unique identifier for this match
    string role; // our role in the game
    double startClock;  // time we have to learn in minutes
    double playClock; // time we have to make each move

    // a set of the roles in the game
    vector<string> roles;

    // A map from the names of sentences to their SentenceStructure
    map<string, SentenceStructure*> sentenceStructures;

    // initial state of the game, as a set of literals
    // No variables (?)
    vector<Sentence*> initialSentences;
    State* initialState;
    
    // a dependency graph for the rules
    // The nodes are literals
    // An edge from literal a to literal b represents there is a rule with
    //    b in the head and r2 in the body, i.e. (<= a b)
    vector<Sentence*> dependencyGraph;

    // a collection of the current literals (sentences and negated sentences)
    // This is the same as the set of literals l1 ... ln such that (true l1)
    //    for all i
    State* currentState;

    // a collection of the goals in the game (for all players).  This will
    //    be a collection of pointers to nodes in the graph.
    vector<Sentence*> goals;

    // a collection of the rules for updating the current state
    vector<Sentence*> updateRules;

    // a collection of rules for determining legal moves
    // the pair is used to store the parameters corrensponding to a role
    //vector<pair<string, Sentence*> > legalMoves;
    vector<Action*> legalMoveRules;

    // a colections of rules that will determine the value of a property
    // These should not depend on the previous state.
    vector<Sentence*> definitions;
    
    // a collection of legal moves for the current state
    vector<Action*> legalMoves;

    // a collection of the actions within the game
    //vector<SentenceStructure*> actions;

public:

    /*
     * Constructor
     * Parameters:   rules - string to define rules to create a new GameWorld
     * No return type
     * Uses the rules to initialize the GameWorld
     */
    GameWorld(const string& rules);

    /*
     * Copy Constructor
     * Initializes this to be a copy of the original GameWorld.
     */
    GameWorld(const GameWorld& oldWorld);

    /*
     * operator=
     * Sets this to be a copy of the original GameWorld
     */
    GameWorld& operator=(const GameWorld& oldWorld);

    /*
     * Deconstructor
     * Frees up the memory.
     */
    ~GameWorld();

    /*
     * parse
     * Parameters:   rules - string containing the rules
     * Return value: none
     * Parses rules to create a GameWorld that we can use
     */
    void parse(const string& rules);

    /*
     * getMatchID
     * No parameters
     * Return type: string
     * Returns the match id for this game
     */
    string getMatchID();

    /*
     * getRole
     * No parameters
     * Return type: string
     * Returns the role of this program in the game
     */
    string getRole();

    /*
     * getRoles
     * Parameters: none
     * Return type: a vector of strings
     * Returns all roles in this game.
     */
    const vector<string>& getRoles() const;

    /*
     * getStartClock
     * No parameters
     * Return type: double
     * Returns the time available for learning before the match starts. 
     *   This time will be in *minutes*
     */
    double getStartClock();

    /*
     * getPlayClock
     * No parameters
     * Return type: double
     * Returns the time available to make each move during the match.  This
     *    time will be in *seconds*
     */
    double getPlayClock();

    /*
     * tokenize
     * Parameters: line - a string that may contain multiple works or arguments
     * Return type: a vector of strings
     * Breaks the line into a series of arguments.  These arguments will be 
     * first level, meaning that if you have nested arguments, you will 
     * just get back an unparsed copy of that argument.  CHANGE: The first
     * parenthesis will be ignored, assuming that the end parenthesis is at
     * the end of the string.
     */
    vector<string> tokenize(string line) const;

    /*
     * function that prints out everything, for "testing"
     */
    void output() const;

    /*
     * update
     * Parameters: actions - a string containing a list of the actions
     *                       taken by the other players
     * No Return type
     * Updates the game state for a new turn.
     */
    void update(string actions);

    /*
     * update
     * Parameters: currentActions - a vector of actions containing the actions 
     *                              taken by players previously.
     * No return type
     * Updates the game state based on the actions taken, and the current
     * state.
     */
    void update(vector<Action*> currentActions);

    /*
     * getLegalMoves
     * Parameters: none
     * Return type: a vector of Action pointers
     * Returns a set of legal moves for the default player.
     */
    vector<Action*> getLegalMoves() const;

    /*
     * getLegalMoves
     * Parameters: player - the player to get the actions for
     * Return type: a vector of Action pointers
     * Returns a set of legal moves for the player.  If the player does
     * not exist in the game, it will return an empty vector
     */
    vector<Action*> getLegalMoves(string player) const;    

    /*
     * getState
     * No parameters.
     * Returns the current state for this GameWorld
     */
    State* getState() const;

    /*
     * isDone
     * Parameters: none
     * Return type: bool
     * Returns true if the game has reached a terminal state, and false 
     * otherwise.
     */
    bool isDone();

    /*
     * startGame
     * No parameters or return type
     * Initializes the GameWorld for a new game
     */
    void startGame();

    /*
     * getReward
     * Parameters: curRole - the role we are interested in
     * Return type: int
     * Returns the reward for the current state.  No goal is satisfied,
     * it returns the default value.
     */
    int getReward(string curRole) const;


    /***************************************************************
     * Private functions
     ***************************************************************/

private:
    
    /*
     * parseRules
     * Parameters:   rules - string containing the rules of the game
     *               start - place to start parsing the rules
     * Return value: int - the index of the last letter in the rules
     * Parses the rules from the string and puts them into the class fields,
     *   returning the last index used
     */
    int parseRules(const string& rules);

    /*
     * parseRule
     * Parameters:   rule - a string containing a single rule to be parsed
     * Return value: none
     * Parses the rule into the GameWorld
     */
    void parseRule(const string& rule);


    /*
     * getFirstWord
     * Parameters: rule - a string containing the rule we are interested in
     * Return type: string
     * Extracts the first word from the rule, and returns it.  NOTE: The first
     * parenthesis in the rule should be removed before calling this
     */
    string getFirstWord(string rule) const;

    /*
     * parseInit
     * Parameters: rule - a string containing the rule we are interested in
     * No return type
     * Extracts an initial state rule, and stores it appropriately
     */
    void parseInit(string rule);
    
    /*
     * parseInit
     * Parameters: rule - a string containing the rule we are interested in
     * No return type
     * Extracts a role rule, and stores it appropriately
     */
    void parseRole(string rule);

    /*
     * parseDatalogRule
     * Parameters: rule - a string containing the rule we are interested in
     * No return type
     * Extracts a datalog rule, and stores it appropriately
     */
    void parseDatalogRule(string rule);

    /*
     * parseHead
     * Parameters:  headString - a string containing a text representation of
     *                           the head for a rule
     * Return type: Sentence pointer
     * Returns the Sentence corresponding to the head
     */
    Sentence* parseHead(string headString);

    /*
     *parseSentence
     *Parameters: tokens - a vector<string> containing in its first index the name of the sentence and the rest of them are the parameters of the sentence
     * Return type: Sentence pointer
     * Returns the parsed version of the sentence
     */
    Sentence* parseSentence(vector<string> tokens);

    /*
     * parseAction
     * Parameters: tokens - a vector<string containing in its first index the
     *                      name of the action, and the rest are the parameters
     *                      of the action
     *             actor - the agent who performs this action
     *             inGame - this variable is true if we are currently playing
     *                      the game, and do not want to be updating the rules
     * Return type: Action*
     * Returns the parsed version of the action
     */
    Action* parseAction(vector<string> tokens, string actor, bool inGame = false);

    /*
     *updateSentenceStructure
     *Parameters: tokens - The string in the first index of tokens, new size of tokens, boolean to see if sentence represents action
     *Return type: a SentenceStructure pointer
     *Returns the new structure of the sentence after it has been updated
     */
    
    SentenceStructure* updateSentenceStructure(vector<string> name, bool isAction);

    /*
     * parseBody
     * Parameters:  body - a string containing one component of the body of the
     *                     rule
     *              head - a Sentence that is the head of this rule
     * No return type
     * Parses this piece of the body, and adds it as a dependency to the head
     */
    void parseBody(string body, Sentence* head);


    /*
     * initializeFields
     * No parameters or return type
     * Initializes the appropriate fields for this class
     */
    void initializeFields();

    /*
     * checkSentenceStructure
     * Parameters: tokens - a vector of strings containing the tokens for
     *                      this sentence
     *             isAction - a boolean that is true if the sentence should
     *                        be an action, and false otherwise
     * Return type: bool
     * Returns true if the Sentence is legal in the rules, and false
     * otherwise
     */
    bool checkSentenceStructure(vector<string> tokens, bool isAction);

    

    /**
     * applyUpdateRule
     * Parameters: updateRule - the current rule to apply
     *             state - the state that we are building
     *             currentActions - the most recently performed actions
     * No Return type
     * Adds properties determined by the updateRules to the state
     */
    void applyUpdateRule(Sentence* updateRule, State* state, 
                         vector<Action*> currentActions);

    /**
     * applyDefinitions
     * Parameters: state - the state that we are building
     * No return type
     * Runs through the definitions and adds any applicable properties
     * to the state
     */
    void applyDefinitions(State* state);

    /**
     * applyDefinition
     * Parameters: definition - the current definition
     *             state - where to apply the definition
     * Return type: none
     * Applies the definition to the current state.
     */
    void applyDefinition(Sentence* definition, State* state);

    /**
     * applyRule
     * Parameters: rule - the rule to apply: sentence with dependencies
     *             newState - the state to write the new rule to
     *             oldState - the state to get information from
     *             currentActions - a set of the most recent actions
     * Return type: none
     * Applies the rule to the newState given the oldState and the
     * current actions.
     */
    void applyRule(Sentence* rule, State* newState, State* oldState, 
                   vector<Action*> currentActions);

    /**
     * initializeState
     * No parameters or return type
     * Using the discovered sentence structures, get the appropriate size
     * for a state and initialize initialState and currentState appropriately
     */
    void initializeState();

    /*
     * findLegalMoves
     * No parameters or return types
     * Finds all the legal moves for the current state
     */
    void findLegalMoves();

    /*
     * applyLegalMoveRule
     * Parameters: rule - the rule to apply
     *             actions - a reference to a vector of actions where any
     *                       new legal moves should be stored
     * No return type
     * Applies the rule and puts any legal moves that are found in the 
     * actions vector.
     */
    void applyLegalMoveRule(Action* rule, vector<Action*>& actions);

    /*
     * areDependenciesSatified
     * Parameters: rule - the Sentence* rule to check
     *             state - the State to look for dependencies in
     * Return type: bool
     * Returns true if all of the dependencies for the rule are satisfied,
     * and false otherwise.
     */
    bool areDependenciesSatisfied(Sentence* rule, State* state);

    /*
     * isDependencySatisfied
     * Parameters: dependency - the Sentence* to check
     *             state - the state in which to check if the dependency is
     *                     satisfied
     * Return type: bool
     * Returns true if the dependency is satisfied in this state, and false
     * otherwise
     */
    bool isDependencySatisfied(Sentence* dependency, State* state);

    /*
     * fillInValues
     * No parameters or return type
     * fills in missing values in the sentence structures
     */
    void fillInValues();

};


#endif