woodsxcs.c

XCS is a new algorithm for artificial intelligent

/*
/       WoodsEnvironment for XCS
/       ------------------------------------
/       a Learning Classifier System based on accuracy
/
/     by Martin Butz
/     University of Wuerzburg / University of Illinois at Urbana/Champaign
/     [e-mail]
/     Last modified: 10-19-99
/
/     The woods environment coded binary
*/


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include "env.h"

int xp=0,yp=0;
int xs=0,ys=0;
int xe1=0,ye1=0;
char *env=NULL;
int enemyHidden=0;
char lastEnemyState[LENGTH_OF_ONE_ATTRIBUTE];

/*############################################ construct and destruct the environment ############################################*/

int initEnv(FILE *fp)
{
  char s[100], *help;
  int i, sublength;
  xs=0, ys = 0;
  
  if(ENEMY_EXISTS){
    lastEnemyState[0]='0';
    if(LENGTH_OF_ONE_ATTRIBUTE>1){
      lastEnemyState[1]='0';
      if(LENGTH_OF_ONE_ATTRIBUTE>2){
	lastEnemyState[2]='0';
      }
    }
  }

  while(fscanf(fp,"%s",s)==1){
    if(xs==0){
      xs=strlen(s);
      assert((env=calloc(xs*LENGTH_OF_ONE_ATTRIBUTE+1,sizeof(char)))!=NULL);
      assert((help=calloc(1,sizeof(char)))!=NULL);/* this is necessary as help always is freed */
      sublength=0;
    }else{
      if(xs!=strlen(s)){
        printf("Error in File of environment!\n");
        return 0;
      }
      help=env;
      sublength=strlen(help);
      assert((env=calloc(strlen(s)*LENGTH_OF_ONE_ATTRIBUTE+sublength+1,sizeof(char)))!=NULL);
      strncpy(env,help,sublength);
    }
    for(i=0; i<xs; i++){
      switch(s[i]){
      case 'O':
	env[i*LENGTH_OF_ONE_ATTRIBUTE +sublength]=OBSTACLEO0;
	if(LENGTH_OF_ONE_ATTRIBUTE>1){
	  env[i*LENGTH_OF_ONE_ATTRIBUTE+1 +sublength]=OBSTACLEO1;
	  if(LENGTH_OF_ONE_ATTRIBUTE>2){
	    env[i*LENGTH_OF_ONE_ATTRIBUTE+2 +sublength]=OBSTACLEO2;
	  }
	} 
	break;
      case 'Q':
	env[i*LENGTH_OF_ONE_ATTRIBUTE +sublength]=OBSTACLEQ0;
	if(LENGTH_OF_ONE_ATTRIBUTE>1){
	  env[i*LENGTH_OF_ONE_ATTRIBUTE+1 +sublength]=OBSTACLEQ1;
	  if(LENGTH_OF_ONE_ATTRIBUTE>2){
	    env[i*LENGTH_OF_ONE_ATTRIBUTE+2 +sublength]=OBSTACLEQ2;
	  }
	}
	break;
      case 'F':
	env[i*LENGTH_OF_ONE_ATTRIBUTE +sublength]=FOODF0;
	if(LENGTH_OF_ONE_ATTRIBUTE>1){
	  env[i*LENGTH_OF_ONE_ATTRIBUTE+1 +sublength]=FOODF1;
	  if(LENGTH_OF_ONE_ATTRIBUTE>2){
	    env[i*LENGTH_OF_ONE_ATTRIBUTE+2 +sublength]=FOODF2;
	  }
	}
	break;
      case 'G':
	env[i*LENGTH_OF_ONE_ATTRIBUTE +sublength]=FOODG0;
	if(LENGTH_OF_ONE_ATTRIBUTE>1){
	  env[i*LENGTH_OF_ONE_ATTRIBUTE+1 +sublength]=FOODG1;
	  if(LENGTH_OF_ONE_ATTRIBUTE>2){
	    env[i*LENGTH_OF_ONE_ATTRIBUTE+2 +sublength]=FOODG2;
	  }
	}
	break;
      case '*':
	env[i*LENGTH_OF_ONE_ATTRIBUTE +sublength]=FREE0;
	if(LENGTH_OF_ONE_ATTRIBUTE>1){
	  env[i*LENGTH_OF_ONE_ATTRIBUTE+1 +sublength]=FREE1;
	  if(LENGTH_OF_ONE_ATTRIBUTE>2){
	    env[i*LENGTH_OF_ONE_ATTRIBUTE+2 +sublength]=FREE2;
	  }
	}
	break;
      default:
	printf("Fehler beim Fileeinlesen!\n");
	return 0;
	break;
      }
    }
    env[sublength+ xs*LENGTH_OF_ONE_ATTRIBUTE]='\0';
    free(help);
  }

  ys=strlen(env)/(xs*LENGTH_OF_ONE_ATTRIBUTE);
  xe1=0;ye1=0;
  /* set the enemy (demon) if applied */
  if(ENEMY_EXISTS){
    setFreeRandPos(&xe1,&ye1);
    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){
      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){
        lastEnemyState[1]=env[(ye1*xs+xe1)*LENGTH_OF_ONE_ATTRIBUTE+2];
        env[(ye1*xs+xe1)*LENGTH_OF_ONE_ATTRIBUTE+2]=ENEMY2;
      }
    }
  }
  enemyHidden=0;
  printf("Read in: %s\n",env);
  return 1;
}

void freeEnv()
{
  free(env);
}


/* This is the function that is called to move the animat
 * move also the enemy (demon) and set the perceived reward
 * returns if a reset must take place - reset has to be called separately*/
int doAction(char *state,char *action,int *reset)
{
  int reward, moved;

  moved=moveObject(action,&xp,&yp);
  reward=checkReward(xp,yp);
  if(ENEMY_EXISTS && !enemyHidden)
    moveEnemy();
  /* sets the new entered state */
  setState(state);

  if(reward > 0 && RESET_ON_REWARD )
    *reset = 1;
  else
    *reset = 0;

  return reward;
}

/* changes x and y if the action leads to a free spot, returns if the object was actually moved */
int moveObject(char *action,int *x,int *y)
{
  int moved=0;
  if(strcmp(action,"000")==0){
    if(frand()<1.-SLIPPROB||enemyHidden)
      moved=north(x,y);
    else
      if(frand()<0.5)
        moved=northwest(x,y);
      else
        moved=northeast(x,y);
  }else if(strcmp(action,"001")==0){
    if(frand()<1.-SLIPPROB||enemyHidden)
      moved=northeast(x,y);
    else
      if(frand()<0.5)
        moved=north(x,y);
      else
        moved=east(x,y);
  }else if(strcmp(action,"010")==0){
    if(frand()<1.-SLIPPROB||enemyHidden)
      moved=west(x,y);
    else
      if(frand()<0.5)
        moved=northwest(x,y);
      else
        moved=southwest(x,y);
  }else if(strcmp(action,"011")==0){
    if(frand()<1.-SLIPPROB||enemyHidden)
      moved=southeast(x,y);
    else
      if(frand()<0.5)
        moved=south(x,y);
      else
        moved=east(x,y);
  }else if(strcmp(action,"100")==0){
    if(frand()<1.-SLIPPROB||enemyHidden)
      moved=south(x,y);
    else
      if(frand()<0.5)
        moved=southwest(x,y);
      else
        moved=southeast(x,y);
  }else if(strcmp(action,"101")==0){
    if(frand()<1.-SLIPPROB||enemyHidden)
      moved=southwest(x,y);
    else
      if(frand()<0.5)
        moved=west(x,y);
      else
        moved=south(x,y);
  }else if(strcmp(action,"110")==0){
    if(frand()<1.-SLIPPROB||enemyHidden)
      moved=east(x,y);
    else
      if(frand()<0.5)
        moved=northeast(x,y);
      else
        moved=southeast(x,y);
  }else if(strcmp(action,"111")==0){
    if(frand()<1.-SLIPPROB||enemyHidden)
      moved=northwest(x,y);
    else
      if(frand()<0.5)
        moved=north(x,y);
      else
        moved=west(x,y);
  }else{
    printf("Fehler bei der Aktion! Aktion:%s\n",action);
  }
  return moved;
}

/* the eight possible movements: get the point that is desired. If the point is free, set x and y to the new point */

int north(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)%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-1;(*y)%=ys;
      return 1;
    }
  return 0;
}

int northeast(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)+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;
      return 1;
    }
  return 0;
}
int east(int *x,int *y)
{
  char point[LENGTH_OF_ONE_ATTRIBUTE];
  int i;
  
  for(i=0; i<LENGTH_OF_ONE_ATTRIBUTE; i++)