root/ggpa/Action.h

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

#ifndef ACTION_H
#define ACTION_H

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

#include "Sentence.h"

/*
 * This class of objects represents an action in a game. It will contain
 *    a name and several parameters.  For a given action, there will always
 *    be the same number of parameters.
 */
class Action : public Sentence {

private:

    // declare any private variables here
    string actor;
    
    // the possible actors
    vector<string> possibleActors;

public:

   /*
         * Constructor for Action
         * Parameters:  theValues - a vector of values for the Action
         *              theStructure - a pointer to a SentenceStructure. Must be an action.
    *       theActor - the current actor for this Action
    *       actors - the possible actors for this Action
         * Return type: none
         * Sets the values of the sentence equal to a copy of theValues,
         * checking that the values are all in the SentenceStructure.
         */
    Action(vector<string> theValues, SentenceStructure* theStructure, 
           string theActor, const vector<string>& actors);

    Action(const Action &action);

    /*
     * getActor
     * No parameters
     * Return type: string
     * Returns the name of the player that does this action
     */
    string getActor() const;

    /*
     * setActor
     * Parameters: theActor - the name of the player that does this action
     * Return type: none
     * Sets the actor to be theActor
     */
    void setActor(string theActor);

    /**
     * getAtomicAction
     * Parameters: variableMap - a mapping of the variables
     * Return type: a new Sentence
     * Creates a new sentence with any variables mapped by the parameter map
     */
    Action* getAtomicAction(map<string, string> variableMap) const;

    /**
     * getAtomicSentence
     * Parameters: variableMap - a mapping of the variables
     * Return type: a new Sentence
     * Creates a new sentence with any variables mapped by the parameter map
     */
    virtual Sentence* getAtomicSentence(map<string, string> variableMap) const;

   /**
    * getVariables
    * No parameters.
    * Return type: a map from variables to vectors of of their possible values
    * Searches through the sentence and its dependencies, and returns all
    * of the variables, along with their posible values
    */
   virtual map<string, vector<string> > getVariables() const;

    //int operator=(const Action &action);

    /*
     * operator==
     * Parameters: action - an action to compare to
     * Return type: bool
     * Returns true if the actions are identical, and false otherwise
     */
    bool operator==(const Action &action) const;
    
    //bool operator<(const Action &action) const;

    /******************************************************************
     * These three functions will be required for using the Action with a 
     *    neural network.  Do not change their signatures unless absolutely
     *    necessary.
     */

    /*
     * getName
     * Parameters: None
     * Return value: string
     * Returns the name of the action
     */
    // already exists in Sentence.h
    // string getName() const;

    /*
     * toInputs
     * 
     * Parameters:   None
     * Return value: An array of doubles, each between 0 and 1
     *
     * This function converts a state to an array of doubles, each between 0
     * and 1.  This array will always be the same for a specific Action.
     */
    vector<double> toInputs() const;

    /*
     * inputSize
     *
     * Parameters: None
     * Return value: int
     * Returns the number of inputs required for a Action.  This is the same
     * as the length of the array returned by the toInputs function. 
     */
    int inputSize() const;

   /*
    * print
    * Parameters: output: a stream to output to.
    *             indent: indent on each line
    * No return type.
    * Prints the sentence to the given stream
    */
   void print(ostream& output = cout, string indent = "") const;

    /*
     * mergeValues
     * No parameters or return type.
     * Merges possible values for variables in this sentence.
     */
    virtual void mergeValues();

private:
   /*
    * getVariables
    * Parameters: variableMap: a map where we should add the new variables
    * Return type: none
    * Adds the variables and their set of possible values to the variableMap
    */
   void getVariables(map<string, vector<string> >& variableMap) const;
   
   /*
    * mergeValues
    * Parameters: variableMap:  a multimap from variables to their set of
    *                           possible values
    * Return type: none
    * Merges the sets of values for the variables
    */
   virtual void mergeValues(multimap<string, PossibleValues*>& variableMap);

};

#endif