Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package jason.environment.grid;
  
  import java.util.Random;



Simple model for a grid world (with agents and obstacles).

Every agent gets an identification (a integer from 0 to the number of ag - 1). The relation of this identification with agent's name should be done in the environment class and is application dependent.

Every type of object in the environment is represented by a bit mask: an agent is 000010; an obstacle is 000100; .... New types of objects should follow this pattern, for example, GOLD = 8 (001000), ENEMY=16 (010000), ... A place with two object is represented by the OR between the masks: an agent and a gold is 001010.

Limitations:

  • The number of agents can not change dynamically
  • Two agents can not share the same place. More generally, two objects with the same "mask" can not share a place.

Author(s):
Jomi
 
 public class GridWorldModel {
 
     // each different object is represented by having a single bit 
     // set (a bit mask is used in the model), so any power of two
     // represents different objects. Other numbers represent combinations 
     // of objects which are all located in the same cell of the grid.
     public static final int       CLEAN    = 0;
     public static final int       AGENT    = 2;
     public static final int       OBSTACLE = 4;
 
     protected int                 widthheight;
     protected int[][]             data = null
     protected Location[]          agPos;
     protected GridWorldView       view;
 
     protected Random              random = new Random();
     
 
     protected GridWorldModel(int wint hint nbAgs) {
           = w;
          = h;
 
         // int data
          = new int[][];
         for (int i = 0; i < i++) {
             for (int j = 0; j < j++) {
                 [i][j] = ;
             }
         }
 
          = new Location[nbAgs];
         for (int i = 0; i < .i++) {
             [i] = new Location(-1, -1);
         }
     }
 
     public void setView(GridWorldView v) {
          = v;
     }
     
     public int getWidth() {
         return ;
     }
 
     public int getHeight() {
         return ;
     }
 
     public int getNbOfAgs() {
         return .;
     }
 
     public boolean inGrid(Location l) {
         return inGrid(l.xl.y);
     }
     
     public boolean inGrid(int xint y) {
         return y >= 0 && y <  && x >= 0 && x < ;
     }
 
     public boolean hasObject(int objLocation l) {
         return inGrid(l.xl.y) && ([l.x][l.y] & obj) != 0;
     }
     public boolean hasObject(int objint xint y) {
         return inGrid(xy) && ([x][y] & obj) != 0;
     }
 
     // gets how many objects of some kind are in the grid
     public int countObjects(int obj) {
        int c = 0;
        for (int i = 0; i < i++) {
            for (int j = 0; j < j++) {
                if (hasObject(obj,i,j)) {
                    c++;
                }
            }
        }
        return c;
    }
    
    public void set(int valueint xint y) {
        [x][y] = value;
        if ( != null.update(x,y);
    }
    
    public void add(int valueLocation l) {
        add(valuel.xl.y);
    }
    public void add(int valueint xint y) {
        [x][y] |= value;
        if ( != null.update(x,y);
    }
    public void addWall(int x1int y1int x2int y2) {
        for (int x = x1x <= x2x++) {
            for (int y = y1y <= y2y++) {
                add(xy);
            }
        }
    }
    public void remove(int valueLocation l) {
        remove(valuel.xl.y);
    }
    public void remove(int valueint xint y) {
        [x][y] &= ~value;
        if ( != null.update(x,y);
    }
    public void setAgPos(int agLocation l) {
        Location oldLoc = getAgPos(ag);
        if (oldLoc != null) {
            remove(oldLoc.xoldLoc.y);
        }
        [ag] = l;
        add(l.xl.y);
    }
    public void setAgPos(int agint xint y) {
        setAgPos(agnew Location(xy));
    }
    public Location getAgPos(int ag) {
        try {
            if ([ag]. == -1)
                return null;
            else
                return (Location)[ag].clone();
        } catch (Exception e) {
            return null;
        }
    }

    
returns the agent at location l or -1 if there is not one there
    public int getAgAtPos(Location l) {
        return getAgAtPos(l.xl.y);
    }

    
returns the agent at x,y or -1 if there is not one there
    public int getAgAtPos(int xint y) {
        for (int i=0; i<.i++) {
            if ([i]. == x && [i]. == y) {
                return i;
            }
        }
        return -1;
    }

    
returns true if the location l has no obstacle neither agent
    public boolean isFree(Location l) {
        return isFree(l.xl.y);
    }

    
returns true if the location x,y has neither obstacle nor agent
    public boolean isFree(int xint y) {
        return inGrid(xy) && ([x][y] & ) == 0 && ([x][y] & ) == 0;
    }

    
returns true if the location l has not the object obj
    public boolean isFree(int objLocation l) {
        return inGrid(l.xl.y) && ([l.x][l.y] & obj) == 0;     
    }
    
returns true if the location x,y has not the object obj
    public boolean isFree(int objint xint y) {
        return inGrid(xy) && ([x][y] & obj) == 0;     
    }
    
    public boolean isFreeOfObstacle(Location l) {
        return isFree(l);
    }
    public boolean isFreeOfObstacle(int xint y) {
        return isFree(xy);
    }

    
returns a random free location using isFree to test the availability of some possible location (it means free of agents and obstacles)
 
    protected Location getFreePos() {
        for (int i=0; i<(getWidth()*getHeight()*5); i++) {
            int x = .nextInt(getWidth());
            int y = .nextInt(getHeight());
            Location l = new Location(x,y);
            if (isFree(l)) {
                return l;
            }
        }
        return null// not found
    }

    
returns a random free location using isFree(object) to test the availability of some possible location
 
    protected Location getFreePos(int obj) {
        for (int i=0; i<(getWidth()*getHeight()*5); i++) {
            int x = .nextInt(getWidth());
            int y = .nextInt(getHeight());
            Location l = new Location(x,y);
            if (isFree(obj,l)) {
                return l;
            }
        }
        return null// not found
    }
New to GrepCode? Check out our FAQ X