/*                CSC 16 Lab 3 : Random map generation with 2D arrays                    
                                                                         
                        Due Tuesday 9/27 (please observe due date)

   The week's lab will introduce you to the use of multi-dimensional arrays.             
A 2D array of doubles, for example, is created as follows:                               
                                                                                         
  double[][] A;                                                                          
  A = new double[4][5];                                                                  
                                                                                         
  The array consists of 4 rows and 5 columns.  Arrays in Java (as well as C++)           
  are stored "row-major" order, which means that the row number or y-coordinate         
  comes before the column number or x-coordinate.  Please visualize the coordinates      
  in the correct orientation.                                                            
                                                                                         
  An array variable such as A above is a pointer to a structure stored on the heap.      
                                                                                         
  One can also think of a 2D array as a one-dimensional array with elements that         
are also (pointers to) one-dimensional arrays.  It is perfectly valid to treat           
a 2D array this way.  For example, the expression A.length will return 4, the            
length of the "outer" array.  A[0].length will give 5, which is the length of the        
"inner" array.                                                          
                                                                                         
Operations on 2D arrays usually will involve a nested loop, which enumerates through     
each coordinate of the array.  The following code sets the value of every element of     
an array to 1:                                                                           
                                                                                         
int rows = A.length;                                                                     
int cols = A[0].length;                                                                  
for(int i=0;i<rows;i++)                                                                  
  for(int j=0;j<cols;j++)                                                                
    { A[i][j] = 1; }                                                                     
                                                                                         
                                                                                         
For this assignment we will use a 2D array of integers to represent a
map.  One finds such maps in many computer games.  Although the game
maps may look fancier, the basic technique is the same.  Each cell on
the map represents a type of terrain:
                                                                                         
     0 = desert                                                                          
     1 = water                                                                           
     2 = forest                                                                          

We want different types of terrain on the map.  One can try the following:

   for(int i=0;i<rows;i++)                                                             
     for(int j=0;j<cols;j++)
       {
          double r = Math.random();  // r is a number between 0 and 0.999999...
	  if (r<0.33) map[i][j] = desert;
	  else if (r<0.66) map[i][j] = water;
	  else map[i][j] = forest;
       }

Such a simple loop would "work" but we're not going to get a very interesting map.
We want a map with patches of water and patches of forest.  That is, the different
types of terrain should be bunched together.  The solution to this is to
"grow" the map gradually.  Let's first consider how to add water patches (lakes) to 
the map, which is initially set to all desert:

First, start with a very low probability, say 0.005 (1/2 percent).
Going through the map array once, each cell will only have a very
small chance of becomming water.

We then apply the following algorithm for several successive "generations":

For each cell map[i][j], look at all the cells that surrounds it:
up: map[i-1][j], down: map[i+1][j], left: map[i][j-1], and right: map[i][j+1].

For every one of these neighboring cells that also has value water, you increase
the probability that map[i][j] is also going to be water.  If all four surrounding cells
are water cells, then the probability that map[i][j] will be water should be very high.
If we apply this algorithm for several generations (your program will consist of 
triple-nested loops), the water cells will grow into large patches.

You will need to experiment with how many generations to run, and what the exact 
probability values are.

MOST IMPORTANTLY, you must be careful of the boundary conditions.  Not all cells have
four neighbors.  You cannot examine map[i-1][j] without first checking that i>0.  
Similarly, you cannot refer to map[i+1][j] without first checking that i<rows-1.  
If you do not think about the boundary cells carefully, your program will crash with
an "ArrayIndexOutOfBounds" exception.

After generating patches of water, generate patches of forest.  You may experiment
with different approaches.  For example, you may want the forests to be close to water.

I've written the following skeleton program so you can give your map a graphical 
representation.  The map array is declared inside the class (and created inside the
constructor) so dont' re-declare it.  The function drawmap will draw the map onto the
screen.  You only need to modify the "genmap" function.  Currently, it generates a
wildly random map using the naive approach I first described. You need to replace the
code with your own algorithm.  You may also want to add additional parameters to 
the class or the genmap function. For example, the same genmap function should be
usable for generating both water and forest patches.  This can be achieved by adding
additional parameters to genmap.
*/

import java.awt.*;
import java.awt.Graphics;
import javax.swing.*;

public class randommap extends JFrame
{
    public int[][] map;      // array representing map
    public int rows;   // number of rows in array
    public int cols;   // number of columns in array
    public int size = 10;  // size of graphical representation
    public static final int DESERT = 0;
    public static final int WATER = 1;
    public static final int FOREST = 2;
    // colors that corresponds to array type:
    public static Color[] colorof = {Color.yellow,Color.blue,Color.green};
    private Graphics display;  // drawing object

    public static void main(String[] args)
    {
	randommap w = new randommap(70,100);
	w.genmap();
    } // main

    public randommap(int r, int c) // takes arguments size of map
    {   rows = r; cols = c;
    map = new int[rows][cols];  // creates array
    int XDIM = cols*size;  int YDIM = rows*size;
    setBounds(0,0,XDIM,YDIM+size);
    setVisible(true); 
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	display = this.getGraphics();
	try{Thread.sleep(500);} catch(Exception e) {} // Synch with system
	for(int i=0;i<r;i++) for(int j=0;j<c;j++) map[i][j] = DESERT;
	// draw static background as a yellow rectangle
	display.setColor(Color.yellow);
	display.fillRect(0,0,XDIM,YDIM+40);
    }  // constructor

    public void drawmap()
    {
	for(int i=0;i<rows;i++)
	        for(int j=0;j<cols;j++)
		    {
   		        display.setColor(colorof[map[i][j]]);
		        display.fillRect(j*size,i*size+size,size,size);
		    }
	try{Thread.sleep(50);} catch(Exception e) {}  // animation delay
    } //drawmap

    /* ******************************************************** */
    public void genmap()  // replace code here with your own:
    {   int i, j;  // array coords
        double r;  // random number
        for(i=0;i<rows;i++)
          for(j=0;j<cols;j++)
	      {
		  r = Math.random();  // r is a number between 0 and 0.999999...
                  if (r<0.33) map[i][j] = DESERT;
                  else if (r<0.66) map[i][j] = WATER;
                  else map[i][j] = FOREST;
	      } // nested for loop
        drawmap();  // displays map on screen
    } //genmap

}  // randommap