512 Final Homework

Demonstration

Description

If you use the "curses" or "ncurses" package (info here) it will be fairly easy to produce a real-time display of exactly what is going on. But that is not required.

The creatures should communicate with each other when they meet (not necessarily every time, but at least sometimes). It doesn't really matter what they communicate, so long as it is in some way real information. Perhaps you could scatter some "interesting" objects about their world for them to find and tell each other about.

The creatures must be object oriented (that is, there should be a class to represent creatures, with appropirate methods and members, and each creature should be represented by an object in that class).

The creatures should run independently in their own threads (info here), making their own moves in their own time. They should not simply be animated by a "main program" that processes each one in turn in an endless loop.

Because the creatures run in their own time in their own threads, you will have to be careful to avoid the problems that occur when two threads try to modify the same data at the same time. This should only be a problem in communications, so make sure you use an interlocked queue (info here) or something similarly protected to deliver messages.

Design Ideas

It might be a good idea to have the World itself represented by a single object. There will probably only be one world in your simulation, so defining a whole class just for one object may seem a little wasteful, but it does help to keep things organised. Instead of dozens of different global variables to represent various aspects of the world, you'd just have a single globally accessible object, with public members or methods to give access to the important thing.

Assuming that the class to represent the world is called "World", and the class to represent creatures is called "Creature", you would probably have something like this (only larger):

class World
{ ...
    Creature *population[POPMAX];
    int threads[POPMAX];
    int current_population;
    char map[MAPMAX][MAPMAX];
  ...
    World(void); // initialise map, create creatures, start them running
    void redisplay(void);
  ... };

Remember that when you start a thread, you get an integer that can be used to refer to that thread again later (this allows you to check to see if a particular thread is still running or if it has terminated). The "threads" array is simply used to keep these integer thread references safe.

Making the map a two dimensional array of characters is a very simple way of doing things. You may choose to have something more sophisticated.

The redisplay() function may or may not be needed, depending on the design you choose. The idea here is that each creature as it is running will occasionally decide to move or do something else that should make the display move. Curses and ncurses don't automatically update the display after every change, they need to be told to do it. So, whenever a creature has made all the modifications to the world that it needs to make, it can call the world's redisplay() method. This would be where curses is told to do its stuff (by refresh() or wrefresh()). This way, you can keep all the curses operations insode the World class, and none of the rest of the program will need to even know they exist.

You will almost certainly design your creature class to have at least the following parts:

class Creature
{ ...
    char myname;
    int mypos_x, mypos_y;
    World *w;
  public:
    Creature(World *wo);
    void main(void);
    void tell(Message m);
  protected:
    Queue incoming_messages;
  ... };

The idea here is that a creature knows its own name and position in the world. (The name is just a single character so that it will fit nicely in the map for displaying). The constructor for a creature initialises all the members approriately. it would be a very good idea if a creature also has a pointer to the world it is part of, then you might not need ugly global variables at all.

Some other function (probably a method (perhaps the constructor) of the World object) will create all the creatures, then start them running in their own threads. The bit of program that creates the creatures and starts them running might look like this (assuming it is a method of World):

  for (int i=0; i<desired_population; i+=1)
  { population[i]=new Creature(this);       // this creates the creatures
    current_population=i+1; }
  ...
  for (int i=0; i<current_population; i+=1)
  {                                         // this starts them running
    threads[i]=start_thread(creature_starter,i); }

void creature_starter(int n)
{ Creature *c=the_world.population[n];
  c->main(); } 

Therefore, each creature's main() method should have a non-terminating loop. Each time round the loop, it can look at its message queue, to see if anyone has sent it a message, it can decide whether or not it wants to move somewhere, it can do anything else it likes, but IT MUST take a little rest (using the sleep() or usleep()) function. If it doesn't take a little rest it will just swallow up all of the CPU time, and no other creatures will be able to do anything, and nobody else will be able to use the computer. usleep() takes a single integer parameter, which tells it the number of micro-seconds (millionths of a second) to rest.

So your creatures' main() methods might look something like this:

void main(void)
{ ...  // set up before starting
  while (alive)
  { usleep(200000);
    if (!(incoming_messages.isempty()))
    { Message *m=incoming_messages.remove();
      // deal with message *m }
    if (you want to move)
    { work out where, update the world's map
         w->map[oldy][oldx]=' ';
         w->map[y][x]=myname;
      and do all the other related stuff, then call
         w->redisplay(); }
    if (you want to do anything else)
    { do it } } }