Introduction

While I've done my share of CA-type worlds, I believe a rich environment is important for doing rich problem solving. I decided to spend a little time now as I gear up for my next series of AI research creating such a world. Since I've been making my living lately developing with Visual Basic .NET and because of the benefits .NET offers, I decided to build this world using VB.NET. I know it doesn't offer the fastest execution speed, but it does really make coding much easier and helps to hone my own .NET skills.

I wanted to make this freely available to other people with similar interests. It may also serve as a helpful model of a physics engine to game programmers.

Take a look at the screen shot to the right, which illustrates a sample world constructed as I'm building and testing this program. In it, you'll see examples of each of the following types of entities that can exist in this world:

• A rectangular "planet" in which everything you see resides.
• Three free-floating "particles" with spring-type links connecting them together.
• One gravity-style force field centered in the black circle drawing free particles toward it from everywhere.
• One fixed-position particle (black) protecting free particles from the infinite gravitational force at its center.
• One vortex force field in the blue circle spinning free particles inside it clockwise.
• One planar force field in the blue rectangle pushing free particles upward.
• Two barriers in gray that particles bounce off of.
• One planar force pulling all things lightly, uniformly downward (invisible here)
• One planar force that varies with distance originating just below the bottom of the planet that works like anti-gravity, making free particles "float" just above the bottom and countering the downward force field.

It's actually pretty fascinating to watch this sample world in action. The three free particles are linked to one another with simple spring-type links, so they move together as a single entity. Because the links are springy, you see the collective entity is "squishy" as it hits obstacles like the outer walls, barriers, and other particles.

First, you have to know how to program in .NET. VB.NET is the easiest choice, but if you're more comfortable with C#, J#, Perl.NET, or whatever else, you can always change this project to output a DLL instead of an executable. Then you can create a reference to this project in your own project and start creating your own derived classes, UI, etc. in your preferred language.

I've endeavored to add lots of comments to the code and to make it as understandable as possible. For those who want to understand how all the data structures, math, and other algorithms work, you'll find the techniques and comments very helpful.

You'll find this project is very object oriented. I believe an AI or A-life project with a rich world is best implemented with three basic layers:

• The world
• The robots that inhabit the world
• The brains that drive the robots

The current state of this project is such that only the first layer is basically done. I'm continuing my work now into the second layer, and I'll include it in this project as a helpful starting point for other researchers, too.

You'll find the essential machinery located in the World folder in the project. You'll find there the following classes' implementations:

• Planet: Your project can have one or more rectangular planets, and each one of the other entities resides in one planet or another.
• Vector: The foundation of most all of the math. These are composed of floating point X and Y ordinates and offer a variety of common vector operations like addition, subtraction, division, dot product, right-angle, and so on.
• Particle: Simple circles with defined mass, radius, and so on. The essential basis, in conjunction with links, of any robot.
• Link: Used to connect any two particles with spring, gravity, anti-gravity, or neutral force effects. Also the basis for more advanced things like communications and end effectors.
• Barrier: Horizontal or vertical blocks with round end-caps.
• ForceField: Applies forces to free particles in a rich variety of modes.

The Planet class has a series of collections; one for each type of object you can create within a planet. It also has a .Tick() method, which executes a single moment of time. With each tick, the free particles interact with their environment. This is actually a fairly complex process already, but if you study the algorithm, you'll see how all the forces in the system interact because they're clearly delineated and well-commented.

The Robotics folder contains the beginnings of an experimental world I'm working on to turn particles into robots. I intend to derive new classes from Particle and Link to engender computing, sensing, and motive power. For example, I intend to make it so certain kinds of particles can store energy and impart it to, say, thrusters. Thruster is derived from Particle and includes a reference to another particle it uses to determine which direction to apply thrust. Similarly, I might derive a single-pixel eye from the Link class, again because of the inherent directionality. I will probably also derive a sort of muscle class. Energy consumed by one will serve to increase or decrease a connecting spring-type link's resting length, thus applying force to expand or contract it.

The Viewer folder contains the UI code that provides the means for users to watch and interact with the world. There are simple means to zoom and pan (right-click while zoomed in and you can pan around easily). You can left-click on any particle and drag it around. Let it go while moving the mouse, and it will keep moving in that direction, so you can push particles around at will. You can take individual steps to see what's happening or resume full-speed motion. Also, if you're picky about optimization, you can make a small modification to make use of threaded execution instead of having it synchronized to a built-in timer.

In the latter stages of development of this product, I added support for XML files for configuring whole worlds. You'll probably find this preferable to hard-coding all the constructs. One reason is because you can simply modify the XML and hit the "Restart" button to load the latest version. Another is because it has an inheritance model that allows you to define a "segment" -- perhaps a leg composed of many particles -- and then reuse it in a different place, but with other modifications to angles, colors, sub-positions, and so forth. And you can instantiate a defined "body" any number of times to populate a planet.