MapHandler.java

import java.util.*;

public class MapHandler {

    private static final char [] [] markers = {
            {' ', '#', ' ', '.', '$', '*', '@', '+', '%'},
            {'-', '#', ' ', '.', '$', '*', '@', '+', '%'},
            {' ', '#', '.', ',', 'O', 'Q', 'A', 'Y', '%'},
            {' ', '#', '.', ':', '$', 'S', '@', 'a', '%'},
    };
    private static int markersType = 0;
    private static String errorMessage;
    private static int width, height, count;
    private static short [] [] mazeMap, cellIndices;
    private static CellVector porter;
    private static CellVector [] boxVectors, targetVectors, cellVectors;

    public static boolean process (String [] mapSource) {
        int k, l, minX, maxX, minY, maxY;
        int [] [] tempMap;
        String rowString;
        int [] mapRow;
        CellVector vector, newVector;
        List <CellVector> boxesList, targetsList, cellsList;
        Queue <CellVector> queue;
        Iterator <CellVector> vectorIterator;
        short cellIndex;

        errorMessage = "No errors.";
        height = mapSource .length;
        width  = 0;

        for (k = 0; height > k; ++k) {
            maxY = mapSource [k] .length ();
            if (width < maxY) {
                width = maxY;
            }
        }

        tempMap = new int [height + 2] [width + 2];
        Arrays .fill (tempMap [0], 1);
        Arrays .fill (tempMap [height + 1], 1);
        maxY = width + 2;
        boxesList = new ArrayList <> ();
        targetsList = new ArrayList <> ();
        porter = null;

        for (k = 0; height > k; ++k) {
            rowString = mapSource [k];
            mapRow = tempMap [k + 1];
            mapRow [0] = 1;
            for (l = 0; rowString .length () > l; ++l) {
                vector = new CellVector (l + 1, k + 1);
                switch (rowString .charAt (l)) {
                case '$':
                    boxesList .add (vector);
                    break;
                case '*':
                    boxesList .add (vector);
                case '.':
                    targetsList .add (vector);
                    break;
                case '+':
                    targetsList .add (vector);
                case '@':
                    if (null != porter) {
                        errorMessage = "Duplicate porter marker.";
                        return false;
                    }
                    porter = vector;
                case '#':
                    mapRow [l + 1] = 1;
                case ' ':
                    break;
                default:
                    errorMessage = "Unknown map marker.";
                    return false;
                }
            }
            ++l;
            for (; maxY > l; ++l) {
                mapRow [l] = 1;
            }
        }

        queue = new ArrayDeque <> ();
        porter .setCell (tempMap, 2);
        queue .add (porter);
        minX = porter .getX ();
        maxX = porter .getX ();
        minY = porter .getY ();
        maxY = porter .getY ();

        while (!queue .isEmpty ()) {
            vector = queue .poll ();
            for (k = 0; 4 > k; ++k) {
                newVector = vector .neighbour (k);
                switch (newVector .getCell (tempMap)) {
                case 0:
                case 4:
                    newVector .setCell (tempMap, 2);
                    queue .add (newVector);
                    break;
                case 1:
                    newVector .setCell (tempMap, 3);
                    break;
                }
                if (minX > newVector .getX ()) {
                    minX = newVector .getX ();
                }
                if (maxX < newVector .getX ()) {
                    maxX = newVector .getX ();
                }
                if (minY > newVector .getY ()) {
                    minY = newVector .getY ();
                }
                if (maxY < newVector .getY ()) {
                    maxY = newVector .getY ();
                }
            }
            for (; 8 > k; ++k) {
                newVector = vector .neighbour (k);
                switch (newVector .getCell (tempMap)) {
                case 0:
                    newVector .setCell (tempMap, 4);
                    break;
                case 1:
                    newVector .setCell (tempMap, 3);
                    break;
                }
            }
        }

        vectorIterator = boxesList .iterator ();
        while (vectorIterator .hasNext ()) {
            if (2 != vectorIterator .next () .getCell (tempMap)) {
                vectorIterator .remove ();
            }
        }

        vectorIterator = targetsList .iterator ();
        while (vectorIterator .hasNext ()) {
            if (2 != vectorIterator .next () .getCell (tempMap)) {
                vectorIterator .remove ();
            }
        }

        count = boxesList .size ();
        if (count != targetsList .size ()) {
            errorMessage = "Box and target counts are inconsistent.";
            return false;
        }

        boxVectors = boxesList .toArray (new CellVector [count]);
        targetVectors = targetsList .toArray (new CellVector [count]);
        vector = new CellVector (-minX, -minY);
        porter = porter .sumWith (vector);

        for (k = 0; count > k; ++k) {
            boxVectors [k] = boxVectors [k] .sumWith (vector);
            targetVectors [k] = targetVectors [k] .sumWith (vector);
        }

        width = maxX - minX + 1;
        height = maxY - minY + 1;
        mazeMap = new short [height] [width];

        for (k = minY; maxY >= k; ++k) {
            for (l = minX; maxX >= l; ++l) {
                switch (tempMap [k] [l]) {
                case 2:
                    break;
                case 3:
                case 4:
                    mazeMap [k - minY] [l - minX] = -1;
                    break;
                default:
                    mazeMap [k - minY] [l - minX] = -2;
                }
            }
        }

        cellIndices = makeMapCopy ();
        cellsList = new ArrayList <> ();
        cellIndex = 0;

        for (k = 0; height > k; ++k) {
            for (l = 0; width > l; ++l) {
                vector = new CellVector (l, k);
                if (0 == vector .getCell (mazeMap)) {
                    cellsList .add (vector);
                    vector .setCell (cellIndices, cellIndex);
                    ++cellIndex;
                    if (0 > cellIndex) {
                        errorMessage = "Cells count overflow.";
                        return false;
                    }
                }
            }
        }

        cellVectors = cellsList .toArray (new CellVector [cellIndex]);

        return true;
    }

    private static short [] [] makeMapCopy () {
        short [] [] result = new short [height] [width];
        for (int k = 0; height > k; ++k) {
            result [k] = Arrays .copyOf (mazeMap [k], width);
        }
        return result;
    }

    public static String errorMessage () {
        return errorMessage;
    }

    public static int boxesCount () {
        return count;
    }

    public static int cellsCount () {
        return cellVectors .length;
    }

    public static short [] stateCells () {
        int k;
        short [] result = new short [count + 1];
        for (k = 0; count > k; ++k) {
            result [k] = boxVectors [k] .getCell (cellIndices);
        }
        result [k] = porter .getCell (cellIndices);
        return result;
    }

    public static short [] boxCells () {
        short [] result = new short [count];
        for (int k = 0; count > k; ++k) {
            result [k] = boxVectors [k] .getCell (cellIndices);
        }
        return result;
    }

    public static short [] targetCells () {
        short [] result = new short [count];
        for (int k = 0; count > k; ++k) {
            result [k] = targetVectors [k] .getCell (cellIndices);
        }
        return result;
    }

    public static NetworkRep networkRepresentation () {
        int k, l, size;
        short value;
        ArrayList <Short> valuesList;
        ArrayList <Integer> indicesList;
        CellVector vector, nextVector;
        NetworkRep result;

        valuesList  = new ArrayList <> ();
        indicesList = new ArrayList <> ();

        for (k = 0; cellVectors .length > k; ++k) {
            indicesList .add (valuesList .size ());
            vector = cellVectors [k];
            for (l = 0; 4 > l; ++l) {
                nextVector = vector .neighbour (l);
                value = nextVector .getCell (cellIndices);
                if (0 > value) {
                    continue;
                }
                valuesList .add ((short) l);
                valuesList .add (value);
                valuesList .add (nextVector .neighbour (l) .getCell (cellIndices));
                valuesList .add (vector .rearNeighbour (l) .getCell (cellIndices));
            }
        }
        indicesList .add (valuesList .size ());

        result = new NetworkRep ();
        result .cellsCount       = cellVectors .length;
        result .activeCellsCount = cellVectors .length;

        size = valuesList .size ();
        result .values = new short [size];
        for (k = 0; size > k; ++k) {
            result .values [k] = valuesList .get (k);
        }

        size = indicesList .size ();
        result .indices = new int [size];
        for (k = 0; size > k; ++k) {
            result .indices [k] = indicesList .get (k);
        }

        return result;
    }

    public static class NetworkRep {

        private int cellsCount, activeCellsCount;
        /*
            values:
            -   move index
            -   move cell
            -   next cell
            -   rear cell
        //*/
        private short [] values;
        private int   [] indices;

        public int cellsCount () {
            return cellsCount;
        }

        public int activeCellsCount () {
            return activeCellsCount;
        }

        public short [] values () {
            return Arrays .copyOf (values,  values  .length);
        }

        public int [] indices () {
            return Arrays .copyOf (indices,  indices  .length);
        }
    }

    public static void setMarkersType (int type) {
        if (0 <= type && markers .length > type) {
            markersType = type;
        }
    }

    public static void displayMaze () {
        int k, l;

        for (k = 0; height > k; ++k) {
            for (l = 0; width > l; ++l) {
                System .out .print (markers [markersType] [2 + mazeMap [k] [l]]);
            }
            System .out .println ();
        }
        System .out .println ();
    }

    public static void displayMap () {
        int k, l;
        short [] [] newMap;
        CellVector vector;

        newMap = makeMapCopy ();

        for (k = 0; count > k; ++k) {
            vector = targetVectors [k];
            if (0 == vector .getCell (newMap)) {
                vector .setCell (newMap, (short) 1);
            } else {
                vector .setCell (newMap, (short) 6);
            }
        }

        for (k = 0; height > k; ++k) {
            for (l = 0; width > l; ++l) {
                System .out .print (markers [markersType] [2 + newMap [k] [l]]);
            }
            System .out .println ();
        }
        System .out .println ();
    }

    public static void displayState (short [] stateCells) {
        int k, l;
        short [] [] newMap;
        CellVector vector;

        newMap = makeMapCopy ();

        for (k = 0; count > k; ++k) {
            vector = targetVectors [k];
            if (0 == vector .getCell (newMap)) {
                vector .setCell (newMap, (short) 1);
            } else {
                vector .setCell (newMap, (short) 6);
            }
        }

        for (k = 0, l = stateCells .length - 1; l > k; ++k) {
            vector = cellVectors [stateCells [k]];
            switch (vector .getCell (newMap)) {
            case 0:
                vector .setCell (newMap, (short) 2);
                break;
            case 1:
                vector .setCell (newMap, (short) 3);
                break;
            default:
                vector .setCell (newMap, (short) 6);
            }
        }

        vector = cellVectors [stateCells [k]];
        switch (vector .getCell (newMap)) {
        case 0:
            vector .setCell (newMap, (short) 4);
            break;
        case 1:
            vector .setCell (newMap, (short) 5);
            break;
        default:
            vector .setCell (newMap, (short) 6);
        }

        for (k = 0; height > k; ++k) {
            for (l = 0; width > l; ++l) {
                System .out .print (markers [markersType] [2 + newMap [k] [l]]);
            }
            System .out .println ();
        }
        System .out .println ();
    }
}