Messages

31

Tips and Tricks / Distances, coordinates, units

« on: May 12, 2008, 07:35:52 PM »

So, I'm measuring the distance between two bots with:

(This is inside an if block which has a boolean value on the boolean stack indicating whether code inside the if block should run or not)

Code: [Select]

*.refxpos *.refypos dist dupbool dup *998 != and 998 store dropbool
*.xpos *.refxpos sub dup mult *.ypos *.refypos sub dup mult add sqr dupbool dup *997 != and 997 store dropbool
The first line is dist(refxpos, refypos), and the second line is sqr(((xpos - refxpos)*dup) + ((ypos - refypos)*dup))

I have a bot which does repro 50, and then both it and the child move away from each other, until they pass 400 dist (according to dist, not the manual formula), at which point they both fixpos.

The bots are still close enough at that point to shoot each other, regardless of map size, indicating that the coordinates returned by dist are the actual (or near) coordinates. (The bots do not aim their movement or shots very well on the largest map size though)

(I'm going to write ~number in the rest of this post where I mean the number is sometimes that number, but is sometimes 1 higher or 1 lower than that number instead, to save time.)

(And for each bot, I'll say what I got for the dist method and the manual method with dist:manual)

On size 1-4 maps, I get either ~452:~452, or ~522:~522. Said another way, each single bot has either ~522 and ~522 for both methods, or ~452 and ~452 for both methods.

On size 5 maps, I get either ~452:~362, or ~522:~417.

Size 6 maps: ~452:~301, or ~522:~348

* = within 1 distance point anyhow.

So, we can conclude that:
1. Refxpos/refypos and xpos/ypos are returning values which are scaled down by the size of the map
2. dist() takes in scaled-down units, and returns actual distance units

So how do we do work on actual x or y coordinate differences? We have to get the actual distance, which we can do like so: dist(xpos+xdiff, ypos) or dist(xpos, ypos+ydiff).

Additionally, this is helpful: refvel* are in actual distance units rather than scaled-down units: My test bots are showing the same values at the same tick for these in both the smallest and largest map size.

There's just two problems I see so far:
1. At very large map sizes you end up with refxpos,refypos coordinates whose difference from your xpos,ypos is so tiny (say, 6 on the largest map) that the actual coordinates returned by dist (and angle) are unreliable.
2. Why are the actual distances being returned as sometimes ~452 and sometimes ~522 (which are ~70 units apart), and never something in between? (Note: I'm discounting the results from huge maps which return different actual distance values than ~452 and ~522, because their scaled-down units are so tiny that it makes the result inaccurate)

32

Internet Mode Commentary / The State of the Simulation

« on: May 12, 2008, 01:27:06 AM »

Both EricL and EricL2 are running pretty standard physics with a few visible shapes.  Bots that arn't shape aware tend to bash themselves to death.

How DO you get shape-aware bots, anyhow? I've spawned some random shapes, and as far as I can tell, the bots can run right into them and still not see them - reftype is 0 still and the vision distance isn't appearing shorter like it does when it sees a bot.

Though as far as I can tell, running into the shapes isn't doing any damage either.

33

Internet Mode Commentary / The State of the Simulation

« on: May 11, 2008, 05:12:46 PM »

BTW, Nanite Detonators seem to be doing OK in my sim, they are not growing fast, but at least they are not dying...  They are managing to get by...

My 2.2 version wipes out everything I put it against in my sim, but as far as I can tell from the internet population thing, they aren't doing well anywhere else.

I even started a sim up with nothing but seasnake 1.2 and algae minimalis, waited until the seasnakes were dominant and swimming around with 6 or so bots per snake, and then introduced a few nanite detonators, which proceeded to spread and eventually take over the sim (There are about 67 seasnake bots left, in the upper-left and lower-left corner of the sim. There were 80-something the last time the graph updated before that).

What conditions are y'all using in your sims? (I'm using standard F1 conditions, I think)

Edit: Though after they reach 1000 bots of the same species in the sim, they mostly just sit there and do nothing. (Putting most of their energy into body)

34

Tips and Tricks / Shot Projection/Position Prediction..

« on: May 11, 2008, 02:41:54 PM »

I'm not yet sure if negatives are supported in .sx and .dx, but if its at all like pleasure or pain they should be inverse of each other. The problem that is inherent shows up in more chaotically maneuvering bots, the change in direction  or speeds can result in errors, as was inherit with Guardian. I'm still working out the kinks for a sytem similar to the behvior learning genes, only it would provide adaptable tactics.

Negatives are supported in .sx, .dx, .dn, and .up. Guardian maneuvered using only .dn and .sx (and made sure .up and .dx were set to 0).

As for targetting chaotically moving bots, in order to really move sufficiently chaotically to confuse aiming, you have to be small, and small bots are difficult to hit to begin with.

*.refvelsx *.velsx sub 1 add mod *.maxvel -1 rnd 1 mult .sx store
*.refxpos *.refypos angle .setaim store
*.refxpos *.sx add *.refypos angle .aimshot store

Edit: Say, it looks like you've made a mistake (or more than one) in that code you pasted. Firstly, you're missing a parameter to %, aren't you? And the first parameter to the first angle seems to be maxvel, which you put on the stack before setting sx to rnd(-1)*1, and I don't know why you are doing the *1, or whether rnd(-1) does something useful.

This is what I got when I tried to translate it (manually):

Code: [Select]

    MISSING PARAMETER % ((refvelsx - velsx) + 1)
    sx = rnd(-1)*1
    setaim = angle(maxvel, angle(refxpos, refypos))
    aimshot = angle((refxpos+sx), refypos)

35

The Gene depository / OCULUS II

« on: May 11, 2008, 12:55:31 PM »

The loop could be a serious problem, I could imagine DB being held in a loop pretty easily.

I'm not suggesting adding a loop operator. I included it and the [] in the first pseudocode to show the basis for the idea. As I said, you would unroll the loop (and convert the eye[num] into eye1, eye2, etc), and you can see what that looks like (with 2 eyes instead of all 9) in the third code block in that post.

36

DNA - General / The Quick guide to making a 1-gene bot

« on: May 11, 2008, 12:50:25 PM »

AND

ConditionA conditionB mult
If both are 1, the result will be 1*1=1.

If both conditions are either 0 or 1, conditionA conditionB & will work the same, but faster than mult. You do still need to multiply times your location or value at the end, though.

OR
Calculating the Condition from numbers A and B

  Equals

You seem to have included the same or similar block of text in your post twice, starting with Equals and continuing through comparing.

NOT

ConditionA conditionB add sgn
if both are 0, it will add to 0 and sgn will return 0. If one of them is 1, 1 will be returned, and if both are 1, 2 will be returned. Either way, sgn reduces it to 1.

I guess you mislabelled that - From your description, that's an OR. But you don't need to do that at all - DBII has an | operator which is bitwise or, and it will work just fine for this, since your numbers are always 0 or 1.

XOR

ConditionA conditionB add -- abs -- abs

You can do this one with ^, which is the bitwise xor operator.

These ones aren't very important, but:

Negation

 A -- abs

If you see - ++ in a bot's code, that's another way to write negation/not.

Equals
A B sub sgn abs -- abs

If you see sub sgn abs - ++ in a bot's DNA, that's another way to write this too.

What I use for comparison operators:
'>' is 'sub sgn 0 floor'
'<' is 'sub sgn - 0 floor'
'>=' is 'sub 1 add sgn 0 floor'
'<=' is 'sub 1 sub sgn - 0 floor'
'==' is 'sub sgn abs - ++'
'!=' is 'sub sgn abs'

37

Tips and Tricks / Shot Projection/Position Prediction..

« on: May 11, 2008, 12:32:11 PM »

Although if you really want sine and cosine, you can use polynomial approximations. I'm pretty sure that's what trafalgar did in Guardian.

What Guardian did was:
1. Determine how far away a target bot was and what its relative x and y velocities were, estimate how long it would take a shot to reach that position,
2. Estimate where that bot would be at that time if it had continued moving at its current speed, then
3. Estimate how long it would take a shot to reach that second predicted position, and then where the target would be at that time, and then
4. Calculate the angle to fire a shot at in order to strike the third predicted position at the time when it was estimated the target would be there.

In order for that to work, I had to measure how fast shots moved in F1 conditions, and how the firing bot's speed affected them. It turned out that (IIRC) shots moved at 39 units per tick relative to their firing bot, or something like that.

Things I'm not sure of at the moment:
1. Would it work on sims with gravity? Theoretically it might do OK with buoyant bots and others that aren't beginning to freefall - if shots aren't affected by gravity.
2. Does it work on sims above 32000 x or y size?
3. Does it still work at all on smaller sims?
4. Is the shot speed still correct?

It was defined like this: (These are essentially macros, and yes, this results in a lot of code duplication but no stores)

Code: [Select]

    define nextrefxpos: refxpos+((refveldx*dist(refxpos,refypos))/39)
    define nextrefypos: refypos-((refvelup*dist(refxpos,refypos))/39)
    define betternextrefxpos: refxpos+((refveldx*dist(nextrefxpos,nextrefypos))/39)
    define betternextrefypos: refypos-((refvelup*dist(nextrefxpos,nextrefypos))/39)
    define fixedangle: angle(betternextrefxpos, betternextrefypos)
    define range: (dist(betternextrefxpos, betternextrefypos))
It used range to decide how much to power up for distance shots, and whether to even fire at all.

38

The Gene depository / OCULUS II

« on: May 11, 2008, 11:44:23 AM »

I was thinking that the many many many SGized comparisons are a bit inefficient in CPU-usage, and thought about alternatives. What I came up with first:

Code: [Select]

highest = -4
highestVal = 0
    
for (num=1; num<9; num++):
    if (eye[num]>highestVal):
        highest = num - 5
        highestVal = eye[num]
focuseye = highest
The first step to implementing that would be unrolling the loop, of course. Next I thought, well, to avoid doing a bunch of stores, we could make highest and highestVal be stack values that we change instead of actual variables. Unfortunately, that is, as far as I can tell, impossible. Actually, I can make them stack variables and do work on them just fine. The problem is that they aren't affected by the boolean stack's top value. They run whether it's true or false.

If highestVal were the topmost stack value and highest was below it, what I had for popping/dropping highestVal and changing highest was:

Code: [Select]

+ dup ^ -4 + *.eye1, with -4 and *.eye1 replaced by other values for other eyes.

I did write a version which uses stores, but it can have up to 19 stores in a cycle if the eyes are all perfectly in order so that eye2 is higher than eye1, eye3 higher than eye2, etc (DNA length 93). Here's a snippet of it with the beginning, two eyes, and the end (Actually, there is no end).

Code: [Select]

*.eyef .highestVal store

*.highestVal *.eye1 <=
-4 .focuseye store
*.eye1 .highestVal store
dropbool *.highestVal *.eye2 <=
-3 .focuseye store
*.eye2 .highestVal store
dropbool
There's one optimization in that - it starts highestVal off with the value in eyef (maybe I could actually modify eyef instead), so that no stores will be made for eyes which see nothing closer than eyef. Effectively, if the focuseye is the best one there will only be one store. If we use eyef instead of highestVal, it would be 0 stores.

OCULUS II's DNA length is 524, but of course it has the huge advantage of *always* only having one store.

Alternately, I've made something else that you might consider an improvement on OCULUS II (Although I wrote this with pybot, and the code came out very similar to OCULUS II, and then I rearranged the eye order so that it came out in the same order too, for ease of comparison). Most of the DNA came out the same, but this has most of the multiplication replaced by &, which should be faster, and it checks to make sure it isn't setting focuseye to what it is already set to. Comparisons with a lower eye to a higher eye use >= instead of >, which makes the DNA a tiny bit larger, but that means eye1 is considered more important than eye2-9, eye2 is more important than 3-9, etc. Oh, and apparently we omitted a condition set for a different eye. You omitted #6, whereas I omitted #5. This has a DNA length of 537.

Code: [Select]

-4 *.eye1 *.eye9 sub 1 add sgn 0 floor *.eye1 *.eye8 sub 1 add sgn 0 floor & *.eye1 *.eye7 sub 1 add sgn 0 floor & *.eye1 *.eye6 sub 1 add sgn 0 floor & *.eye1 *.eye5 sub 1 add sgn 0 floor & *.eye1 *.eye4 sub 1 add sgn 0 floor & *.eye1 *.eye3 sub 1 add sgn 0 floor & *.eye1 *.eye2 sub 1 add sgn 0 floor & mult 4 *.eye9 *.eye8 sub sgn 0 floor *.eye9 *.eye7 sub sgn 0 floor & *.eye9 *.eye6 sub sgn 0 floor & *.eye9 *.eye5 sub sgn 0 floor & *.eye9 *.eye4 sub sgn 0 floor & *.eye9 *.eye3 sub sgn 0 floor & *.eye9 *.eye2 sub sgn 0 floor & *.eye9 *.eye1 sub sgn 0 floor & mult add -3 *.eye2 *.eye9 sub 1 add sgn 0 floor *.eye2 *.eye8 sub 1 add sgn 0 floor & *.eye2 *.eye7 sub 1 add sgn 0 floor & *.eye2 *.eye6 sub 1 add sgn 0 floor & *.eye2 *.eye5 sub 1 add sgn 0 floor & *.eye2 *.eye4 sub 1 add sgn 0 floor & *.eye2 *.eye3 sub 1 add sgn 0 floor & *.eye2 *.eye1 sub sgn 0 floor & mult add 3 *.eye8 *.eye9 sub 1 add sgn 0 floor *.eye8 *.eye7 sub sgn 0 floor & *.eye8 *.eye6 sub sgn 0 floor & *.eye8 *.eye5 sub sgn 0 floor & *.eye8 *.eye4 sub sgn 0 floor & *.eye8 *.eye3 sub sgn 0 floor & *.eye8 *.eye2 sub sgn 0 floor & *.eye8 *.eye1 sub sgn 0 floor & mult add -2 *.eye3 *.eye9 sub 1 add sgn 0 floor *.eye3 *.eye8 sub 1 add sgn 0 floor & *.eye3 *.eye7 sub 1 add sgn 0 floor & *.eye3 *.eye6 sub 1 add sgn 0 floor & *.eye3 *.eye5 sub 1 add sgn 0 floor & *.eye3 *.eye4 sub 1 add sgn 0 floor & *.eye3 *.eye2 sub sgn 0 floor & *.eye3 *.eye1 sub sgn 0 floor & mult add 2 *.eye7 *.eye9 sub 1 add sgn 0 floor *.eye7 *.eye8 sub 1 add sgn 0 floor & *.eye7 *.eye6 sub sgn 0 floor & *.eye7 *.eye5 sub sgn 0 floor & *.eye7 *.eye4 sub sgn 0 floor & *.eye7 *.eye3 sub sgn 0 floor & *.eye7 *.eye2 sub sgn 0 floor & *.eye7 *.eye1 sub sgn 0 floor & mult add -1 *.eye4 *.eye9 sub 1 add sgn 0 floor *.eye4 *.eye8 sub 1 add sgn 0 floor & *.eye4 *.eye7 sub 1 add sgn 0 floor & *.eye4 *.eye6 sub 1 add sgn 0 floor & *.eye4 *.eye5 sub 1 add sgn 0 floor & *.eye4 *.eye3 sub sgn 0 floor & *.eye4 *.eye2 sub sgn 0 floor & *.eye4 *.eye1 sub sgn 0 floor & mult add 1 *.eye6 *.eye9 sub 1 add sgn 0 floor *.eye6 *.eye8 sub 1 add sgn 0 floor & *.eye6 *.eye7 sub 1 add sgn 0 floor & *.eye6 *.eye5 sub sgn 0 floor & *.eye6 *.eye4 sub sgn 0 floor & *.eye6 *.eye3 sub sgn 0 floor & *.eye6 *.eye2 sub sgn 0 floor & *.eye6 *.eye1 sub sgn 0 floor & mult add dup *.focuseye != .focuseye store dropbool
So what happens with yours if there are targets in two eyes with exactly the same distance? (The >=s in this one should prevent that from resulting in more than one eye's addition occurring)

39

Short bots / Nanite Detonators v2.2 (SG, F1) (Trafalgar) - (05.11.2008)

« on: May 11, 2008, 03:19:26 AM »

Revised and updated nanite detonators for the current DBII version. These don't function the way the original nanite detonators did, since the instakill tie attack exploits have been fixed. They only inherit the same premise (well, half of it*) and the means of spreading out.

These normally don't shoot, but if they have above 500 energy, they will. They don't aim very well while moving or while their enemy is moving, though, and they pay little heed to targets being out of range, but it's enough to let them finish off Bacillus' recently posted Collosus v1.1 in a more reasonable amount of time than what they were doing without shots (those colossi are nigh-immune to ties).  

P.S. They only use one eye, and it's almost half the possible radius. That reduces their vision distance, but it seems to be sufficient for their needs.

* = The half about replicating in huge numbers and overwhelming opponents, but not the half about using instakill tie attacks which no longer work.

DNA length: 1112. Genes: 1.

Code: [Select]

'Nanite Detonators 2.2.txt compiled by PyBot V2 from Nanite Detonators 2.2.pyr.
' These updated Nanite Detonators now feed off veggies (non-mutated ones, anyways), and use their energy to pump out more nanite detonator bots. The normal nanites cease reproducing after the total number of nanites reaches 500, and the ones connected to a veggie (factory nanites) stop pumping out more tiny nanites at 600, but will produce larger ones whenever they exceed 1000 body, until the total number of nanites reaches 1000.
def lastTieNum 988
def lastTiePres 986
def mode 981
def myid 985
def reproducedLastCycle 962
def isVeggie 984
cond
true
start
0 dup *.fixpos != .fixpos store dropbool
.myid dup *.tmemloc != .tmemloc store dropbool
.myid dup *.memloc != .memloc store dropbool
9136 dup *.myid != .myid store dropbool
500 dup *.eye5width != .eye5width store dropbool
*.aim 630 add dup *.setaim != *.robage 1 = and .setaim store dropbool
*.nrg 150 > *.velscalar 100 > and *.body 10 > and *.totalmyspecies 500 < and
50 .repro store
*.robage .reproducedLastCycle store
dropbool *.nrg 500 >
dupbool dupbool *.eye5 0 > *.memval 9136 != and *.robage 2 > and *.refage 2 > and and
*.refxpos *.refypos angle .setaim store
dupbool dupbool *.timer 3 & 0 = and
-1 .shoot store
10 .shootval store
not and not dupbool not dupbool *.timer 3 & 1 = and
-6 .shoot store
-10 .shootval store
not and dupbool *.timer 3 & 2 = and
.mkslime .shoot store
-31999 .shootval store
not and not or not
.shootval .shoot store
31999 .shootval store
dropbool
0 .aimshoot store
dropbool dropbool
dropbool *.numties 0 =
0 .mode store
dupbool dupbool *.eye5 0 > *.memval 9136 != and *.robage 2 > and *.refage 2 > and and
dupbool dupbool *.lastTiePres 2354 = *.lastTieNum 2354 = and and
1 .fixpos store
not and
dropbool
2354 .tie store
*.tie .tienum dupbool *.tie 0 != and store dropbool
*.refxpos *.refypos angle .setaim store
not and
dupbool dupbool *.velscalar 50 > and
dupbool dupbool *.veldx 1 > and
*.veldx .aimdx store
not and not dupbool not dupbool *.velsx 1 > and
*.velsx .aimsx store
dropbool dropbool dropbool
dropbool dropbool
dropbool dupbool dupbool *.shoot 0 = and
0 .fixpos store
dupbool dupbool *.robage 0 > and
.up dupbool *.nrg 25 > and inc dropbool
.up dupbool *.nrg 50 > and inc dropbool
.up dupbool *.nrg 75 > and inc dropbool
.up dupbool *.nrg 100 > and inc dropbool
dropbool dropbool
dropbool dropbool
not
*.numties 0 sub sgn 0 floor *.trefshell 0 sub sgn abs - ++ & *.trefeye 0 sub sgn abs - ++ & *.trefshoot 0 sub sgn abs - ++ & *.trefup 0 sub sgn abs - ++ & *.trefdn 0 sub sgn abs - ++ & *.trefsx 0 sub sgn abs - ++ & *.trefdx 0 sub sgn abs - ++ & *.tmemval 0 sub sgn abs - ++ & *.reproducedLastCycle *.robage sub abs 2 sub sgn 0 floor & dupbool dup *.isVeggie != and .isVeggie store dropbool
dupbool dupbool *.lastTieNum 2354 = and
2354 dupbool dup *.tienum != and .tienum store dropbool
dupbool dupbool *.tiepres 2354 = and
dupbool dupbool *.isVeggie 0 != and
dupbool dupbool *.mode 0 = and
.mode inc
.fixpos .tieloc store
1 .tieval store
*.trefxpos *.trefypos angle 630 add .setaim store
1 .fixpos store
not and not dupbool not dupbool *.mode 1 = and
.mode inc
.setaim .tieloc store
*.trefxpos *.trefypos angle 630 add .tieval store
not and dupbool *.mode 3 & 2 = and
.mode inc
.tie .tieloc store
9753 .tieval store
not and dupbool *.mode 10 > and
1 dupbool dup *.tielen != and .tielen store dropbool
0 dupbool dup *.mode != and .mode store dropbool
not and not or not
.mode inc
*.tiepres .tienum store
-1 .tieloc store
-10000 .tieval store
dropbool
not and not dupbool not dupbool *.tmemval 9136 != *.robage 2 > and *.reproducedLastCycle *.robage sub abs 2 > and and
dupbool dupbool *.mode -1 = and
dupbool dupbool *.nrg *.body dup add < and
-1 .tieloc store
not and
-6 .tieloc store
dropbool
-31999 .tieval store
not and
.tie .tieloc store
9753 .tieval store
dropbool
-1 .mode store
not and not or not
*.tiepres .deltie store
dropbool
not and
*.tiepres .tienum store
.shootval .tieloc store
31999 .tieval store
100 dupbool dup *.stifftie != and .stifftie store dropbool
-1 dupbool dup *.mode != and .mode store dropbool
dropbool
not and not dupbool not dupbool *.reproducedLastCycle *.robage sub abs 2 <= and
dupbool dupbool *.tiepres 0 = and
4824 dupbool dup *.tie != and .tie store dropbool
4824 dupbool dup *.deltie != and .deltie store dropbool
dropbool dropbool
not and dupbool *.lastTieNum 0 > *.lastTieNum 5 < and *.trefnrg 0 > and and
dupbool dupbool *.tiepres *.lastTieNum != *.tiepres 0 != and and
dupbool dupbool *.mode -1 != and
*.tiepres .deltie store
not and
*.tiepres .tienum store
.mode inc
dropbool
not and
*.lastTieNum .tienum store
dropbool dupbool dupbool *.multi 0 != and
dupbool dupbool *.trefnrg 100 mult *.trefnrg *.nrg add div 10 >= and
.sharenrg .tieloc store
1 *.isVeggie 9 mult add .tieval store
not and not dupbool not dupbool *.waste 100 > and
.sharewaste .tieloc store
100 .tieval store
not and not or not
.fdbody .tieloc store
100 .tieval store
dropbool
not and
.shootval .tieloc store
31999 .tieval store
dropbool dupbool dupbool *.tieang 1256 < and
*.tieang 100 add .tieang store
not and
1 .tieang store
dropbool dupbool dupbool *.tielen 100 < and
100 .tielen store
dropbool dropbool
not and dupbool *.lastTieNum 0 = *.tiepres 0 > *.tiepres 5 < and *.tiepres 4824 = or and and
*.tiepres dupbool dup *.deltie != and .deltie store dropbool
not and dupbool *.robage 2 < and
*.tiepres dupbool dup *.deltie != and .deltie store dropbool
not and dupbool *.tiepres 0 != and
*.tiepres dupbool dup *.tienum != and .tienum store dropbool
dupbool dupbool *.multi 0 != *.trefnrg 100 mult *.trefnrg *.nrg add div 2 >= and and
.sharenrg dupbool dup *.tieloc != and .tieloc store dropbool
1 dupbool dup *.tieval != and .tieval store dropbool
not and
.fdbody dupbool dup *.tieloc != and .tieloc store dropbool
100 dupbool dup *.tieval != and .tieval store dropbool
dropbool dupbool dupbool *.tieang 1256 < and
*.tieang 20 add dupbool dup *.tieang != and .tieang store dropbool
not and
1 dupbool dup *.tieang != and .tieang store dropbool
dropbool dupbool dupbool *.tielen 100 < and
100 dupbool dup *.tielen != and .tielen store dropbool
dropbool dropbool
not and not or not
4824 dupbool dup *.tie != and .tie store dropbool
4824 dupbool dup *.deltie != and .deltie store dropbool
dropbool dupbool dupbool *.robage 2 > and
dupbool dupbool *.nrg 1000 > and
dupbool dupbool *.body 10 > *.totalmyspecies 600 < and *.body 1000 > *.totalmyspecies 1000 < and or and
50 dupbool dup *.repro != and .repro store dropbool
*.robage dupbool dup *.reproducedLastCycle != and .reproducedLastCycle store dropbool
*.aim 5 rnd add 2 sub dupbool dup *.setaim != and .setaim store dropbool
not and
100 dupbool dup *.strbody != and .strbody store dropbool
dropbool
dropbool dropbool
dropbool dropbool
dropbool
*.body 1 sub dup *.fdbody != *.body 1 > *.strbody 0 = and *.nrg 700 < and and .fdbody store dropbool
*.tienum dup *.lastTieNum != *.tienum 0 != and .lastTieNum store dropbool
*.tiepres dup *.lastTiePres != .lastTiePres store dropbool
stop

40

Bug reports / Overflow error in longrunning internet simulation OPEN

« on: May 10, 2008, 09:48:24 PM »

This just happened to me too - in this case, however, I was only away for about 2 hours.

Screenshot of DB after I came back:
http://screencast.com/t/DC3kiWEK

error.sim in a zip file: http://shadowlord13.googlepages.com/overflow.error.zip

In case it's relevant: The internet log has 138 lines in it, not including the blank line at the top of it.
I'm using windows XP home sp2 on an athlon 64 x2 4600+.

41

Bot Tavern / The F1 League lives again!

« on: May 10, 2008, 06:38:03 PM »

Nice idea to do, and you're right guardian was protected by stronger bots

*cough*
Various DBII changes since the last time I was here have resulted in Guardian becoming nearly blind, and its main form of attack no longer works. (There might be other things that have broken too, who knows)

42

Internet Mode Commentary / What's going on with the DB server?

« on: May 09, 2008, 09:35:15 PM »

Where did you get that Bittorrent client, which one was it? There are a many many different bittorrent clients.

43

Bot Tavern / The amazing Antbot

« on: May 08, 2008, 12:22:34 PM »

Can't you use the * operator, or am I misunderstanding what you're saying?

44

Bugs and fixes / Changes 2.43 - 2.43.1d

« on: May 07, 2008, 07:06:29 PM »

I noticed in the changelogs that xpos, ypos, and refxpos and refypos are relative to map size instead of in the same units as dist now.

Question: How do dx, sx, etc behave now? Are they in the same units as xpos/ypos, or the same units as dist?

Do we need to do dist(refxpos, 0) to convert refxpos, for instance, to normal units now? (And would that be slow?)

This affects the position and movement code in most of my bots, which generally have a fixed angle of facing that they maintain all the time, and thus have sx and dx on the same axes that xpos and ypos are on. For instance, they may set up to refypos - ypos, and sx to refxpos - xpos.

It also applies to the target-position-prediction on many of my bots, like basically all versions of Guardian.

45

Evolution and Internet Sharing Sims / Zerobot evolution prize for conditional logic

« on: May 07, 2008, 06:38:30 PM »

Not to my knowledge.  The prize is certainly still available.

I posted this on aug 11: http://www.darwinbots.com/Forum/index.php?...p;#entry1371550

I had uploaded the bot's DNA in a zipped txt file here: http://shadowlord13.googlepages.com/bigzer...aimdx_3aims.zip (that's still a valid link)

The zerobot-descendants I wrote about in that thread had evolved pacing back and forth. If I analyzed the zerobot's DNA correctly,  it was setting .dn to -15 normally, but changing it to 365 whenever angle(0,0) < 461.

I described the approach I was using to evolving them in a post on Aug 4 and another on the 9th, in this thread (both of those were prior to the conditional evolution mentioned on the 11th): http://www.darwinbots.com/Forum/index.php?...amp;pid=1371468

I don't know if I posted the DNA for any version of my shepherd bots (I was modifying them as I went to try to encourage different directions of development) on the forums anywhere, but I still have the saved sims, and I can post the semi-unreadable DNA or readable-but-not-DB-code version of the last version of the shepherds.

This is a screenshot showing (part of) the list of saved sim files sorted by date (that's only showing the most recent 1/3 of the saved sim files): http://screencast.com/t/6XvlVQA6n

I can zip and upload any of these you would like, but I'd need to know which. I'm attempting to 7-zip all the ones from bzb4 and up now, and it's going slow, and who knows how big the 7z file will be.

(bigzerobots-1.sim, for reference, was on 7/13/2007)

I've skimmed through the changelogs, and if I understood them correctly, it sounds like some of the changes to cond stack stuff would break the conditional-behavior of the bots that I had evolved. (There are three conds which together determine whether the last gene runs, and it is that gene which gives rise to the conditional behavior)

Edit: The bzb4 sim files and all later ones were compressed by 7zip to 1.63 MB. I've uploaded the 7z file: http://shadowlord13.googlepages.com/main_bzb4to13_sims.7z

I think the bots in those sims evolved in 2.43 and 2.43a (I typo'd the version on the aug 11 post as "4.23a" and never noticed until just now).