root/ggpa/GameWorld.cpp

/*
 * GameWorld.cpp
 * Implementation of GameWorld class
 */

#include "GameWorld.h"
#include "VariableAssignmentIterator.h"
#include <string>
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <sstream>
using namespace std;

#define START_KEYWORD "START"
#define START_KEYWORD_LENGTH 5
#define SPACE_CHARS " \t\n"
#define END_CHARS ") \t\n"
#define LEADING_CHARS " \t\n"
#define TERMINAL_NAME "terminal"
#define GOAL_NAME "goal"
#define LEGAL_NAME "legal"
#define NEXT_NAME "next"
#define TRUE_NAME "true"
#define DOES_NAME "does"
#define NOT_NAME "not"
#define OR_NAME "or"
#define INIT_TAG "init"
#define ROLE_TAG "role"
#define DATALOG_RULE_TAG "<="
// DISTINCT_NAME defined in Sentence.h
#define DEFAULT_REWARD 0


/*
 * Constructor
 * Parameters:   rules - string to define rules to create a new GameWorld
 * No return type
 * Uses the rules to initialize the GameWorld
 */
GameWorld::GameWorld(const string& rules) : roles(), sentenceStructures(), initialSentences(), initialState(NULL), dependencyGraph(), currentState(NULL), goals(), legalMoveRules(), definitions() {
    initializeFields();
    parse(rules);
}


/*
 * Copy Constructor
 * Initializes this to be a copy of the original GameWorld.
 */
GameWorld::GameWorld(const GameWorld& oldWorld) {
    // right now we are sharing most of the data.  We may need to
    // change this later.
    roles = oldWorld.roles;
    sentenceStructures = oldWorld.sentenceStructures;
    initialSentences = oldWorld.initialSentences;
    initialState = oldWorld.initialState;
    dependencyGraph = oldWorld.dependencyGraph;
    goals = oldWorld.goals;
    legalMoveRules = oldWorld.legalMoveRules;
    definitions = oldWorld.definitions;
    
    // independent copies
    currentState = new State(*(oldWorld.currentState));

}

/*
 * operator=
 * Sets this to be a copy of the original GameWorld
 */
GameWorld& GameWorld::operator=(const GameWorld& oldWorld) {
    if (this == &oldWorld) {
        delete currentState;
        currentState = NULL;

        roles = oldWorld.roles;
        sentenceStructures = oldWorld.sentenceStructures;
        initialSentences = oldWorld.initialSentences;
        initialState = oldWorld.initialState;
        dependencyGraph = oldWorld.dependencyGraph;
        goals = oldWorld.goals;
        legalMoveRules = oldWorld.legalMoveRules;
        definitions = oldWorld.definitions;
    
        // independent copies
        currentState = new State(*(oldWorld.currentState));
        
    }

    return *this;
}

/*
 * Deconstructor
 * Frees up the memory.
 */
GameWorld::~GameWorld() {
    delete currentState;
    currentState = NULL;

}

/*
 * parse
 * Parameters:   rules - string containing the rules
 * Return value: none
 * Parses rules to create a GameWorld that we can use
 */
void GameWorld::parse(const string& rules){
    // better implementation
    vector<string> tokens = tokenize(rules);
    /*
    for (unsigned int i =0; i<tokens.size(); i++)
      cout<<tokens[i]<<endl;
    */
    if (tokens.size() != 6) {
        cerr << "Incorrect number of arguments in the rules" << endl;
        cerr << tokens.size() << " instead of " << 6 << endl;
        exit(1);
    }

    matchID = tokens[1];
    role = tokens[2];
    parseRules(tokens[3]);
    startClock = atof(tokens[4].c_str());
    playClock = atof(tokens[5].c_str());
    
    findLegalMoves();
    
    return;
}

/*
 * getMatchID
 * No parameters
 * Return type: string
 * Returns the match id for this game
 */
string GameWorld::getMatchID() {
    return matchID;
}

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

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

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

}

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

/*
 * 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 GameWorld::update(string actions) {
    vector<string> tokens = tokenize(actions);
    
    if (tokens.size() != roles.size()) {
        cerr << "Wrong number of actions recieved: " << tokens.size() 
             << " instead of " << roles.size() << endl;
    }

    vector<Action*> currentActions;
    for (unsigned int player = 0; player < roles.size(); player++) {
        currentActions.push_back(parseAction(tokenize(tokens[player]), 
                                             roles[player], 
                                             true));
    }

    update(currentActions);
}

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

/*
 * 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*> GameWorld::getLegalMoves(string player) const {
    vector<Action*> moves;
    for (unsigned int index = 0; index < legalMoves.size(); index++) {
        if (legalMoves[index]->getActor() == player) {
            moves.push_back(legalMoves[index]);
        }
    }
    return moves;
}

/*
 * 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 GameWorld::parseRules(const string& rules) {
    //cout << rules << endl;
  vector<string> ruleTokens = tokenize(rules);
  unsigned int i;
  for (i = 0; i < ruleTokens.size(); i++){
      //cout << ruleTokens[i] << endl;
    parseRule(ruleTokens[i]);
  }

  // initialize the state
  //output();
  fillInValues();
  initializeState();
  
  return i;
}

/*
 * parseRule
 * Parameters:   rule - a string containing a single rule to be parsed
 * Return value: none
 * Parses the rule into the GameWorld
 */
void GameWorld::parseRule(const string& rule) {
    vector<string> tokens = tokenize(rule);
    
    //cout << rule << endl;
    /*
    for (unsigned int token = 0; token < tokens.size(); token++) {
        cout << tokens[token] << endl;
    }
    */
    if (tokens.size() == 0) {
        // empty rule - do nothing
        return;
    }
    string firstWord = tokens[0];

    if (firstWord == "") {
        // empty rule
        return;
    } else if (firstWord == INIT_TAG) {
        parseInit(rule);
    } else if (firstWord == ROLE_TAG) {
        parseRole(rule);
    } else if (firstWord == DATALOG_RULE_TAG) {
        parseDatalogRule(rule);
    } else {
        cerr << "Invalid rule: " << rule << endl;
        cerr << "First word is invalid: " << firstWord << endl;
        exit(1);
    }

    return;
}



string GameWorld::getFirstWord(string rule) const {
    string firstWord;
    unsigned int stop = rule.find(" ", 0);
    
    if (stop == string::npos) {
        // assume empty rule
        return "";
    }

    firstWord = rule.substr(0, stop);
    return firstWord;
}

vector<string> GameWorld::tokenize(string line) const {
    vector<string> tokens;
    
    // get the start of the first word
    unsigned int start = line.find_first_not_of(LEADING_CHARS, 0);
    if (line[start] == '(') {
        // ignore the first parenthesis, assuming that the closing parenthesis
        // is at the end of the string
        start = line.find_first_not_of(LEADING_CHARS, start+1);
    }
    unsigned int stop = start;
    unsigned int length = line.length();

    // find all the words
    while(start != string::npos) {
        if (line[start] == '(') {
            int depth = 1;
            stop = start;
            while(depth > 0) {
                stop = line.find_first_of("()", stop + 1);
                if (stop == string::npos) {
                    cerr << "Mismatched parenthesis on line " << line << endl;
                    exit(1);
                } else if (line[stop] == '(') {
                    depth++;
                } else { // line[stop] == ')'
                    depth--;
                }
            }
            stop = line.find_first_of(SPACE_CHARS, stop);
        } else {
            stop = line.find_first_of(END_CHARS, start);
        }
        
        if (stop == string::npos) {
            tokens.push_back(line.substr(start, length-start));
            return tokens;
        } else {
            tokens.push_back(line.substr(start, stop-start));
            start = line.find_first_not_of(END_CHARS, stop);
        }

    }

    return tokens;
    
}

void GameWorld::parseInit(string rule) {
    vector<string> tokens = tokenize(rule);
    if (tokens.size() != 2) {
        cerr << "Wrong number of values in init rule" << endl;
    }

    Sentence* sentence = parseSentence(tokenize(tokens[1]));
    initialSentences.push_back(sentence);
    return;
}
    
void GameWorld::parseRole(string rule) {
    vector<string> tokens = tokenize(rule);
    if (tokens.size() != 2) {
        cerr << "Wrong number of values for role rule" << endl;
        exit(1);
    }
    roles.push_back(tokens[1]);
    return;
}

void GameWorld::parseDatalogRule(string rule) {
    vector<string> tokens = tokenize(rule);
    if (tokens.size() <= 2) {
        cerr << "There are not enough terms in the datalog rule " << rule 
             << endl;
        exit(1);
    }
    
    // parse the head of the rule
    Sentence* head = parseHead(tokens[1]);

    // parse the body of the rule
    for (unsigned int token = 2; token < tokens.size(); token++) {
        // parse the token
        parseBody(tokens[token], head);

        
    }

    return;
}


/*
 * 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* GameWorld::parseHead(string headString) {
    vector<string> tokens = tokenize(headString);
    Sentence* head;

    if (tokens[0] == NEXT_NAME) {
        head = parseSentence(tokenize(tokens[1]));
        updateRules.push_back(head);
    } else if (tokens[0] == LEGAL_NAME) {
        Action* action = parseAction(tokenize(tokens[2]), tokens[1]);
        legalMoveRules.push_back(action);
        head = action;
        /*
        head = parseSentence(tokenize(tokens[2]));
        pair<string, Sentence*> thePair(tokens[1], head);
        legalMoves.push_back(thePair);
        */
    } else if (tokens[0] == TERMINAL_NAME) {
        if (sentenceStructures[TERMINAL_NAME] == NULL) {
            cerr << "Terminal sentence structure is NULL!" << endl;
            exit(1);
        }
        head = new Sentence(vector<string>(0), 
                            sentenceStructures[TERMINAL_NAME]);
    } else if (tokens[0] == GOAL_NAME) {
        head = parseSentence(tokens);
        goals.push_back(head);
        definitions.push_back(head);
    } else { // a definition
        head = parseSentence(tokens);
        definitions.push_back(head);
    }

    return head;
}

/*
 *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* GameWorld::parseSentence(vector<string> tokens) {
     SentenceStructure* structure = updateSentenceStructure(tokens, false);
    
    // get rid of the name
    tokens.erase(tokens.begin());

    return new Sentence(tokens, structure);
}

/*
 * 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
 * Return type: Action*
 * Returns the parsed version of the action
 */
Action* GameWorld::parseAction(vector<string> tokens, string actor, 
                               bool inGame) {
    SentenceStructure* structure;
    if (!inGame) {
        structure = updateSentenceStructure(tokens, true);
    } else {
        if (checkSentenceStructure(tokens, true) == false) {
            cerr << "Action did not match expectations" << endl;
            exit(1);
        }
    }
    //cout << "Action name: " << tokens[0] << endl;
    // get rid of name
    tokens.erase(tokens.begin());

    return new Action(tokens, structure, actor, roles); 
}

 /*
  *updateSentenceStructure
  *Parameters: tokens - a vector<string> passed by parseSentence
  *Return type: a SentenceStructure pointer
  *Returns the new structure of the sentence after it has been updated
  */
SentenceStructure* GameWorld::updateSentenceStructure(vector<string> tokens, bool isAction)
 {
     string name = tokens[0];
     
     // get the SentenceStructure
     SentenceStructure* structure;
     if (sentenceStructures.find(name) == sentenceStructures.end()) {
         // create a new SentenceStructure
         structure = new SentenceStructure(name, tokens.size()-1, isAction);
         sentenceStructures[name] = structure;
     } else {
         structure = sentenceStructures[name];
     }

     // update each parameter
     if (structure->getNumParameters() != tokens.size()-1) {
         cerr << "Wrong number of parameters" << endl;
         exit(1);
     }

     for (unsigned int parameter = 0; parameter < tokens.size()-1; 
          parameter++) {
         if (!isVariable(tokens[parameter+1])) {
             structure->addValue(parameter, tokens[parameter+1]);
         }
     }

     if (structure == NULL) {
         cerr << "NULL structure?! Structure: " << name << endl;
     }
     return structure;

 }  

/*
 * 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 GameWorld::parseBody(string body, Sentence* head) {
    
    vector<string> tokens = tokenize(body); 

    if (tokens[0] == TRUE_NAME) {
        // second parameter is a sentence
        Sentence* sentence = parseSentence(tokenize(tokens[1]));
        head->addAndDependency(sentence, false);
    } else if (tokens[0] == DOES_NAME) {
        if (tokens.size() != 3) {
            cerr << "Inproper use of 'does' - wrong number of arguments" << endl;
            exit(1);
        }

        string actor = tokens[1];
        
        Action* action = parseAction(tokenize(tokens[2]), actor);
        
        head->addAndDependency(action, false);
        
    } else if (tokens[0] == NOT_NAME) {
        if (tokens.size() != 2) {
            cerr << "Inproper use of 'not' - wrong number of arguments" << endl;
            exit(1);
        }
        vector<string> subTokens = tokenize(tokens[1]);
        if (subTokens[0] == OR_NAME) {
            if (subTokens.size() < 2) {
                cerr << "Inproper use of 'or' - wrong number of arguments" << endl;
                exit(1);
            }
            vector<Sentence*> dependency;
            for (unsigned int token = 1; token < subTokens.size(); token++) {
                dependency.push_back(parseSentence(tokenize(subTokens[token])));
            }
            head->addOrDependency(dependency, true);
        } else {

            Sentence* sentence = parseSentence(subTokens);
            head->addAndDependency(sentence, true);
        }
    } else if (tokens[0] == OR_NAME) {
        if (tokens.size() < 2) {
            cerr << "Inproper use of 'or' - wrong number of arguments" << endl;
            exit(1);
        }
        vector<Sentence*> dependency;
        for (unsigned int token = 1; token < tokens.size(); token++) {
            dependency.push_back(parseSentence(tokenize(tokens[token])));
        }
        head->addOrDependency(dependency, true);
    } else {  
        // this dependency just does not have "true" in the front
        Sentence* sentence = parseSentence(tokens);
        head->addAndDependency(sentence, false);
    }


}



/*
 * initializeFields
 * No parameters or return type
 * Initializes the appropriate fields for this class
 */
void GameWorld::initializeFields() {
    // create any constant structures
    SentenceStructure* terminal 
        = new SentenceStructure(TERMINAL_NAME, 0, false);
    if (terminal == NULL) {
        cerr << "Terminal state was not created correctly!" << endl;
    }
    sentenceStructures[TERMINAL_NAME] = terminal;
    
    SentenceStructure* goal = new SentenceStructure(GOAL_NAME, 2, false);
    sentenceStructures[GOAL_NAME] = goal;

    SentenceStructure* distinct = new SentenceStructure(DISTINCT_NAME, 2, false);
    sentenceStructures[DISTINCT_NAME] = distinct;

}

/*
 * function that prints out everything, for "testing"
 */
void GameWorld::output() const {
    map<string, SentenceStructure*>::const_iterator printItr = sentenceStructures.begin();
    cout << sentenceStructures.size() << " Sentence Structures: " << endl;
    for (; printItr != sentenceStructures.end(); printItr++) {
        //cout << "Structure name: " << printItr->first << endl;
        printItr->second->print();
        cout << endl;
    }
    cout << endl;
    
    // print update rules
    cout << updateRules.size() << " Update rules" << endl;
    vector<Sentence*>::const_iterator ruleItr = updateRules.begin();
    for (; ruleItr != updateRules.end(); ruleItr++) {
        //cout << (*ruleItr)->getName() << endl;
        (*ruleItr)->print();
        cout << endl;
    }
    cout << endl;

    // print definitions
    cout << definitions.size() << " definitions" << endl;
    for (ruleItr = definitions.begin(); ruleItr != definitions.end(); 
         ruleItr++) {
        (*ruleItr)->print();
        cout << endl;
    }
    cout << endl;

    // print goal states
    cout << goals.size() << " goal" << endl;
    for (ruleItr = goals.begin(); ruleItr != goals.end(); 
         ruleItr++) {
        (*ruleItr)->print();
        cout << endl;

    }
    cout << endl;

    // print initial sentences
    cout << initialSentences.size() << " initialSentences" << endl;
    for (ruleItr = initialSentences.begin(); ruleItr != initialSentences.end(); 
         ruleItr++) {
        (*ruleItr)->print();
        cout << endl;

    }
    cout << endl;


    // print legal move rules
    vector<Action*>::const_iterator actionItr;
    cout << legalMoveRules.size() << " legal moves" << endl;
    for (actionItr = legalMoveRules.begin(); actionItr != legalMoveRules.end(); 
         actionItr++) {
        (*actionItr)->print();
        cout << endl;
    }
    cout << endl;
}

/*
 * 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 GameWorld::checkSentenceStructure(vector<string> tokens, 
                                       bool isAction) {
    string name = tokens[0];
    
    if (sentenceStructures.find(name) == sentenceStructures.end()) {
        return false;
    }

    SentenceStructure* structure = sentenceStructures[name];

    if (tokens.size() - 1 != structure->getNumParameters()) {
        return false;
    }

    for (unsigned int token = 1; token < tokens.size(); token++) {
        if (structure->getValueIndex(token - 1, tokens[token]) == -1) {
            return false;
        }
    }

    return true;
}


/*
 * 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 GameWorld::update(vector<Action*> currentActions){
    
    State* newState = new State(currentState->getSize());
    
    // check the update rules
    for (unsigned int updateRule = 0; updateRule < updateRules.size(); 
         updateRule++) {
        applyUpdateRule(updateRules[updateRule], newState, currentActions);
    }


    // run through the definitions until we get everything
    applyDefinitions(currentState);
    
    findLegalMoves();
}


void GameWorld::applyUpdateRule(Sentence* updateRule, State* state, 
                                vector<Action*> currentActions) {
    applyRule(updateRule, state, currentState, currentActions);
/*
    map<string, vector<string> > variables = updateRule->getVariables();


    // for each variable assignment
    VariableAssignmentIterator assignmentItr(variables);
    for (;!assignmentItr.atEnd(); assignmentItr++) {
        map<string,string> assignment = assignmentItr.getCurrent();
        
        // get the sentence with this assignment
        Sentence* sentence = updateRule->getAtomicSentence(assignment);

        // check each of the dependencies to see if they are satisfied.
        vector<vector<Sentence*> > dependencies = sentence->getDependencies();
        bool allSatisfied = true;
        for (unsigned int dependencyIndex = 0;
             dependencyIndex < dependencies.size();
             dependencyIndex++) {
            vector<Sentence*> dependency = dependencies[dependencyIndex];
            bool satisfied = false;
            for (unsigned int subIndex = 0; 
                 !satisfied && subIndex < dependency.size(); 
                 subIndex++) {
                if (dependency[subIndex]->getStructure()->isAction()) {
                    for (unsigned int actionIndex = 0; 
                         actionIndex < currentActions.size(); actionIndex++) {
                        if (currentActions[actionIndex] == dependency[subIndex]) {
                            satisfied = true;
                            break;
                        }
                    }
                } else {
                    if (currentState->containsSentence(dependency[subIndex])) {
                        satisfied = true;
                    }
                }
            }
            if (!satisfied) {
                allSatisfied = false;
            }
        }
        if (allSatisfied) {
            state->addSentence(sentence);
        }



        // release the sentence
        delete sentence;
    }
*/
}

/**
 * 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 GameWorld::applyDefinitions(State* state) {
    State lastState;
    do {
        lastState = *state;
        for (unsigned int definitionIndex = 0; 
             definitionIndex < definitions.size();
             definitionIndex++) {
            applyDefinition(definitions[definitionIndex], state);
        }
    } 
    while (!(lastState == *state));
}

/*
 * applyDefinition
 * Parameters: definition - the current definition
 *             state - where to apply the definition
 * Return type: none
 * Applies the definition to the current state.
 */
void GameWorld::applyDefinition(Sentence* definition, State* state) {
    vector<Action*> emptyActions;
    applyRule(definition, state, state, emptyActions);
}

/**
 * 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 GameWorld::applyRule(Sentence* rule, State* newState, State* oldState, 
                          vector<Action*> currentActions) {
    map<string, vector<string> > variables = rule->getVariables();


    // for each variable assignment
    VariableAssignmentIterator assignmentItr(variables);
    for (;!assignmentItr.atEnd(); assignmentItr.next()) {
        map<string,string> assignment = assignmentItr.getCurrent();
        
        // get the sentence with this assignment
        Sentence* sentence = rule->getAtomicSentence(assignment);

        if (areDependenciesSatisfied(sentence, oldState)) {
            newState->addSentence(sentence);
        }



        // release the sentence
        delete sentence;
    }
}

/**
 * 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 GameWorld::initializeState() {
    int total = 0;
    // initialize state structure
    map<string, SentenceStructure*>::iterator structureItr;
    for (structureItr = sentenceStructures.begin();
         structureItr != sentenceStructures.end(); structureItr++) {
        SentenceStructure* structure = structureItr->second;
        if (!structure->isAction() && structure->getName() != DISTINCT_NAME) {
            structure->setOffset(total);
            total += structure->numPossibleSentences();
        }
    }

    initialState = new State(total);
    //cout << "Adding " << initialSentences.size() << " initial sentences" 
    //     << endl;
    // get all of the sentences in the initial state
    for (unsigned int initialSentence = 0; 
         initialSentence < initialSentences.size(); initialSentence++) {
        //cout << "Initial sentence " << initialSentence 
        //     << "/" << initialSentences.size() << endl;
        vector<Sentence*> sentences 
            = initialSentences[initialSentence]->getAtomicSentences();
        for (unsigned int index = 0; index < sentences.size(); index++) {
            //cout << "Adding Sentence" << endl;
            initialState->addSentence(sentences[index]);
        }
        
    }
    //initialState->print();
    // apply the definitions here
    applyDefinitions(initialState);
    //initialState->print();
    //cout << endl;
    currentState = new State(*initialState);
    //currentState->print();
}

/**
 * findLegalMoves
 * No parameters or return types
 * Finds all the legal moves for the current state
 */
void GameWorld::findLegalMoves() {
    vector<Action*> actions;
    for (unsigned int index = 0; index < legalMoveRules.size(); index++) {
        applyLegalMoveRule(legalMoveRules[index], actions);
    }
    
    // clear the old legal moves
    for (unsigned int index = 0; index < legalMoves.size(); index++) {
        delete legalMoves[index];
        legalMoves[index] = NULL;
    }
    
    legalMoves = actions;
}

/*
 * 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 GameWorld::applyLegalMoveRule(Action* rule, vector<Action*>& actions) {
    rule->getDependencies();
    map<string, vector<string> > variables = rule->getVariables();


    // for each variable assignment
    VariableAssignmentIterator assignmentItr(variables);
    for (;!assignmentItr.atEnd(); assignmentItr.next()) {
        map<string,string> assignment = assignmentItr.getCurrent();
        
        // get the sentence with this assignment
        Action* action = rule->getAtomicAction(assignment);

        if (areDependenciesSatisfied(action, currentState)) {
            actions.push_back(action);
        }

        // release the sentence
        delete action;
    }
}


/*
 * getState
 * No parameters.
 * Returns the current state for this GameWorld
 */
State* GameWorld::getState() const {
    State* state = new State(*currentState);
    return state;
}

/*
 * isDone
 * Parameters: none
 * Return type: bool
 * Returns true if the game has reached a terminal state, and false 
 * otherwise.
 */
bool GameWorld::isDone() {
    vector<string> values;
    SentenceStructure* structure = sentenceStructures[TERMINAL_NAME];
    Sentence* terminal 
        = new Sentence(values, structure);

    return currentState->containsSentence(terminal);
}

/*
 * startGame
 * No parameters or return type
 * Initializes the GameWorld for a new game
 */
void GameWorld::startGame() {
    delete currentState;
    currentState = initialState;
    findLegalMoves();
}


/*
 * 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 GameWorld::getReward(string curRole) const {
    for (unsigned int goalNum = 0; goalNum < goals.size(); goalNum++) {
        Sentence* goal = goals[goalNum];
        if ((*goal)[0] == curRole && currentState->containsSentence(goal)) {
            istringstream buffer((*goal)[1]);
            int reward;
            buffer >> reward;
            return reward;
        }
    }

    // NOTE: We might want to change how this is handled.
    return DEFAULT_REWARD;
}


/*
 * 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 GameWorld::areDependenciesSatisfied(Sentence* rule, State* state) {
    // check each of the dependencies to see if they are satisfied.
    /* can't do this for an action
    if (state->containsSentence(rule)) {
        // it does not need to be added again, so return false
        // NOTE: is this the best action?
        return false;
    }
    */
    vector<vector<Sentence*> > dependencies = rule->getDependencies();
    bool allSatisfied = true;
    for (unsigned int dependencyIndex = 0;
         dependencyIndex < dependencies.size();
         dependencyIndex++) {
        vector<Sentence*> dependency = dependencies[dependencyIndex];
        bool satisfied = false;
        for (unsigned int subIndex = 0; 
             !satisfied && subIndex < dependency.size(); 
             subIndex++) {
            if (isDependencySatisfied(dependency[subIndex], state)) {
                satisfied = true;
            }
                
        }
        bool negated = rule->isDependencyNegated(dependencyIndex);
        if ((!satisfied && !negated) || (satisfied && negated)) {
            allSatisfied = false;
        }
    }
    
    return allSatisfied;
}

/*
 * 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 GameWorld::isDependencySatisfied(Sentence* dependency, State* state) {
    if (dependency->getName() == DISTINCT_NAME) {
        if ((*dependency)[0] != (*dependency)[1]) {
            return true;
        } else {
            return false;
        }
    }
    if (state->containsSentence(dependency)) {
        return true;
    }

    return false;
}


/*
 * fillInValues
 * No parameters or return type
 * fills in missing values in the sentence structures
 */
void GameWorld::fillInValues() {
    for (unsigned int index = 0; index < updateRules.size(); index++) {
        updateRules[index]->mergeValues();
    }
    
    for (unsigned int index = 0; index < legalMoveRules.size(); index++) {
        legalMoveRules[index]->mergeValues();
    }
    
    for (unsigned int index = 0; index < definitions.size(); index++) {
        definitions[index]->mergeValues();
    }
    
}