/**
* Sets the face and passable value of the tile at the specified (x, y) location.
*
* @param face the new face of the tile
* @param passable the new passable value of the tile
* @param x the x value of the position being updated
* @param y the y value of the position being updated
*/
public void setTile(ColoredChar face, boolean passable, int x, int y) {
Guard.argumentIsNotNull(face);
Guard.argumentsInsideBounds(x, y, width, height);
grid[x][y].face = face;
grid[x][y].passable = passable;
}
/**
* Removes an {@code Actor} from the {@code World}. The {@code Actor} must be both bound to this
* {@code World} and not held by another {@code Actor}. However, if the {@code Actor} is expired,
* it may always be removed.
*
* @param actor the {@code Actor} to be removed
*/
public void removeActor(Actor actor) {
Guard.argumentIsNotNull(actor);
Guard.verifyState(actor.bound(this));
Guard.verifyState(!actor.held() || actor.expired());
unregisterActor(actor);
removeFromGrid(actor);
actor.setWorld(null);
}
/**
* Adds an {@code Actor} to the {@code World} at the specified location.
*
* @param actor the {@code World} being added
* @param x the x location of the {@code Actor}
* @param y the y location of the {@code Actor}
*/
public void addActor(Actor actor, int x, int y) {
Guard.argumentIsNotNull(actor);
Guard.argumentsInsideBounds(x, y, width, height);
Guard.verifyState(!actor.bound());
Guard.verifyState(!actor.held());
actor.setWorld(this);
actor.setXY(x, y);
addToGrid(actor);
registerActor(actor);
}
/**
* Gets a randomly chosen open tile on the {@code World} within the given bounds. If after 100
* randomly selected tiles are closed, then each tile will be checked and the first open tile
* found is returned. If the entire {@code World} is closed, null is returned.
*
* @param dice the random number generator used to randomly select tiles
* @param x1 the bounds left most value
* @param y1 the bounds upper most value
* @param x2 the bounds right most value
* @param y2 the bounds bottom most value
* @return a randomly chosen open tile
*/
public Coordinate getOpenTile(Dice dice, int x1, int y1, int x2, int y2) {
Guard.argumentIsNotNull(dice);
Guard.argumentsInsideBounds(x1, y1, width, height);
Guard.argumentsInsideBounds(x2, y2, width, height);
for (int i = 0; i < 100; i++) {
int x = dice.nextInt(x1, x2);
int y = dice.nextInt(y1, y2);
if (passableAt(x, y)) return new Coordinate(x, y);
}
for (int x = x1; x <= x2; x++)
for (int y = y1; y <= y2; y++) if (passableAt(x, y)) return new Coordinate(x, y);
return null;
}
/**
* Sets the face and passable value of the tile at the specified {@code Coordinate}.
*
* @param face the new face of the tile
* @param passable the new passable value of the tile
* @param coord the value of the position being updated
*/
public final void setTile(ColoredChar face, boolean passable, Coordinate coord) {
Guard.argumentIsNotNull(coord);
setTile(face, passable, coord.x(), coord.y());
}
/**
* Returns true if the tile at the provided {@code Coordinate} is passable.
*
* @param coord the value of the position being queried
* @return true if the tile at the given {@code Coordinate}
*/
public final boolean passableAt(Coordinate coord) {
Guard.argumentIsNotNull(coord);
return passableAt(coord.x(), coord.y());
}
/**
* Returns the face of the tile at the provided coordinates.
*
* @param coord the value of the position being queried
* @return the face of the tile at then given {@code Coordinate}
*/
public final ColoredChar tileAt(Coordinate coord) {
Guard.argumentIsNotNull(coord);
return tileAt(coord.x(), coord.y());
}
/**
* Returns the face that should be drawn for the given location.
*
* @param pos the location being queried
* @return the face that should be drawn for the given location.
*/
public final ColoredChar look(Coordinate pos) {
Guard.argumentIsNotNull(pos);
return look(pos.x(), pos.y());
}
/**
* Returns every tile that is visible at a given location, ordered such that the tile with highest
* priority (the tile returned by look) is first, and the lowest priority is last. This last tile
* will be the face of the actual tile itself. Note that any actor which has a null face will not
* be included.
*
* @param pos the location being queried
* @return every tile that is visible at a given location
*/
public final List<ColoredChar> lookAll(Coordinate pos) {
Guard.argumentIsNotNull(pos);
return lookAll(pos.x(), pos.y());
}
/**
* Returns a {@code Collection<T extends Actor>} of all {@code Actor} of the given class at the
* given location.
*
* @param <T> the generic type of the class type to be returned
* @param cls the {@code Class<T extends Actor>} of the {@code Actor} to be returned
* @param pos the location being queried
* @return a {@code Collection<T extends Actor>} of all {@code Actor} of the given class located
* at (x, y)
*/
public final <T extends Actor> Collection<T> getActorsAt(Class<T> cls, Coordinate pos) {
Guard.argumentIsNotNull(pos);
return getActorsAt(cls, pos.x(), pos.y());
}
/**
* Adds an {@code Actor} to the {@code World} at the specified location.
*
* @param actor the {@code World} being added
* @param coord the location of the {@code Actor}
*/
public final void addActor(Actor actor, Coordinate coord) {
Guard.argumentIsNotNull(coord);
addActor(actor, coord.x(), coord.y());
}
/**
* Returns the sum of all values across a particular {@code Categorical}.
*
* @param key the key of the {@code Categorical} being queried
* @return the sum of all values in the specified {@code Categorical}
*/
public int sumCountGiven(K key) {
Guard.argumentIsNotNull(key);
return getCategorical(key).sumCounts();
}
