copyright (c) 1992, 2003 Aaron Maupin
fluffies.zip 1700k Windows 98 and above required
Fluffies! is the graphical representation of a small ecological
simulation that I came up with 11 years ago. Two lifeforms are
simulated - slightly complex prey called fluffies, and simple
predators called nasties. The fluffies move around a 10x10 map
in search of pebbles, which they collect. The more pebbles they
collect the happier they become. Each location on the map grid
has one of eight different terrain types, one of five objects (or
no object at all), and up to ten pebbles.
The simulation is a turn-based one. (Yes, I realize turn-based
sims are rather old school, but I wanted to create exactly the
simulation as I first envisioned it.)
Each fluffy has 4 attributes:
Health (1-10): When health reaches zero a fluffy dies.
Health is decreased by one every turn that a
fluffy is starving, parched, or drowning.
It is also decreased in rare occasions
when the fluffies are extremely
uncomfortable due to weather/terrain.
Health is increased when a fluffy eats.
Intelligence (1-10): Smarter fluffies move toward hiding
shelters when they see a nearby
nasty, or weather shelters if the
weather is bad. Dumb fluffies
panic more often, running in the
opposite direction of the first nasty
they see.
Perception (1-10): Fluffies with higher perception have
a better chance of seeing objects/
nasties in nearby squares. Thus they
are better able to find food and water
or escape nasties. A fluffy with a
perception of 1 has only one chance
to look outside of its current square
per turn, while a fluffy with 10
perception slots will look at 10 random
squares and use that information to
decide what to do.
Noticability (1-10): Fluffies with higher noticability
are more likely to be seen by nasties.
Unlike the fluffies, nasties cannot be killed. They are the
ultimate killing machines.
The graphics are modular and may be improved:
Clicking on fluffies, nasties, or terrain will display information
at the right of the map.
Special terrain:
Dense Forest: Fluffies and nasties cannot see into it.
Water: Fluffies that fall into water can (AND WILL) drown.
Years ago, a GEnie reviewer commented, "For God's
sake don't name the fluffies after your housepets."
A fluffy's mood is determined by a mixture of terrain, weather,
and the number of pebbles it has.
Special objects:
Food dispensor: The only source of food for fluffies.
Water dispensor: A source of water. Fluffies can also drink
from water squares on the map, or catch
rainwater if it's raining.
Weather shelter: Shelters fluffies from the weather but is not
completely safe from nasties.
Hiding shelter: Completely safe from nasties. Nasties cannot
see into them or get at fluffies inside them.
Spinner: The spinners are colorful pinwheels. They are to
fluffies what televisions are to humans.
There are six different weather types: sunny, rainy, stormy, mellow,
sizzling, and humid.
Which traits aid survival time the most? I recorded 112 runs of the
logfile survivor.txt (included). There are 9 fluffies in survivor.txt.
They each have one trait at the extreme end of the scale (1 or 10), and
the rest of the traits are all average (5). They all start in the same
square, with 4 nasties on the opposite end of the map.
The higher the number, the more quickly the fluffy died in relation to
its comrades:
Weakling Health:1 811
Blindy PER:1 635
Neon NOT:10 579
Looky PER:10 547
Baxter control 540
Stupid INT:1 531
Smarty INT:10 496
Healthy Health:10 468
Camo NOT:1 415
Not surprisingly, Camo tended to die last, while Weakling dies first.
What is surprising is that there is a range where high perception,
stupidity, and intelligence tend to blend together. Baxter, the control,
and Looky, with a perception of 10, almost perform the same. However
Blindy, with a perception of 1, does slightly worse. It seems that once
perception is at 5, anything higher doesn't much effect the fluffy's
survival (in relation to other fluffies).
You can compare the results to the same number of experiments run on the
file skull-island.txt (donated by Matt Rea), a map with the same fluffies,
but lots of water, five nasties, and only 2 food dispensors:
Weakling 738
Neon 684
Blindy 608
Stupid 529
Baxter 528
Smarty 522
Looky 522
Healthy 506
Camo 393
I may do another run, recording the total amount of turns a fluffy lives,
which I expect would put some more space between the numbers above.
Disclaimer
----------
You use Fluffies! at your own risk! No warranty is provided, the
software is available "as is" and any effects it may cause are not
the responsibility of its author. The author will not be liable for
any damage it does to your computer.
Fluffies! is written in Visual Basic.
Translating a 10x10 static grid to a 400x400 pixel map was a bit
challenging, but the most impressive thing about Fluffies! is the
routine to generate the map bitmap. It uses none of VB's graphical
functions but instead generates the bitmap by reading source bitmaps
as binary files and overlapping them in a large array, with built-in
transparency. In the process of writing this routine I generated an
easy way to make seamless grids (that are not rudely divided into
squares) that I may use in future programs.
Why is this program so strange? Because I wrote it originally when I
was in high school. It's anyone's guess what I was thinking back then.
This version makes no changes from the original, only adding a graphical
front end so you can see what's happening rather than printing out an
ascii map every turn.
Version history
---------------
v1.0
First release
v1.05
Added window icon.
Fixed a bug in which blood sprites (left on the map after a fluffy
is killed) could sometimes appear in front of other objects.
Fixed a bug in which fluffies sometimes talked/interacted with
blood sprites. (Fluffies are supposed to occasionally talk to
fluffies that have died of natural causes.)
v1.1
Added the function to log events.
v1.2 (Current Release)
Logfiles ("fluffylog.txt") are now created automatically.
Fluffies! can now load states from these logfiles, including
map data, and fluffy and nasty data. This also means you
can create your own maps using a text editor. Some samples
are included. If you want to run an experiment more than
once, just rename the file "fluffylog.txt" (created when
you first run the simulation) and then load it as many times
as you like.
Fixed some bugs in the Setup window that would crash the
program if "cancel" was selected.
There is a major bug in the current release involving reparsing
fluffy logfiles. When logfiles are loaded the random number pool
is not reseeded. For now, generating a random map before reparsing
a logfile will bypass this bug, because generating a map calls the
randomize timer function.
This page is still under construction.
This site and Fluffies! copyright © 1992, 2003 Maupin.