Matchbox maze - initial solution

const string MATCHBOX = "matchbox";
const string WALL = "shelfwall_";
const string RAY_SEGMENT_FILE = "sdiv";

void OnStart()
{
  //#1: Create the detectors & init vats
  CreateDetectors(MATCHBOX,RAY_SEGMENT_FILE,0.5f,10);
  //#2: Set the initial direction
  SetCurrentDir(EAST);
  //#3: Wait until the crate hits the floor (2 seconds)
  AddTimer("TMR_CRATE_MOVE",2.0f,"tmrCrateMotion");
}

///////////////////////////////
//+ DETECTOR INIT
///////////////////////////////
//Create a set of wall detectors around the matchbox
void CreateDetectors(string &in asEntity, string &in asFileBase, float afStepSize, int maxDetectors)
 {
   string filename = asFileBase + afStepSize + ".ent";

   //Create the beam of detectors
   for(int i = 0; i < maxDetectors; i++)
    {
      float pos = afStepSize * i;
      //East detectors (X+)
      CreateWallDetector(pos,filename,asEntity,EAST, i);
      //West detectors (X-)
      CreateWallDetector(pos,filename,asEntity,WEST, i);
      //North detectors (Z+)
      CreateWallDetector(pos,filename,asEntity,NORTH, i);
      //South detectors (Z-)
      CreateWallDetector(pos,filename,asEntity,SOUTH, i);
    }

   //Calculate the min detectors
   @RayCastCondition = @rccMatchboxInit;
   SetMinDir(NORTH); SetMinDir(SOUTH); SetMinDir(EAST); SetMinDir(WEST);
   @RayCastCondition = @rccWall;
 }

//Create a single wall detector
void CreateWallDetector(float afAmt, string &in asFileName, string &in asAttachBase, Direction dir, int alIndex)
 {
   string dname = DirectionPrefix(dir) + alIndex;
   AttachProp(asAttachBase,dname,asFileName, Xcomp(dir) * afAmt, Ycomp(dir) * afAmt, Zcomp(dir) * afAmt);
 }

//Fixed variant of AddAttachedPropToProp
void AttachProp(string &in asPName,string &in asAName, string &in aFile, float afX, float afY, float afZ) { AddAttachedPropToProp(asPName,asAName,aFile,afX,afY,0,afZ,90.0f,afZ); }
///////////////////////////////
//- DETECTOR INIT
///////////////////////////////

///////////////////////////////
//+ CRATE MOTION
///////////////////////////////
float TIMESTEP = 1.0f / 5.0f;
void tmrCrateMotion(string &in asTimer)
 {
    Direction dir = GetCurrentDir();
    //Move the crate forward
    float impulse = 1.0f;
    AddPropImpulse(MATCHBOX, impulse * Xcomp(dir), impulse * Ycomp(dir), impulse * Zcomp(dir), "world");
    //Raycast forward -> Are we at the wall?
    @RayCastCondition = @rccWall;
    AddDebugMessage("RCV: " + RayCast(dir),false);
    if(RayCast(dir) <= GetMinDir(dir))
     {
       AddDebugMessage("At end of path. Picking new direction.",false);
       SetCurrentDir(SelectBestDirection(dir));
     }
    AddTimer(asTimer,TIMESTEP,"tmrCrateMotion");
 }

//Select the best direction by seeing which way has the longest distance box can move (excluding where box came from)
Direction SelectBestDirection(Direction oldDirection)
 {
    //Get a collection of directions the box can move in
    Direction[] newDirections = GetNewDirections(oldDirection);

    //Assume first defined direction is best for now
    Direction bestDirection = newDirections[0];
    int bestValue = RayCast(newDirections[0]);

    //Look through all remaining possible directions to pick best path
    for(uint i = 1; i<newDirections.length(); i++)
     {
       int newValue = RayCast(newDirections[i]);
       if(newValue > bestValue)
        {
          //Longer path than before - this is now the best direction to move
          bestValue = newValue;
          bestDirection = newDirections[i];
        }
     }

    AddDebugMessage(DirectionPrefix(oldDirection) + " -> " + DirectionPrefix(bestDirection) + " (" + bestValue + ")",false);
    return bestDirection;
 }

//Get all the directions the box can move excluding where the box came from
Direction[] GetNewDirections(Direction oldDirection)
 {
    switch(oldDirection)
     {
       case NORTH: return DS03;
       case SOUTH: return DS04;
       case EAST:  return DS01;
       case WEST:  return DS02;
     }
    return DS00;
 }

Direction[] DS00 = {NORTH, SOUTH, EAST, WEST};
Direction[] DS01 = {NORTH, SOUTH, EAST};
Direction[] DS02 = {NORTH, SOUTH, WEST};
Direction[] DS03 = {NORTH, EAST, WEST};
Direction[] DS04 = {SOUTH, EAST, WEST};

///////////////////////////////
//- CRATE MOTION
///////////////////////////////

///////////////////////////////
//+ RAY CASTING
///////////////////////////////

//Returns how many ray segments in the given direction there are until a collision occurrs
int RayCast(Direction dir)
 {
  string pfx = DirectionPrefix(dir);
  int i =0;

  for(; GetEntityExists(pfx+i); i++)
    if(RayCastCondition(pfx+i)) return i;

  return i;
 }

//used to determine if the raytrace should continue
funcdef bool RAYCASTCONDITION(string &in);
RAYCASTCONDITION @RayCastCondition = @rccWall;

//returns true if ray segment collides with a wall (used for detector)
bool rccWall(string &in asRaySegment)
 {
   //i<100 to get around missing wall peices.
   for(int i = 1; i < 100; i++)
      if(GetEntitiesCollide(WALL+i,asRaySegment)) return true;
   return false;
 }

//returns true if ray segment doesn't collide with the matchbox (used in init)
bool rccMatchboxInit(string &in asRaySegment)
 { return !GetEntitiesCollide(MATCHBOX,asRaySegment); }

///////////////////////////////
//- RayCasting
///////////////////////////////

///////////////////////////////
//+ DIRECTION ENUM
///////////////////////////////
enum Direction
 {
   NORTH,
   SOUTH,
   EAST,
   WEST
 }

//Prefix of a given direction
string DirectionPrefix(Direction dir)
 {
   switch(dir)
    {
      case NORTH: return "N";
      case SOUTH: return "S";
      case EAST: return "E";
      case WEST: return "W";
    }
    AddDebugMessage("Error: Unknown direction error",false);
    return "?";
 }

//Get/Set the min value for a direction
void SetMinDir(Direction dir)
 {
  string vn = "MIN_" + DirectionPrefix(dir);
  SetLocalVarInt(vn,RayCast(dir));
  AddDebugMessage(vn + ":" + GetLocalVarInt(vn),false);
 }

int GetMinDir(Direction dir)
 {
    return GetLocalVarInt("MIN_" + DirectionPrefix(dir));
 }

//Get/Set current direction
void SetCurrentDir(Direction dir)
 {
    switch(dir)
    {
      case NORTH: SetLocalVarInt("CDIR",1); break;
      case SOUTH: SetLocalVarInt("CDIR",2); break;
      case EAST: SetLocalVarInt("CDIR",3); break;
      case WEST: SetLocalVarInt("CDIR",4); break;
    }
 }

Direction GetCurrentDir()
 {
    switch(GetLocalVarInt("CDIR"))
    {
      case 1: return NORTH;
      case 2: return SOUTH;
      case 3: return EAST;
      case 4: return WEST;
    }
    return NORTH;
 }

//Components of direction
float Xcomp(Direction dir) { switch(dir) { case EAST: return 1.0f; case WEST: return -1.0f; } return 0.0f; }
float Ycomp(Direction dir) { return 0.0f; }
float Zcomp(Direction dir) { switch(dir) { case NORTH: return 1.0f; case SOUTH: return -1.0f; } return 0.0f; }

///////////////////////////////
//- DIRECTION ENUM
///////////////////////////////