API tools faq
paste
Advertisement
Guest User

MapHandler.java

a guest
May 15th, 2021
66
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 25.32 KB | None | 0 0
raw download clone embed print report
  1. //  Sokoban state space explorer.
  2. //  Discussion: https://dxdy.ru/topic144781.html
  3.  
  4. import java.util.*;
  5.  
  6. public class MapHandler {
  7.    
  8.     private static final int CELLS_LIMIT = 10000;
  9.     private static final int
  10.             MAZE_CELL_EMPTY        =  0,
  11.             MAZE_CELL_WALL         = -1,
  12.             MAZE_CELL_UNREACHABLE  = -2,
  13.             MAZE_CELL_EMPTY_MARKED = -3,
  14.             MAZE_CELL_EMPTY_ANGLE  = -4,
  15.             MAZE_CELL_WALL_MARKED  = -5;
  16.    
  17.     private boolean initFlag;
  18.     private String errorMessage;
  19.     private int mazeWidth, mazeHeight, boxesNumber, cellsNumber, activeCellsNumber;
  20.     private int [] [] mazeMap, cellIndices;
  21.     private boolean [] [] activeCellsMap;
  22.     private CellVector porter;
  23.     private ArrayList <CellVector> boxVectors, tgtVectors, cellVectors;
  24.    
  25.     public MapHandler () {
  26.         initFlag = false;
  27.         errorMessage = "Uninitialized.";
  28.     }
  29.    
  30.     public boolean process (String [] mapLines) {
  31.        
  32.         initFlag = false;
  33.        
  34.         if (parseMapSource (mapLines)) {
  35.             return true;
  36.         }
  37.        
  38.         if (reworkMaze ()) {
  39.             return true;
  40.         }
  41.        
  42.         if (enumerateCells ()) {
  43.             return true;
  44.         }
  45.        
  46.         if (findActiveCells ()) {
  47.             return true;
  48.         }
  49.        
  50.         reenumerateCells ();
  51.        
  52.         initFlag = true;
  53.        
  54.         return false;
  55.     }
  56.    
  57.     public String getErrorMessage () {
  58.         return errorMessage;
  59.     }
  60.    
  61.     public boolean isInitialised () {
  62.         return initFlag;
  63.     }
  64.    
  65.     public int getCellsNumber () {
  66.         return cellsNumber;
  67.     }
  68.    
  69.     public int getActiveCellsNumber () {
  70.         return activeCellsNumber;
  71.     }
  72.    
  73.     public int getBoxesNumber () {
  74.         return boxesNumber;
  75.     }
  76.    
  77.     public int getMazeWidth () {
  78.         return mazeWidth;
  79.     }
  80.    
  81.     public int getMazeHeight () {
  82.         return mazeHeight;
  83.     }
  84.    
  85.     public short getPorterCell () {
  86.         return (short) porter .getCell (cellIndices);
  87.     }
  88.    
  89.     public short [] getBoxCells () {
  90.         short [] result = new short [boxesNumber];
  91.         for (int k = 0; boxesNumber > k; ++k) {
  92.             result [k] = (short) boxVectors .get (k) .getCell (cellIndices);
  93.         }
  94.         return result;
  95.     }
  96.    
  97.     public short [] getTargetCells () {
  98.         short [] result = new short [boxesNumber];
  99.         for (int k = 0; boxesNumber > k; ++k) {
  100.             result [k] = (short) tgtVectors .get (k) .getCell (cellIndices);
  101.         }
  102.         return result;
  103.     }
  104.    
  105.     //================================================================================
  106.    
  107.     public CellsAdjacency getCellsAdjacencySimple () {
  108.         int k, l, size, value;
  109.         ArrayList <Short> valuesList;
  110.         ArrayList <Integer> indicesList;
  111.         CellVector vector, nextVector;
  112.         short [] values;
  113.         int   [] indices;
  114.        
  115.         valuesList  = new ArrayList <> ();
  116.         indicesList = new ArrayList <> ();
  117.        
  118.         size = cellVectors .size ();
  119.         for (k = 0; size > k; ++k) {
  120.             indicesList .add (valuesList .size ());
  121.             vector = cellVectors .get (k);
  122.             for (l = 0; 4 > l; ++l) {
  123.                 nextVector = vector .neighbour (l);
  124.                 value = nextVector .getCell (cellIndices);
  125.                 if (0 > value) {
  126.                     continue;
  127.                 }
  128.                 valuesList .add ((short) l);
  129.                 valuesList .add ((short) value);
  130.                 valuesList .add ((short) nextVector .neighbour (l) .getCell (cellIndices));
  131.                 valuesList .add ((short) vector .rearNeighbour (l) .getCell (cellIndices));
  132.             }
  133.         }
  134.         indicesList .add (valuesList .size ());
  135.        
  136.         size = valuesList .size ();
  137.         values = new short [size];
  138.         for (k = 0; size > k; ++k) {
  139.             values [k] = valuesList .get (k);
  140.         }
  141.        
  142.         size = indicesList .size ();
  143.         indices = new int [size];
  144.         for (k = 0; size > k; ++k) {
  145.             indices [k] = indicesList .get (k);
  146.         }
  147.        
  148.         return new CellsAdjacency (cellsNumber, cellsNumber, values, indices);
  149.     }
  150.    
  151.     //================================================================================
  152.    
  153.     public CellsAdjacency getCellsAdjacencySmart () {
  154.         int k, l, size, value;
  155.         ArrayList <Short> valuesList;
  156.         ArrayList <Integer> indicesList;
  157.         CellVector vector, nextVector;
  158.         short [] values;
  159.         int   [] indices;
  160.        
  161.         valuesList  = new ArrayList <> ();
  162.         indicesList = new ArrayList <> ();
  163.        
  164.         size = cellVectors .size ();
  165.         for (k = 0; size > k; ++k) {
  166.             indicesList .add (valuesList .size ());
  167.             vector = cellVectors .get (k);
  168.             for (l = 0; 4 > l; ++l) {
  169.                 nextVector = vector .neighbour (l);
  170.                 value = nextVector .getCell (cellIndices);
  171.                 if (0 > value) {
  172.                     continue;
  173.                 }
  174.                 valuesList .add ((short) l);
  175.                 valuesList .add ((short) value);
  176.                 nextVector = nextVector .neighbour (l);
  177.                 if (nextVector .getCell (activeCellsMap)) {
  178.                     valuesList .add ((short) nextVector .getCell (cellIndices));
  179.                 } else {
  180.                     valuesList .add ((short) -1);
  181.                 }
  182.                 nextVector = vector .rearNeighbour (l);
  183.                 if (nextVector .getCell (activeCellsMap) && vector .getCell (activeCellsMap)) {
  184.                     valuesList .add ((short) nextVector .getCell (cellIndices));
  185.                 } else {
  186.                     valuesList .add ((short) -1);
  187.                 }
  188.             }
  189.         }
  190.         indicesList .add (valuesList .size ());
  191.        
  192.         size = valuesList .size ();
  193.         values = new short [size];
  194.         for (k = 0; size > k; ++k) {
  195.             values [k] = valuesList .get (k);
  196.         }
  197.        
  198.         size = indicesList .size ();
  199.         indices = new int [size];
  200.         for (k = 0; size > k; ++k) {
  201.             indices [k] = indicesList .get (k);
  202.         }
  203.        
  204.         return new CellsAdjacency (cellsNumber, activeCellsNumber, values, indices);
  205.     }
  206.    
  207.     //================================================================================
  208.    
  209.     private boolean parseMapSource (String [] mapSource) {
  210.         int k, l, m, value;
  211.         String rowString;
  212.         CellVector vector;
  213.        
  214.         errorMessage = "No errors.";
  215.         mazeHeight = mapSource .length;
  216.         mazeWidth  = 0;
  217.        
  218.         for (k = 0; mazeHeight > k; ++k) {
  219.             value = mapSource [k] .length ();
  220.             if (mazeWidth < value) {
  221.                 mazeWidth = value;
  222.             }
  223.         }
  224.        
  225.         value = mazeWidth + 2;
  226.         mazeMap = new int [mazeHeight + 2] [value];
  227.         Arrays .fill (mazeMap [0],              MAZE_CELL_WALL);
  228.         Arrays .fill (mazeMap [mazeHeight + 1], MAZE_CELL_WALL);
  229.         porter = null;
  230.         boxVectors = new ArrayList <> ();
  231.         tgtVectors = new ArrayList <> ();
  232.        
  233.         for (k = 1; mazeHeight >= k; ++k) {
  234.             rowString = mapSource [k - 1];
  235.             mazeMap [k] [0] = MAZE_CELL_WALL;
  236.             for (l = 0, m = 1; rowString .length () > l; l = m, ++m) {
  237.                 vector = new CellVector (m, k);
  238.                 vector .setCell (mazeMap, MAZE_CELL_EMPTY);
  239.                 switch (rowString .charAt (l)) {
  240.                 case '$':
  241.                     boxVectors .add (vector);
  242.                     break;
  243.                 case '*':
  244.                     boxVectors .add (vector);
  245.                 case '.':
  246.                     tgtVectors .add (vector);
  247.                     break;
  248.                 case '+':
  249.                     tgtVectors .add (vector);
  250.                 case '@':
  251.                     if (null != porter) {
  252.                         errorMessage = "Duplicate porter marker.";
  253.                         return true;
  254.                     }
  255.                     porter = vector;
  256.                     break;
  257.                 case '#':
  258.                     vector .setCell (mazeMap, MAZE_CELL_WALL);
  259.                 case ' ':
  260.                     break;
  261.                 default:
  262.                     errorMessage = "Unknown map marker.";
  263.                     return true;
  264.                 }
  265.             }
  266.             ++l;
  267.             for (; value > l; ++l) {
  268.                 mazeMap [k] [l] = MAZE_CELL_WALL;
  269.             }
  270.         }
  271.        
  272.         return false;
  273.     }
  274.    
  275.     //================================================================================
  276.    
  277.     private boolean reworkMaze () {
  278.         int k, l, m, n, minX, maxX, minY, maxY;
  279.         Queue <CellVector> queue;
  280.         CellVector vector, newVector;
  281.         Iterator <CellVector> vectorIterator;
  282.         int [] [] oldMap;
  283.        
  284.         queue = new ArrayDeque <> ();
  285.         porter .setCell (mazeMap, MAZE_CELL_EMPTY_MARKED);
  286.         queue .add (porter);
  287.         minX = porter .getX ();
  288.         maxX = porter .getX ();
  289.         minY = porter .getY ();
  290.         maxY = porter .getY ();
  291.        
  292.         while (!queue .isEmpty ()) {
  293.             vector = queue .poll ();
  294.             for (k = 0; 4 > k; ++k) {
  295.                 newVector = vector .neighbour (k);
  296.                 switch (newVector .getCell (mazeMap)) {
  297.                 case MAZE_CELL_EMPTY:
  298.                 case MAZE_CELL_EMPTY_ANGLE:
  299.                     newVector .setCell (mazeMap, MAZE_CELL_EMPTY_MARKED);
  300.                     queue .add (newVector);
  301.                     break;
  302.                 case MAZE_CELL_WALL:
  303.                     newVector .setCell (mazeMap, MAZE_CELL_WALL_MARKED);
  304.                 case MAZE_CELL_WALL_MARKED:
  305.                 case MAZE_CELL_EMPTY_MARKED:
  306.                     break;
  307.                 default:
  308.                     throw new IllegalArgumentException ("\n\nImpossible error: unknown maze cell type.\n");
  309.                 }
  310.                 if (minX > newVector .getX ()) {
  311.                     minX = newVector .getX ();
  312.                 }
  313.                 if (maxX < newVector .getX ()) {
  314.                     maxX = newVector .getX ();
  315.                 }
  316.                 if (minY > newVector .getY ()) {
  317.                     minY = newVector .getY ();
  318.                 }
  319.                 if (maxY < newVector .getY ()) {
  320.                     maxY = newVector .getY ();
  321.                 }
  322.             }
  323.             for (; 8 > k; ++k) {
  324.                 newVector = vector .neighbour (k);
  325.                 switch (newVector .getCell (mazeMap)) {
  326.                 case MAZE_CELL_EMPTY:
  327.                     newVector .setCell (mazeMap, MAZE_CELL_EMPTY_ANGLE);
  328.                     break;
  329.                 case MAZE_CELL_WALL:
  330.                     newVector .setCell (mazeMap, MAZE_CELL_WALL_MARKED);
  331.                 case MAZE_CELL_WALL_MARKED:
  332.                 case MAZE_CELL_EMPTY_MARKED:
  333.                 case MAZE_CELL_EMPTY_ANGLE:
  334.                     break;
  335.                 default:
  336.                     throw new IllegalArgumentException ("\n\nImpossible error: unknown maze cell type.\n");
  337.                 }
  338.             }
  339.         }
  340.        
  341.         vectorIterator = boxVectors .iterator ();
  342.         while (vectorIterator .hasNext ()) {
  343.             if (MAZE_CELL_EMPTY_MARKED != vectorIterator .next () .getCell (mazeMap)) {
  344.                 vectorIterator .remove ();
  345.             }
  346.         }
  347.        
  348.         vectorIterator = tgtVectors .iterator ();
  349.         while (vectorIterator .hasNext ()) {
  350.             if (MAZE_CELL_EMPTY_MARKED != vectorIterator .next () .getCell (mazeMap)) {
  351.                 vectorIterator .remove ();
  352.             }
  353.         }
  354.        
  355.         boxesNumber = boxVectors .size ();
  356.         if (boxesNumber != tgtVectors .size ()) {
  357.             errorMessage = "Numbers of reachable boxes and targets do not agree.";
  358.             return true;
  359.         }
  360.        
  361.         vector = new CellVector (-minX, -minY);
  362.         porter = porter .sumWith (vector);
  363.        
  364.         for (k = 0; boxesNumber > k; ++k) {
  365.             boxVectors .set (k, boxVectors .get (k) .sumWith (vector));
  366.             tgtVectors .set (k, tgtVectors .get (k) .sumWith (vector));
  367.         }
  368.        
  369.         mazeWidth  = maxX - minX + 1;
  370.         mazeHeight = maxY - minY + 1;
  371.         oldMap  = mazeMap;
  372.         mazeMap = new int [mazeHeight] [mazeWidth];
  373.        
  374.         for (k = minY, m = 0; maxY >= k; ++k, ++m) {
  375.             for (l = minX, n = 0; maxX >= l; ++l, ++n) {
  376.                 switch (oldMap [k] [l]) {
  377.                 case MAZE_CELL_WALL:
  378.                 case MAZE_CELL_EMPTY:
  379.                     mazeMap [m] [n] = MAZE_CELL_UNREACHABLE;
  380.                     break;
  381.                 case MAZE_CELL_WALL_MARKED:
  382.                 case MAZE_CELL_EMPTY_ANGLE:
  383.                     mazeMap [m] [n] = MAZE_CELL_WALL;
  384.                     break;
  385.                 case MAZE_CELL_EMPTY_MARKED:
  386.                     mazeMap [m] [n] = MAZE_CELL_EMPTY;
  387.                     break;
  388.                 default:
  389.                     throw new IllegalArgumentException ("\n\nImpossible error: unknown maze cell type.\n");
  390.                 }
  391.             }
  392.         }
  393.        
  394.         /*
  395.         System .out .println ();
  396.         boxVectors .forEach (p -> System .out .println (p .toString ()));
  397.         System .out .println ();
  398.         tgtVectors .forEach (p -> System .out .println (p .toString ()));
  399.         //*/
  400.        
  401.         return false;
  402.     }
  403.    
  404.     //================================================================================
  405.    
  406.     private boolean enumerateCells () {
  407.         int k, l;
  408.         CellVector vector;
  409.        
  410.         cellIndices = new int [mazeHeight] [mazeWidth];
  411.         cellVectors = new ArrayList <> ();
  412.         cellsNumber = 0;
  413.        
  414.         for (k = 0; mazeHeight > k; ++k) {
  415.             for (l = 0; mazeWidth > l; ++l) {
  416.                 vector = new CellVector (l, k);
  417.                 switch (vector .getCell (mazeMap)) {
  418.                 case MAZE_CELL_EMPTY:
  419.                     vector .setCell (cellIndices, cellsNumber);
  420.                     ++cellsNumber;
  421.                     if (CELLS_LIMIT < cellsNumber) {
  422.                         errorMessage = "Number of cells exceeds limit.";
  423.                         return true;
  424.                     }
  425.                     cellVectors .add (vector);
  426.                     break;
  427.                 case MAZE_CELL_WALL:
  428.                 case MAZE_CELL_UNREACHABLE:
  429.                     vector .setCell (cellIndices, -1);
  430.                     break;
  431.                 default:
  432.                     throw new IllegalArgumentException ("\n\nImpossible error: unknown maze cell type.\n");
  433.                 }
  434.             }
  435.         }
  436.        
  437.         return false;
  438.     }
  439.    
  440.     //================================================================================
  441.    
  442.     private boolean findActiveCells () {
  443.         int k, l;
  444.         boolean [] forwardFlags, backwardFlags;
  445.         boolean [] [] stateFlags;
  446.         Queue <SingleBoxState> queue;
  447.         SingleBoxState state, newState;
  448.         CellVector porterVector, boxVector, newPorterVector, newBoxVector, vector;
  449.        
  450.         forwardFlags  = new boolean [cellsNumber];
  451.         stateFlags    = new boolean [cellsNumber] [cellsNumber];
  452.         queue = new ArrayDeque <> ();
  453.        
  454.         for (k = 0; boxesNumber > k; ++k) {
  455.             state = new SingleBoxState (
  456.                             porter              .getCell (cellIndices),
  457.                             boxVectors .get (k) .getCell (cellIndices));
  458.             queue .add (state);
  459.             state .flagState (stateFlags);
  460.             state .flagBox (forwardFlags);
  461.         }
  462.        
  463.         while (!queue .isEmpty ()) {
  464.             state = queue .poll ();
  465.             //System .out .println ("State: " + state .porter + ", " + state .box);
  466.             porterVector = cellVectors .get (state .porter);
  467.             boxVector    = cellVectors .get (state .box);
  468.             for (k = 0; 4 > k; ++k) {
  469.                 newPorterVector = porterVector .neighbour (k);
  470.                 if (MAZE_CELL_EMPTY != newPorterVector .getCell (mazeMap)) {
  471.                     continue;
  472.                 }
  473.                 if (boxVector .equals (newPorterVector)) {
  474.                     newBoxVector = boxVector .neighbour (k);
  475.                     if (MAZE_CELL_EMPTY != newBoxVector .getCell (mazeMap)) {
  476.                         continue;
  477.                     }
  478.                 } else {
  479.                     newBoxVector = boxVector;
  480.                 }
  481.                 newState = new SingleBoxState (
  482.                                     newPorterVector .getCell (cellIndices),
  483.                                     newBoxVector    .getCell (cellIndices));
  484.                 if (newState .isStateFlagged (stateFlags)) {
  485.                     continue;
  486.                 }
  487.                 queue .add (newState);
  488.                 newState .flagState (stateFlags);
  489.                 newState .flagBox (forwardFlags);
  490.             }
  491.         }
  492.        
  493.         //displayMazeFlagged (forwardFlags);
  494.        
  495.         backwardFlags = new boolean [cellsNumber];
  496.         stateFlags    = new boolean [cellsNumber] [cellsNumber];
  497.         queue = new ArrayDeque <> ();
  498.        
  499.         for (k = 0; boxesNumber > k; ++k) {
  500.             boxVector = tgtVectors .get (k);
  501.             for (l = 0; 4 > l; ++l) {
  502.                 porterVector = boxVector .neighbour (l);
  503.                 if (MAZE_CELL_EMPTY != porterVector .getCell (mazeMap)) {
  504.                     continue;
  505.                 }
  506.                 state = new SingleBoxState (
  507.                                 porterVector .getCell (cellIndices),
  508.                                 boxVector    .getCell (cellIndices));
  509.                 queue .add (state);
  510.                 state .flagState (stateFlags);
  511.                 state .flagBox (backwardFlags);
  512.             }
  513.         }
  514.        
  515.         while (!queue .isEmpty ()) {
  516.             state = queue .poll ();
  517.             //System .out .println ("State: " + state .porter + ", " + state .box);
  518.             porterVector = cellVectors .get (state .porter);
  519.             boxVector    = cellVectors .get (state .box);
  520.             for (k = 0; 4 > k; ++k) {
  521.                 newPorterVector = porterVector .neighbour (k);
  522.                 if (MAZE_CELL_EMPTY != newPorterVector .getCell (mazeMap)) {
  523.                     continue;
  524.                 }
  525.                 if (boxVector .equals (newPorterVector)) {
  526.                     continue;
  527.                 }
  528.                 newState = new SingleBoxState (
  529.                                     newPorterVector .getCell (cellIndices),
  530.                                     boxVector       .getCell (cellIndices));
  531.                 if (!newState .isStateFlagged (stateFlags)) {
  532.                     queue .add (newState);
  533.                     newState .flagState (stateFlags);
  534.                     //System .out .println ("  new state: " + newState .porter + ", " + newState .box);
  535.                 }
  536.                 newBoxVector = boxVector .neighbour (k);
  537.                 if (!porterVector .equals (newBoxVector)) {
  538.                     continue;
  539.                 }
  540.                 newState = new SingleBoxState (
  541.                                     newPorterVector .getCell (cellIndices),
  542.                                     newBoxVector    .getCell (cellIndices));
  543.                 if (newState .isStateFlagged (stateFlags)) {
  544.                     continue;
  545.                 }
  546.                 queue .add (newState);
  547.                 newState .flagState (stateFlags);
  548.                 newState .flagBox (backwardFlags);
  549.                 //System .out .println ("  new state: " + newState .porter + ", " + newState .box + " *");
  550.             }
  551.         }
  552.        
  553.         //displayMazeFlagged (backwardFlags);
  554.        
  555.         activeCellsMap = new boolean [mazeHeight] [mazeWidth];
  556.        
  557.         for (k = 0; cellsNumber > k; ++k) {
  558.             vector = cellVectors .get (k);
  559.             vector .setCell (activeCellsMap, forwardFlags [k] && backwardFlags [k]);
  560.         }
  561.        
  562.         //displayMazeActiveCells ();
  563.        
  564.         for (k = 0; boxesNumber > k; ++k) {
  565.             if (!boxVectors .get (k) .getCell (activeCellsMap)) {
  566.                 errorMessage = "Some boxes are placed in dead cells.";
  567.                 return true;
  568.             }
  569.             if (!tgtVectors .get (k) .getCell (activeCellsMap)) {
  570.                 errorMessage = "Some target cells are unreachable by boxes.";
  571.                 return true;
  572.             }
  573.         }
  574.        
  575.         return false;
  576.     }
  577.    
  578.     //================================================================================
  579.    
  580.     private class SingleBoxState {
  581.        
  582.         public int porter, box;
  583.        
  584.         public SingleBoxState (int porter, int box) {
  585.             this .porter = porter;
  586.             this .box    = box;
  587.         }
  588.        
  589.         public void flagState (boolean [] [] stateFlags) {
  590.             stateFlags [porter] [box] = true;
  591.         }
  592.        
  593.         public boolean isStateFlagged (boolean [] [] stateFlags) {
  594.             return stateFlags [porter] [box];
  595.         }
  596.        
  597.         public void flagBox (boolean [] boxFlags) {
  598.             boxFlags [box] = true;
  599.         }
  600.     }
  601.    
  602.     //================================================================================
  603.    
  604.     private void reenumerateCells () {
  605.         int k, l, index;
  606.         CellVector vector;
  607.        
  608.         cellIndices = new int [mazeHeight] [mazeWidth];
  609.         cellVectors = new ArrayList <> ();
  610.         index = 0;
  611.        
  612.         for (k = 0; mazeHeight > k; ++k) {
  613.             for (l = 0; mazeWidth > l; ++l) {
  614.                 vector = new CellVector (l, k);
  615.                 if (!vector .getCell (activeCellsMap)) {
  616.                     continue;
  617.                 }
  618.                 vector .setCell (cellIndices, index);
  619.                 ++index;
  620.                 cellVectors .add (vector);
  621.             }
  622.         }
  623.        
  624.         activeCellsNumber = index;
  625.        
  626.         for (k = 0; mazeHeight > k; ++k) {
  627.             for (l = 0; mazeWidth > l; ++l) {
  628.                 vector = new CellVector (l, k);
  629.                 switch (vector .getCell (mazeMap)) {
  630.                 case MAZE_CELL_EMPTY:
  631.                     if (!vector .getCell (activeCellsMap)) {
  632.                         vector .setCell (cellIndices, index);
  633.                         ++index;
  634.                         cellVectors .add (vector);
  635.                     }
  636.                     break;
  637.                 case MAZE_CELL_WALL:
  638.                 case MAZE_CELL_UNREACHABLE:
  639.                     vector .setCell (cellIndices, -1);
  640.                     break;
  641.                 default:
  642.                     throw new IllegalArgumentException ("\n\nImpossible error: unknown maze cell type.\n");
  643.                 }
  644.             }
  645.         }
  646.     }
  647.    
  648.     //================================================================================
  649.    
  650.     public void displayMaze () {
  651.         int k, l;
  652.        
  653.         System .out .println ();
  654.         for (k = 0; mazeHeight > k; ++k) {
  655.             for (l = 0; mazeWidth > l; ++l) {
  656.                 switch (mazeMap [k] [l]) {
  657.                 case MAZE_CELL_EMPTY:
  658.                     System .out .print ('.');
  659.                     break;
  660.                 case MAZE_CELL_WALL:
  661.                     System .out .print ('#');
  662.                     break;
  663.                 default:
  664.                     System .out .print (' ');
  665.                     break;
  666.                 }
  667.             }
  668.             System .out .println ();
  669.         }
  670.     }
  671.    
  672.     public void displayMazeFlagged (boolean [] flags) {
  673.         int k, l;
  674.        
  675.         System .out .println ();
  676.         for (k = 0; mazeHeight > k; ++k) {
  677.             for (l = 0; mazeWidth > l; ++l) {
  678.                 switch (mazeMap [k] [l]) {
  679.                 case MAZE_CELL_EMPTY:
  680.                     if (flags [cellIndices [k] [l]]) {
  681.                         System .out .print (',');
  682.                     } else {
  683.                         System .out .print ('.');
  684.                     }
  685.                     break;
  686.                 case MAZE_CELL_WALL:
  687.                     System .out .print ('#');
  688.                     break;
  689.                 default:
  690.                     System .out .print (' ');
  691.                     break;
  692.                 }
  693.             }
  694.             System .out .println ();
  695.         }
  696.     }
  697.    
  698.     public void displayMazeWithActiveCells () {
  699.         int k, l;
  700.        
  701.         System .out .println ();
  702.         for (k = 0; mazeHeight > k; ++k) {
  703.             for (l = 0; mazeWidth > l; ++l) {
  704.                 switch (mazeMap [k] [l]) {
  705.                 case MAZE_CELL_EMPTY:
  706.                     if (activeCellsMap [k] [l]) {
  707.                         System .out .print (',');
  708.                     } else {
  709.                         System .out .print ('.');
  710.                     }
  711.                     break;
  712.                 case MAZE_CELL_WALL:
  713.                     System .out .print ('#');
  714.                     break;
  715.                 default:
  716.                     System .out .print (' ');
  717.                     break;
  718.                 }
  719.             }
  720.             System .out .println ();
  721.         }
  722.     }
  723. }
  724.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!