Main.java

Go to the documentation of this file.

import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.*;
import javax.swing.*;


public class Main
{
    public static void helpPrinter()
    {
        System.out.println("  Command Line Parameters are as follows:");
        System.out.println("    \"--help\" : You're looking at it");
        System.out.println("    \"-w [int]\" : Set the width of the terrain map");
        System.out.println("      Example: -w 500");
        System.out.println("    \"-h [int]\" : Set the height of the terrain map");
        System.out.println("      Example: -h 500");
        System.out.println("    \"-seed [int]\" : Set the seed value for generating the terrain map");
        System.out.println("      Example: -seed 3");
        System.out.println("    \"-roughness [0-7]\" : Set the roughness of the terrain map");
        System.out.println("      Example: -roughness 4");
        System.out.println("    \"-movement [cem]\" : Set the type of movement [c: Chess, e: Euclidean, m: Manhattan]");
        System.out.println("      Example: -movement c");
        System.out.println("    \"-contour\" : Displays the order of revealed nodes");
        System.out.println("    \"-chaotic\" : Slightly corrupts the terrain every one second");
        System.out.println("    \"-load [filename]\" : Loads up the given file to use as the terrain map");
        System.out.println("      Example: -load MTAFT.XYZ");
        System.out.println("    All other arguments are algorithms to be run on the generated map");
        System.out.println("Note: Later command-line options override earlier ones if they are incompatable\n");
        System.out.println("Example: java Main -w 500 -h 500 DijkstraAI AstarAI");
    }


    public static void createDisplayWindow(final BufferedImage im, final String title)
    {
        // Set up a frame and a panel that paints this image.
        final JFrame frame = new JFrame("Path Finder: " + title);
        final JPanel panel = new JPanel()
        {
            @Override
            public void paintComponent(final Graphics g)
            {
                super.paintComponent(g);
                g.drawImage(im, 0, 0, getWidth(), getHeight(), null);
            }
        };
        
        panel.setPreferredSize(new Dimension(im.getWidth(), im.getHeight()));
        frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        frame.add(panel);
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args)
    {        
        ArrayList<AIModule> aiList = new ArrayList();
        TerrainGenerator terraGen = null;
        boolean flexible = true;
        boolean showContour = false;
        boolean chaotic = false;
        int width = 500;
        int height = 500;
        int roughness = 3;
        long seed = System.currentTimeMillis();
        TerrainMap.MovementType moveType = TerrainMap.MovementType.Chess;

        // Parse through the command line arguements
        int i = 0;
        try
        {
            while(i < args.length)
            {
                // Width switch.
                if(args[i].equalsIgnoreCase("-w"))
                {
                    if(!flexible)
                        continue;
                    
                    width = Integer.parseInt(args[i + 1]);
                    if(width <= 0)
                    {
                        throw new IllegalArgumentException("Widths must be nonnegative.");
                    }
                }
                // Height switch
                else if(args[i].equalsIgnoreCase("-h"))
                {
                    if(!flexible)
                        continue;
                    
                    height = Integer.parseInt(args[i + 1]);
                    if(width <= 0)
                    {
                        throw new IllegalArgumentException("Heights must be nonnegative.");
                    }
                }
                // Random seed switch
                else if(args[i].equalsIgnoreCase("-seed"))
                {
                    seed = Integer.parseInt(args[i + 1]);
                }
                // Roughness switch.
                else if(args[i].equalsIgnoreCase("-roughness"))
                {
                    roughness = Integer.parseInt(args[i + 1]);
                    if(roughness < 0 || roughness >= 8)
                        throw new IllegalArgumentException("Roughness must be between 0 and 7.");
                }
                // Movement switch.
                else if(args[i].equalsIgnoreCase("-movement"))
                {
                    switch(args[i + 1].charAt(0))
                    {
                        case 'c': moveType = TerrainMap.MovementType.Chess; break;
                        case 'e': moveType = TerrainMap.MovementType.Euclidean; break;
                        case 'm': moveType = TerrainMap.MovementType.Manhattan; break;
                        default: throw new IllegalArgumentException("Unrecognized movement type.");
                    }
                }
                // Contour switch.
                else if(args[i].equalsIgnoreCase("-contour"))
                {
                    showContour = true;
                    i--;
                }
                // Chaos switch.
                else if(args[i].equalsIgnoreCase("-chaotic"))
                {
                    chaotic = true;
                    i--;
                }
                // Load a file
                else if(args[i].equalsIgnoreCase("-load"))
                {
                    String filename = args[i + 1];
                    terraGen = new TerrainFileLoader(filename);
                    byte[][] terrain = terraGen.getTerrain();
                    width = terrain.length;
                    height = terrain[0].length;
                    flexible = false;
                }
                // Help switch
                else if(args[i].equalsIgnoreCase("--help"))
                {
                    helpPrinter();
                    System.exit(0);
                }
                // If none of these, then we should treat it as a class to load.
                else
                {
                    aiList.add((AIModule) Class.forName(args[i]).newInstance());
                    i--;
                }
                i += 2;
            }
        }
        catch(ClassNotFoundException cnf)
        {
            System.err.println("AI Not Found: " + args[i]);
            System.exit(1);
        }
        catch(IndexOutOfBoundsException ioob)
        {
            System.err.println("Invalid Arguements: " + args[i]);
            System.exit(2);
        }
        catch(NumberFormatException e)
        {
            System.err.println("Invalid Integer: " + args[i]);
            System.exit(3);
        }
        catch(Exception e)
        {
            System.err.println("Unknown Error");
            System.exit(4);
        }
        
        if(terraGen == null)
        {
            terraGen = new PerlinTerrainGenerator(width, height, roughness, seed);
        }

        // For each module we've loaded, create a new map and run the appropriate
        // AI module on that map.
        for(AIModule ai : aiList)
        {
            final TerrainMap map = new TerrainMap(width, height, terraGen, moveType, chaotic);
            final long startTime = System.currentTimeMillis();
            final double cost = map.findPath(ai);
            final long endTime = System.currentTimeMillis();

            System.out.println(ai.getClass().getName());
            System.out.println("Path Cost:  " + cost);
            System.out.println("Uncovered:  " + map.getNumVisited());
            System.out.println("Time taken: " + (endTime - startTime) + "\n");

            createDisplayWindow(map.createImage(), ai.getClass().getName());
            if(showContour)
                createDisplayWindow(map.createContourImage(), ai.getClass().getName());
        }
    }
}

---