I can't remember what was the original source of my realization, but sometime during my freshman year
in High School, I became aware of the interaction between what I feel and what I do. I started to
ponder what the ramifications of our emotional wiring was on our behavior.
I eat because I feel hungry. I choose what to eat based on what I will like the taste of most. I
remember one day standing in the school's cafeteria line thinking about what I should buy. I consciously,
noticed myself anticipating the tastes of different foods and comparing them to one another. (I'm
pretty sure I had pie for lunch that day)
It occurred to me that we do things that will make us feel good and avoid doing things that will make us
feel bad. One of the first ramifications of this, that I found a bit disturbing, is that there can be
no such thing as true altruism. Even the person who does things that only benefits others while giving
them no benefit, really only does so, because they feel good doing it. At a base level
there is no difference between an altruistic person and a non-altruistic person; they both simply do
things that make themselves feel good. The difference being, the types of things that make them feel
good.
I took Biology that year and started to think about the evolutionary advantages of various human behaviors.
I had an English class that had a unit on Greek mythology. It occurred to me that this wasn't just a set of stories
or fairy tales, but was an ancient religion. A religion that people believed in and worshipped and
discussed just like Christianity or any other modern religion. Juxtaposing that with the seemingly
ridiculous things that Greek mythology was saying and the reaction that modern people have to those
stories, was the last little push I needed to realize that perhaps everything I had been told up to
that point regarding my own religion wasn't exactly true.
Religion was very pervasive however, it seemed that every culture at every time in history had some
religion or another to base their beliefs upon. So, I wondered if perhaps religion itself was embedded
in our genes.
For the next few years, I observed my own and other's emotions and behaviors and thought about what
their origin could be in the context of evolution. While at University of Chicago I had a lot of time
to develop theories on many phenomena of human existence. My 3rd year there I took a class on Evolutionary
biology. For the class' final paper I wrote about the things that I had been
thinking about for the past 7 years.
The paper is quite sloppy and really needs to be significantly longer in order to really explore some of the
ideas. It also has a fairly grating tone, which I apologize for. There are also some concepts that I didn't
quite understand at the time.
Even at the time of writing the paper, I was concerned about its degree of rigor. Ultimately, how strong
can words really be when trying to argue the evolutionary advantages of any given behavior. Perhaps,
the ideas are reasonable, but how does one really test their validity.
A few years after graduation I started trying to solve that problem in earnest. Evolizer is a java program
that tries to create an environment where the cases given in the paper could actually be tested. Any Java
developer can develop their own species and see how it matches up against other developer's species.
Creating Your Own Species
In order to create your own species, download the Evolizer.zip and AepUtil.jar.
You will also need a copy of the Java SDK (JDK),
if you don't already have that. I'm pretty sure Evolizer will work with either JDK 1.3 or JDK 1.4; I have not
tested it with earlier versions of the JDK, so I am not sure about those. In general all one needs to program
Java is the JDK and a text editor, however Java development can greatly be aided by an IDE (Integrated
Development Environment). I personally use IntelliJ, but I have
used JBuilder in the past; also, IBM has a decent one out
that I believe is free called, Eclipse.
For newer developers, the hardest part is going to be downloading all the software / files, installing them, copying
them to the correct directories, setting up the correct classpath and path environment variables and figuring
out how to compile and run the project. Once this is all completed everything else becomes much easier.
Any developer interested in creating their own species must simply create a class that extends
com.aepryus.evolizer.biology.Species. Species is an abstract class that requires two methods to be implemented.
The first is pretty easy: public Species getNew (), which will always look like this:
public Species getNew () {
return new MySpecies();
}
Where MySpecies is replaced by your Species' (aka Class') name.
The second method is much more interesting: public void step (List view). This is the method where a developer
defines the behavior of their species. Evolizer will pass a List of all the Things that a given individual
can see currently. A species can loop through the list and look for things that it is interested in such as
Fruit, Enemies or Friends.
Each individual can choose from 5 different actions. Move: allows them to move up to
their maximum speed. Eat: allows them to eat fruit and regain energy. Fight: allows them to attack other
individuals at close range. Shoot: allows them to attack other individuals at a distance. Bonk: allows them
to attempt to reproduce with another member of their species that is of the opposite sex.
I have included all of the species that I currently have the code for. Many were written by me: Kelp, SuperKelp,
Trilobite, Amoeba, Protozoa, Congeal and a few others. Some were written by others: Whelk, Rat, WindClouds.
Kelp was the first species that I wrote that was self sustaining; meaning that, if I put it in the world by itself it could
survive indefinitely. Kelp is a pretty simple Species and a great place for inexperienced developers to look to in
order to learn how to develop a species.
SuperKelp uses basically the same philosophy of Kelp, but is written with more advanced Java concepts which
makes it a good place for more experienced Java developers to start. It also removes some of the mistakes
that Kelp was making. I don't think I have ever seen Kelp beat SuperKelp.
Each individual has 15 genetic traits. In a match, each species starts with 20 individuals that
have a random distribution of genes. The 15 genes are:
Gene Initial Max What It Represents
speed 10 Pixels per Step
closeAttack 10 Hit Propensity
closeDamage 50 Hit Points
closeArmor 10 Hit Propensity
closeRate 3 Actions per 12 steps
farRange 100 Pixels
farAttack 10 Hit Propensity
farDamage 20 Hit Points
farArmor 10 Hit Propensity
farRate 6 Actions per 12 Steps
maxHitPoints 200 HitPoints
maxEnery 2000 Energy
energyEfficiency 1 Gained Energy / Eatten Energy
viewRange 100 Pixels
bonkRate 2 Actions per 12 steps
Everytime a gene is replicated there is a chance that it will mutate, which will shift the trait
up or down by some relatively small percent, so it is possible to get individuals that have traits
higher than the initial max.
Once a species is ready, the last step is to add the new species to the species queue. In order to
do this edit the class com.aepryus.evoilzer.Evolizer. The first part of the method: public void go (),
creates a List called species and then adds a prototype individual of each species to that List.
Add the line: species.add(new MySpecies()); to the code and recompile.
In order to force the species that you are currently working on to always be selected for each match,
don't add the above line. Instead, replace the line: ecosystem.addSpecies((Species)species.get(0)); with
ecosystem.addSpecies(new MySpecies());
Current Work
Evolizer is still very much so, a work in progress. I originally started the current version of evolizer
in 1999-2000. I was much less experienced with object oriented design at that time, so I have recently
embarked on a rewrite of the program.
Currently, creating species around range attacks is very difficult because not much relevant information
is returned that would allow an individiual to know if their shot fell short, if it hit, how much damage it did, etc.
I plan to create some utilites that would allow for people to select which species to send against
one another and also create tournements between sets of species.
I am interested in holding tournements, if there is enough interest in species creation.
Ultimately the goal of Evolizer was to discover ways to internally increase the rate of evolution. As it
currently stands, a species military or economic strategy can be as much or more important as its reproduction
strategies. For this reason, it would be interesting to perhaps keep the species separate for a period of time
before they come into contact with one another.
Web Server
I have done some work on an Evolizer webserver. There is a limit to how many trials a single computer
can accomplish in a single day. I have been thinking that putting out an Evolizer Screen Saver, that would download
species from the evolizer server, run a trial and then report the results back would be a
fun way to run many trials quickly. One of the difficulties to overcome is security. I would want to create a system
that didn't open up the possibility of inaccurate match results being posted to the evolizer server.
Java Training
Often in first year development courses, the range of programs that can be worked on is fairly small
and unlikely to involve much of anything that is of great interest to the student learning Java. Creating
a species in Java can be fairly simple, can illustrate a number of the basic concepts, such as simple
program flow (loops, conditionals, etc), but can also illustrate some more interesting topics such as
anonymous inner classes. Evolizer itself, is a decent example of OO design.
Longer Term
In playing with evolizer over the last few years, there are a number of concepts that I understand at
a more intuitive level than before. There are also some concepts that I didn't know about at all before.
In order to really explore these concepts I really need to append some statistical tools to the program.
I think that Evolizer could be used as a basis for constructing the embryonic rules of evolutionary mechanics.
Beyond that, ultimately Evolizer has a fairly serious flaw. The more I think about it, the more I realize
that in the history of the world, an evolizer type situation (2 competitors suddenly come into contact with one
another) is probably fairly rare and certainly not the base mechanism by which evolution takes place.
A much more realistic simulation would have developers not create their own species, but would rather have
them create their own behavioral genes. Let the genes loose in a population and see if it can achieve
dominance over other behavioraly genes.
