Keskustelu: Ohjelmointikysymykset: Limbo: Langton's Ant

implement LangtonsAnt;

include "sys.m";
   sys: Sys;

include "draw.m";
   draw: Draw;
   Context, Display, Point, Rect, Image, Screen: import draw;

include "tk.m";
   tk: Tk;
   Toplevel: import tk;

include   "tkclient.m";
   tkclient: Tkclient;



LangtonsAnt: module
{
   init:   fn(ctxt: ref Context, argv: list of string);
};



display : ref Display;
t: ref Toplevel;

EMPTY, TRAIL : con iota;

MAPX : con 100;
MAPY : con 100;

IMAPX : con MAPX + 1;
IMAPY : con MAPY + 1;

CELLX : con 5;
CELLY : con 5;

PAD : con 1;

BUFX : con (MAPX * CELLX) + ((MAPX + PAD) * PAD);
BUFY : con (MAPY * CELLY) + ((MAPY + PAD) * PAD);


map := array[IMAPX] of { * => array[IMAPY] of { * => EMPTY } };


Tick: adt {
   delay: int;
   new : fn(delay : int) : ref Tick;
   set : fn(t : self ref Tick, delay : int);
};


tickch : chan of int;
tick : ref Tick;




langton_cfg := array[] of {
   "frame .f",
   "frame .b",
   "scale .b.delay -label {Delay of simulation} -from 10 -to 2000 -orient horizontal" +
      " -showvalue 0 -command {send cmd delay}",
   ".b.delay set 1000",
   "pack .b.delay -side left -fill x -expand 1",
   "pack .b -side top -fill both -expand 1",
   "pack .f -side bottom -fill both -expand 1"
};





init(ctxt: ref Context, nil: list of string)
{
   sys = load Sys Sys->PATH;
   draw = load Draw Draw->PATH;
   tk = load Tk Tk->PATH;
   tkclient = load Tkclient Tkclient->PATH;

   sys->pctl(Sys->NEWPGRP, nil);

   tkclient->init();

   if(ctxt == nil)
      ctxt = tkclient->makedrawcontext();

   display = ctxt.display;

   menubut: chan of string;
   (t, menubut) = tkclient->toplevel(ctxt, "", "Langton's Ant", 0);

   cmdch := chan of string;
   tk->namechan(t, cmdch, "cmd");

   for (i := 0; i < len langton_cfg; i++)
      cmd(t, langton_cfg[i]);

   cmd(t, "update");

   tkclient->startinput(t, "ptr"::"kbd"::nil);
   tkclient->onscreen(t, nil);

   tickch = chan of int;
   tick = Tick.new(1000);

   spawn simulate();

   for(;;) alt {
   s := <- t.ctxt.kbd =>
      tk->keyboard(t, s);
   s := <- t.ctxt.ptr =>
      tk->pointer(t, *s);
   s := <- t.ctxt.ctl or
   s = <- t.wreq or
   s = <- menubut =>
      tkclient->wmctl(t, s);

   cmd := <- cmdch =>
      (nil, tokens) := sys->tokenize(cmd, " ");
      if(hd tokens == "delay")
      {
         tick.set(int hd tl tokens);
      }

   }

}



simulate()
{
   dirs := array [4] of { Point(-1, 0), Point(0, 1), Point(1, 0), Point(0, -1) };
   antdir := 0;

   cellr := Rect((0,0), (CELLX, CELLY));
   bufr := Rect((0,0), (BUFX, BUFY));

   antmap := Point(MAPX / 2, MAPY / 2);
   antbuf := Point(antmap.x * CELLX, antmap.y * CELLY);
   antbuf = antbuf.add(Point(antmap.x * PAD + PAD, antmap.y * PAD + PAD));
   last := antbuf;

   colour := array [2] of ref Image;

   colour[0] = display.white;
   colour[1] = display.black;

   red := display.color(Draw->Red);

   buffer := display.newimage(bufr, t.image.chans, 0, Draw->Black);
   if (buffer == nil) {
      sys->fprint(sys->fildes(2), "Langton's Ant: failed to allocate image\n");
      exit;
   }

  for(y := 0; y < MAPY; y ++)
      for(x := 0; x < MAPX; x ++)
      {
         p1 := Point(x * CELLX, y * CELLY);
         p2 := Point(x * PAD + PAD, y * PAD + PAD);
         p := p1.add(p2);

         buffer.draw(cellr.addpt(p), colour[map[x][y]], nil, Point(0, 0));
      }

   buffer.draw(cellr.addpt(antbuf), red, nil, Point(0, 0));

   cmd(t, "panel .f.p -bd 3 -relief flat");
   cmd(t, "pack .f.p -fill both -expand 1");

   tk->putimage(t, ".f.p", buffer, nil);
   cmd(t, ".f.p dirty; update");

   sys->sleep(1000);
   spawn ticker(tickch, tick);

   while(1)
   {
      <- tickch;


      if(map[antmap.x][antmap.y] == TRAIL)
      {
         map[antmap.x][antmap.y] = EMPTY;
         buffer.draw(cellr.addpt(antbuf), colour[EMPTY], nil, Point(0, 0));
         antdir = (antdir + 1) % 4;
      }
      else
      {
         map[antmap.x][antmap.y] = TRAIL;
         buffer.draw(cellr.addpt(antbuf), colour[TRAIL], nil, Point(0, 0));
         antdir = (antdir + 3) % 4;
      }

      antmap = antmap.add(dirs[antdir]);
      antmap.x = (antmap.x + MAPX) % MAPX;
      antmap.y = (antmap.y + MAPY) % MAPY;

      antbuf = Point(antmap.x * CELLX, antmap.y * CELLY);
      antbuf = antbuf.add(Point(antmap.x * PAD + PAD, antmap.y * PAD + PAD));

      dirtyr1 := cellr.addpt(last);
      dirtyr2 := cellr.addpt(antbuf);
      dirtyr := dirtyr1.combine(dirtyr2);

      last = antbuf;

      buffer.draw(cellr.addpt(antbuf), red, nil, Point(0, 0));

      cmd(t, ".f.p dirty " + r2s(dirtyr) + "; update");

   }

}



Tick.new(delay : int) : ref Tick
{
   t := ref Tick (delay);
   return t;
}


Tick.set(t : self ref Tick, delay : int)
{
   t.delay = delay;
}



ticker(tick: chan of int, ticki: ref Tick)
{
   tick <-= 1;

   while((delay := ticki.delay) >= 0) {
      sys->sleep(delay);
      tick <-= 1;
   }

   tick <-= 0;
}



r2s(r: Rect): string
{
   return sys->sprint("%d %d %d %d", r.min.x, r.min.y, r.max.x, r.max.y);
}



cmd(win: ref Tk->Toplevel, s: string): string
{
   r := tk->cmd(win, s);
   if (len r > 0 && r[0] == '!') {
      sys->print("error executing '%s': %s\n", s, r[1:]);
   }
   return r;
}