Modules/BehaviorControl/GT2004BehaviorControl/GT2004DTT/DefaultTacticChooser.cpp

Go to the documentation of this file.

/**
* @file DefaultTacticChooser.cpp
* 
* Implementation of class DefaultTacticChooser
*  
*  @author <A href=mailto:b@tchman.de>Mathias Hülsbusch</A>
*/

#include "DefaultTacticChooser.h"
#include "Tools/DynamicTeamTactic/RateableOptions.h"
#include "Tools/Location.h"
#include "Tools/Streams/InStreams.h"

static const int FADING_START_TIME = 1000;
static const int FADING_END_TIME = 6000;


DefaultTacticChooser::DefaultTacticChooser(const BehaviorControlInterfaces& interfaces,
                                           CollectedBeliefs& collectedBeliefs,
                                           ChooserRaterInterfaces& chooserRaterInterfaces)
: TacticChooser(interfaces, collectedBeliefs, chooserRaterInterfaces)
{
  freeze = false;
  // precalculation of all possible Dog permutaions...
  // it's not nice, but does it for all kinds of numOfPlayerNumbers > 0
  facOfNumOfPlayerNumbers = 1;
  int i;
  for (i = 2; i <= Player::numOfPlayerNumbers; ++i)
    facOfNumOfPlayerNumbers *= i;

  // create some space to store permutations...
  for (i = 0; i < Player::numOfPlayerNumbers; ++i)
    dogPermutation[i] = new int[facOfNumOfPlayerNumbers];

  // calculating some ranges..
  int divisors[Player::numOfPlayerNumbers-2];
  int tmp = facOfNumOfPlayerNumbers;
  
  // to be sure ...
  if (Player::numOfPlayerNumbers > 2) {
    for (i = Player::numOfPlayerNumbers; i > 2; --i) {
      divisors[Player::numOfPlayerNumbers - i] = tmp / i;
      tmp = divisors[Player::numOfPlayerNumbers - i];
    }
  }

  // generate the permutations...
  int dogs[Player::numOfPlayerNumbers];
  int j,k,l;
  for (i = 0; i < facOfNumOfPlayerNumbers; ++i) {
    // initialising some fresh dogs...
    for (j = 0; j < Player::numOfPlayerNumbers; ++j)
      dogs[j] = j;
    // go, create...
    tmp = i;
    j = 0;
    if (Player::numOfPlayerNumbers > 2) 
      for (j = 0; j < Player::numOfPlayerNumbers-2; ++j) {
        k = tmp / divisors[j];
        tmp %= divisors[j];
        // adding dog to permutation...
        dogPermutation[j][i] = dogs[k];
        for (l = k; l < Player::numOfPlayerNumbers-1; ++l)
          dogs[l] = dogs[l+1];
      }

    // adding the last two dogs...
    dogPermutation[j][i]   = dogs[tmp];
    if (Player::numOfPlayerNumbers > 1) 
      dogPermutation[j+1][i] = dogs[1-tmp];
  }


  // Loading the TacticEntryArray
  InBinaryFile stream(getLocation().getFilename("default.dtt"));
  if (stream.exists())
  {
    stream >> tacticEntryArray;
  }
  else
  {
    OUTPUT(idText,text,"DefaultTacticChoose : couldn't load TacticEntryArray "<<getLocation().getFilename("default.dtt"));
  }


}

DefaultTacticChooser::~DefaultTacticChooser()
{
  // release the space for the permutations...
  for (int i = 0; i < Player::numOfPlayerNumbers; ++i)
    delete[] dogPermutation[i];
}

bool DefaultTacticChooser::handleMessage(InMessage& message)
{
  if (message.getMessageID() == idTacticEntryArray)
  {
    message.bin >> tacticEntryArray;
    return true;
  }
  if (message.getMessageID() == idFreezeRequest)
  {
    message.bin >> freeze;
    return true;
  }
  return false;
}



RateableOptions::OptionID DefaultTacticChooser::chooseOption()
{
  if (tacticEntryArray.entryCount == 0)
  {
    INFO(sendOptionRatings,idChoosenTacticEntry,text,"empty Taktic Entry Array");
    return RateableOptions::noOption;
  }

  RateableOptions::OptionID optToChoose = RateableOptions::noOption;
  if (freeze)
    optToChoose = RateableOptions::stand;
  else {
    RateableOptions::OptionID usedOptions[Player::numOfPlayerNumbers];
    double maxScore = 0;
    int choosenTacticEntry = 0;
    unsigned long actTime = SystemCall::getCurrentSystemTime();
    double timeWeight[Player::numOfPlayerNumbers];
    int k;
    int timediff;
    // doing some Aging...
    for (k = 0; k < Player::numOfPlayerNumbers; ++k) {
      timediff = actTime - collectedBeliefs.singleBeliefs[k].timeStamp;
      if (timediff < FADING_START_TIME)
        timediff = 0;
      else if (timediff > FADING_END_TIME)
        timediff = FADING_END_TIME - FADING_START_TIME;
      else timediff = timediff - FADING_START_TIME;
      timeWeight[k] = (double)((FADING_END_TIME - FADING_START_TIME)-timediff) /
                      (double)(FADING_END_TIME - FADING_START_TIME);
    }

      
    // preparing the global Analysers...
    for (int n = 0; n < RateableOptions::numOfGlobalAnalysers; ++n)
      globalAnalyser[n]->update();

    for (int i = 0; i < facOfNumOfPlayerNumbers; ++i) 
    {

      // walk through all TacticEntrys with that permutation..
      for (int te=0; te < tacticEntryArray.entryCount; ++te)
      {
        // get score for permutation i
        double score = 0;

        TacticEntry& aktTE = tacticEntryArray.entrys[te];

        // is this permutation a valid permutation for this tacticEntry ?
        int validPermutation = 1;
        for (int j = 0; j < Player::numOfPlayerNumbers; ++j)
          validPermutation *= aktTE.allowedDogs[dogPermutation[j][i]][j];

        if (validPermutation)
        {
          // get the options for this entry ...
          for (k = 0; k < Player::numOfPlayerNumbers; ++k)
            if (aktTE.isOptionClass[k])
              usedOptions[k] = 
    collectedBeliefs.singleBeliefs[dogPermutation[k][i]].getBestOptionInOptionClass(
                           (RateableOptions::OptionClassID)(aktTE.neededOptions[k])
                                                                                   );
            else usedOptions[k] = (RateableOptions::OptionID)(aktTE.neededOptions[k]);

          for (k = 0; k < Player::numOfPlayerNumbers; ++k)
            score += aktTE.optionWeights[k] * timeWeight[dogPermutation[k][i]] *
    collectedBeliefs.singleBeliefs[dogPermutation[k][i]].ratedOptions[usedOptions[k]];

          score *= aktTE.weight;

          // applying global analysers
          for (k = 0; k < RateableOptions::numOfGlobalAnalysers; ++k)
            score *= globalAnalyser[k]->getWeight(aktTE.globalAnalysersInfo[k]);

          if (score >= maxScore)
          {
            maxScore = score;
            choosenTacticEntry = te;
            for (int l = 0; l < Player::numOfPlayerNumbers; ++l)
              if (dogPermutation[l][i] == getPlayer().getPlayerNumber())
              {
                optToChoose = usedOptions[l];
                break;
              }
            for (int j = 0; j < Player::numOfPlayerNumbers; ++j)
              ocplayerrole[dogPermutation[j][i]] = usedOptions[j];
          }// if (maxScore)
        }// if (validPermutation)
      }// for (TE)
    }

  //  OUTPUT(idText, text, RateableOptions::getOptionName(optToChoose));
    INFO(sendOptionRatings,idChoosenTacticEntry,text,tacticEntryArray.entrys[choosenTacticEntry].name);
    char buffer[10];
    char buffer2[50] = "|";
    for (k=0; k < Player::numOfPlayerNumbers; ++k)
    {
      //_gcvt(timeWeight[k],2,buffer);
      sprintf( buffer, "%4.2f", timeWeight[k]);
      strcat(buffer,"|");
      strcat(buffer2,buffer);
    }
    INFO(sendOptionRatings,idTimeWeights,text,buffer2);

    if (optToChoose == RateableOptions::keepOption)
      optToChoose = chooserRaterInterfaces.lastChoosenOption;

  } // end else part of "if (freeze)"
 
  INFO(sendOptionRatings,idChoosenOption,text,RateableOptions::getOptionName(optToChoose));
  return optToChoose;

}


/*
 * Change log :
 * $Log: DefaultTacticChooser.cpp,v $
 * Revision 1.2  2004/08/09 13:51:48  hamerla
 * import OpenChallen Behavior to WM
 *
 * Revision 1.1  2004/07/22 22:38:31  kerdels
 * added DTT used by Open Challenge, RIP and Xabsl-Options will follow
 *
  *
 */

---