OpenEuphoria

1. maze bots: playing field suggestions

• Posted by isaac <isaaca at MINDSPRING.COM> Nov 06, 1998
• 449 views

It seems to me program executing the bots would haveto have  it's own set
of rules as to what instructions it would allow, but these should be equal
and agreed upon ahead of time (each executor would be a game unto itself).
Also, actions must be carried out by the executor, not the bots themselves,
else cheating would be in shades of grey, and the list would flood with
irate posters with dead bots.  I see two ways of doing this:

The first would be to think of the executor as a proccesor; each bot would
be a file containing a binary string (or perhaps a get() readable sequence)
written in something resembling assembly language.  The executor would
handle memory/computation with a set of virtual registers assigned to each
bot. Control might alternate turn by turn, each turn ending with something
like an interrupt, an instruction by which the bot would actually do
something(move, shoot, communicate, etc).  Or instructions could be carried
out simultaneously, thus rewarding efficient computation, with the executor
acting as ref where they conflict(A_bot shoots Z_bot on the same turn Z_bot
moves out of the square A_bot was shooting at).  It may seem awkward to
program in terms of {24,17,33,04}, but if commands were defined as
constants in an assembler (written in Euphoria of course) it wouldn't be
too hard.

The second method would allow the bots to be written in euphoria as well,
rather than just the executor.  Each bot would be an include containing a)
one or several fuctions to be called by the executor to which would be
passed game information and which would return an instruction understood by
the executor (again, a standardized instruction set for each executor) b)
something to the effect of:


outside of any routine, to be executed when the bot is included.  The
executor would begin with something like:

global sequence ROUTE
seqence move,fire,sense
move={}
fire={}
sense={}

include A_bot.bot
move=move&ROUTE[1]
fire=fire&ROUTE[2]
sense=sense&ROUTE[3]
ROUTE={}

include Z_bot.bot
move=move&ROUTE[1]
fire=fire&ROUTE[2]
sense=sense&ROUTE[3]
ROUTE={}

etc.
Using routine_id() means less need be changed when the contestants or
number of contestants change.

The advantage of the first method is that the bots must use equal and
limited memory spaces, making for a more rigourous programing environment.
Also, bots could be rewarded for more efficient computations (though this
could be accomplished with the second method as well by checking the bots'
times returning from each function). The advantage of the second method is
that it teaches Euphoria in a competative environment (and besides, we'd
all rather program in Euphoria anyway, right?)

Well, enough of my rambling.  We'll see what developes.

        isaac