Hi all you MSX freaks!
Stefano Fronteddu <[EMAIL PROTECTED]> launched this idea:
> I was thinking to develop a battle game: blah, what the news !!! No
> this was my idea:
>
> I intended to develop a program that was able to read 2 files.
> These files were the source code to control the action of a
> simulated 'robot'.
>
> I must be more clear ....
>
> The game screen is a grid of established dimension.
> Each cells can contain one of these objects (randomized
> positioning):
>
> NULL
> Enemy's robot
> pyramid (Marco Casali will apreciate this)
> cobweb
> mine
>
> Pyramids are the place where robots can find new weapons (laser,
> shield, mines, ...). If a robot goes in a cell where there is a
> cobweb is blocked for 2 turns. If a robot goes in a cell with a mine
> it takes 3 damnages.
>
> (etc.)
I love it!
These kinds of simulations are one of the things I love to run on my
computer, when I run into these.
This immediately made me think of Conway's game of Life (I think you
will know this).
Your idea seems like a similar 'recipe' for such a simulation. I did
wonder about this: did you cook this up yourself, or is it something
you found elsewhere (and maybe modified it a bit)? If so, can you
please tell us where you found this, who figured out the original
concept of this?
I'm not going to program this I think, but if anyone else does, I
volunteer as a beta-tester, to see how to make it a more interesting
simulation!
This made me remember several similar things, for anyone who's going
to use this idea:
I saw on TV once a simulation, where 2 robots where put against each
other in a simple 'arena' (a square playingfield), with only 1 goal:
to get a 'prize' (a simple ball, initially placed in the middle), and
take it home (to some corner, or back to their own starting
position).
At the start, these 2 robots would ofcourse have equal chances, by
putting them on opposite sides, but equal distance from the prize.
These 2 robots had certain characteristics, like speed, weight,
endurance, and (important) a certain shape.
The simulation would modify these parameters slightly each for one,
or both robots (in a different way), and run a number of simulations,
to see what set of characteristics would show to be the most
succesfull one. By trying this back and forth with the robots used in
previous simulations, you could watch an entire 'evolution' evolving
in the shapes and other characteristics of these robots.
I guess it was done this way, that changing a single parameter would
either be non-related to others (like the program controlling the
behaviour of the robots), or have its effect on other parameters: if
an 'arm' was made longer, the weight would increase, making it
slower, or taking more effort to move, and thus giving it less
endurance.
Or making it move faster, but with less accuracy, etc. etc.
You would see robots 'growing' longer arms, to be able to reach the
prize before the other one did.
One might see opponents of such a robot 'respond' by getting smaller,
but faster, in order to grab the prize first, and make a run for it.
Or some might get an extra large body, to be able to put themselves
between the prize and the other robot, to prevent this other one from
grabbing it back from them, etc.
Fun to watch!
Another related idea is this:
In a simulated 'computer', the 'lifeforms' consist of pieces of
program code, written in a simple code (like for a stripped Z80), and
given small amounts of CPU-time one by one (I'm not sure how
exactly).
Purpose for each 'liveform' was to survive, that is, to keep a copy
of itself somewhere in the simulated CPU memory (like a computer
virus), and maybe have many 'children' (copies in other places in
this memory).
At the start, a number of simple liveforms would be put in here (or
the memory filled with random data), and to make it more
interesting, this memory would have random bit changes from time to
time (call it 'mutations', or 'radiation effects').
You would see simple liveforms, that would simply copy itself to a
bit futher on in memory, to get a copy, and thus survive, when
another program/liveform would erase their initial one.
After a while, more sophisticated methods would be seen: a program
might use parts of other liveforms to copy themselves (by calling, or
copying these), to save program size of their own, and thus allow to
copy themselves quicker than others (shorter program = less CPU
cycles needed to copy the thing).
And ofcourse you would get a separation in different techniques used:
some liveforms might stay small and simple, to be able to copy
themselves more quickly, and survive by numbers. Others might grow
more sophisticated instead, to prevent being erased, or actively hunt
down/erase others.
An idea I had myself once, was to run a simulation of an ant heap (or
several), in a simulated environment.
Scientists have always wondered, how it is possible that such simple
creatures like ants, or bees, can produce such complex societies,
when put together in large numbers.
I think the common idea these days is, that for every single ant, or
bee or such, the behaviour is controlled by a very limited number of
simple 'rules' (some estimated something like 250 very basic rules,
together fully describing the behaviour of an ant), and that the
resulting complexity simply comes from numbers, and a long evolution
of the physical properties, and sets of rules, making up each ant.
My idea was, to make a simulation of this by running one or several
heaps of simulated ants, were each ant would be similar to the
creatures wandering around in computer games: described by a simple
set of rules and variables, and simply processed in a row, with
discrete steps in time to control their movements.
You might take a couple of hundred (thousands?) of ants, put 'food'
in random places, place obstacles in the way, or introduce hazards
like 'no-go areas', unrelated types of enemies, natural disasters,
competing, but differently working ant species, or make different
types of ants (workers, fighters) etc. etc. etc., and just watch what
happens.
Would make a great screensaver, I think!
P.S. Does anyone know of such simulations written for MSX machines,
and similar 'recipes' for simulations?
I gave the above ideas, and I know of implementations of Conway's
Live game for MSX (one called 'bosbrand', by the MCCM, and another
one written by myself once). But are there more versions of this Live
simulation, or other simulations like it, written for MSX?
Greetings,
Alwin Henseler ([EMAIL PROTECTED])
http://huizen.dds.nl/~alwinh/msx (MSX Tech Doc page)
****
MSX Mailinglist. To unsubscribe, send an email to [EMAIL PROTECTED] and put
in the body (not subject) "unsubscribe msx [EMAIL PROTECTED]" (without the
quotes :-) Problems? contact [EMAIL PROTECTED] (www.stack.nl/~wiebe/mailinglist/)
****
