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.

© 2015 Aepryus Software, Inc.