woodsxcs.c

XCS is a new algorithm for artificial intelligent

    point[i]=env[((*y)*xs+(((*x)+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+i];
  
  if(((point[0]==FREE0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FREE1)) && (LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FREE2 ))
     ||((point[0]==FOODF0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODF1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODF2))
     ||((point[0]==FOODG0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODG1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODG2)))
    {
      (*x)++;(*x)%=xs;
      return 1;
    }
  return 0;
}
int southeast(int *x,int *y)
{
  char point[LENGTH_OF_ONE_ATTRIBUTE];
  int i;
  
  for(i=0; i<LENGTH_OF_ONE_ATTRIBUTE; i++)
    point[i]=env[((((*y)+1)%ys)*xs+(((*x)+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+i];
  
  if(((point[0]==FREE0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FREE1)) && (LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FREE2 ))
     ||((point[0]==FOODF0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODF1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODF2))
     ||((point[0]==FOODG0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODG1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODG2)))
    {
      (*y)++;(*y)%=ys;
      (*x)++;(*x)%=xs;
      return 1;
    }
  return 0;
}
int south(int *x,int *y)
{
  char point[LENGTH_OF_ONE_ATTRIBUTE];
  int i;
  
  for(i=0; i<LENGTH_OF_ONE_ATTRIBUTE; i++)
    point[i]=env[((((*y)+1)%ys)*xs+(*x))*LENGTH_OF_ONE_ATTRIBUTE+i];
  
  if(((point[0]==FREE0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FREE1)) && (LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FREE2 ))
     ||((point[0]==FOODF0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODF1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODF2))
     ||((point[0]==FOODG0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODG1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODG2)))
    {
      (*y)++;(*y)%=ys;
      return 1;
    }
  return 0;
}
int southwest(int *x,int *y)
{
  char point[LENGTH_OF_ONE_ATTRIBUTE];
  int i;
  
  for(i=0; i<LENGTH_OF_ONE_ATTRIBUTE; i++)
    point[i]=env[((((*y)+1)%ys)*xs+(((*x)+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+i];
  
  if(((point[0]==FREE0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FREE1)) && (LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FREE2 ))
     ||((point[0]==FOODF0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODF1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODF2))
     ||((point[0]==FOODG0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODG1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODG2)))
    {
      (*y)++;(*y)%=ys;
      (*x)=(*x)+xs-1;(*x)%=xs;
      return 1;
    }
  return 0;
}
int west(int *x,int *y)
{
  char point[LENGTH_OF_ONE_ATTRIBUTE];
  int i;
  
  for(i=0; i<LENGTH_OF_ONE_ATTRIBUTE; i++)
    point[i]=env[((*y)*xs+(((*x)+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+i];
  
  if(((point[0]==FREE0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FREE1)) && (LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FREE2 ))
     ||((point[0]==FOODF0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODF1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODF2))
     ||((point[0]==FOODG0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODG1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODG2)))
    {
      (*x)=(*x)+xs-1;(*x)%=xs;
      return 1;
    }
  return 0;
}
int northwest(int *x,int *y)
{
  char point[LENGTH_OF_ONE_ATTRIBUTE];
  int i;
  
  for(i=0; i<LENGTH_OF_ONE_ATTRIBUTE; i++)
    point[i]=env[((((*y)+ys-1)%ys)*xs+(((*x)+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+i];
  
  if(((point[0]==FREE0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FREE1)) && (LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FREE2 ))
     ||((point[0]==FOODF0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODF1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODF2))
     ||((point[0]==FOODG0 && ( LENGTH_OF_ONE_ATTRIBUTE<2 || point[1]==FOODG1)) && ( LENGTH_OF_ONE_ATTRIBUTE<3 || point[2]==FOODG2)))
    {
      (*y)=(*y)+ys-1;(*y)%=ys;
      (*x)=(*x)+xs-1;(*x)%=xs;
      return 1;
    }
  return 0;
}


/* returns the amount of reward given at position x,y */
double checkReward(int x,int y)
{
  if(((env[(y*xs+x)*LENGTH_OF_ONE_ATTRIBUTE]==FOODF0 
      && ( LENGTH_OF_ONE_ATTRIBUTE<2 || env[(y*xs+x)*LENGTH_OF_ONE_ATTRIBUTE+1]==FOODF1))
      && ( LENGTH_OF_ONE_ATTRIBUTE<3 || env[(y*xs+x)*LENGTH_OF_ONE_ATTRIBUTE+2]==FOODF2)
     )||(( 
      env[(y*xs+x)*LENGTH_OF_ONE_ATTRIBUTE]==FOODG0 
      && ( LENGTH_OF_ONE_ATTRIBUTE<2 || env[(y*xs+x)*LENGTH_OF_ONE_ATTRIBUTE+1]==FOODG1))
      && ( LENGTH_OF_ONE_ATTRIBUTE<3 || env[(y*xs+x)*LENGTH_OF_ONE_ATTRIBUTE+2]==FOODG2)
     ))
    return PAYMENT_RANGE;
  else
    return 0;
}

/* set the currently perceived state of the animat */
void setState(char *state)
{
  state[0*LENGTH_OF_ONE_ATTRIBUTE]=env[(((yp+ys-1)%ys)*xs+xp)*LENGTH_OF_ONE_ATTRIBUTE];
  state[1*LENGTH_OF_ONE_ATTRIBUTE]=env[(((yp+ys-1)%ys)*xs+((xp+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE];
  state[2*LENGTH_OF_ONE_ATTRIBUTE]=env[(yp*xs+((xp+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE];
  state[3*LENGTH_OF_ONE_ATTRIBUTE]=env[(((yp+1)%ys)*xs+((xp+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE];
  state[4*LENGTH_OF_ONE_ATTRIBUTE]=env[(((yp+1)%ys)*xs+xp)*LENGTH_OF_ONE_ATTRIBUTE];
  state[5*LENGTH_OF_ONE_ATTRIBUTE]=env[(((yp+1)%ys)*xs+((xp+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE];
  state[6*LENGTH_OF_ONE_ATTRIBUTE]=env[(yp*xs+((xp+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE];
  state[7*LENGTH_OF_ONE_ATTRIBUTE]=env[(((yp+ys-1)%ys)*xs+((xp+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE];
  if(LENGTH_OF_ONE_ATTRIBUTE>1){
    state[0*LENGTH_OF_ONE_ATTRIBUTE+1]=env[(((yp+ys-1)%ys)*xs+xp)*LENGTH_OF_ONE_ATTRIBUTE+1];
    state[1*LENGTH_OF_ONE_ATTRIBUTE+1]=env[(((yp+ys-1)%ys)*xs+((xp+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+1];
    state[2*LENGTH_OF_ONE_ATTRIBUTE+1]=env[(yp*xs+((xp+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+1];
    state[3*LENGTH_OF_ONE_ATTRIBUTE+1]=env[(((yp+1)%ys)*xs+((xp+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+1];
    state[4*LENGTH_OF_ONE_ATTRIBUTE+1]=env[(((yp+1)%ys)*xs+xp)*LENGTH_OF_ONE_ATTRIBUTE+1];
    state[5*LENGTH_OF_ONE_ATTRIBUTE+1]=env[(((yp+1)%ys)*xs+((xp+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+1];
    state[6*LENGTH_OF_ONE_ATTRIBUTE+1]=env[(yp*xs+((xp+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+1];
    state[7*LENGTH_OF_ONE_ATTRIBUTE+1]=env[(((yp+ys-1)%ys)*xs+((xp+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+1];
    if(LENGTH_OF_ONE_ATTRIBUTE>2){
      state[0*LENGTH_OF_ONE_ATTRIBUTE+2]=env[(((yp+ys-1)%ys)*xs+xp)*LENGTH_OF_ONE_ATTRIBUTE+2];
      state[1*LENGTH_OF_ONE_ATTRIBUTE+2]=env[(((yp+ys-1)%ys)*xs+((xp+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+2];
      state[2*LENGTH_OF_ONE_ATTRIBUTE+2]=env[(yp*xs+((xp+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+2];
      state[3*LENGTH_OF_ONE_ATTRIBUTE+2]=env[(((yp+1)%ys)*xs+((xp+1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+2];
      state[4*LENGTH_OF_ONE_ATTRIBUTE+2]=env[(((yp+1)%ys)*xs+xp)*LENGTH_OF_ONE_ATTRIBUTE+2];
      state[5*LENGTH_OF_ONE_ATTRIBUTE+2]=env[(((yp+1)%ys)*xs+((xp+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+2];
      state[6*LENGTH_OF_ONE_ATTRIBUTE+2]=env[(yp*xs+((xp+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+2];
      state[7*LENGTH_OF_ONE_ATTRIBUTE+2]=env[(((yp+ys-1)%ys)*xs+((xp+xs-1)%xs))*LENGTH_OF_ONE_ATTRIBUTE+2];
    }
  }
  /* incase of an additional random bit, switch it with 50% probability */
  if(RANDOMBIT_EXISTS){
    state[CONDITION_LENGTH]=getRandomChar();
    state[CONDITION_LENGTH+1]='\0';
  }else{
    state[CONDITION_LENGTH]='\0';
  }
}

/* moves the enemy (demon) randomly */
int moveEnemy()
{
  int xeo,yeo;
  char *act;

  assert((act=calloc(ACTION_LENGTH+1,sizeof(char)))!=NULL);
  getActions((int)(frand()*8.),act);
  xeo=xe1;yeo=ye1;
  if(moveObject(act,&xe1,&ye1)){
    /* if the enemy moved, set the enemy detection in the environment */
    env[(yeo*xs+xeo)*LENGTH_OF_ONE_ATTRIBUTE]=lastEnemyState[0];
    lastEnemyState[0]=env[(ye1*xs+xe1)*LENGTH_OF_ONE_ATTRIBUTE];
    env[(ye1*xs+xe1)*LENGTH_OF_ONE_ATTRIBUTE]=ENEMY0;
    
    if(LENGTH_OF_ONE_ATTRIBUTE>1){
    
      env[(yeo*xs+xeo)*LENGTH_OF_ONE_ATTRIBUTE+1]=lastEnemyState[1];
      lastEnemyState[1]=env[(ye1*xs+xe1)*LENGTH_OF_ONE_ATTRIBUTE+1];
      env[(ye1*xs+xe1)*LENGTH_OF_ONE_ATTRIBUTE+1]=ENEMY1;
      
      if(LENGTH_OF_ONE_ATTRIBUTE>2){
        env[(yeo*xs+xeo)*LENGTH_OF_ONE_ATTRIBUTE+2]=lastEnemyState[2];
        lastEnemyState[2]=env[(ye1*xs+xe1)*LENGTH_OF_ONE_ATTRIBUTE+2];
        env[(ye1*xs+xe1)*LENGTH_OF_ONE_ATTRIBUTE+2]=ENEMY2;
      }
    }
  }
  free(act);
  return 1;
}


/*################################### generating a new random position #########################################*/

/* after a reset a new position has to be determined */
void resetState(char *state){
  setStartPos(state);
}

/* set the animat to a new new randomly chosen postion and get the perceptions */
void setStartPos(char *state)
{
  setFreeRandPos(&xp,&yp);
  setState(state);
}

/* set x,y to a new randomly chosen free position */
void setFreeRandPos(int *x,int *y)
{
  double help;
  do{
    help=frand()*xs;
    (*x)=help;
    help=frand()*ys;
    (*y)=help;
  }while(!( env[((*y)*xs+(*x))*LENGTH_OF_ONE_ATTRIBUTE]==FREE0
            && (LENGTH_OF_ONE_ATTRIBUTE<2 || env[((*y)*xs+(*x))*LENGTH_OF_ONE_ATTRIBUTE+1]==FREE1)
            && (LENGTH_OF_ONE_ATTRIBUTE<3 || env[((*y)*xs+(*x))*LENGTH_OF_ONE_ATTRIBUTE+2]==FREE2)));
}


/*################################ get environmental properties for testing purposes ###########################################*/

int getActions(int nr,char *action)
{
  switch(nr){
  case 0: strcpy(action,"000");break;
  case 1: strcpy(action,"001");break;
  case 2: strcpy(action,"010");break;
  case 3: strcpy(action,"011");break;
  case 4: strcpy(action,"100");break;
  case 5: strcpy(action,"101");break;
  case 6: strcpy(action,"110");break;
  case 7: strcpy(action,"111");break;
  default: return 0;break;
  }
  return 1;
}

int getEnvXSize()
{
  return xs;
}
int getEnvYSize()
{
  return ys;
}
int getXPos()
{
  return xp;
}
int getYPos()
{
  return yp;
}

/* if x and y point to a free place, set the state to this place (for testing purposes) */
int setPos(int x,int y,char *state)
{
  x=abs(x)%xs;
  y=abs(y)%ys;
  if(!(env[(y*xs+x)*LENGTH_OF_ONE_ATTRIBUTE]==FREE0
       && (LENGTH_OF_ONE_ATTRIBUTE<2 || env[(y*xs+x)*LENGTH_OF_ONE_ATTRIBUTE+1]==FREE1)
       && (LENGTH_OF_ONE_ATTRIBUTE<3 || env[(y*xs+x)*LENGTH_OF_ONE_ATTRIBUTE+2]==FREE2)))
    return 0;
  xp=x;
  yp=y;
  setState(state);
  return 1;
}

/* get '0' or '1', is used for the additional random bit */
char getRandomChar()
{
  double type;
  char c;

  type=frand()*1;

  switch((int)type){
  case 0:c='0';break;
  case 1:c='1';break;
  default:c='X';break;
  }
  return c;
}