cicaprojekt/cicaprojekt/Dungeon.java

package cicaprojekt;

import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class Dungeon {
    /* NOTE: this function assumes that the parameter input is a well-formatted dungeon file.
     * Such file looks like as follows:
     *
     * <map width>x<map height>
     * <empty line>
     * <map matrix line 1>
     * ...
     * ...
     * <map matrix line <map height>>
     * <empty line>
     * <scale y>-<scale x>-<gate y>-<gate x>-<scale trigger weight>
     * ...
     * ...
     * <scale y>-<scale x>-<gate y>-<gate x>-<scale trigger weight>
     *
     * where the map matrix is a matrix of the following chars:
     * W: Wall
     * F: Field
     * Z: Field with a ZMP
     * B: Field with a Box
     * O: Field with ONeill
     * J: Field with Jaffa
     * G: Gate
     * S: Scale                                                                                 */
    Map<String, Tile> buildDungeon(File input) throws IOException
    {
        Tile oneilllocation = null;
        Tile jaffalocation = null;
        Tile replicatorlocation = null;
        try(BufferedReader reader = new BufferedReader(new FileReader(input)))
        {
            String[] sizedata = reader.readLine().split("x");   // read size data at beginning of file
            reader.readLine();                                  // throw empty line away
            int width = Integer.parseInt(sizedata[0]);
            int height = Integer.parseInt(sizedata[1]);

            Tile[][] dungeon = new Tile[width][height];

            String line = null;
            Gate tempgate = new Gate();
            Scale tempscale = new Scale(tempgate, Integer.MAX_VALUE);
            int scalecount = 0;
            for (int y = 0; y < height; ++y)
            {
                line = reader.readLine().replaceAll("\\s","");  // read line and remove whitespaces
                for (int x = 0; x < width; ++x)
                {
                    switch (line.charAt(x))                     // set the dungeon up
                    {
                        case 'W':
                            dungeon[y][x] = new Wall();
                            break;

                        case 'F':
                            dungeon[y][x] = new Field();
                            break;

                        case 'Z':
                            Field zpmfield = new Field();
                            zpmfield.setZPMOnTile(new ZPM());
                            dungeon[y][x] = zpmfield;
                            break;

                        case 'B':
                            Field boxfield = new Field();
                            boxfield.putABox(new Box());
                            dungeon[y][x] = boxfield;
                            break;

                        case 'O':
                            Field oneillfield = new Field();
                            dungeon[y][x] = oneillfield;
                            oneilllocation = oneillfield;
                            break;

                        case 'J':
                            Field jaffafield = new Field();
                            dungeon[y][x] = jaffafield;
                            jaffalocation = jaffafield;
                            break;

                        case 'G':
                            dungeon[y][x] = tempgate;
                            break;

                        case 'S':
                            dungeon[y][x] = tempscale;
                            scalecount++;
                            break;

                        case 'X':
                            dungeon[y][x] = new Gap();
                            break;

                        case 'R':
                            Field replicatorfield = new Field();
                            dungeon[y][x] = replicatorfield;
                            replicatorlocation = replicatorfield;
                            break;
                    }
                }
            }

            reader.readLine();                                  // throw empty line away

            for (int i = 0; i < scalecount; ++i)    // set up scale-gate connections
            {
                String[] scaledata = reader.readLine().split("-");

                dungeon[Integer.parseInt(scaledata[0])][Integer.parseInt(scaledata[1])] =
                        new Scale((Gate)dungeon[Integer.parseInt(scaledata[2])][Integer.parseInt(scaledata[3])],
                                Integer.parseInt(scaledata[4]));
            }

            /* setting up Tile cross references */
            for (int y = 0; y < height; ++y)
            {
                for (int x = 0; x < width; ++x)
                {
                    if (x-1 >= 0)       // leftwards Tile reference
                        dungeon[y][x].setAdajacentTile(dungeon[y][x-1], Direction.WEST);
                    else
                        dungeon[y][x].setAdajacentTile(null, Direction.WEST);

                    if (x+1 < width)    // rightwards Tile reference
                        dungeon[y][x].setAdajacentTile(dungeon[y][x+1], Direction.EAST);
                    else
                        dungeon[y][x].setAdajacentTile(null, Direction.EAST);

                    if (y+1 < height)   // upwards Tile reference
                        dungeon[y][x].setAdajacentTile(dungeon[y+1][x], Direction.NORTH);
                    else
                        dungeon[y][x].setAdajacentTile(null, Direction.NORTH);

                    if (y-1 >= 0)       // downwards Tile reference
                        dungeon[y][x].setAdajacentTile(dungeon[y-1][x], Direction.SOUTH);
                    else
                        dungeon[y][x].setAdajacentTile(null, Direction.SOUTH);
                }
            }
        }

        Map<String, Tile> playermap = new HashMap<>();
        playermap.put("oneill", oneilllocation);
        playermap.put("jaffa", jaffalocation);
        playermap.put("replicator", replicatorlocation);

        return playermap;
    }
}