TerrainMap.java

Go to the documentation of this file.

import java.awt.*;
import java.awt.image.*;
import java.util.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;


public final class TerrainMap
{
    private static final double SQRT_2 = Math.sqrt(2.0);

    public enum MovementType
    {
        Chess, Euclidean, Manhattan
    }
    
    private final MovementType moveType;

    private final byte[][] Board;
    
    private final int[][] Uncovered;
    
    private ArrayList<Point> path;
    
    private final int Width;
    
    private final int Height;
    
    private final Point StartPoint;
    
    private final Point EndPoint;

    private int uncoveredCounter;

    private final boolean chaotic;

    private final Semaphore sem = new Semaphore(1, true);

    private final Timer timer = new Timer();

    private final TimerTask task = new TimerTask()
    {
        @Override
        public void run()
        {
            runChaos();
        }
    };


    public TerrainMap(final int width, final int height, final TerrainGenerator terraGen, final MovementType moveType, final boolean chaotic)
    {
        this.Width = width;
        this.Height = height;
        this.moveType = moveType;

        // State at the center and move towards a corner
        StartPoint = new Point((int) (0.5 * width), (int) (0.5 * height));
        EndPoint = new Point((int) (0.9 * width), (int) (0.9 * height));

        // Use one octave of Perlin noise to generate a wavy terrain.
        Board = terraGen.getTerrain();
        
        // Initially, nothing has been visited.
        Uncovered = new int[width][height];
        for(int x = 0; x < width; x++)
        {
            Arrays.fill(Uncovered[x], 0);
        }
        uncoveredCounter = 0;

        this.chaotic = chaotic;
    }


    public Point getStartPoint()
    {
        return new Point(StartPoint);
    }


    public Point getEndPoint()
    {
        return new Point(EndPoint);
    }


    public boolean validTile(final int x, final int y)
    {
        return x >= 0 && x < Width && y >= 0 && y < Height;
    }


    public boolean validTile(final Point pt)
    {
        return validTile(pt.x, pt.y);
    }


    public int getTile(final int x, final int y)
    {
        if(!validTile(x, y))
        {
            throw new IndexOutOfBoundsException("Tried to access (" + x + ", " + y + ") " +
                                            "in a board of dimension " + Width + " x " + Height);
        }
        down();
        if(Uncovered[x][y] == 0)
        {
            uncoveredCounter++;
            Uncovered[x][y] = uncoveredCounter;
        }
        up();
        return Board[x][y] & 0xFF;
    }


    public int getTile(final Point pt)
    {
        return getTile(pt.x, pt.y);
    }


    public boolean isAdjacent(final Point p1, final Point p2)
    {
        final int dx = Math.abs(p1.x - p2.x);
        final int dy = Math.abs(p1.y - p2.y);
        if((moveType == MovementType.Manhattan) && (dx * dy != 0))
            return false;
        else
            return dx <= 1 && dy <= 1 && (dx != 0 || dy != 0);
    }


    public boolean isDiagonal(final Point p1, final Point p2)
    {
        final int dx = Math.abs(p1.x - p2.x);
        final int dy = Math.abs(p1.y - p2.y);
        if(dx * dy != 0)
            return false;
        else
            return dx <= 1 && dy <= 1 && (dx != 0 || dy != 0);
    }


    public Point[] getNeighbors(final Point pt)
    {
        final ArrayList<Point> neighbors = new ArrayList<Point>();
        for(int dx = -1; dx <= 1; dx++)
        {
            for(int dy = -1; dy <= 1; dy++)
            {
                if(dx == 0 && dy == 0)
                    continue;
                final Point temp = new Point(pt.x + dx, pt.y + dy);
                if(validTile(temp) && isAdjacent(pt, temp))
                    neighbors.add(temp);
            }
        }
        return neighbors.toArray(new Point[0]);
    }


    public double getCost(final Point p1, final Point p2)
    {
        if(!isAdjacent(p1, p2))
            throw new RuntimeException("Cannot get the cost of non-adjacent points");
        final double mult;
        if(moveType == MovementType.Euclidean && isDiagonal(p1, p2))
            mult = SQRT_2;
        else
            mult = 1.0;
        return mult * Math.exp(Math.abs(getTile(p1) - getTile(p2)));
    }
    
    public int getWidth()
    {
        return Width;
    }
    
    public int getHeight()
    {
        return Height;
    }
    

    public double findPath(final AIModule module)
    {
        if(chaotic)
            timer.scheduleAtFixedRate(task, 1000, 1000);
        final List<Point> ai_path = module.createPath(this);
        timer.cancel();
        return verifyPath(ai_path);
    }


    private double verifyPath(final List<Point> path)
    {
        // First, make sure that we haven't already checked a path.
        if(this.path != null)
            throw new IllegalStateException("Attempted to register a path after a path has already been registered.");

        // Next, confirm that the path is non-null and actually contains points.
        if(path == null || path.isEmpty())
        {
            throw new RuntimeException("Empty Path");
        }

        // Make sure that we start and end at the correct points.
        if(!path.get(0).equals(StartPoint) || !path.get(path.size() - 1).equals(EndPoint))
        {
            throw new RuntimeException("Invalid Path");
        }

        // Confirm that each step in the path moves between adjacent points.
        for(int index = 0; index < path.size() - 1; index++)
        {
            if(!isAdjacent(path.get(index), path.get(index + 1)))
            {
                throw new RuntimeException("Invalid Path");
            }
        }

        double PathCost = 0;

        for(int index = 0; index < path.size() - 1; index++)
        {
            PathCost += getCost(path.get(index), path.get(index + 1));
        }
        
        // Deep-copy the path in case we need to modify it.
        this.path = new ArrayList<Point>(path);

        return PathCost;
    }

    public int getNumVisited()
    {
        int numVisited = 0;

        for(int i = 0; i < Width; i++)
        {
            for(int j = 0; j < Height; j++)
            {
                if(Uncovered[i][j] != 0)
                {
                    numVisited++;
                }
            }
        }
        return numVisited;
    }


    public BufferedImage createImage()
    {
        // Confirm that the path is valid.
        if(path == null)
        {
            throw new IllegalStateException("Attempted to create map image, but path isn't set.");
        }
        
        // Create a new image to hold the map.
        final BufferedImage im = new BufferedImage(Width, Height, BufferedImage.TYPE_INT_RGB);
        final WritableRaster raster = im.getRaster();
        final int[] pixels = new int[Width * Height * 3];
        for(int x = 0; x < Width; x++)
        {
            for(int y = 0; y < Height; y++)
            {
                final int offset = (y * Width + x) * 3;
                final int val = Board[x][y] & 0xFF;
                
                if(Uncovered[x][y] != 0)
                {
                    pixels[offset] = 0xFF;
                }
                else
                {
                    pixels[offset] = val;
                }
                
                pixels[offset + 1] = pixels[offset + 2] = val;
            }
        }
        
        raster.setPixels(0, 0, Width, Height, pixels);

        // Next, render the path in blue.
        for(final Point pt : path)
        {
            im.setRGB(pt.x, pt.y, Color.BLUE.getRGB());
        }
        
        // Finally, make the endpoints green.
        im.setRGB(StartPoint.x, StartPoint.y, Color.GREEN.getRGB());
        im.setRGB(EndPoint.x, EndPoint.y, Color.GREEN.getRGB());

        return im;
    }


    public BufferedImage createContourImage()
    {
        // Confirm that the path is valid.
        if(path == null)
        {
            throw new IllegalStateException("Attempted to create map image, but path isn't set.");
        }

        // Create a new image to hold the map.
        final BufferedImage im = new BufferedImage(Width, Height, BufferedImage.TYPE_INT_RGB);
        final WritableRaster raster = im.getRaster();
        final int[] pixels = new int[Width * Height * 3];
        for(int x = 0; x < Width; x++)
        {
            for(int y = 0; y < Height; y++)
            {
                final int offset = (y * Width + x) * 3;
                pixels[offset] = (int)(0.5 + 0xFF * Uncovered[x][y] * 1.0 / uncoveredCounter);
                pixels[offset + 1] = pixels[offset + 2] = 0;
            }
        }
        raster.setPixels(0, 0, Width, Height, pixels);
        return im;
    }

    private BufferedImage toBufferedImage()
    {
        final BufferedImage im = new BufferedImage(Width, Height, BufferedImage.TYPE_BYTE_GRAY);
        final WritableRaster raster = im.getRaster();
        final int[] pixels = new int[Width * Height];
        for(int x = 0; x < Width; x++)
        {
            for(int y = 0; y < Height; y++)
            {
                pixels[y * Width + x] = Board[x][y];
            }
        }
        raster.setPixels(0, 0, Width, Height, pixels);
        return im;
    }

    private void toBoard(final BufferedImage im)
    {
        if(im.getType() != BufferedImage.TYPE_BYTE_GRAY || im.getWidth() != Width || im.getHeight() != Height)
            throw new RuntimeException("Something very bad has happened");
        final WritableRaster raster = im.getRaster();
        final int[] pixels = raster.getPixels(0, 0, Width, Height, new int[Width * Height]);
        for(int x = 0; x < Width; x++)
        {
            for(int y = 0; y < Height; y++)
            {
                Board[x][y] = (byte)pixels[y * Width + x];
            }
        }
    }

    private void runChaos()
    {
        final float f = -0.001f;
        final Kernel kernel = new Kernel(3, 3,
        new float[] {
            f, f, f,
            f, 1.008f, f,
            f, f, f});
        down();
        toBoard(new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null).filter(toBufferedImage(), null));
        up();
    }

    private void down()
    {
        try
        {
            sem.acquire();
        }
        catch(InterruptedException ex)
        {
            throw new RuntimeException("down function was interupted");
        }
    }

    private void up()
    {
        sem.release();
    }
}

---