Tools/DynamicTeamTactic/RateableOptions.h

Go to the documentation of this file.

/**
 * @file RateableOptions.h
 *
 * Declaration of class RateableOptions
 * @author <A href=mailto:jochen@kerdels.de>Jochen Kerdels</A>
 */

#ifndef __RateableOptions_h_
#define __RateableOptions_h_

#include <string.h>

 /**
 *  The class contains an enumeration of rateable options
 */
class RateableOptions
{
public:

  /**
   * Enumerator for available options
   * Add new options here.
   */
  enum OptionID
  {
    noOption = 0,                  //!<  to disable DynamicTactics and use std. Xabsl 
    doNothing,                     //!<  doesn't change the motion request 
    stand,                         //!<  standing around... 
    keepOption,                    //!<  keeps previous choosen option ...
    intro,                         //!<  the oc-intro option
    extro,                         //!<  the oc-extro option
    finished,                      //!<  the oc-finished option    
    gotoBitePos1,                  //!<  dog1 goes to his bite position
    gotoBitePos2,                  //!<  dog2 goes to his bite position
    gotoBitePos3,                  //!<  dog3 goes to his bite position
    gotoBitePos4,                  //!<  dog4 goes to his bite position
    bitePos1,                      //!<  dog1 bites at his position
    bitePos2,                      //!<  dog2 bites at his position
    bitePos3,                      //!<  dog3 bites at his position
    bitePos4,                      //!<  dog4 bites at his position 
    movePos1,                      //!<  dog1 moves directed by dog 5
    movePos2,                      //!<  dog2 moves directed by dog 5
    movePos3,                      //!<  dog3 moves directed by dog 5
    movePos4,                      //!<  dog4 moves directed by dog 5
    gotoBridge,                    //!<  dog5 goes to the bridge
    climbBridge,                   //!<  dog5 climbs the bridge
    waitForBiteDogs,               //!<  dog5 waits for the others to bite their positions
    moveBridge,                    //!<  dog5 directs the other dogs
    numOfOptions                   //!< Number of options 
  };

  /**
   * Enumerator for available options types ... NOT classes
   * This is used for the xabsl-interface
   */
  enum OptionType {
    special,
    gotoPos,
    gotoBallPos,
    kickAction,
    goalieAction,
    notype
  };


  enum OptionClassID
  {
    doSomething = numOfOptions,
    maxOptionClassID,
    numOfOptionClasses = maxOptionClassID - numOfOptions //!< Number of optionclasses 
  };

  typedef struct {
    int        id;
    char      *name;
    int        numOfSubOptions;
    int        changeThreshold;
    OptionType optionType;
    int        slidingAverageRange;
    int        ratingBoost;
  } OptionInfo;
  
  static OptionInfo optionInfos[];
 
  /**
   * Enumerator for available TacticEntryTypes used by GlobalAnalysers
   * Add new engines here.
   */
  enum TacticEntryTypeID {

    FirstTETID = 0,

    // Types for defaultGlobalAnalyser
    defGA_Neutral,               // every analyser should offer a neutral type
    defGA_Max,

    numOfTETIDs
  };

  
  /**
   * returns names for option and option class ids
   */
  static const char* getOptionName(int id);
  static int         getOptionID(const char*  name);
  static OptionType  getOptionType(int id);
  static int         getSlidingAverageRange(int id);
  static int         getRatingBoost(int id);

  /**
   * The following two functions represent the members
   * of a OptionClass.. kind of a hack, i know..
   */
  static int         getNumberOfClassMembers(OptionClassID id);
  static int         getOptionClassChangeThreshold(OptionClassID id);
  static OptionID    getClassMember(OptionClassID id, int idx);
  
  static bool        isOptionClass(int id);
  static bool        isClassMember(OptionClassID OCid, OptionID Oid);

  /**
   * Enumerator for available OptionRating engines
   * Add new engines here.
   */
  enum OptionRatingID
  {
    defaultOptionRating = 0, //!< default engine
    numOfOptionRatings       //!< Number of engines
  };

  /**
   * Enumerator for available TacticChooser engines
   * Add new engines here.
   */
  enum TacticChooserID
  {
    defaultTacticChooser = 0, //!< default engine 
    numOfTacticChoosers       //!< Number of engines 
  };



  /**
   * Enumerator for available GlobalAnalyser engines
   * Add new engines here.
   */
  enum GlobalAnalyserID
  {
    defaultGlobalAnalyser = 0, //!< default engine
    numOfGlobalAnalysers       //!< Number of engines 
  };

  /**
   * returns names of a TETID
   * Add new IDs here
   */
  static const char* getTETIDName(TacticEntryTypeID id)
  {
    switch (id) {
      case defGA_Neutral        : return "Neutral";
      default: return "please edit RateableOptions::getTETIDName";
    }
  }

  /** 
   * returns names of GlobalAnalysers engines
   * Add new engines here
   */
  static const char* getGlobalAnalyserName(GlobalAnalyserID id)
  {
    switch (id)
    {
      case defaultGlobalAnalyser       : return "DefGlobalAnalyser";
      default: return "please edit RateableOptions::getGlobalAnalyserName";
    }
  }

  /** returns the base index of TETIDs of a GlobalAnalysers engine
   * Add new engines here
   */
  static int getGlobalAnalyserTETBase(GlobalAnalyserID id)
  {
    switch (id)  {
      case defaultGlobalAnalyser : return (int)defGA_Neutral;
      default: return -1;
    }
  }

  /** returns the TETID Count of a GlobalAnalysers engine
   * Add new engines here
   */
  static int getGlobalAnalyserTETCount(GlobalAnalyserID id)
  {
    switch (id)  {
      case defaultGlobalAnalyser : return ((int)defGA_Max - (int)defGA_Neutral);
      default: return -1;
    }
  }

  /** returns the neutral TETID of a GlobalAnalysers engine
   * Add new engines here
   */
  static TacticEntryTypeID getGlobalAnalyserNeutralTETID(GlobalAnalyserID id)
  {
    switch (id) {
      case defaultGlobalAnalyser : return defGA_Neutral;
      default: return FirstTETID;
    }
  }

  /**
   * returns ids for TETID names
   * Add new IDs here
   */
  static TacticEntryTypeID getTETID(GlobalAnalyserID id, const char*  name)
  {
    switch (id) {
      case defaultGlobalAnalyser: {
        if (strcmp(name, "Neutral") == 0)
          return defGA_Neutral;
        else
          return FirstTETID;
                           } break;

      default: return FirstTETID;
    }
  }

};

#endif //__RateableOptions_h_

/*
 * Change log :
 * $Log: RateableOptions.h,v $
 * Revision 1.3  2004/07/22 22:38:34  kerdels
 * added DTT used by Open Challenge, RIP and Xabsl-Options will follow
 *
 *
 */

---