Andrew Lovett
NOTE: If you can have any questions, complaints, or glaring errors to point out, please contact me at MisterDrgn@aol.com or contact Louis Gross at gross@tiem.utk.edu.

2d Feeding Optimization
1. Abstract - The purpose of the program
2. Overview - A short description of what the program does
3. Getting Started - Instructions for compiling and running the program
4. Graphic Interface - Instructions for running in graphical mode
5. Optimization - Instructions for running in optimization mode
6. Environmental Constants - Instructions for modifying environmental constants
7. Animals - A description of animal behavior and instructions for modifying animal stats
8. 2d Space - A description of the 2d space in which the animals live


1. Abstract

	The objective of this program is to investigate basic issues of spatial optimization in which there is an overall control that determines certain aspects of the environment in different spatial regions.  We view this as a first step towards a general program structure for spatial optimization of agent-based models.  This has potential applications to problems such as intercropping (in which different agricultural crops are planted in a spatial pattern which reduces the impact of pests or pathogens), biological reserve design (in which a limited amount of funds can be expended to purchase property in different spatial locations so as to best preserve some components of the natural system), and forest management (in which different efforts to control pests, fires, etc. can be applied in a spatially-explicit manner to increase yields or a mixture of yield and other criteria). 
	This first program is designed to investigate only a limited range of potential spatial controls.  The underlying agent-based model consists of relatively simple population dynamics for several agents, with spatial variation in underlying resources both initially and dynamically applied.  The optimization scheme merely scans through a variety of fixed strategies for spatial resource allocation to determine which provides the highest values for certain statistics arising from the simulations.  Since the simulations are stochastic, many possible optimization criteria are possible even for a single measure of the outcomes.  We focus on means - that is we consider the average across several simulations of the variable of concern and determine the strategy that maximizes this mean.  However, the program also allows for some comparisons of the distribution of responses through time by considering viability (the time during the simulation for which the population stays above some minimum viable level). 


2. Overview

	This program simulates the activities of several animals in a 2-dimensional space.  The animals' activities are limited to moving within the space, consuming food, giving birth, and dying.  This is all handled in a relatively simple manner.  Each time step, each animal will either move to an adjacent space or stay in its present space; then, it will eat one unit of food if food is available; then it will age; at this point, assuming it is the appropriate age, there may be a chance of its giving birth or dying; it also will die if it is out of energy.  This is the extent of each animal's "turn."  The state of an animal, in addition to its species, includes its current energy level, location on the grid, and age.  The species vary mainly in the manner in which they determine whether and where to move and in various stats, such as maximum energy, which can be set through an external file.
	Although, as far as the animals are concerned, they are moving only within one large region, this region is actually split into smaller foodspace regions.  These foodspaces are significant because in this simple world, food is not grown; instead, it is dumped into the foodspaces.  Each time food is dumped, it is distributed randomly throughout a foodspace, but the program is able to determine how much food it wishes to dump into each of the foodspaces.  The optimization part of the program assists a user in discovering which strategy for dumping food into the foodspace regions creates the optimal outcome.  These strategies are limited in that they can only dump so much food; the maximum amount of food that can be dumped is a value which depends upon the frequency with which food is.  The maximum amount also varies with the seasons.  Thus any single strategy consists of a set of rules for determining the amount of food to allocate to each foodspace.  Each strategy has seasonal variation included by default.  There are a total of eight strategies included in this model version, some of which vary through time depending upon the current amounts of food in the various foodspaces.  There is no dependence upon the pattern of food within any single foodspace. 
	This program runs in two modes.  The graphical mode uses typical swarm graphics.  A user can run a single simulation in this mode and watch the development of the various species on the display.  Two graphs also aid in assessing the success of the simulation.  Various windows display other useful information about the simulation and enable the user to control factors such as which displays are being updated and which food dump method is being used.  While this mode is extremely useful for trying out a new environmental situation, it is too slow if the user wishes to compare several different food dump methods.
	The optimization mode runs through the simulation several times using several different food dump methods and then outputs useful information about the different dump methods to a text file.  The user can use a separate input file to tell the program how many times to run the simulation, which food dump method to use each time, and how long to make each simulation.  Simulations must be run for a relatively long amount of time (200+ time steps for the default parameters) before they reach equilibrium. If equilibrium is not reached, the methods will be comparing cases with different transient responses; one should not expect consistent results in this case.  Note as well that our use of the term "equilibrium" here is only in an average sense.  Since the simulations are stochastic, we really mean that there is a transient period before a stationary distribution for the process appears to be reached.  Quick-and-dirty simulations can be run for shorter amounts of time, if necessary.



3. Getting Started

	First of all, you must have some kind of Java compiler and Java runtime environment, both of which must be compatible with swarm (you must also have swarm 2.1.1).  We suggest using the software that comes with your swarm package.
Now, let's make sure you have all the necessary files (NOTE: You don't really have to check for all these right now, they're merely listed here so that, should the program not work, you can check to see whether anything is missing).  The main program folder should contain the following files:
Makefile		-- Tells the compiler which Java files to compile
Master.java		-- Runs the entire program
Overlord.java		-- Runs the graphical mode
Optimizer.java		-- Runs the optimizer mode
Middleman.java		-- Runs individual simulations within the graphical mode
Info.java		-- Describes an object which holds information on the results of a simulation run
SimulationState.java	-- Describes an object which holds information on the state of a simulation
Landscape.java		-- Sets up and activates the individual agents and the 2d world
Space2d.java		-- Defines the 2d world and its relationship to foodspace regions
Foodspace.java		-- Defines a region into which food can be dumped
Animal.java		-- Defines most of the behavior for all animals
Cow.java		-- Defines cow behavior
Koala.java		-- Defines koala behavior
Horse.java		-- Defines horse behavior
Monkey.java		-- Defines monkey behavior
Human.java		-- Defines human behavior
	This folder should also contain the subfolder Data, which must contain the following text files:
SimulationData.txt	-- Parameters for optimization
EnvironmentalData.txt	-- Environmental constants
CowData.txt		-- Cow stats
KoalaData.txt		-- Koala stats
HorseData.txt		-- Horse stats
MonkeyData.txt		-- Monkey stats
HumanData.txt		-- Human stats

	Provided you have all the Java files and all the data files, you should be able to get started.  Compile the Java by entering the main folder with a console and typing "make".  Then, run the program by typing "javaswarm Master --varyseed" (NOTE: javaswarm is the command you use if you are using the runtime environment provided with swarm; otherwise, use whatever command your RTE requires - Sun's Java RTE uses the command "javac").  Include "--varyseed" only if you wish to randomize the program, ie keep the random functions from producing the same values each time it runs.  When presented with your options, enter 1 to run the program in graphical mode (just bring all the windows into view and then hit Start on the control panel) or 2 to run the program in optimization mode (you don't need to do anything else for optimization mode, but you may want to read the Optimization section of this file before doing this, so you can make sure you understand the length of time this may take to complete the entire optimization).


4. Graphic Interface

	The purpose of the graphical mode is to show the user exactly how changes in various environmental or agent-related factors affect the simulation.  It is created to convey as much information as possible in as many ways as possible.  To run in graphics mode, simply run Master and choose option 1.  You should be immediately presented with several windows (we suggest spreading the windows out over your monitor so that you can see all of them, but keep in mind that there is a chance you will do something that will cause a message to appear on your console, so don't cover it up entirely).

Basic Swarm GUI Information (You can skip this if you are already familiar with the Swarm GUI)
	First of all, the most important window is your control panel; this is the window with the Start button at its top and the Quit button at its bottom.  This is your master control.  You can press Start at any time to begin or continue the simulation.  You can press Stop to pause the simulation.  Once the simulation is paused, you can press Next to move forward one time step.  Finally, you can press Quit to end the simulation.  DO NOT press Save, as this program is not set up for archiving, and this may cause problems the next time you try to run the simulation (if you do hit Save and you are having problems, you just need to delete the file .swarmArchiver by entering "rm ~/.swarmArchiver" in the console). This graphical mode is created to aid you in understanding patterns of response during the simulation, and thus no results are saved to any files. 
	In addition to the control panel, you have two graphs that are pretty much self-explanatory, a display that shows you the movement of the animals, and two probe windows that convey information about the progress of the simulation.  Both probe windows also contain buttons.  To use a button, enter a value in any fields to the right of the button and click on the button.  Some kind of output corresponding to the value you entered should appear in the field to the left of the button.  If there is a problem with the value you entered, an error message may appear on the console.
	The user can right-click on one of the animals in the display to receive probe information on that individual animal.  You have to click at just the right place on the animal to open the probe, so, needless to say, this is much easier to do if you pause the simulation first.

The Display
	The display, which will be fairly small if you are using the default 4 foodspace regions, shows all animals currently living in the 2d space and shows the amount of food currently found in each space on the grid.  All of this is color-coordinated.  Empty spaces are white.  Space with 1 unit of food are red.  Spaces with more than 1 unit of food are various shades of green; the greater the amount of food, the lighter the shade.  The following are the colors for the animals, provided those colors have not been changed in the animal data files:
Cow:		Grey
Koala: 		Blue
Horse:		Violet
Monkey:		Yellow
Human:		Orange

The SimulationState Probe Display
	The SimulationState probe display reports the time (number of time steps which have elapsed since the simulation began), the season (first letter of the season name, summer is "U"), the number of animals currently living, the number of animals of each species currently living, the total number of births since the simulation began, the total number of deaths since the simulation began, the total amount of food currently found in all foodspace regions, the total number of deaths from starvation since the simulation began, and the total number of deaths from old age since the simulation began.
	This probe display also has three buttons which allow the user to determine what information is updated each time step as a simulation progresses.  The user can turn off a graph or the display by entering a 0 to the right of the appropriate button and clicking the button.  The user can turn it back on by entering a 1 by the button and clicking the button again.  If a graph is turned off in the middle of a simulation and then turned back on later, the graph will fill in information for the elapsed time by simply drawing a straight line between the old value and the new value.

The Space2d Probe Display
	The Space2d probe display reports information on the individual foodspace regions, regions within the 2d grid which are not visible to the animals and which may not be visible to the user when looking at the display, but which affect where food is placed in the grid.  The probe display will tell you how much food is currently in each region and how many animals have died so far in each region.  It also reports the season length and the time interval between each food dump.
	The buttons in this probe display give the user control over the manner in which food is dumped into the regions.  The middle button lets the user choose which of the eight dump methods will be used; the default is method 3.  The first button lets the user set the amount of food to be dumped in each region, assuming dump method 1 has been chosen.  It is important to do this, as the default amount of food to be dumped in each region for method 1 is zero.  The user does this by entering the amount of food to be dumped in the first field to the right of the button, entering the region into which that amount will be dumped in the second field, and clicking on the button.  If the amount of food the user has entered for a region, added to the amount of food the user has entered so far for other regions, is more than the maximum amount of food that can be dumped, an error message will appear on the console and the region will not be assigned the food.  The final button allows the user to find out about each food dump method; the user simply needs to enter a number for one of the food dump methods in the field to the right of the button and click on the button, and a brief description of that food dump method will appear in the console.


5. Optimization

	Optimization of food dumping methods, the final goal of this program, is set up to make things very easy for the user.  This optimization works by running the simulation many times using several different methods for dumping food into the foodspace regions and then reporting information that allows the user to compare the food dump methods.  The user need only enter a little information into a text file, get the program started, and sit back while it works.

The Input File:
	The file SimulationData.txt should be found in the Data folder.  This file allows the user to set up the parameters for the optimization run.  The first numbers in this text file, those found after "Simulation Runs" but before "Simulation Size," refer to the number of times each food dump method will be attempted, ie the number of times the simulation will be run using a given food dump method.  The first number refers to the first food dump method, the second number refers to the second, etc.  If the user does not wish to use, say, the fourth food dump method, the user need only enter the number 0 on the fourth line.  Note that the number of times the simulation is run with a given food dump method will affect only the accuracy of the results, not the magnitude, as all results for a given food dump method are averaged over the number of simulations chosen.  This means that you can compare food dump methods 1 and 2 by running 1 twice and running 2 five times, should you desire; just keep in mind that if you want to be sure of your results for a food dump method, you should run the simulation with that method several times.  For information on what each dump method does, check the file FoodDumpInfo.txt in the Info folder.
	The number following "Simulation Size" refers to the number of time steps each simulation will take.  If you wish to have a good idea of what final situation a food dump method will create, this number should be at least fairly large.  Often the program does not reach equilibrium till nearly 200 time steps into a simulation for the default parameter set - other parameter sets may require longer simulation time periods to reach equilibrium. The user is urged to run the program in graphical mode first to determine the time to reach approximate equilibrium.  However, if the simulation size is set to a value much greater than 200, the program may take an extremely long amount of time to run.  When deciding how much time one is willing to wait for a program to run, it is important to consider both the simulation size and the number of times the simulation will be run; it may not take the program too much time to run through a simulation of size 350 once or twice, but if the program is going to run the simulation 10 times for each dump method, this could take hours.  Check the file OptimizationRunTimes.txt in the Info folder to get an idea of how much time optimizations should take.  Also, keep in mind that a great deal of the time spent in a simulation is used up in looking for moves, so shortening the monkeys' and humans' sight can greatly decrease run times.
	The information that is to be displayed in an output file after an optimization has run will be discussed later in this text.  This information is not based on measurements taken throughout a simulation's run; the nature of the various species' situations may be quite different before a system reaches equilibrium, so any measurements taken too early in the simulation would only throw off the final data.  Therefore, the user should set the next number, which determines at what time the program begins taking measurements, to a time fairly close to the end of the simulation's run and, ideally, a time after the simulation has reached equilibrium.  A time 40-80 time steps before the entire simulation ends is suggested based upon our experience with the default parameter set.
	Finally, the viability level is the population size a species must sustain in order for its prolonged survival to be presumed likely.  The output file will tell the user what percentage of the time during the measurement period a species managed to keep its population equal to or greater than this viability level.  If the simulations are large enough for the system to reach equilibrium, we suggest a viability level in the high teens, or perhaps even early twenties.  However, if the simulation runs are shorter, a smaller viability level may be necessary because animals may not have had enough time to reach such high populations.

The Optimization:
	To run the optimization, simply run Master and choose option 2.  While the optimization is running, there is little to see.  The program will report to the console the number of the simulation run it is currently working on, so that the user may see how many runs remain before the optimization is finished, and the food dump method being used for the current run.  If a simulation run ends prematurely, ie all the animals die, the program will report "oops" and move on to the next simulation.  After the optimization ends, the program will report the number of seconds used by the entire optimization process.

The Output File:
	When the program is finished, it will send the results to the file output.txt in the program's main folder.  Most of the information found in this file is pretty self-explanatory, but we will do our best to explain it anyway.
	First, the output file contains information on every food dump method for which the optimization program ran at least one simulation run.  This information includes the viability of cows, horses, monkeys, and humans.  This is the percentage of the measurement time (the time after the program begins measuring) when each species' population was equal to or above the viability level; ie, if there were more cows than the viability level for about half of the measurement time, then the Cow Viability would be about .5.  The program does not measure the viability of Koalas, the weakest species, because they almost never survive till system equilibrium.  The total animal years is the sum of the total number of animals of all species living for each time step during the measurement time.  The birth rate is the number of animals of all species born per time step, the death rate is the number of animals of all species that died per time step, and the death range is the difference between the death rate in the foodspace region with the highest death rate and the death rate in the foodspace region with the lowest death rate (remember, animals don't know which region they're in, they only know where they are on the 2d grid).  All of these values are actually averages of the values for each simulation run with a given food dump method.
	Below the information on each food dump method, the output file summarizes the information by giving the food dump method for which the best value was found for birth rate, death rate, animal years, etc, and that value.  Keep in mind while examining this information that in situations in which more than one food dump method produced the optimal value, only the earlier food dump method will be mentioned. This particularly will occur if the viability level is chosen sufficiently low that the viability of the species is 1. 


6. Environmental Constants

	The file EnvironmentalData.txt, found in the Data folder, allows the user to edit several significant environmental constants that apply to all simulations, regardless of whether the program will be running in graphical mode or optimization mode.  This is a simple guide to what these values mean.
	The first five numbers refer to the number of instances of each animal in existence when a simulation begins.  If, for reasons of convenience or time constraints, you wish to eliminate an animal from the simulation entirely, simply set its starting number to 0 (for example, monkeys and humans have by far the greatest sight values by default, and looking for food takes up a lot of the time in a simulation, so setting the starting number for both these species to 0 would cause a huge boost to the speed of simulations).
	Time between Food Dumps is the number of time steps the simulation will wait between (what else?) food dumps.  This number is directly related to the maximum amount of food that can be dumped each food dump; ie, the longer the wait before food is dumped, the more food can be dumped.  
	The Season Length is the amount of time between changes in the season.  Seasons are relevant only in that they affect the maximum amount of food that is dumped.  This amount is greatest in the spring and smallest in the winter.  
	The Maximum Food Dump Modifier can be used if the user wants an unusually high or an unusually low amount of food to be dumped.  After the appropriate max food dump for a given situation has been created, it will be multiplied by this number, so if this number is greater than 1.0, extra food will be dumped, and if this number is less than 1.0, less than the appropriate amount of food will be dumped.  This is the only value in this file that is not an integer, so you may enter values such as .7 or 1.5.
	The final two values refer to the number of foodspace regions that make up the 2d grid in which the animals live.  Each of these regions is 20 units x 20 units, so the size of the entire grid is determined by the number of regions.  For example, if you have three 20 x 20 regions in the x direction and two 20 x 20 regions in the y directions, the dimensions of the entire space will be 60 x 40.  A couple things to keep in mind if you change the number of regions from the default of 4 (2 x 2): 1) Increasing the size of the grid does not increase the amount of food that will be dropped, so food will be more spread out and more difficult to find in a larger grid unless you increase the Maximum Food Dump Modifier. 2) The graphical mode can, unfortunately, only be set up to report on the amount of food and number of deaths in a limited number of regions, so if you try to run the graphical mode with more than the maximum number of regions - eight at present - the program will most likely crash.  If you really wish to use more regions, you can go into the file Space2d.java and add Food_In_Region_# and Deaths_In_Region_# variables for all those regions beyond eight (this is not especially complicated, merely find the variables of these types that already exist and create the new ones in exactly the same format, only with a different number at the end).  Make sure to compile the code after doing this.


7. Animals

	The animals in this program are all rather similar in that they decide on and make a move (assuming they have the energy required to move), eat a unit of food at their resulting location (assuming there is any food) and gain any energy that food may provide, and then grow and reproduce.

Comparing Animal Behavior-- Deciding to Move:
	The one difference between animal behaviors that cannot be controlled through a data file is the manner in which an animal decides whether to move.  This decision becomes more complex as the animal becomes more complex.
	The cows are one of the simplest animals.  They always move to an adjacent space.  The horses differ from cows only in their stats; they also always move.  The koalas, the "lazy" animals, are the opposite of this: they never move unless there is no food present at their current location.
	The monkeys, slightly more complicated, will never move when there are at least three units of food in their current location.  There is a 33% that they will move for each unit of food below three at their location.  The humans, even more complicated, will never move if there is more than two food in their current location, always move if there is no food in their location, and decide whether to move depending on the location of the nearest food and their current energy if there is more than zero food but less than three food.

Actually Moving:
	Once the decision to move has been made, the animal's all behave similarly: they always move towards the nearest space with food in it (once they've decided to move, they cannot remain where they are, no matter how much food is present in this space), and if several spaces are equally close, they move to whichever of these spaces contains the most food.  If several of the spaces are still equally appealing, they pick one at random.  They do not consider a space if the immediate move required to move towards that space is blocked by another animal.  If the target location has a different x value and a different y value, they will always move towards it in a diagonal direction, only moving purely vertically or horizontally when they reach a location that has the same x or y value as the target location.  Each animal's move can only be to an adjacent space, and each move can only be made if the animal has at least the amount of energy required to move (usually one or two).  The main difference between animals is that animals with a large sight value will be able to locate and move towards food that is far away, while animals with a sight of 1 can only consider adjacent spaces.  If an animal can find no spaces with any food, it will move randomly.

Growing
	Growing means both gaining age and losing a unit of energy.  As animals rarely expend more than a unit or two of energy to move and they generally gain much more than this each time they eat food, an animal that is surrounded by plentiful food resources should have no problem maintaining a high level of energy and staying alive until it dies of old age.  
	Animals can only give birth or die immediately after growing.  At this point, the program checks an animal's age.  First of all, if the animal's age has reached that species' minimum birth age, it becomes an adult, meaning its maximum energy doubles.  If the age is equal to or above that species' minimum birth age, the animal has not given birth yet, and the animal has more energy than the amount used up in giving birth, there is a chance that the animal will give birth.  Each animal can give birth only once.  When it does this, it simultaneously creates however many babies that species can create; ie, if the number of babies for cows is three, three new cows will be created each time a cow gives birth.  All of these babies must be created in spaces adjacent to the parent; if there are no free adjacent spaces remaining and there are still babies to be born, those babies will simply disappear.  Once a baby is born, it will have an age of 0 and it will begin with half its maximum energy (this is also true of the animals created when a simulation begins).  
	After checking to see whether an animal will give birth, the program checks the animal's energy and kills it if the energy is 0 or less.  Finally, the program looks at the animal's age again, and, if the age is equal to or above the old age level, there is a chance that the animal will die of old age.  The chance of dying from old age on any given time step after reaching old age (currently .1) is considerably less than the chance of giving birth on any given time step after reaching the age for making babies (currently .35).

Editing Animal Stats
	The user can control many of each animal's stats through that animal's data file.  The animal data files are found in the Data folder and named (Animal Name)Data.txt.  The following is a brief description of what each value in the animal data files means:

Speed: This is actually the number of time steps between each "turn" an animal takes.  We strongly recommend leaving this at 1 for all animals, unless you wish to effectively slow down time for a species (giving a species a speed of 2 would cause all animals of that species to move, eat, and grow once for every two times animals of other species did these things).

Sight: This is the number of spaces an animal may look in each direction (including diagonals) in an attempt to discover food.  A sight of 1 means an animal can only detect food in adjacent spaces.  A note of caution: more than half of the time in a long simulation can be spent in looking for the nearest food because with a sight of just 4, an animal will look 4 spaces in every direction; that's 81 spaces to cover (although the animal will not look at farther off spaces once it has found a space with food).  So, keep in mind that if you give an animal of sight of, say, 15, your simulation may start running VERY slowly once 30 of those animals have been created.

Size: This refers only to the size of the square representing the animal on the display, assuming you are in graphical mode.  We suggest leaving this at 1 so that you can better see the rest of the display.

Max Energy: This is the maximum amount of energy an animal can store; no matter how much it eats, it will never gain more than this much energy.  This value will double after an animal reaches its minimum age for giving birth and becomes an adult.

Baby Age: This is the age at which an animal's maximum energy doubles.  It is also the earliest age at which an animal can give birth.  Once the animal reaches this age, there is a certain chance each time step that the animal will have babies.

Old Age: This is the earliest age at which an animal can die of old age.

Number of Babies: This is the number of babies that will be created any time an animal gives birth, assuming there are enough empty spaces around the parent.

Energy to Move: This is the minimum energy an animal must have in order to move and the amount of energy an animal will lose in moving.

Energy from Food: This is the amount of energy an animal will gain any time it eats food.

Energy for a Baby: An animal must have more than this amount of energy to give birth.  Giving birth causes it to lose this much energy.

Color: This number, which must be between 1 and 64, refers to the animal's color in the display, if you are running in graphical mode.  We don't suggest changing this.


8. 2d Space

	All the animals in this program move around in a simple 2-dimensional grid.  Each animal uses only an x value and a y value to keep track of its location within the grid.  However, the program superimposes over this grid a series of foodspace regions, smaller grids that hold only a value for the amount of food at a given coordinate.  Each point on the main grid corresponds to a point on one of the foodspace grids.  The number of foodspace regions that make up the entire grid, and therefore the size of the main grid, as foodspace regions are a constant size, is determined by the EnvironmentalData.txt file, found in the Data folder.  Each foodspace region is 20 units x 20 units, so the default grid, which contains only two regions in the x direction and two regions in the y direction, has the dimensions 40 x 40.
	There is a great deal of exchange of information between the main grid and the foodspace regions.  In addition to dumping food into individual foodspace regions, the main grid keeps track of the amount of food in each region, the number of animals that have died thus far in each region, and the number of animals currently living in each region. Although none of this information is available to the animals, which have no knowledge of these regions, this information proves helpful in several of the food dumping methods.
	The decision regarding how much food to dump into each region is one of the most import parts of the program, as the optimization is designed to determine the optimal food dumping method.  The eight food dumping methods consider everything from the number of animals currently living in each region to the amount of food currently found in each region to arbitrary values set by the user to completely random values in deciding how much food to dump in each region.  All methods are limited by the max food dump, the maximum amount of food that can be dumped at one time.  This value is affected by several factors: the frequency with which food is dumped (default is once every 15 time steps), the season, and the max food dump modifier, a value controlled by the user and found in the file EnvironmentalData.txt.  The seasons, which by default change every 60 time steps, affect the maximum food dump in a very simple manner.  Each season has a modifier; the maximum food dump during that season is the product of the normal maximum food dump and this modifier.  The modifiers are as follows:
Spring:		1.2
Summer:		1.0
Fall:		0.8
Winter:		0.6


	This concludes the instructions.  Give the program a try, see what you can discover, and send me anything of interest at MisterDrgn@aol.com.
