You are right that Darwinbots although named otherwise is not really great on the aspect of evolution.
That has several reasons:
I think the basic thought was to create selection pressure mainly trough competition with other bots, but this means that bots mainly evolve to defend and attack better and more efficiently or to stop fighting there is not much outside of that to enforce selection pressure if you do not choose really special environmentally conditions.
Although over time option after option was added, this only increases the size of the solutionspace making it harder for evolution to work as the bots have to find predefined syntaxes, prethought solutions and thats pretty hard , as was said darwinbots Dna is nolt reall designed for easy evolution.
But more so, when a clever designer can come up with the possibilities that can be used, although he might have problems implementing them(having mostly the same problems as bots with finding the exact syntax, correct solutions) how do we expect a bot to surprise us in finding something new?
Complex behavior is difficult and well complex, that makes its hard to develop, to maintain and optimize in most cass it just to costly in terms of efficiency and performance to have a chance to compete.
The current mutation structure is just dumb, I mean sometimes you need to have almost the exact gene for all 9 eyes and so you write 9 genes or line of code then you need 9 mutations to do that.(If you had some dna command that started a loop that repeats 9 times changing a certain dna cxommand with 0 add, 1 add 2 add etc this could be done in a way one mutation would be enough), sometimes mutation would need to mainly mutate numbers or leave certain parts of the code rather unharmed while mutating others more but currently mutation works totally random.
hmm nice food to think about...
how could we notice evolution in darwinbots even if it was going on?
Maybe a smart species would evolve to perform group inteligence, simply said swarming behaviour to tackle food.
Swarming can be a type of simple group rules, resulting in complex behaviour, dough it rarely advances.
Other ways of recognizing would
For example untis that somehow seam to prefer to be connected to 3 cells and hunt together (where there wasnt a number 3 given, neither in their mutated code).
It would mean that those 3 evolved by balancing their parameters; if they could reproduce and soon form 3 again that might be a hint that there is something going on beyond their individual code.
In our DNA happens a lot of changes too, and altough we dont have 9 eye's I think an eye would only need to be described once, and then finetunes itself to its environment over generations. Hmm maybe the algorythm in darwinbots that creates dna copy error is a bit harsh, more like a cancer then something that deals with how good a species behaved.
When I run the 1G bot I made, and let it run over a night. I noticed that I had evolved to a 2G bot (altough it was an empty gene; maybe call it junk DNA ).
Some species had their vision range changed based on input, I had not coded that in yet myself, neither it was optimal, but maybe it could have evolved to something usefull.
As those species had also wider eyerange as a result, and that might be of benefit for use for futher generation. Sadly next morning, it saw mostly verry poor eyesight and verry small bots (altough lots).
hm I'l go adjust my 1G bot with some extra code, I hope I can fit it in a 1G / or make another bot with more genes.
Add code that would define eyerange shootrange etc, define it with the default valeus.
If I then would run it again, and let DNA copy error only in valeus not in commands (it was 50% 50%), then I wonder what would happen.
Altough this might fine tune a bot species.
It wouldnt evolve for example a bot that would reproduce based on *.nrg > 300 to become reproducing like > *.body *.age mult 20 mod =0
Maybe somthing like this could do that :
Remember old PC's assambler code, in the low memory range they had jumps comands to interupts.
It was like:
gosub ... keyboard (all instruction there to handle the keyboard)
<empty>
<empy>
<return>
gosub .. mouse ...
<empty>
<empty>
<return>
gosub to ..
<empty>
<empty>
<return>
..
.
Well the interesting parts for early assembler programmers where those empty areas.. since the computer walked down all the interupts at an empty place one could define a hook
A hook was a location from where your code would execute, after it had dealed for example with the keyboard, so one could for example dump keystrokes.
Some programs still do that as of today, computer viruses.
However this hooking method I wonder.
Maybe it could be used inside a bot, and the hooking itself could advance like if there was a line
Gosub 10 [<10: do your behaviour commands; for example walk up on eye5> <empty hook> <emptyhook>] return
What if 10 was a valeu which could be changed by darwinbots DNA copy erros.
so it could became Gosub 13 [<13: do different commands with the stack valeus> <empty hook> <emptyhook>]
ofcourse the <empty hook> could contain also new hooks. so you could get
gosub 10 [<10: do behaviour instructions> <emptyhook> <new hook number13>]
its a bit complex tought dough.. using such mechanism in a bot and hoping the hooking would evolve.
So that the DNA code can be generic but the hooking can advance over it.
Hmm wel even our DNA isnt complex enough to deal with the stuff our brains deal with, it only knew how to make a brain.