Robot.java

gehe zur Dokumentation dieser Datei

package de.lathanda.eos.robot;
 
import de.lathanda.eos.base.MutableColor;
import de.lathanda.eos.base.util.Direction;
import de.lathanda.eos.robot.exceptions.CubeImmutableException;
import de.lathanda.eos.robot.exceptions.CubeMissingException;
import de.lathanda.eos.robot.exceptions.RobotException;
import de.lathanda.eos.robot.exceptions.RobotMovementFailedException;
import de.lathanda.eos.robot.exceptions.RobotVoidException;
import de.lathanda.eos.robot.gui.Configuration;
import de.lathanda.eos.robot.gui.Configuration.ConfigurationListener;
 
public class Robot implements ConfigurationListener {
    public static final int SIZE = 3;
    private int jump = Configuration.def.getJumpheight();
    private int fall = Configuration.def.getFallheight();
    private World world;
    private MutableColor robotColor = MutableColor.BLUE;
    private Direction direction = Direction.EAST;
    private int x = 0;
    private int y = 0;
    private int z = 0;
    private MutableColor stoneColor = MutableColor.RED;
    public Robot() {
        Configuration.def.addConfigurationListener(this);
        world = null;
    }
    protected void initialize(World world, int x, int y, int z, Direction d) {
        this.x = x;
        this.y = y;
        this.z = z;
        this.direction = d;
        this.world = world;
    }    
    @Override
    public void robotConfigurationChanged(int fallheight, int jumpheight) {
        jump = jumpheight;
        fall = fallheight;
    }
 
    private Column frontColumn() throws RobotVoidException {
        return getColumn(direction);
    }
    private Column getColumn(Direction d) throws RobotVoidException {
        if (world != null) {
            return world.getColumn(new Coordinate(x + d.dx, y + d.dy));
        } else {
            throw new RobotVoidException();
        }
    }    
    private Column getColumn(int x, int y) throws RobotVoidException {
        if (world != null) {
            return world.getColumn(new Coordinate(x, y));
        } else {
            throw new RobotVoidException();
        }
    }
    private Column getColumn() throws RobotVoidException {
        if (world != null) {
            return world.getColumn(new Coordinate(x, y));
        } else {
            throw new RobotVoidException();
        }
    }
    private void setPosition(int x, int y, int z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }
 
    public final void setMark() throws RobotException {
        getColumn().setMark(true);
    }
 
    public final void setMark(MutableColor c) throws RobotException {
        getColumn().setMark(c);
    }
    
    public final void removeMark() throws RobotException {
        getColumn().setMark(false);
    }
    public final void dropStone() throws RobotException {
        frontColumn().dropCube(z, Cube.createStone(stoneColor));
    }
    public final void dropStone(MutableColor c) throws RobotException {
        frontColumn().dropCube(z, Cube.createStone(c));
    }
    public final MutableColor stoneColor() throws RobotException {
        return frontColumn().stoneColor(z);
    }
    public final void pickup() throws RobotException {
        frontColumn().pickup(z);
    }
    public final void pickup(int n) throws RobotException {
        for (int i = n; i --> 0; ) {
            pickup();
        }
    }
    public final boolean isMarked() throws RobotException {
        return getColumn().isMarked();
    }
    public final boolean isMarked(MutableColor c) throws RobotException {
        return getColumn().isMarked(c);
    }    
    public final void turnLeft() {
        direction = direction.getLeft();
    }
    public final void turnRight() {
        direction = direction.getRight();
    }
    public final void turnAround() {
        direction = direction.getLeft().getLeft();
    }
    private void stepDirection(Direction d) throws RobotException {
        Column columnTo = getColumn(d);
        int newZ = columnTo.isReachable(z, SIZE, jump, fall);
        if (newZ >= 0) {
            setPosition(x + d.dx, y + d.dy, newZ);
        } else {
            throw new RobotMovementFailedException();
        }       
    }
    public void step() throws RobotException {
        stepDirection(direction);
    }
    public void step(int count) throws RobotException {
        for(int i = count; i --> 0; ) {
            step();
        }
    }
    public void stepBack() throws RobotException {
        stepDirection(direction.getBack());     
    }
    public void stepLeft() throws RobotException {
        stepDirection(direction.getLeft());     
    }
    public void stepRight() throws RobotException {
        stepDirection(direction.getRight());        
    }
    private boolean isObstacleDirection(Direction direction) throws RobotException {
        return getColumn(direction).isReachable(z, SIZE, jump, fall) < 0;
    }
    public boolean isObstacle() throws RobotException {
        return isObstacleDirection(direction);
    }
    public boolean isLeftObstacle() throws RobotException {
        return isObstacleDirection(direction.getLeft());
    }
    public boolean isRightObstacle() throws RobotException {
        return isObstacleDirection(direction.getRight());
    }
    public boolean isBackObstacle() throws RobotException {
        return isObstacleDirection(direction.getBack());
    }
    private void flyDirection(int dx, int dy, int dz) throws RobotException {
        Column column=  world.getColumn(new Coordinate(x + dx, y + dx));
        if (column.isFree(z+dz, SIZE)) {
            setPosition(x + dx, y + dy, z+dz);
        } else {
            throw new RobotMovementFailedException();
        }           
    }
    public void flyDown() throws RobotException {
        flyDirection(0,0,-1);
    }
    public void flyUp() throws RobotException {
        flyDirection(0,0,1);
    }
    public void fly() throws RobotException {
        flyDirection(direction.dx, direction.dy, 0);
    }
    public void flyLeft() throws RobotException {
        flyDirection(direction.getLeft().dx, direction.getLeft().dy, 0);
    } 
    public void flyRight() throws RobotException {
        flyDirection(direction.getRight().dx, direction.getRight().dy, 0);
    } 
    public void flyBack() throws RobotException {
        flyDirection(direction.getBack().dx, direction.getBack().dy, 0);
    } 
    private boolean isFreeDirection(int dx, int dy, int dz) throws RobotException {
        return getColumn(x+dx, y+dy).isFree(z+dz, SIZE);
    }
    public boolean isFree() throws RobotException {
        return isFreeDirection(direction.dx, direction.dy, 0);
    }
    public boolean isLeftFree() throws RobotException {
        return isFreeDirection(direction.getLeft().dx, direction.getLeft().dy, 0);
    }
    public boolean isRightFree() throws RobotException {
        return isFreeDirection(direction.getRight().dx, direction.getRight().dy, 0);
    }
    public boolean isBackFree() throws RobotException {
        return isFreeDirection(direction.getBack().dx, direction.getBack().dy, 0);
    }
    public boolean isTopFree() throws RobotException {
        return isFreeDirection(0,0,1);
    }
    public boolean isBottomFree() throws RobotException {
        return isFreeDirection(0,0,-1);
    }
    public void placeStone(int n) throws RobotException {
        frontColumn().setCube(z+n, Cube.createStone(stoneColor));   
    }
    public void placeStone(int n, MutableColor c) throws RobotException {
        frontColumn().setCube(z+n, Cube.createStone(c));    
    }
    public void removeStone(int n) throws RobotException {
        frontColumn().removeCube(z+ n);
    }
    public void setStoneColor(MutableColor c) {
        stoneColor = c;     
    }
    public MutableColor getStoneColor() {
        return stoneColor;
    }
    public boolean hasStone() throws RobotException {
        return frontColumn().hasCube();
    }
    public boolean hasStone(int n) throws RobotException  {
        return frontColumn().hasCube(n);
    }
    public boolean isFacingSouth() {
        return direction == Direction.SOUTH;
    }
    public boolean isFacingWest() {
        return direction == Direction.WEST;
    }
    public boolean isFacingNorth() {
        return direction == Direction.NORTH;
    }
    public boolean isFacingEast() {
        return direction == Direction.EAST;
    }
    
    public MutableColor getRobotColor() {
        return robotColor;
    }
    public void setRobotColor(MutableColor robotColor) {
        this.robotColor = robotColor;
    }
    public Direction getDirection() {
        return direction;
    }
    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
    public int getZ() {
        return z;
    } 
}