formation.c

足球机器人仿真组CMU97的源码

				 fRT_INSIDE_HALFBACK,fRT_OUTSIDE_HALFBACK,
				 fRT_INSIDE_QTRBACK,fRT_OUTSIDE_QTRBACK,
				 fRT_INSIDE_FULLBACK,fRT_OUTSIDE_FULLBACK,0};
  for (int i=0; i<TEAM_SIZE; i++)
    formation->SetCandidateReceivers(i,TEAM_SIZE-i-1,receiverlist);

  formation->AllocateUnits(3);

  /* Positions listed in order of importance, captain indicated as index into list */

  int defenders[3] = {fRT_GOALIE, fRT_INSIDE_FULLBACK, fRT_OUTSIDE_FULLBACK};
  formation->GetUnit(DEFENSIVE_UNIT)->InitializeUnit(DEFENSIVE_UNIT, 3, defenders, 0);

  int midfielders[6] = {fRT_INSIDE_QTRBACK,  fRT_OUTSIDE_QTRBACK,
			fRT_INSIDE_HALFBACK, fRT_OUTSIDE_HALFBACK,
			fRT_INSIDE_3QTRBACK,  fRT_OUTSIDE_3QTRBACK};
  formation->GetUnit(MIDFIELD_UNIT)->InitializeUnit(MIDFIELD_UNIT, 6, midfielders, 2);

  int forwards[2] = {fRT_INSIDE_FORWARD, fRT_OUTSIDE_FORWARD};
  formation->GetUnit(FORWARD_UNIT)->InitializeUnit(FORWARD_UNIT, 2, forwards, 0);
}

/************************ LEFT  Formation ********************************/

#define fLT_GOALIE_BUF      2
#define fLT_POSITION_BUF    3

#define fLT_GOALTENDERX   (-52)
#define fLT_FULLBACKX     (-35)
#define fLT_QTRBACKX      (-15)
#define fLT_HALFBACKX      0
#define fLT_3QTRBACKX      12
#define fLT_FORWARDX       30
#define fLT_OUTSIDEY       22
#define fLT_INSIDEY        7
#define fLT_CENTERY        0

#define fLT_HOMEXRANGE    20
#define fLT_HOMEYRANGE    10
#define fLT_MAXXRANGE     30
#define fLT_MAXYRANGE     30

void Initialize_LT_Formation(Formation *formation){
  
  /* set position within goal stay, in penalty box      */
  formation->SetPosition(fLT_GOALIE, fLT_GOALTENDERX, fLT_CENTERY, fLT_GOALIE_BUF, 
			 (X0- (-fLT_GOALTENDERX))*2, GOAL_WIDTH, 
			 /*(-fLT_GOALTENDERX - PA_X)*2, PA_Y*2, */
			 (X0- (-fLT_GOALTENDERX))*2, GOAL_WIDTH, 
			 GOALIEMAXACTIVEDIST, MININACTIVEDIST, FALSE);  

  formation->SetPosition(fLT_INSIDE_FULLBACK, fLT_FULLBACKX, fLT_INSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);

  formation->SetPosition(fLT_OUTSIDE_FULLBACK, fLT_FULLBACKX, fLT_OUTSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);

  formation->SetPosition(fLT_INSIDE_QTRBACK, fLT_QTRBACKX, fLT_INSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);

  formation->SetPosition(fLT_OUTSIDE_QTRBACK, fLT_QTRBACKX, fLT_OUTSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);

  formation->SetPosition(fLT_INSIDE_HALFBACK, fLT_HALFBACKX, fLT_INSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);

  formation->SetPosition(fLT_OUTSIDE_HALFBACK, fLT_HALFBACKX, fLT_OUTSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);

  formation->SetPosition(fLT_INSIDE_3QTRBACK, fLT_3QTRBACKX, fLT_INSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);

  formation->SetPosition(fLT_OUTSIDE_3QTRBACK, fLT_3QTRBACKX, fLT_OUTSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);

  formation->SetPosition(fLT_INSIDE_FORWARD, fLT_FORWARDX, fLT_INSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);

  formation->SetPosition(fLT_OUTSIDE_FORWARD, fLT_FORWARDX, fLT_OUTSIDEY, fLT_POSITION_BUF, 
			 fLT_HOMEXRANGE,fLT_HOMEYRANGE,
			 fLT_MAXXRANGE ,fLT_MAXYRANGE,
			 MAXACTIVEDIST, MININACTIVEDIST, TRUE);


  /* Candidate receivers will be chosen on the fly here */
  int receiverlist[TEAM_SIZE] = {fLT_INSIDE_FORWARD,fLT_OUTSIDE_FORWARD,
				 fLT_INSIDE_3QTRBACK,fLT_OUTSIDE_3QTRBACK,
				 fLT_INSIDE_HALFBACK,fLT_OUTSIDE_HALFBACK,
				 fLT_INSIDE_QTRBACK,fLT_OUTSIDE_QTRBACK,
				 fLT_INSIDE_FULLBACK,fLT_OUTSIDE_FULLBACK,0};
  for (int i=0; i<TEAM_SIZE; i++)
    formation->SetCandidateReceivers(i,TEAM_SIZE-i-1,receiverlist);

  formation->AllocateUnits(3);

  /* Positions listed in order of importance, captain indicated as index into list */

  int defenders[3] = {fLT_GOALIE, fLT_INSIDE_FULLBACK, fLT_OUTSIDE_FULLBACK};
  formation->GetUnit(DEFENSIVE_UNIT)->InitializeUnit(DEFENSIVE_UNIT, 3, defenders, 0);

  int midfielders[6] = {fLT_INSIDE_QTRBACK,  fLT_OUTSIDE_QTRBACK,
			fLT_INSIDE_HALFBACK, fLT_OUTSIDE_HALFBACK,
			fLT_INSIDE_3QTRBACK,  fLT_OUTSIDE_3QTRBACK};
  formation->GetUnit(MIDFIELD_UNIT)->InitializeUnit(MIDFIELD_UNIT, 6, midfielders, 2);

  int forwards[2] = {fLT_INSIDE_FORWARD, fLT_OUTSIDE_FORWARD};
  formation->GetUnit(FORWARD_UNIT)->InitializeUnit(FORWARD_UNIT, 2, forwards, 0);
}


/*************************************************************************/
/************************ FUNCTION DEFINITIONS ***************************/
/*************************************************************************/

/************************ RECTANGLE CLASS FUNCTIONS **********************/

void Rectangle::DefineRectangle(float x,float y,float w,float h){
  centerX = x;
  centerY = y;
  width   = w;
  height  = h;
}

void  Rectangle::DefineRectangleFromTLCorner(float x,float y,float w,float h){
  DefineRectangle(x+w/2,y+h/2,w,h);
}

float Rectangle::DistanceToEdge(float x, float y){
  if ( IsWithin(x,y) )  /* return a positive number */
    return MIN(TopY()-y, MIN(y-BottomY(), MIN(LeftX()-x, x-RightX())));

  float xdist = -1000; /* want maximum negative distance (min abs) */
  float ydist = -1000; /* want maximum negative distance (min abs) */
  if (TopY()-y    <= 0 && TopY()-y    > ydist) ydist = TopY()-y;
  if (y-BottomY() <= 0 && y-BottomY() > ydist) ydist = y-BottomY();
  if (LeftX()-x   <= 0 && LeftX()-x   > xdist) xdist = LeftX()-x;
  if (x-RightX()  <= 0 && x-RightX()  > xdist) xdist = x-RightX();

  /* If it's outside in 2 dimensions, want min negative distance (max abs) */
  float result;
  if ( xdist == -1000 )
    result = ydist;
  else if ( ydist == -1000 )
    result = xdist;
  else
    result = MIN(xdist,ydist);

  if (result == -1000){
    printf("(%.1f, %.1f) distance to edge of \n",x,y);
    this->Print();
    my_error("Well then IsWithin should have been true");
  }

  return result;
}

int   Rectangle::IsWithin(float x, float y){
  if ( x<LeftX() || x>RightX() || y>TopY() || y<BottomY() )
    return FALSE;
  
  return TRUE;
}

void  Rectangle::AdjustToWithin(float *x, float *y){
  if (TopY()-*y    <0) *y = TopY();
  if (*y-BottomY() <0) *y = BottomY();
  if (RightX()-*x  <0) *x = RightX();
  if (*x-LeftX()   <0) *x = LeftX();
}

void  Rectangle::Print(){
  printf("RECTANGLE:  x = %.1f to %.1f   y = %.1f to %.1f\n",
	 LeftX(),RightX(),BottomY(),TopY());
}

/************************ TEAMPOSITION CLASS FUNCTIONS *****************/

TeamPosition::TeamPosition(){
  HomeRange = new Rectangle;
  MaxRange  = new Rectangle;
  HomeX = HomeY = HomeBuffer = 0;
  MaxActiveDistance = 0;
  only_active_if_closest = TRUE;
  type = side = 0;
}

TeamPosition::~TeamPosition(){
  delete HomeRange;
  delete MaxRange;
}

void TeamPosition::SetHome(float x, float y, float buf){
  HomeX = x;
  HomeY = y;
  HomeBuffer = buf;

  /* Determine the type and the side of a position */
  if      ( x < (ROUGH_GOALTENDERX+ROUGH_DEFENDERX)/2 ) type = GOALTENDER;
  else if ( x < (ROUGH_DEFENDERX+ROUGH_MIDFIELDERX)/2 ) type = DEFENDER;
  else if ( x < (ROUGH_MIDFIELDERX+ROUGH_FORWARDX) /2 ) type = MIDFIELDER;
  else                                                  type = FORWARD;

  if      ( y < (ROUGH_RIGHTY+ROUGH_CENTERY)/2 ) side = RIGHT;
  else if ( y < (ROUGH_CENTERY+ROUGH_LEFTY) /2 ) side = CENTER;
  else                                           side = LEFT;
}

void TeamPosition::SetHomeRange(float width, float height){
  HomeRange->DefineRectangle(HomeX,HomeY,width,height);
}

void TeamPosition::SetMaxRange (float width, float height){
  MaxRange->DefineRectangle(HomeX,HomeY,width,height);
}

void TeamPosition::PrintHomeRange (){
  HomeRange->Print();
}

void TeamPosition::PrintMaxRange (){
  MaxRange->Print();
}

/************************** UNIT CLASS FUNCTIONS ***********************/

Unit::Unit(){
  type = size = captain = 0;
  members = NULL;
}

Unit::~Unit(){
  if ( members != NULL )
    delete members;
}

Unit::InitializeUnit(int tp, int sz, int *mems, int capt){
  type = tp;
  size = sz;
  captain = mems[capt];
  members = new int[size];

  for (int i=0; i<size; i++)
    members[i] = mems[i];
}

int Unit::IsMember(int position){
  for (int i=0; i<size; i++){
    if ( members[i] == position )
      return TRUE;
  }
  return FALSE;
}

int Unit::IsCaptain(int position){
  if ( members[0] == position )
      return TRUE;
  return FALSE;
}

int Unit::ImportantPosition(int p1, int p2){
  int index1, index2;

  for (int i=0; i<size; i++){
    if ( members[i] == p1 )
      index1 = i;
    if ( members[i] == p2 )
      index2 = i;
  }

  if ( index1 < index2 )
    return p1;
  else if ( index2 < index1 )
    return p2;
  else
    my_error("indeces shouldn't be the same");
}

/************************ FORMATION CLASS FUNCTIONS ********************/

Formation::Formation(int formation_number){
  type = formation_number;
  FormationUnits = NULL;
}

Formation::~Formation(){
  if ( FormationUnits != NULL )
    delete FormationUnits;
}

Formation::AllocateUnits(int num){
  NumUnits = num;
  FormationUnits = new Unit[NumUnits];
}

void Formation::SetPosition(int num, float x, float y, float buffer,
			    float home_width, float home_height, 
			    float max_width, float max_height, float max_act_dist,
			    float min_inact_dist, int act_if_closest){
  /* Use this to put in the parameters for the positions in a given formation */
  PositionList[num].SetHome(x,y,buffer);
  PositionList[num].SetHomeRange(home_width,home_height);
  PositionList[num].SetMaxRange(max_width,max_height);

  PositionList[num].SetMaxActiveDistance  (max_act_dist  );
  PositionList[num].SetMinInactiveDistance(min_inact_dist);
  PositionList[num].SetOnlyActiveIfClosest(act_if_closest);
}

TeamPosition *Formation::GetPosition(int num){
  if (num >= TEAM_SIZE) 
    my_error("position list index only goes from 0 to TEAM_SIZE -1");
  return &(PositionList[num]);