/*
 * 
 * HEATBUGS in MAML
 * (c) 1998, CEU Systems Laboratory
 * 
 * This simulation is based on the following model:
 * 
 * Heatbugs application. Copyright (C) 1996 Santa Fe Institute.
 * This library is distributed without any warranty; without even the
 * implied warranty of merchantability or fitness for a particular purpose.
 * See file LICENSE for details and terms of copying.
 * 
 */

// The simple agent of the model

@agent Heatbug {
@uses <space.h>;				  // We need this Swarm
						  // package as Grid2d is
						  // there (check out the 
						  // variable storing the 
						  // reference to the world

// the state of the agent
@var: double unhappiness;                         // my current unhappiness
@var: int x, y;                                   // my spatial coordinates
@var: HeatValue idealTemperature;                 // my ideal temperature
@var: HeatValue outputHeat;                       // how much heat I put out
@var: float randomMoveProbability;                // chance of moving randomly

// devices to its environment
@var: Grid2d world;                               // the world I live in
@var: HeatSpace heat;                             // the heat for the world

// for programmers only (helps in optimizing the code)
@var: int worldXSize, worldYSize;                 // how big the world is


  // Setting the named parameters (at initialization)
  @sub: (void) setWorld: (Grid2d) w Heat: (HeatSpace) h {
    world = w;
    heat = h;
  }

  // End of create phase. Finishes the initialization
  @sub: (id) createEnd {
    worldXSize = [world getSizeX];
    worldYSize = [world getSizeY];
    return self;
  }

  // Setting the named parameters
  @sub: (void) setIdealTemperature: (HeatValue) i { idealTemperature = i; }
  @sub: (void) setOutputHeat: (HeatValue) o { outputHeat = o; }
  @sub: (void) setRandomMoveProbability: (float) p {
    randomMoveProbability = (float) p; 
  }
  @sub: (void) setX: (int) inX Y: (int) inY {
    x = inX;
    y = inY;
    // Administrate it on the global (model level) grid
    [world putObject: self atX: x Y: y];             
  }

  // Making a step
  @sub: (void) step {
    HeatValue heatHere;
    int newX, newY;
    int tries;

    // Calculating local values (heat/unhappiness)
    heatHere = [heat getValueAtX: x Y: y];
    unhappiness = ( (heatHere<idealTemperature) ? 
                          (double)(idealTemperature - heatHere) / maxHeat :
                          (double)(heatHere - idealTemperature) / maxHeat );

    // Decide where to go based on the heat level
    newX = x;
    newY = y;
    [heat findExtremeType: (heatHere < idealTemperature) ? hot : cold
          X: &newX Y: &newY];

    // Is it going to be a random move? If so, make it!
    if (((float)[uniformDblRand
          getDoubleWithMin: 0.0 withMax: 1.0]) < randomMoveProbability) {
      newX = (x + [uniformIntRand getIntegerWithMin: -1L withMax: 1L]); 
      newY = (y + [uniformIntRand getIntegerWithMin: -1L withMax: 1L]);
      newX = (newX + worldXSize) % worldXSize;
      newY = (newY + worldYSize) % worldYSize;
    }

    // If the selected spot is occupied, try to find another place randomly.
    // Give it up after 10 unsuccessful tries.
    tries = 0;
    while ([world getObjectAtX: newX Y: newY] != nil && tries < 10) {
      newX = (x + [uniformIntRand getIntegerWithMin: -1L withMax: 1L]); 
      newY = (y + [uniformIntRand getIntegerWithMin: -1L withMax: 1L]);
      newX = (newX + worldXSize) % worldXSize;
      newY = (newY + worldYSize) % worldYSize;
      tries++;
    }

    // If we failed to find a good spot, the we'll stay here.
    if (tries == 10) {
      newX = x;
      newY = y;
    }

    // Emitting some heat
    [heat addHeat: outputHeat X: x Y: y];

    // Moving from the current position
    [world putObject: nil atX: x Y: y];

    // Moving to the new position
    x = newX;
    y = newY;
    [world putObject: self atX: newX Y: newY];
  }
}