Added mid-level actions.

example/example_high_level_random_agent.py

@@ -11,9 +11,9 @@ except:
   exit()
 
 def get_random_action():
-  """ Returns a random high-level action """
-  high_lv_actions = [HFO_Actions.SHOOT, HFO_Actions.PASS, HFO_Actions.DRIBBLE]
-  return (random.choice(high_lv_actions), 0, 0)
+  """Returns a random high-level action. Pass is omitted for simplicity."""
+  high_lv_actions = [HFO_Actions.SHOOT, HFO_Actions.DRIBBLE]
+  return random.choice(high_lv_actions)
 
 def play_hfo(num):
   """ Method called by a thread to play 5 games of HFO """
@@ -27,11 +27,11 @@ def play_hfo(num):
         if state[5] == 1: #state[5]  is 1 when player has the ball
           status = hfo_env.act(get_random_action())
         else:
-          status = hfo_env.act((HFO_Actions.MOVE, 0, 0))
+          status = hfo_env.act(HFO_Actions.MOVE)
   except:
     pass
   finally:
-    print "Agent " + str(num) + " exiting." 
+    print "Agent " + str(num) + " exiting."
     hfo_env.cleanup()
 
 def main():

example/hfo_example_agent.cpp

@@ -22,9 +22,8 @@ int main() {
       // Get the vector of state features for the current state
       const std::vector<float>& feature_vec = hfo.getState();
       // Create a dash action
-      Action a = {DASH, 20.0, 0.0};
       // Perform the dash and recieve the current game status
-      status = hfo.act(a);
+      status = hfo.act(DASH, 20.0);
     }
     // Check what the outcome of the episode was
     cout << "Episode " << episode << " ended with status: ";

example/hfo_example_agent.py

@@ -22,7 +22,7 @@ if __name__ == '__main__':
       # Grab the state features from the environment
       features = hfo.getState()
       # Take an action and get the current game status
-      status = hfo.act((HFO_Actions.DASH, 0, 0))
+      status = hfo.act(HFO_Actions.DASH, 20.0, 0)
     print 'Episode', episode, 'ended with',
     # Check what the outcome of the episode was
     if status == HFO_Status.GOAL:

example/high_level_random_agent.cpp

@@ -10,10 +10,9 @@ using namespace hfo;
 // $./bin/HFO --offense-agents 1
 
 // Returns a random high-level action
-Action get_random_high_lv_action() {
-  action_t action_indx = (action_t) ((rand() % 4) + 4);
-  Action act = {action_indx, 0, 0};
-  return act;
+action_t get_random_high_lv_action() {
+  action_t action_indx = (action_t) ((rand() % 4) + MOVE);
+  return action_indx;
 }
 
 int main(int argc, char** argv) {
@@ -32,10 +31,9 @@ int main(int argc, char** argv) {
     while (status == IN_GAME) {
       // Get the vector of state features for the current state
       const vector<float>& feature_vec = hfo.getState();
-      // Create a dash action
-      Action a = get_random_high_lv_action();
-      // Perform the dash and recieve the current game status
-      status = hfo.act(a);
+      // Perform the action and recieve the current game status
+      status = hfo.act(get_random_high_lv_action());
     }
   }
+  hfo.act(QUIT);
 };

example/low_level_random_agent.cpp

@@ -9,10 +9,12 @@ using namespace hfo;
 // Before running this program, first Start HFO server:
 // $./bin/HFO --offense-agents 1
 
+float arg1, arg2;
+
 // Returns a random low-level action
-Action get_random_low_lv_action() {
-  action_t action_indx = (action_t) (rand() % 4);
-  float arg1, arg2;
+action_t get_random_low_lv_action() {
+  action_t action_indx = (action_t) ((rand() % 4) + DASH);
+  std::cout << action_indx << std::endl;
   switch (action_indx) {
     case DASH:
       arg1 = (rand() / float(RAND_MAX)) * 200 - 100; // power: [-100, 100]
@@ -34,8 +36,7 @@ Action get_random_low_lv_action() {
       cout << "Invalid Action Index: " << action_indx;
       break;
   }
-  Action act = {action_indx, arg1, arg2};
-  return act;
+  return action_indx;
 }
 
 int main(int argc, char** argv) {
@@ -54,10 +55,8 @@ int main(int argc, char** argv) {
     while (status == IN_GAME) {
       // Get the vector of state features for the current state
       const vector<float>& feature_vec = hfo.getState();
-      // Create a dash action
-      Action a = get_random_low_lv_action();
-      // Perform the dash and recieve the current game status
-      status = hfo.act(a);
+      // Perform the action and recieve the current game status
+      status = hfo.act(get_random_low_lv_action(), arg1, arg2);
     }
   }
 };

hfo/hfo.py

@@ -14,14 +14,20 @@ class HFO_Actions:
   [Low-Level] Turn(direction)
   [Low-Level] Tackle(direction)
   [Low-Level] Kick(power, direction)
+  [Mid-Level] Kick_To(target_x, target_y, speed)
+  [Mid-Level] Move(target_x, target_y)
+  [Mid-Level] Dribble(target_x, target_y)
+  [Mid-Level] Intercept(): Intercept the ball
   [High-Level] Move(): Reposition player according to strategy
   [High-Level] Shoot(): Shoot the ball
-  [High-Level] Pass(): Pass to the most open teammate
+  [High-Level] Pass(teammate_unum): Pass to teammate
   [High-Level] Dribble(): Offensive dribble
-  QUIT
+  NOOP(): Do Nothing
+  QUIT(): Quit the game
 
   '''
-  DASH, TURN, TACKLE, KICK, MOVE, SHOOT, PASS, DRIBBLE, QUIT = range(9)
+  DASH, TURN, TACKLE, KICK, KICK_TO, MOVE_TO, DRIBBLE_TO, INTERCEPT, \
+    MOVE, SHOOT, PASS, DRIBBLE, NOOP, QUIT = range(14)
 
 class HFO_Status:
   ''' Current status of the HFO game. '''
@@ -38,6 +44,24 @@ class HFOEnvironment(object):
     self.numFeatures = None # Given by the server in handshake
     self.features = None # The state features
 
+  def NumParams(self, action_type):
+    ''' Returns the number of required parameters for each action type. '''
+    return {
+      HFO_Actions.DASH : 2,
+      HFO_Actions.TURN : 1,
+      HFO_Actions.TACKLE : 1,
+      HFO_Actions.KICK : 2,
+      HFO_Actions.KICK_TO : 3,
+      HFO_Actions.MOVE_TO : 2,
+      HFO_Actions.DRIBBLE_TO : 2,
+      HFO_Actions.INTERCEPT : 0,
+      HFO_Actions.MOVE : 0,
+      HFO_Actions.SHOOT : 0,
+      HFO_Actions.PASS : 1,
+      HFO_Actions.DRIBBLE : 0,
+      HFO_Actions.NOOP : 0,
+      HFO_Actions.QUIT : 0}.get(action_type, -1);
+
   def connectToAgentServer(self, server_port=6000,
                            feature_set=HFO_Features.HIGH_LEVEL_FEATURE_SET):
     '''Connect to the server that controls the agent on the specified port. '''
@@ -92,9 +116,14 @@ class HFOEnvironment(object):
     size numFeatures. '''
     return self.features
 
-  def act(self, action):
+  def act(self, *args):
     ''' Send an action and recieve the game status.'''
-    self.socket.send(struct.pack("iff", *action))
+    assert len(args) > 0, 'Not enough arguments provided to act'
+    action_type = args[0]
+    n_params = self.NumParams(action_type)
+    assert n_params == len(args) - 1, 'Incorrect number of params to act: '\
+      'Required %d provided %d'%(n_params, len(args)-1)
+    self.socket.send(struct.pack('i'+'f'*n_params, *args))
     # Get the current game status
     data = self.socket.recv(struct.calcsize("i"))
     status = struct.unpack("i", data)[0]

src/HFO.cpp

@@ -47,6 +47,41 @@ std::string HFOEnvironment::ActionToString(Action action) {
   return ss.str();
 };
 
+int HFOEnvironment::NumParams(action_t action) {
+ switch (action) {
+   case DASH:
+     return 2;
+   case TURN:
+     return 1;
+   case TACKLE:
+     return 1;
+   case KICK:
+     return 2;
+   case KICK_TO:
+     return 3;
+   case MOVE_TO:
+     return 2;
+   case DRIBBLE_TO:
+     return 2;
+   case INTERCEPT:
+     return 0;
+   case MOVE:
+     return 0;
+   case SHOOT:
+     return 0;
+   case PASS:
+     return 1;
+   case DRIBBLE:
+     return 0;
+   case NOOP:
+     return 0;
+   case QUIT:
+     return 0;
+ }
+ std::cerr << "Unrecognized Action: " << action;
+ return -1;
+}
+
 bool HFOEnvironment::ParseConfig(const std::string& message, Config& config) {
   config.num_offense = -1;
   config.num_defense = -1;
@@ -203,14 +238,31 @@ const std::vector<float>& HFOEnvironment::getState() {
   return feature_vec;
 }
 
-status_t HFOEnvironment::act(Action action) {
+status_t HFOEnvironment::act(action_t action, ...) {
   status_t game_status;
-  // Send the action
-  if (send(sockfd, &action, sizeof(Action), 0) < 0) {
+  // Send the action_type
+  if (send(sockfd, &action, sizeof(action_t), 0) < 0) {
     perror("[Agent Client] ERROR sending from socket");
     close(sockfd);
     exit(1);
   }
+  // Send the arguments
+  int n_args = NumParams(action);
+  if (n_args > 0) {
+    float params[n_args];
+    va_list vl;
+    va_start(vl, n_args);
+    for (int i = 0; i < n_args; ++i) {
+      params[i] = va_arg(vl, double);
+    }
+    va_end(vl);
+    // Send the arguments
+    if (send(sockfd, &params, sizeof(float) * n_args, 0) < 0) {
+      perror("[Agent Client] ERROR sending from socket");
+      close(sockfd);
+      exit(1);
+    }
+  }
   // Get the game status
   if (recv(sockfd, &game_status, sizeof(status_t), 0) < 0) {
     perror("[Agent Client] ERROR recieving from socket");

src/HFO.hpp

@@ -17,15 +17,20 @@ enum feature_set_t
 // The actions available to the agent
 enum action_t
 {
-  DASH,    // [Low-Level] Dash(power, relative_direction)
-  TURN,    // [Low-Level] Turn(direction)
-  TACKLE,  // [Low-Level] Tackle(direction)
-  KICK,    // [Low-Level] Kick(power, direction)
-  MOVE,    // [High-Level] Move(): Reposition player according to strategy
-  SHOOT,   // [High-Level] Shoot(): Shoot the ball
-  PASS,    // [High-Level] Pass(teammate_unum): Pass to the most open teammate
-  DRIBBLE, // [High-Level] Dribble(): Offensive dribble
-  QUIT     // Special action to quit the game
+  DASH,       // [Low-Level] Dash(power, direction)
+  TURN,       // [Low-Level] Turn(direction)
+  TACKLE,     // [Low-Level] Tackle(direction)
+  KICK,       // [Low-Level] Kick(power, direction)
+  KICK_TO,    // [Mid-Level] Kick_To(target_x, target_y, speed)
+  MOVE_TO,    // [Mid-Level] Move(target_x, target_y)
+  DRIBBLE_TO, // [Mid-Level] Dribble(target_x, target_y)
+  INTERCEPT,  // [Mid-Level] Intercept(): Intercept the ball
+  MOVE,       // [High-Level] Move(): Reposition player according to strategy
+  SHOOT,      // [High-Level] Shoot(): Shoot the ball
+  PASS,       // [High-Level] Pass(teammate_unum): Pass to the most open teammate
+  DRIBBLE,    // [High-Level] Dribble(): Offensive dribble
+  NOOP,       // Do nothing
+  QUIT        // Special action to quit the game
 };
 
 // An Action consists of the discreet action as well as required
@@ -65,6 +70,9 @@ class HFOEnvironment {
   // Returns a string representation of an action.
   static std::string ActionToString(Action action);
 
+  // Get the number of parameters needed for a action.
+  static int NumParams(action_t action);
+
   // Parse a Trainer message to populate config. Returns a bool
   // indicating if the struct was correctly parsed.
   static bool ParseConfig(const std::string& message, Config& config);
@@ -77,7 +85,7 @@ class HFOEnvironment {
   const std::vector<float>& getState();
 
   // Take an action and recieve the resulting game status
-  status_t act(Action action);
+  status_t act(action_t action, ...);
 
  protected:
   int numFeatures; // The number of features in this domain

src/agent.cpp

@@ -425,38 +425,66 @@ void Agent::actionImpl() {
     exit(1);
   }
 
-  // Get the action
-  Action action;
-  if (recv(newsockfd, &action, sizeof(Action), 0) < 0) {
+  // Get the action type
+  action_t action;
+  if (recv(newsockfd, &action, sizeof(action_t), 0) < 0) {
     perror("[Agent Server] ERROR recv from socket");
     close(sockfd);
     exit(1);
   }
-  if (action.action == SHOOT) {
+  // Get the parameters for that action
+  int n_args = HFOEnvironment::NumParams(action);
+  float params[n_args];
+  if (n_args > 0) {
+    if (recv(newsockfd, &params, sizeof(float)*n_args, 0) < 0) {
+      perror("[Agent Server] ERROR recv from socket");
+      close(sockfd);
+      exit(1);
+    }
+  }
+  if (action == SHOOT) {
     const ShootGenerator::Container & cont =
         ShootGenerator::instance().courses(this->world(), false);
     ShootGenerator::Container::const_iterator best_shoot
         = std::min_element(cont.begin(), cont.end(), ShootGenerator::ScoreCmp());
     Body_SmartKick(best_shoot->target_point_, best_shoot->first_ball_speed_,
                    best_shoot->first_ball_speed_ * 0.99, 3).execute(this);
-  } else if (action.action == PASS) {
+  } else if (action == PASS) {
     Force_Pass pass;
-    int receiver = int(action.arg1);
+    int receiver = int(params[0]);
     pass.get_pass_to_player(this->world(), receiver);
     pass.execute(this);
   }
-  switch(action.action) {
+  switch(action) {
     case DASH:
-      this->doDash(action.arg1, action.arg2);
+      this->doDash(params[0], params[1]);
       break;
     case TURN:
-      this->doTurn(action.arg1);
+      this->doTurn(params[0]);
       break;
     case TACKLE:
-      this->doTackle(action.arg1, false);
+      this->doTackle(params[0], false);
       break;
     case KICK:
-      this->doKick(action.arg1, action.arg2);
+      this->doKick(params[0], params[1]);
+      break;
+    case KICK_TO:
+      Body_SmartKick(Vector2D(feature_extractor->absoluteXPos(params[0]),
+                              feature_extractor->absoluteYPos(params[1])),
+                     params[2], params[2] * 0.99, 3).execute(this);
+      break;
+    case MOVE_TO:
+      Body_GoToPoint(Vector2D(feature_extractor->absoluteXPos(params[0]),
+                              feature_extractor->absoluteYPos(params[1])), 0.25,
+                     ServerParam::i().maxDashPower()).execute(this);
+      break;
+    case DRIBBLE_TO:
+      Body_Dribble(Vector2D(feature_extractor->absoluteXPos(params[0]),
+                            feature_extractor->absoluteYPos(params[1])), 1.0,
+                   ServerParam::i().maxDashPower(), 2).execute(this);
+      break;
+    case INTERCEPT:
+      Body_Intercept().execute(this);
       break;
     case MOVE:
       this->doMove();
@@ -468,13 +496,15 @@ void Agent::actionImpl() {
     case DRIBBLE:
       this->doDribble();
       break;
+    case NOOP:
+      break;
     case QUIT:
       std::cout << "[Agent Server] Got quit from agent." << std::endl;
       close(sockfd);
       exit(0);
     default:
       std::cerr << "[Agent Server] ERROR Unsupported Action: "
-                << action.action << std::endl;
+                << action << std::endl;
       close(sockfd);
       exit(1);
   }

src/feature_extractor.cpp

@@ -9,8 +9,13 @@
 
 using namespace rcsc;
 
-FeatureExtractor::FeatureExtractor() :
-    numFeatures(-1)
+FeatureExtractor::FeatureExtractor(int num_teammates,
+                                   int num_opponents,
+                                   bool playing_offense) :
+    numFeatures(-1),
+    numTeammates(num_teammates),
+    numOpponents(num_opponents),
+    playingOffense(playing_offense)
 {
   const ServerParam& SP = ServerParam::i();
 
@@ -92,17 +97,35 @@ void FeatureExtractor::addFeature(float val) {
   feature_vec[featIndx++] = val;
 }
 
-void FeatureExtractor::addNormFeature(float val, float min_val, float max_val) {
-  assert(featIndx < numFeatures);
+float FeatureExtractor::normalize(float val, float min_val, float max_val) {
   if (val < min_val || val > max_val) {
     std::cout << "Feature " << featIndx << " Violated Feature Bounds: " << val
-              << " Expected min/max: [" << min_val << ", " << max_val << "]" << std::endl;
+              << " Expected min/max: [" << min_val << ", "
+              << max_val << "]" << std::endl;
     val = std::min(std::max(val, min_val), max_val);
   }
-  feature_vec[featIndx++] = ((val - min_val) / (max_val - min_val))
+  return ((val - min_val) / (max_val - min_val))
       * (FEAT_MAX - FEAT_MIN) + FEAT_MIN;
 }
 
+float FeatureExtractor::unnormalize(float val, float min_val, float max_val) {
+  if (val < FEAT_MIN || val > FEAT_MAX) {
+    std::cout << "Unnormalized value Violated Feature Bounds: " << val
+              << " Expected min/max: [" << FEAT_MIN << ", "
+              << FEAT_MAX << "]" << std::endl;
+    float ft_max = FEAT_MAX; // Linker error on OSX otherwise...?
+    float ft_min = FEAT_MIN;
+    val = std::min(std::max(val, ft_min), ft_max);
+  }
+  return ((val - FEAT_MIN) / (FEAT_MAX - FEAT_MIN))
+      * (max_val - min_val) + min_val;
+}
+
+void FeatureExtractor::addNormFeature(float val, float min_val, float max_val) {
+  assert(featIndx < numFeatures);
+  feature_vec[featIndx++] = normalize(val, min_val, max_val);
+}
+
 void FeatureExtractor::checkFeatures() {
   assert(feature_vec.size() == numFeatures);
   for (int i=0; i<numFeatures; ++i) {
@@ -241,3 +264,33 @@ void FeatureExtractor::splitAngles(std::vector<OpenAngle> &openAngles,
   }
   openAngles = resAngles;
 }
+
+float FeatureExtractor::normalizedXPos(float absolute_x_pos) {
+  float tolerance_x = .1 * pitchHalfLength;
+  if (playingOffense) {
+    return normalize(absolute_x_pos, -tolerance_x, pitchHalfLength + tolerance_x);
+  } else {
+    return normalize(absolute_x_pos, -pitchHalfLength-tolerance_x, tolerance_x);
+  }
+}
+
+float FeatureExtractor::normalizedYPos(float absolute_y_pos) {
+  float tolerance_y = .1 * pitchHalfWidth;
+  return normalize(absolute_y_pos, -pitchHalfWidth - tolerance_y,
+                   pitchHalfWidth + tolerance_y);
+}
+
+float FeatureExtractor::absoluteXPos(float normalized_x_pos) {
+  float tolerance_x = .1 * pitchHalfLength;
+  if (playingOffense) {
+    return unnormalize(normalized_x_pos, -tolerance_x, pitchHalfLength + tolerance_x);
+  } else {
+    return unnormalize(normalized_x_pos, -pitchHalfLength-tolerance_x, tolerance_x);
+  }
+}
+
+float FeatureExtractor::absoluteYPos(float normalized_y_pos) {
+  float tolerance_y = .1 * pitchHalfWidth;
+  return unnormalize(normalized_y_pos, -pitchHalfWidth - tolerance_y,
+                     pitchHalfWidth + tolerance_y);
+}

src/feature_extractor.h

@@ -8,7 +8,7 @@ typedef std::pair<float, float> OpenAngle;
 
 class FeatureExtractor {
 public:
-  FeatureExtractor();
+  FeatureExtractor(int num_teammates, int num_opponents, bool playing_offense);
   virtual ~FeatureExtractor();
 
   // Updated the state features stored in feature_vec
@@ -68,6 +68,12 @@ public:
                           float oppAngleBottom,
                           float oppAngleTop);
 
+  // Convert back and forth between normalized and absolute x,y postions
+  float normalizedXPos(float absolute_x_pos);
+  float normalizedYPos(float absolute_y_pos);
+  float absoluteXPos(float normalized_x_pos);
+  float absoluteYPos(float normalized_y_pos);
+
 protected:
   // Encodes an angle feature as the sin and cosine of that angle,
   // effectively transforming a single angle into two features.
@@ -92,6 +98,11 @@ protected:
   // Add a feature without normalizing
   void addFeature(float val);
 
+  // Returns a normalized feature value
+  float normalize(float val, float min_val, float max_val);
+  // Converts a normalized feature value back into original space
+  float unnormalize(float val, float min_val, float max_val);
+
   // Add a feature and normalize to the range [FEAT_MIN, FEAT_MAX]
   void addNormFeature(float val, float min_val, float max_val);
 
@@ -118,6 +129,9 @@ protected:
   // Useful measures defined by the Server Parameters
   float pitchLength, pitchWidth, pitchHalfLength, pitchHalfWidth,
     goalHalfWidth, penaltyAreaLength, penaltyAreaWidth;
+  int numTeammates; // Number of teammates in HFO
+  int numOpponents; // Number of opponents in HFO
+  bool playingOffense; // Are we playing offense or defense?
 };
 
 #endif // FEATURE_EXTRACTOR_H

src/highlevel_feature_extractor.cpp

@@ -10,10 +10,7 @@ using namespace rcsc;
 HighLevelFeatureExtractor::HighLevelFeatureExtractor(int num_teammates,
                                                      int num_opponents,
                                                      bool playing_offense) :
-    FeatureExtractor(),
-    numTeammates(num_teammates),
-    numOpponents(num_opponents),
-    playingOffense(playing_offense)
+    FeatureExtractor(num_teammates, num_opponents, playing_offense)
 {
   assert(numTeammates >= 0);
   assert(numOpponents >= 0);

src/highlevel_feature_extractor.h

@@ -25,9 +25,6 @@ protected:
   const static int num_basic_features = 9;
   // Number of features for each player or opponent in game.
   const static int features_per_teammate = 5;
-  int numTeammates; // Number of teammates in HFO
-  int numOpponents; // Number of opponents in HFO
-  bool playingOffense; // Are we playing offense or defense?
 };
 
 #endif // HIGHLEVEL_FEATURE_EXTRACTOR_H

src/lowlevel_feature_extractor.cpp

@@ -10,10 +10,7 @@ using namespace rcsc;
 LowLevelFeatureExtractor::LowLevelFeatureExtractor(int num_teammates,
                                                    int num_opponents,
                                                    bool playing_offense) :
-    FeatureExtractor(),
-    numTeammates(num_teammates),
-    numOpponents(num_opponents),
-    playingOffense(playing_offense)
+    FeatureExtractor(num_teammates, num_opponents, playing_offense)
 {
   assert(numTeammates >= 0);
   assert(numOpponents >= 0);

src/lowlevel_feature_extractor.h

@@ -19,9 +19,6 @@ protected:
   const static int num_basic_features = 58;
   // Number of features for each player or opponent in game.
   const static int features_per_player = 8;
-  int numTeammates; // Number of teammates in HFO
-  int numOpponents; // Number of opponents in HFO
-  bool playingOffense; // Are we playing offense or defense?
 };
 
 #endif // LOWLEVEL_FEATURE_EXTRACTOR_H