Driver.java creates an instance of the ScapeG class.

import javax.swing.JFrame;
import java.io.*;
public class Driver
{
   public static void main(String[] args)
   {
      JFrame frame = new JFrame("Andy Menke's Sugarscape v0.2");
      frame.setSize(800, 800);
      frame.setLocation(0, 0);
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      try
      {
      	frame.setContentPane(new ScapeG(new Scape(50, 50, "DefaultScape.txt")));
      }
      catch(IOException e)
      {
      	System.err.println("Caught IOException: " + e.getMessage());
      }
      frame.setVisible(true);
   }
}
   
ScapeG.java controls all of the graphical aspects of my program. It contains an instance of the Scape class, which actually processes everything.

import java.util.ArrayList;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;

//cell: 20 x 20

public class ScapeG extends JPanel
{
	private Scape myScape;
	private BufferedImage myImage;
	private Graphics myBuffer;
	private Timer t;
	
	public ScapeG(Scape s)
	{
		myScape = s;
		try
		{
			myScape.addAgent(new Agent(myScape,8,8,0, new Location(7, 0, myScape)));
		}
		catch(Exception e)
		{
			System.err.println("Caught Exception: " + e.getMessage());
		}
		myImage =  new BufferedImage(800, 800, BufferedImage.TYPE_INT_RGB);
		myBuffer = myImage.getGraphics();
      myBuffer.setColor(Color.white);
      myBuffer.fillRect(0, 0, 800, 800);
      t = new Timer(100, new TimeListener());
      t.start();
	}
	
	public void paintComponent(Graphics g)
   {
      g.drawImage(myImage, 0, 0, getWidth(), getHeight(), null);
   }
   
   public void clearBuffer()
   {
      myBuffer.setColor(Color.white);
      myBuffer.fillRect(0, 0, 800, 800);
   }
   
   public void display(Scape s) //This method actually displays what is going on in the Scape program.
   {
   	Location[][] locs = s.getLocs();
   	ArrayList agents = s.getAgents();
   	myBuffer.setColor(Color.yellow);
   	for(int i=0; i<locs.length; i++)
   	{
   		for(int j=0; j<locs[0].length; j++)
   		{
   			Location l = locs[i][j];
   			myBuffer.fillOval(16*j+8-l.getSugar()*2, 16*i+8-l.getSugar()*2, l.getSugar()*4, l.getSugar()*4);
   		}
   	}
   	myBuffer.setColor(Color.red);
   	for(int k=0; k<agents.size(); k++)
   	{
   		Agent a = (Agent)agents.get(k);
   		Location l = a.getLoc();
   		myBuffer.fillOval(16*l.getX(), 16*l.getY(), 16, 16);
   	}
   }
   
   private class TimeListener implements ActionListener
   {
   	public void actionPerformed(ActionEvent e) //Note: this method is called every time the timer ticks.
   	{
   		clearBuffer();
   		
   		/*myBuffer.setColor(Color.red);
   		for(int y=1; y<50; y++)
   		{
   			//myBuffer.drawLine(20*y, 0, 20*y, 800);
   			//myBuffer.drawLine(0, 20*y, 800, 20*y);
   			myBuffer.fillRect(20*y, 0, 2, 1000);
   			myBuffer.fillRect(0, 20*y, 1000, 2);
         }*/
         
         myScape.update();
         //myBuffer.setColor(Color.yellow);
         display(myScape);
         
         repaint();
   	}
   }
}

Scape.java contains a two-dimensional array of Locations and an array of Agents. This class contains all of the methods that do the actual work of keeping updating the scape.

import java.io.*;
import java.util.*;
import java.lang.*;

public class Scape
{
	int sizeX;
	int sizeY;
	ArrayList agents;
	Location[][] locs;
	String myFile;
	
	
	public Scape(int y, int x, String f) throws IOException
	{
		sizeX = x;
		sizeY = y;
		locs=new Location[sizeY][sizeX];
		agents=new ArrayList();
		
		BufferedReader br = new BufferedReader(new FileReader("DefaultScape.txt"));
		for(int j=0; j<sizeY; j++)
		{
			String tmp = br.readLine();
			String[] foo = tmp.split(" ");
			for(int i=0; i<sizeX; i++)
			{
				locs[j][i]=new Location(j, i, this, Integer.parseInt(foo[i]));
			}
		}
		br.close();
	}
	
	public Location[][] getLocs()
	{
		return locs;
	}
	
	public ArrayList getAgents()
	{
		return agents;
	}
	
	public Location getLocation(int y, int x)
	{
		/*if(y>=0 && y<sizeY && x>=0 && x<sizeX)
		{
			return locs[y][x];
		}
		else
		{
			return null;
		}*/
		
		return locs[(y+sizeY) % sizeY][(x+sizeX) % sizeX];
	}
	
	public void addAgent(Agent a)
	{
		agents.add(a);
	}
	
	public void update() //This method is the most important; it updates each of the locations and each agent.
	{
		for(int i=0; i<sizeY; i++)
		{
			for(int j=0; j<sizeX; j++)
			{
				locs[j][i].G(1);
			}
		}
		for(int k=0; k<agents.size(); k++)
		{
			Agent a = (Agent)agents.get(k);
			boolean d = a.rule();
			if(d)
			{
				agents.remove(a);
			}
		}
	}		
}

Location.java is the class that represents a single grid point in the scape, with an associated amount of sugar.

import java.lang.*;

public class Location
{
	int myX;
	int myY;
	int mySugar; //0-4, for now
	int maxSugar;
	Scape myScape;
	
	public Location(int y, int x, Scape sc)
	{
		myX=x;
		myY=y;
		myScape=sc;
	}
	
	public Location(int y, int x, Scape sc, int s)
	{
		myX=x;
		myY=y;
		myScape=sc;
		maxSugar=s;
		mySugar=s;
		//myAgent=a;
	}
	
	public int getX()
	{
		return myX;
	}
	
	public int getY()
	{
		return myY;
	}
	
	public int getSugar()
	{
		return mySugar;
	}
	
	public int takeSugar()
	{
		int tmp=mySugar;
		mySugar=0;
		return tmp;
	}
	
	public void G(int a) //This method increments the amount of sugar at a location by a until it is at the maximum.
	{
		mySugar=Math.min(mySugar+a, maxSugar);
	}
}

Agent.java represents an agent.

import java.lang.Math;
import java.util.*;

public class Agent
{
	Scape myScape;
	int myVision; //1-6
	int myMetabolism; //1-4
	int mySugar;
	Location myLoc; //must be in scape
	
	public Agent(Scape sc, int v, int m, int s, Location l) throws Exception
	{
		myScape=sc;
		if (v>=1 && v<=6 && m>=1 && m<=4)
		{
			myVision=v;
			myMetabolism=m;
		}
		else
		{
			throw new Exception("Invalid vision or metabolism");
			System.exit(1);
		}
		myLoc=l;
		mySugar=s;
	}
	
	public Agent(Scape sc, Location l)
	{
		myScape=sc;
		myLoc=l;
		myVision=(int)(Math.random()*6)+1;
		myMetabolism=(int)(Math.random()*4)+1;
		mySugar=20;
	}
	
	public Location getLoc()
	{
		return myLoc;
	}
	
	private void eat()
	{
		mySugar=mySugar-myMetabolism;
	}
	
	private void collect()
	{
		mySugar+=myLoc.takeSugar();
	}
	
	public boolean rule() //general strategy
	{
		this.M();
		this.collect();
		this.eat();
		return mySugar <= 0;
	}
	
	//movement rules
	
	public void M() //Agent finds nearest location with maximal amount of sugar, then moves there.
	{
		int max=-1;
		Location maxLoc = myLoc;
		Location pos=myLoc;
		int[] dirs = {0,1,2,3};
		dirs=randomize(dirs);
		for(int k=0; k<=myVision; k++)
		{
			for(int n=0; n<4; n++)
			{
				Location tmp=checkDir(k,dirs[n]);
				if(tmp != null && tmp.getSugar()>max)
				{
					max=tmp.getSugar();
					maxLoc=tmp;
				}
			}
		}
		myLoc=maxLoc;
	}
	
	//end movement rules
	
	private Location checkDir(int dist, int dir) // This gets the location a given distance away in a given direction.
	{
		int x=myLoc.getX();
		int y=myLoc.getY();
		switch(dir)
		{
			case 1: y-=dist; break;
			case 2: x+=dist; break;
			case 3: y+=dist; break;
			case 4: x-=dist; break;
			default: break;
		}
		return myScape.getLocation(y,x);
	}
	
	private int[] randomize(int[] a) //This method randomizes the order of an array. For an agent, this will randomize the order of directions that he 												//checks.
	{
		int[] ret = new int[a.length];
		ArrayList tmp = new ArrayList();
		for(int k=0; k<a.length; k++)
		{
			tmp.add(new Integer(a[k]));
		}
		Random r = new Random();
		for(int m=a.length; m>0; m--)
		{
			int val=r.nextInt(m);
			Integer i=(Integer)tmp.get(val);
			tmp.remove(val);
			ret[a.length-m]=i.intValue();
		}
		//print(ret);
		return ret;
	}
	
	private void print(int[] a) //For debugging.
	{
		for(int k=0; k<a.length; k++)
		{
			System.out.print(a[k]+" ");
		}
		System.out.println();
	}
}