/**
* Changes the positions of the worm as a result of a jump from the current position.
*
* @post If the worm jumped out of the map it will have been removed.
* |this.getWorld().getWorms().contains(this) == false
* @post The worm jumped to the correct position | while (world.isPassable(tempXpos, tempYpos,
* this.getRadius())) | tempXpos = this.jumpStep(t)[0] | tempYpos = this.jumpStep(t)[1] | t +=
* timeStep | if ((world.isAdjacent(tempXpos, tempYpos, this.getRadius())) && |
* (Math.sqrt(Math.pow((origXpos-tempXpos), 2)+Math.pow((origYpos-tempYpos),
* 2))>=this.getRadius() )) | new.getXpos() == tempXpos | new.getYpos() == tempYpos
* @post The worm's actionpoints are reduced to zero. |new.getActionPoints() == 0;
* @throws IllegalStateException When the worm has no action point left to jump the exception is
* thrown. |! canJump()
*/
@Raw
public void jump(Double timeStep) throws IllegalStateException {
if (this.canJump()) {
World world = this.getWorld();
double origXpos = this.getXpos();
double origYpos = this.getYpos();
double tempXpos = this.getXpos();
double tempYpos = this.getYpos();
double t = 0;
while (world.isPassable(tempXpos, tempYpos, this.getRadius())) {
tempXpos = this.jumpStep(t)[0];
tempYpos = this.jumpStep(t)[1];
t += timeStep;
if (isOutOfTheMap(tempXpos, tempYpos)) {
this.killWorm();
break;
}
if ((world.isAdjacent(tempXpos, tempYpos, this.getRadius()))
&& (Math.sqrt(Math.pow((origXpos - tempXpos), 2) + Math.pow((origYpos - tempYpos), 2))
>= this.getRadius())) {
this.setXpos(tempXpos);
this.setYpos(tempYpos);
this.consumeFood();
this.setActionPoints(0);
break;
}
}
} else throw new IllegalStateException();
}
/**
* Returns the time it takes to worm to jump (to his new position).
*
* @throws IllegalStateException If the worm can't jump the exception is thrown. | ! canJump()
*/
@Raw
public double jumpTime(double timeStep) throws IllegalStateException {
World world = this.getWorld();
double origXpos = this.getXpos();
double origYpos = this.getYpos();
double tempXpos = this.getXpos();
double tempYpos = this.getYpos();
double t = 0;
if (this.canJump()) {
while (world.isPassable(tempXpos, tempYpos, this.getRadius())) {
tempXpos = this.jumpStep(t)[0];
tempYpos = this.jumpStep(t)[1];
t += timeStep;
if ((world.isAdjacent(tempXpos, tempYpos, this.getRadius()))
&& (Math.sqrt(Math.pow((origXpos - tempXpos), 2) + Math.pow((origYpos - tempYpos), 2))
>= this.getRadius())) {
return t;
}
if (isOutOfTheMap(tempXpos, tempYpos)) {
return t;
}
}
return t;
} else throw new IllegalStateException();
}
/**
* This method deletes a worm from the list of objects.
*
* @param world The world from where the worm needs to be deleted.
* @post The worm will be deleted from the current world. | new.objects.contains(this) == false;
*/
@Raw
public void deleteWorm(World world) {
int index = world.getCurrentWormIndex() + 1;
int size = world.getWorms().size();
if (index == size) this.getWorld().setCurrentWormIndex(0);
if (this.getIsAlive() == false) world.deleteWorm(this);
}
/**
* Makes the worm fall, if it can fall, until the worm falls on an obstacle or falls out of the
* map.
*
* @post The worm has fallen to a new position that is adjacent. The x-position stays the same but
* the y-position changes. |this.getWorld().isAdjacent(new.getXpos(),new.getYpos(),
* new.getDirecetion) == true |new.getXpos()==old.getXpos() |while
* (world.isPassable(this.getXpos(), this.getYpos(), this.getRadius())) | newYpos =
* this.getYpos()-this.getRadius() | if (this.getYpos()<0) | then new.getYpos ==
* (this.getRadius()*1.1) | break; | else if ((this.getYpos()>=0)){ | while
* (!world.isAdjacent(this.getXpos(), this.getYpos(), this.getRadius())) | newYpos =
* (this.getYpos()+0.1*this.getRadius()) | new.getYpos() == newYpos
* @post The worms hitpoints are correctly reduced. |new.getHitPoints() == old.getHitPoints() -
* 3*distance
* @post After the fall the worm could be on food this gets checked. | this.consumeFood()
* @throws IllegalStateException If the worm can't fall because he is on adjacent terrain the
* exception is thrown. | ! canFall()
*/
@Raw
public void fall() throws IllegalStateException {
World world = this.getWorld();
double distance = 0;
boolean trigger = false;
if (canFall()) {
while (world.isPassable(this.getXpos(), this.getYpos(), this.getRadius())) {
this.setYpos(this.getYpos() - this.getRadius());
distance += this.getRadius();
if (this.getYpos() < 0) {
this.setYpos(0 + this.getRadius() * 1.1);
trigger = true;
break;
}
}
if ((this.getYpos() >= 0) && !trigger) {
while (!world.isAdjacent(this.getXpos(), this.getYpos(), this.getRadius())) {
this.setYpos(this.getYpos() + 0.1 * this.getRadius());
distance -= 0.1 * this.getRadius();
}
}
this.setHitPoints(this.getHitPoints() - (3 * (int) Math.floor(distance)));
this.consumeFood();
} else {
throw new IllegalStateException();
}
}
/**
* Checks if the given position is out of the boundaries of the map.
*
* @param xpos The x-position to be checked.
* @param ypos The y-position to be checked.
* @return True if the given position isn't in the boundaries of the map. False if e given
* position is in the boundaries of the map. |
* !((xpos<=(world.getWidth()-this.getRadius()))&&((xpos>=this.getRadius()))&& | ((ypos <=
* world.getHeight()-this.getRadius())) && ((ypos>=this.getRadius())))
*/
@Raw
private boolean isOutOfTheMap(double xpos, double ypos) {
World world = this.getWorld();
return !((xpos <= (world.getWidth() - this.getRadius()))
&& ((xpos >= this.getRadius()))
&& ((ypos <= world.getHeight() - this.getRadius()))
&& ((ypos >= this.getRadius())));
}
/**
* Sets the team to a random team, if there are teams.
*
* @post If there where teams the worm is added to a team. If there where no teams the worm isn't
* added to a team. | if ((this.getWorld().getTeams().size()!=0)) { | then this.hasTeam() ==
* true;
*/
@Raw
public void setTeamRandom() {
World world = this.getWorld();
ArrayList<Team> teams = (ArrayList<Team>) world.getTeams();
if (!(teams.size() == 0)) {
int i = teams.size();
int randomIndex = (int) (Math.random() * i);
this.setTeamTo(teams.get(randomIndex));
}
}
/**
* Changes the positions of the projectile as a result of a jump from the current position.
*
* @post If the projectile hits a worm this worm loses some hit points and the projectile is
* removed from the world and set non active. | if ((Math.sqrt(Math.pow(w.getXpos()-tempXpos,
* 2)+Math.pow(w.getYpos()-tempYpos, 2))< maxDistance)) | while (this.getActive == true) |
* then (new.setHitPoints(worm.getHitPoints-this.getDamage()) | then (world.getProjectile() ==
* null) | then (new.getActive == false))
* @post If the projectile doesn't hit a worm, the projectile will be deleted when it leaves the
* map or when it hits impassable terrain. | if !((Math.sqrt(Math.pow(w.getXpos()-tempXpos,
* 2)+Math.pow(w.getYpos()-tempYpos, 2))< maxDistance)) | then ( if
* ((isOutOfTheMap(tempXpos,tempYpos))) | then ((world.getProjectile() == null) | then
* (new.getActive == false)) | (else if (world.isImpassable(tempXpos, tempYpos,
* this.getRadius()))) | then ((world.getProjectile() == null) | then (new.getActive ==
* false)))
* @throws IllegalStateException If the projectile can't jump the exception is thrown. |!
* canJump()
*/
@Raw
public void jump(Double timeStep) throws IllegalStateException {
if (this.canJump()) {
World world = this.getWorld();
double tempXpos = this.getXpos();
double tempYpos = this.getYpos();
double t = 0;
while ((world.isPassable(tempXpos, tempYpos, this.getRadius()))) {
tempXpos = this.jumpStep(t)[0];
tempYpos = this.jumpStep(t)[1];
Collection<Worm> collection = (world.getWorms());
for (Worm w : collection) {
Worm overlappingWorm = null;
double maxDistance = this.getRadius() + w.getRadius();
if (!(w == world.getCurrentWorm())
&& (Math.sqrt(
Math.pow(w.getXpos() - tempXpos, 2) + Math.pow(w.getYpos() - tempYpos, 2))
< maxDistance)) {
overlappingWorm = w;
while ((this.getActive() == true)) {
overlappingWorm.setHitPoints(overlappingWorm.getHitPoints() - this.getDamage());
this.deleteProjectile(world);
this.setActive(false);
}
} else {
overlappingWorm = null;
if ((isOutOfTheMap(tempXpos, tempYpos))) {
this.deleteProjectile(world);
this.setActive(false);
} else if (((world.isImpassable(tempXpos, tempYpos, this.getRadius())))
&& (this.getActive() == true)) {
this.deleteProjectile(world);
this.setActive(false);
}
}
}
t += timeStep;
}
} else {
throw new IllegalStateException();
}
}
/** This method return the food objects that overlap with the worms position. */
@Raw
public Food overlappingFood() {
World world = this.getWorld();
double maxDistance = this.getRadius() + 0.2;
Food overlappingFood = null;
Collection<Food> collection = (world.getFood());
for (Food f : collection) {
if (Math.sqrt(
Math.pow(f.getXpos() - this.getXpos(), 2) + Math.pow(f.getYpos() - this.getYpos(), 2))
< maxDistance) {
overlappingFood = f;
break;
} else {
overlappingFood = null;
}
}
return overlappingFood;
}
/**
* Initialize a worm in a given world, and a x-and y-position (meters), direction (radians),
* radius (meters) and a name will be determined.
*
* @param world The world in which a worm is being added.
* @pre The world must be valid. |world!=null
* @post The x- and y-position are set to valid x- and y-positions.
* |isValidXpos(world,new.getXpos()) == true |isValidYpos(world,new.getYpos()) == true
* @post The x- and y-position are set to passable position adjacent to impassable terrain.
* |world.isAdjacent(new.getXpos(), new.getYpos()) == true
* @post The direction is set to a valid direction. |isValidDirection(new.getDirection()) == true
* @post The radius is set to a valid radius |isValidRadius(new.getRadius()) == true
* @post The mass of a worm is set accordingly to its radius. |new.getMass() ==
* DENSITY*((4.0/3.0)*Math.PI*Math.pow(radius, 3))
* @post The maximum amount of actionpoints is set accordingly to the worm's mass.
* |new.getMaxActionPoints() == (int) Math.round(this.getMass())
* @post The amount of actionpoints are set to the maximum amount of actionpoints.
* |new.getActionPoints() == new.getMaxActionPoints()
* @post The maximum amount of hitpoints is set accordingly to the worm's mass.
* |new.getMaxHitPoints() == (int) Math.round(this.getMass())
* @post The amount of hitpoints are set to the maximum amount of hitpoints. |new.getHitPoints()
* == new.getMaxHitPoints()
* @post The name of the worm is set to the given name. |new.getName() == name.
* @post The Worm is added to a team is there are any teams. |if (world.getTeams.size()!=0) | then
* this.hasTeam() == true
* @post The lower bound of the radius is set to the given lower bound. Or when no lower bound is
* given it's set to 0.25 as it is in this case. |new.getRadiusLowerBound() == 0.25
*/
@Raw
public Worm(World world) {
super(world);
Random perimeter = world.getPerimeter();
this.setRadius(radiusLowerBound);
this.position = new Position(world, this);
this.setDirection(perimeter.nextDouble() * (2 * Math.PI));
this.setName("Worm");
this.setActionPoints(this.getMaxActionPoints());
this.setHitPoints(this.getMaxHitPoints());
this.setTeamRandom();
}
/** Checks whether the worms still has actionpoints is placed in passable terrain. */
@Raw
private boolean canJump() {
World world = this.getWorld();
return ((this.getActionPoints() > 0)
&& world.isPassable(this.getXpos(), this.getYpos(), this.getRadius()));
}
/**
* Returns true if the worm is positioned in passable terrain and adjacent to impassable terrain.
*/
@Raw
private boolean canMove() {
World world = this.getWorld();
return world.isAdjacent(this.getXpos(), this.getYpos(), this.getRadius());
}
/**
* The method makes the worm move to a next position that is adjacent to impassable terrain
* following the slope of that terrain in the direction. The worm shall aim to maximize the
* distance while minimizing the divergence. If no such location exists because all locations in
* the direction +- 0,7875 are impassable the worm shall remain at its current position. If
* locations in the direction are passable but not adjacent the worm shall move there and then
* drop passively.
*
* @post If the worm can maximize the distance while minimizing the divergence, the worm has moved
* to the optimal location. |for (double a = 0.1;a<=this.getRadius();a=a+(0.01*a)) { | x2 =
* x+Math.cos(direction)*a; | y2 = y+Math.sin(direction)*a; | if (world.isAdjacent(x2, y2,
* this.getRadius()) && | world.isPassable(x2, y2, this.getRadius())) { | double d =
* Math.sqrt(Math.pow((x-x2),2)+Math.pow((y-y2),2)); | double s = Math.atan((x-x2)/(y-y2)); |
* if ((d>=maxD) && (s<minS)) { | minS=s; | maxD=d; | x2Max = x2; | y2Max= y2; | direction =
* direction +0.0175; |new.getXpos()==x2Max |new.getYpos() == y2Max
* @post If the worm can't maximize the distance while minimizing the divergence and there is only
* impassable terrain in the checked directions, the worm will not have moved. |new.getXpos()
* == old.getXpos() |new.getYpos() == old.getYpos()
* @post If the worm can't maximize the distance while minimizing the divergence and there is only
* passable terrain in the checked directions that is not adjacent, the worm will move there.
* |new.getXpos() == old.getXpos() + cos(direction)*radius |new.getYpos() == old.getYpos() +
* sin(direction)*radius
* @post The worms actionpoints are correctly reduced. |new.getActionPoints ==
* old.getActionPoints() - old.computeCost2(old.getXpos(),old.getYpos())
* @throws IllegalArgumentException If the worm can't move because he has insufficient
* actionpoints the exception is thrown. | ! isValidStep()
* @throws IllegalStateException If the worm can't move because the worm isn't positioned in
* passable terrain and adjacent to impassable terrain the exception is thrown. | ! canMove()
*/
@Raw
public void move() throws IllegalArgumentException, IllegalStateException {
if (!isValidStep()) throw new IllegalArgumentException();
if (canMove()) {
World world = this.getWorld();
double x = this.getXpos();
double y = this.getYpos();
double prevx = x;
double prevy = y;
double x2 = x;
double y2 = y;
double x2Max = x2;
double y2Max = y2;
double c = -0.7875;
double direction = this.getDirection() + c;
double maxD = 0;
double minS = this.getDirection();
// geval 1: na gaan of in direction+-45° er een gischike volgende positie is
// en zo ja, ernaar verplaatsen.
for (double a = 0.1; a <= this.getRadius(); a = a + (0.01 * a)) {
x2 = x + Math.cos(direction) * a;
y2 = y + Math.sin(direction) * a;
if (world.isAdjacent(x2, y2, this.getRadius())
&& world.isPassable(x2, y2, this.getRadius())) {
double d = Math.sqrt(Math.pow((x - x2), 2) + Math.pow((y - y2), 2));
double s = Math.atan((x - x2) / (y - y2));
if ((d >= maxD) && (s < minS)) {
minS = s;
maxD = d;
x2Max = x2;
y2Max = y2;
}
}
direction = direction + 0.0175;
}
if (this.isOutOfTheMap(x2Max, y2Max)) {
this.killWorm();
} else {
this.setXpos(x2Max);
this.setYpos(y2Max);
this.setActionPoints(this.getActionPoints() - this.computeCost2(prevx, prevy));
}
// geval2: Er werd in direction+-45° geen geschikte plaats gevonden
// nagaan of er in direction naar een passable locatie kan verplaatst worden,
// daarnaar verplaatsen en dan vallen (fall).
if ((x2Max == x) && (y2Max == y)) {
double pasXpos = x;
double pasYpos = y;
pasXpos = (x + (Math.cos(this.getDirection()) * this.getRadius()));
pasYpos = (y + (Math.sin(this.getDirection()) * this.getRadius()));
if (!world.isAdjacent(pasXpos, pasYpos, this.getRadius())
&& world.isPassable(pasXpos, pasYpos, this.getRadius())) {
if (this.isOutOfTheMap(pasXpos, pasYpos)) {
this.killWorm();
} else {
this.setXpos(pasXpos);
this.setYpos(pasYpos);
this.setActionPoints(this.getActionPoints() - this.computeCost2(prevx, prevy));
}
}
}
this.consumeFood();
} else throw new IllegalStateException();
}
/**
* Checks if the worm can fall. That is if the worm's position is passable and is not adjacent.
*
* @return True if the worm can fall. False if the worm can't fall. |
* world.isPassable(this.getXpos(), this.getYpos(), this.getRadius()) &&
* |!world.isAdjacent(this.getXpos(), this.getYpos(), this.getRadius()));
*/
@Raw
public boolean canFall() {
World world = this.getWorld();
return (world.isPassable(this.getXpos(), this.getYpos(), this.getRadius())
&& !world.isAdjacent(this.getXpos(), this.getYpos(), this.getRadius()));
}
/**
* Deletes the projectile from the given world.
*
* @param world The world where the projectile gets removed from.
*/
@Raw
public void deleteProjectile(World world) {
world.deleteProjectile(this);
}
/** Checks whether the begin position of the projectile is in passable terrain. */
public boolean canJump() {
World world = this.getWorld();
return (world.isPassable(this.getXpos(), this.getYpos(), this.getRadius()));
}
