Column.java

gehe zur Dokumentation dieser Datei

package de.lathanda.eos.robot;
 
import java.util.ArrayList;
 
import de.lathanda.eos.base.MutableColor;
import de.lathanda.eos.robot.exceptions.CubeImmutableException;
import de.lathanda.eos.robot.exceptions.CubeMissingException;
import de.lathanda.eos.robot.exceptions.CubeNoSpaceException;
import de.lathanda.eos.robot.exceptions.RobotException;
 
public class Column {
    private CubeArray cubes = new CubeArray();
    private MutableColor mark = null;
    private static final MutableColor MARK = MutableColor.YELLOW;
 
    public void dropCube(int level, Cube cube) throws RobotException {
        if(cubes.get(level).isFree()) {
            int n = level;
            while (cubes.get(n-1).isFree()) { n--; }
            cubes.set(n, cube);
        } else {
            int n = level+1;
            while (!cubes.get(n).isFree()) {
                n++;
            }
            cubes.set(n, cube);
        }
    }
    public void dropCube(Cube cube) throws RobotException {
        //drop from above
        dropCube(cubes.size(), cube);
    }
    public MutableColor stoneColor(int level) throws RobotException {
        if(cubes.get(level).isFree()) {
            int n = level;
            while (cubes.get(n-1).isFree()) { n--; }
            return cubes.get(n-1).getColor();
        } else {
            int n = level+1;
            while (!cubes.get(n).isFree()) {
                n++;
            }
            return cubes.get(n-1).getColor();
        }       
    }
    public void setMark(boolean mark) throws RobotException {
        this.mark = (mark)?MARK:null;      
    }
 
    public int isReachable(int level, int size, int climb, int fall) throws RobotException {
        int maxDifference = Math.min(fall,  climb);
        int difference = 0;
        while (difference <= maxDifference) {
            if (isWalkable(level - difference, size)) {
                return level - difference;
            }
            if (isWalkable(level + difference, size)) {
                return level + difference;
            }
            difference++;
        }
        if (fall < climb) {
            while (difference <= climb) {
                if (isWalkable(level + difference, size)) {
                    return level + difference;
                }       
                difference++;
            }
        } else {
            while (difference <= fall) {
                if (isWalkable(level - difference, size)) {
                    return level - difference;
                }       
                difference++;
            }
        }
        return -1;
    }
    private boolean isWalkable(int level, int size) throws RobotException {
        if (cubes.get(level - 1).isFree()) {
            return false; //check solid ground
        }
        for (int i = size; i-- > 0;) {
            if (!cubes.get(level + i).isFree()) {
                return false; //check free space
            }
        }
        return true;
    }
    public boolean isFree(int level, int size) throws RobotException {
        for (int i = size; i-- > 0;) {
            if (!cubes.get(level + i).isFree()) {
                return false; //check free space
            }
        }
        return true;
    }
 
    public void pickup() throws RobotException {
        pickup(cubes.size());
    }
    void pickup(int level) throws RobotException {
        if (cubes.get(level).isFree()) {
            for(int n = level; n --> 0;) {
                if(!cubes.get(n).isEmpty()) {
                    removeCube(n);
                }
            }
        } else {
            int n = level;
            while (!cubes.get(n+1).isFree()) {n++;}
            removeCube(n);
        }
    }
    public boolean isMarked() throws RobotException {
        return mark != null;
    }
    public boolean isMarked(MutableColor c) throws RobotException {
        return (mark == null)?false:mark.equals(c);
    }    
    public MutableColor getMark() throws RobotException {
        return mark;
    }
    public void setMark() throws RobotException {
        mark = MARK;
    }
    public void setMark(MutableColor c) throws RobotException {
        mark = c;
    }
    public void toggleMark() throws RobotException {
        if (mark == null) {
            mark = MARK;
        } else {
            mark = null;
        }
    }
    public void toggleMark(MutableColor c) throws RobotException {
        if (mark == null) {
            mark = c;
        } else {
            mark = null;
        }
    }
    public void removeCube(int level) throws RobotException {
        cubes.get(level).setEmpty();
    }
    public boolean hasCube() throws RobotException {
        for (int i = 0; i < cubes.size(); i++) {
            if (!cubes.get(i).isFree()) {
                return true;
            }
        }
        return false;
    }
    public boolean hasCube(int n) throws RobotException {
        int numberOfCubes = 0;
        for (int i = 0; i < cubes.size(); i++) {
            if (!cubes.get(i).isFree()) {
                numberOfCubes++;
            }
        }
        return numberOfCubes == n;
    }
 
    public void setCube(int level, Cube cube) throws RobotException {
        cubes.set(level, cube);
    }
    public Cube[] getCubes() throws RobotException {
        return cubes.getAll();
    }
    public void remove(int level) throws RobotException {
        cubes.set(level, Cube.createEmpty());
    }
    private static class CubeArray {
        private ArrayList<Cube> cubes = new ArrayList<>();
        private synchronized Cube get(int level) throws RobotException {
            if (level < 0) {
                return Cube.createGround();
            }
            if (level < cubes.size()) {
                return cubes.get(level);
            } else {
                return Cube.createEmpty();
            }
        }    
        public synchronized void set(int level, Cube cube) throws RobotException {
            //fill up
            for (int n = level - cubes.size() + 1; n --> 0;) {
                cubes.add(Cube.createEmpty());
            }
            //set cube
            cubes.set(level,  cube);
            //clean up
            int n = cubes.size() - 1;
            while ( n >= 0 && cubes.get(n).isEmpty()) {
                cubes.remove(n);
                n--;
            }
        }
 
        public synchronized Cube[] getAll() throws RobotException {
            Cube[] cubeArray = new Cube[cubes.size()];
            return cubes.toArray(cubeArray);
        }   
        public int size() {
            return cubes.size();
        }
    }
}