Directions

All operations that interact with the universe using (x, y) coordinates will specify coordinates like these.

Normalized Vectors

• values less than 0 (< 0) => map to -1.
• values equal to 0 (= 0) => map to 0.
• values more than 0 (> 0) => map to 1.

For example,

	-30  4   OMOVE		; move organism using vector (-1, 1)
	  0 -4   CMOVE		; move cell using vector (0, -1)
	  9 29 5 MAKE-SPORE	; make spore using vector (1, 1) (with energy 5)

Organism Connectivity

Consider this organism,

One of its corner cells has been killed,

Our connectivity constraints are such that a multi-cellular organism must always have at least one neighbor in the up, down, left or right location. A diagonal neighbor is not sufficient.

Therefore in this example, after the dead cell is removed, we have to make the organism properly connected. We do this by killing off one of the regions.

To resolve this problem, we analyse the organism and kill off the smallest regions. Keeping just the largest section. In the event of a "tie" we just choose the first region that our traversal algorithm considered.

The "L" shaped region had the smaller number of cells, so it was killed off. This is how "organic material" gets created. It is left over material from such interactions. Each white square has a fraction of the original organisms energy amount.

Let's look at another example:

In this case the death of this cell does not break the organism into multiple sections. So in this case we just kill of the cell in question.

The following are examples of bogus organisms:

This is bogus because cell 2 doesn't connect to cell 4. And cell 4 doesn't connect to cell 5.

This organism is bogus because cell 1 doesn't connect to cell 3. The rest of the organism is okay though.

Energy

Every organism must maintain at least one unit of energy just to be considered "alive". If some operation causes this value to go to zero, the organism is dead.

Why Energy?

I like to think of "energy" as the 3rd dimension of the simulation. When you specify the universe you give it a width and height. Energy is like the depth of the sim. If you were to view the universe in three dimensions then energy would be the depth component. It would form a bumpy surface. Some grids would contains lots of energy and some grids would contains none (empty squares). But the maximum depth would remain constant (whatever the starting energy was).

No Cost Stack

When a cell dies in this fashion, it is removed from the organism (and connectivity checks are performed) and all stack elements past the 50th element, are converted back int energy and returned to the organisms energy account.

Example

As a result of the cells attempt to push "-3" on the stack, the cell is killed and the extra stack elements are converted to energy and returned to the organism. In this case, 5 units of energy are added back to the organism (55 - 50 = 5).

So after this cell is killed the organism will have a total energy of 6. (1 + 5 = 6).

Energy and Organic Material

For example, a cell, that is using 53 stack elements, happens to be in a region that is to be killed off. The organism (which consists of 20 cells) has 100 units of energy. If this cell gets converted to organic material then it will be given: 3 + 100 * 1/20 units of energy. Or 8.

Energy and Spores

Energy and Other Operations

Use energy to control the overall population of your simulation:

• 10,000 units of energy equals about 1,000 organisms.
• 40,000 units of energy equals about 4,000 - 6,000 organisms.
• 50,000 units of energy equals about 8,000 - 10,000 organisms.

Of course the other factor in population is the width x height of the universe. A bigger universe will give more room for more organisms.

OMOVE

Assume that cell 2 has executed the instruction 1 0 OMOVE. The vector (1,0) means move right 1 square.

Or assume that cell 1 has executed the instruction -1 1 OMOVE. The vector (-1, 1) means move left and down diagonally.

The OMOVE instruction first checks that all squares that organism will move to, are vacant.

ROTATE

Consider this organism, the cell with the dot will execute a ROTATE instruction.

Here's what the organism looks like after a -1 ROTATE:

Here's what the organism looks like after a 1 ROTATE (from starting figure):

This instruction requires that all grid locations that the rotated organism is to be moved are vacant.

CMOVE

	0 1 CMOVE	; cell 1 executes this instruction
	0 1 CMOVE	; then cell 4 executes this instruction
	1 -1 CMOVE	; then cell 5 executes this instruction

	0 1 CMOVE	; <--- cell 1 executes this

	0 1 CMOVE	; <--- cell 4 executes this

	1 -1 CMOVE	; <--- cell 5 executes this

Notice that cell 5 moved diagonally! This is perfectly fine, as long as the organism is properly connected after the move.

This last pictures shows what the creature looks like after these 3 CMOVE instructions.

GROW

The GROW instruction is how an organism (which always starts out life as a single cell) becoms multi-cellular.

Let's assume this is our organism:

To get to the state shown below several possibilities exist:

	1 1 GROW ; executed by cell 2 or,
	1 0 GROW ; executed by cell 3

Another GROW operation produces the organism below. What are the possible operations that could create the organism? Here are the only possibilities:

	0  1 GROW	; executed by cell 3 or,
	-1 1 GROW	; executed by cell 4

As shown above, the GROW operation creates a new cell. The new cell recieves the execution context of the cell that executed the GROW instruction. The only difference is the new cell has a -1 on top of its data stack and the other cell has a 1.

Grow is very much like the fork() system call on Unix. Fork creates a new process. But fork does it by cloning the current process. The only way for a programmer to know which execution context they are in is by examining the return value of fork(). The same applies to the GROW instruction.

Grow also allows a creature to increase its processing power. An organism consisting of two cells has twice the processing power of a single celled creature. Such an organism can do twice the computations in the same amount of steps as a single celled creature. This is profound capability and any creature that makes the leap into multi-cellularism has a lot going for it.

Example KFORTH code using GROW,

main:
{
	1 0 GROW -1 = LeafCell if

	brain call
}

LeafCell:
{
   1 0 EAT pop
   -1 -1 EAT pop
   1 ?loop
}

brain:
{
  ; ... creature brain goes here ...
}

In this example a new cell is grown at coordinates (1, 0), and the new cell begins its life executing inside of the code block 'LeafCell'. The LeafCell just eat's forever. The parent cell continues to call the 'brain' routine to do the normal creature processing.

You can write your routine to encapsulate this common logic as follows:

main:
{
	1 0 LeafCell myGROW call
	brain call
}

LeafCell:
{
    ; .... leaf cell stuff here ...
}

brain:
{
    ; ... brain cell stuff here ...
}

;
; (x y cb -- )
;
; Grow and call 'cb' for the new cell
;
myGROW:
{
	-rot GROW -1 = { pop } ifelse
}

In this example cell 2, executes the 1 1 EAT instruction.

After the instruction the white square (organic material) has been removed.

Not shown is what happens when a cell tries to eat another living cell. In this case the cell being eaten is flagged as dead (it will show up RED). The organism which has dead cells will have to resolve that issue later in the simulation.

To eat the spore located at (0, 1) this instruction could be used: 0 1 EAT.

This figure shows all 8 direction vectors from a single cell. The LOOK instruction would return the following for this cell:

	 0 -1 LOOK	; what = 8, where = 100
	 1 -1 LOOK	; what = 2, where = 3
	 1  0 LOOK	; what = 1, where = 2
	 1  1 LOOK	; what = 8, where = 4
	 0  1 LOOK	; what = 4, where = 3
	-1  1 LOOK	; what = 8, where = 4
	-1  0 LOOK	; what = 2, where = 7
	-1 -1 LOOK	; what = 4, where = 3

	 0  0 LOOK      ; what = 0, where = 0

Vision using LOOK (and the other vision instructions) will look through the organism itself. This makes the vision instructions less evolutionary brittle, as an "eye" cell can evolve inside the middle of a multi-cellular organism.

The 'what' values are powers of 2, which allows them to be OR'd together for form a search mask (see NEAREST and FARTHEST).

A LOOK operation using the vector (0, 0) returns a what=0, where=0.

"What" values are assigned according to this key:

• 1 = Cell
• 2 = Spore
• 4 = Organic Material
• 8 = Barrier

WHAT

WHAT returns the type of thing seen along a direction vector. It is a shorthand for these instructions:

   LOOK pop

This instruction takes a bit-mask which is an OR'ing of 'what' values. Only these types of things will be used when determining the nearest direction.

For example, a mask value of 5 (binary 0101), matches Cells and Organics (but not spores or barriers). So this code,

   5 NEAREST	; returns (1, 0)

Would return vector (1, 0) because that direction has a "cell" at distance 2 (which is the smallest distance that matches the bit-mask).

NOTE: If more than one direction "tie" for seeing the nearest (or farthest) thing, then instructions NEAREST, FARTHEST, NEAREST2, FARTHEST2 will resolve the tie by choosing one of the matches randomly.

This instruction takes a bit-mask which is an OR'ing of 'what' values. Only these types of things will be used when determining the farthest direction.

For example, a mask value of 2 (binary 0010), matches only spores (but nothing else). So this code,

   2 FARTHEST	; returns (-1, 0)

Would return vector (-1, 0) because that direction has a "spore" at distance 7 (which is the largest distance to any spore).

This instruction takes a bit-mask which is an OR'ing of 'what' values. Only these types of things will be used when determining the nearest direction. It also takes a distance value which limits the search radius.

For example, a mask value of 8 (binary 1000), matches Barriers (but nothing else). So this code,

   8 3 NEAREST2	; returns (0, 0)

Would return vector (0, 0) because there are no barriers within the search distance of '3'.

This instruction takes a bit-mask which is an OR'ing of 'what' values. Only these types of things will be used when determining the farthest direction. It also takes a distance value which limits the search radius.

For example, a mask value of 2 (binary 0010), matches only spores (but nothing else). So this code,

    2 3 FARTHEST2	; returns (1, -1)

Would return vector (1, -1) because that direction has a "spore" at distance 3 (which is the largest distance to any spore within our search radius of '3'). The other spore doesn't match because it is outside our search radius.

Move entire organism by 1 square in the up, down, left, right, or diagonal direction.

1. If there are not 2 elements on the data stack, then skip this instruction.
2. Remove the (x, y) coordinates from the stack.
3. Normalize the coordinates.
4. Examine every square that we may be moving to to make sure it is empty, or contains one of our cells.
5. If the move is possible, reposition every cell in our organism by the (x, y) offset.
6. A move using vector (0, 0) always fails, and returns 0.

RETURNS:

• 0 - move failed.
• 1 - move was successful.

ENERGY: Does not require any energy.

Rotate the organism by 90 degree units around the cell that executes this instruction.

1. If there is not 1 element on the data stack, then skip this instruction.
2. Remove the rotation amount n from the stack.
3. Translate all cells in the organism to the new location, and check that the spot is vacant (or contains cells from this organism). If not, return 0.
4. Else, rotate organism and return 1.
5. A rotation value of 0 always fails, and returns 0.

RETURNS:

• 0 - organism could not be rotated.
• 1 - success.

ENERGY: Does not require any energy.

Move the cell that executes this instruction relative to the organism.

1. If there are not 2 elements on the data stack, then skip this instruction.
2. Remove the (x, y) coordinates from the stack.
3. Normalize the coordinates.
4. Examine the destination square (as indicated by the offsets) and see if it is vacant. If not, return 0.
5. Check that the organism is propery connected after the move. If not return 0.
6. Else, Move the cell to the new location and return 1.
7. A CMOVE of (0,0) always fails and returns 0.

RETURNS:

• 0 - cell could not be moved.
• 1 - success.

ENERGY: Does not require any energy.

Eat stuff at (x, y) from this cell. Return 'n' the amount of energy eaten.

1. Normalize the (x, y) coordinates.

2. Try to eat whatever is at this location:
3. Organic material (white squares) will be eaten and all its energy transferred to this organism.

4. Spores (blue squares) will be eaten and all their energy transferred to this organism. Even spores created by this organism will be eaten (so be careful!).

5. Living tissue from other creatures will be eaten:
   • The living tissue must be from ANOTHER organism, not itself. The cell cannot eat itself!

   • The cell being eaten must not already be flagged as dead (not already red).

   • The cell being eaten is then flagged as dead (red square).

   • All stack elements from this cell will be converted to energy and trasnferred to this organism.

   • 1/x units of energy (where x is the number of cells in the organism being eaten) will be removed from the organism we ate, and transferred to this organism.

   • any remainder from the integer "1/x" calculation is also removed from the organism we ate and transferred to us.

RETURNS:

• 0 - nothing was eaten
• n - the amount of energy we were able to eat.

ENERGY: Will transfer energy from eaten items to this organism.

Create new spore (or fertilize and existing spore).

Add a new cell to this organism.

1. If there are not 2 elements on the data stack, then skip this instruction.
2. Remove the (x, y) coordinates from the stack.
3. Normalize the coordinates.
4. If the location specified by the coordinates is not blank, then return 0.
5. Compute the amount of energy needed to grow (this is the sum of the data stack size and the call stack size).
6. If organims does not have enough energy to GROW a new cell, then return 0.
7. If the location specified is not "touching" the organism in the up, down, left or right direction, then return 0.
8. Create new cell at location specified. Clone this cells data and call stack (as well as registers, and so on).
9. Subtract the stack sizes from this organisms energy account.
10. For the cell executing the GROW instruction return 1.
11. For the new cell, just created, make it appear as if it returned -1.

RETURNS:

• 0 - could not grow
• 1 - grow succeeded (the cell that executed the GROW instruction)
• -1 - grow succeeded (the new cell)

ENERGY: Requires (c.data_stack_size + c.call_stack_size + 1) units of energy. (where 'c' is the cell executing the GROW instruction). The "+ 1" is for the return value that we will place on the new cells data stack.

Look along a normalized (x, y) direction vector. Return the thing it found, and the distance.

1. If there are not 2 elements on the data stack, then skip this instruction.
2. Remove the (x, y) coordinates from the stack and normalize the coordinate.
3. Look along the direction vector until something is found (or the edge of the universe is reached).
4. Ignore any cell that happens to be from the same organism as us.
5. Push the type of thing ('what' value) on the data stack. (WHAT value Key: 1=cell, 2=spore, 4=organic material, 8=barrier).
6. Push the distance ('where' value) on the data stack. A distance of 1 means the thing seen is touching this cell.

RETURNS:

• what where - before reaching the end of the vector something was found. "something" is one of ORGANIC MATERIAL, SPORE, or living cell.
• 0 0 - when then (x, y) vector was (0, 0).

ENERGY: Does not use energy.

WHAT returns the type of thing seen along a direction vector. It is a shorthand for these instructions:

    LOOK pop

RETURNS:

• 0 - no spore seen along this vector.
• distance - before reaching the end of the vector a spore was found.

ENERGY: Does not use energy.

WHERE returns the distance to something along a direction vector. It is a shorthand for these instructions:

   LOOK swap pop

Looks in all 8 directions and return the (x, y) direction vector that corresponds to the thing with the smallest distance (and matches a 'mask' value).

1. If there is not 1 element on the data stack, then skip this instruction.
2. remove 'mask' value from data stack.
3. strip all bits from the mask, except first 4 bits (e.g. 000001111)
4. if mask bits are all 0, then return the vector (0, 0)
5. Look in all 8 directions, beginning with a RANDOM direction and proceeding in a clock-wise direction.
6. Keep track of the closest thing seen (whose 'what' value is set in the bit-mask)
7. Return the (x, y) direction vector.
8. If nothing matched the bit-mask, then (0, 0) is returned.

RETURNS:

• x y - the direction vector that is nearest and matches the 'mask'
• 0 0 - nothing matched the 'mask'

ENERGY: Does not use energy.

Looks in all 8 directions and return the (x, y) direction vector that corresponds to the thing with the largest distance (and matches a 'mask' value).

1. If there is not 1 element on the data stack, then skip this instruction.
2. remove 'mask' value from data stack.
3. strip all bits from the mask, except first 4 bits (e.g. 000001111)
4. if mask bits are all 0, then return the vector (0, 0)
5. Look in all 8 directions, beginning with a RANDOM direction and proceeding in a clock-wise direction.
6. Keep track of the farthest thing seen (whose 'what' value is set in the bit-mask)
7. Return the (x, y) direction vector.
8. If nothing matched the bit-mask, then (0, 0) is returned.

RETURNS:

• x y - the direction vector that is farthest and matches the 'mask'
• 0 0 - nothing matched the 'mask'

ENERGY: Does not use energy.

Looks in all 8 directions and return the (x, y) direction vector that corresponds to the thing with the smallest distance (and matches a 'mask' value and is within the distance search radius).

1. If there are not 2 elements on the data stack, then skip this instruction.
2. remove 'mask' value from data stack.
3. remove 'dist' value from data stack.
4. strip all bits from the mask, except first 4 bits (e.g. 000001111)
5. if mask bits are all 0, then return the vector (0, 0)
6. if 'dist' is 0 or less, then return the vector (0, 0)
7. Look in all 8 directions, beginning with a RANDOM direction and proceeding in a clock-wise direction.
8. Keep track of the closest thing seen (whose 'what' value is set in the bit-mask and whose distance is less then or equal to 'dist').
9. Return the (x, y) direction vector.
10. If nothing matched the bit-mask or was within the search radius, then return (0, 0).

RETURNS:

• x y - the direction vector that is nearest and matches the 'mask'
• 0 0 - nothing matched the 'mask'

ENERGY: Does not use energy.

Looks in all 8 directions and return the (x, y) direction vector that corresponds to the thing with the smallest distance (and matches a 'mask' value and is within the distance search radius).

1. If there are not 2 elements on the data stack, then skip this instruction.
2. remove 'mask' value from data stack.
3. remove 'dist' value from data stack.
4. strip all bits from the mask, except first 4 bits (e.g. 000001111)
5. if mask bits are all 0, then return the vector (0, 0)
6. if 'dist' is 0 or less, then return the vector (0, 0)
7. Look in all 8 directions, beginning with a RANDOM direction and proceeding in a clock-wise direction.
8. Keep track of the farthest thing seen (whose 'what' value is set in the bit-mask and whose distance is less then or equal to 'dist').
9. Return the (x, y) direction vector.
10. If nothing matched the bit-mask or was within the search radius, then return (0, 0).

RETURNS:

• x y - the direction vector that is farthest and matches the 'mask'
• 0 0 - nothing matched the 'mask'

ENERGY: Does not use energy.

Refer to this figure for the descriptions of the following instructions. The mood register is something the cell sets, and others can look at. The message register is something that others set, and this cell looks at.

Using the instructions pack2, pack4, unpack2, unpack4 many values can be combined into a single 64-bit integer and stored in the MOOD and MESSAGE registers. For example, to send 4 integers to another cell, this code could be used:

	23 -999 5901 3 pack4		; combined these 4 (16-bit intgers) into single 64-bit int.
	-1 1 SEND			; send to cell

The reciving cell, can extract these 4 values like so:

	RECV
	unpack4			; the values 23, -999, 5901, 3 are now on the stack

Every cell has its own "MOOD" register. This instruction queries another cell using an (x, y) vector. This vector is not normalized which allows the cell to query any other cell within its own organism (not just adjacent cells). For example, if cell 2 executed the following instructions:

	0 0 MOOD   ; returns -23
	-1 0 MOOD   ; returns 123
	-1 1 MOOD   ; returns 33
	99 99 MOOD   ; returns 0

If a bogus (x, y) is specified then 0 is pushed on the data stack. (0, 0) refers to the cell executing the instruction.

ENERGY: Does not use energy.

The cell executing this instruction will set its own mood register. It is not possible to set others. The purpose of the mood register is for a cell it advertise its "mood" to other cells in the organism. For example, if cell 3 executed these instructions:

	0 0 MOOD 1 + MOOD!

ENERGY: Does not use energy.

This instruction takes the value off of the top of the data stack and sets the message register for every cell in our organism.

ENERGY: Does not use energy.

This instruction takes 3 arguments. An (x, y) vector and a value 'm'. The vector is NOT normalized so that the cell can send a message 'm' to any other cell in the same organism (not just adjacent cells). For example, if cell 1 exectuted this these two instructions:

	100     1 0 SEND   ; set cell 2's message register to 100
	-46812  0 1 SEND   ; set cell 3's message register to -46812
	0       0 0 SEND   ; set out message register to 0.
	12   -99 99 SEND   ; does nothing because (-99, 99) is bogus

ENERGY: Does not use energy.

The RECV instruction just pushes a copy of our message register on top of the data stack.

ENERGY: Does not use energy.

Fetch the organisms "energy" field and place it on our data stack. Please be aware that putting something on the data stack requires 1 unit of energy. So the value placed on the data stack is BEFORE the simulator subtracts 1 unit of energy for the data stack entry.

Also this instruction does not account for any energy that is stored in the form of stack elements. (This is a good thing, because such energy is not really available to be used).

ENERGY: Does not use energy.

Fetch the organisms "age" field (which is the number of elapsed simulation step) and push this value on our data stack.

ENERGY: Does not use energy.

Push the number of cells that comprise this organism on our data stack.

ENERGY: Does not use energy.

1. On the data stack should be two values. If not, we ignore this instruction.
2. The two values are popped off the stack (they are NOT normalized). This forms an (x, y) vector that refers to one of our nearby grid locations.
3. If we have a cell at this (x, y) offset, then this instruction returns 1. Else 0 will be returned.
4. The vector (0,0) is allowed, and always returns 1.

RETURNS:

• 1 - at offset (x, y) is one of our cells.
• 0 - at offset (x, y) it NOT one of our cells.

ENERGY: Does not use energy.