home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / xplatfrm / tierra / queues.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-26  |  7.9 KB  |  249 lines
  1. /* queues.c  28-10-91  Artificial Life simulator */
  2. /** Tierra Simulator V3.0: Copyright (c) 1991 Thomas S. Ray **/
  3.  
  4. #include "license.h"
  5.  
  6. #ifndef lint
  7. static char     sccsid[] = "%W%     %G%";
  8. #endif
  9.  
  10. #include "tierra.h"
  11. #include "extern.h"
  12.  
  13. void IncrSliceQueue() /* increment slicer queue */
  14. {   ThisSlice = (cells + ThisSlice)->q.n_time;
  15.     while(!(cells + ThisSlice)->ld) /* get dead cells out of queue */
  16.         RmvFrmSlicer(ThisSlice);
  17. }
  18.  
  19. void EntBotSlicer(ci)
  20. I32s  ci;
  21. {   Pcells  ce; /* new cell being added to bottom of slicer queue */
  22.     Pcells  tc; /* ThisSlice cell */
  23.     Pcells  pc; /* previous slice cell */
  24.  
  25.     ce = cells + ci; tc = cells + ThisSlice; pc = cells + tc->q.p_time;
  26. #ifdef ERROR
  27.     if(ce->q.n_time != ce->q.p_time && NumCells > 1)
  28.     {   sprintf(mes[0],
  29.             "Tierra EntBotSlicer() error: cell already in slicer queue");
  30.         if (!hangup)
  31.             FEMessage(1);
  32.         else
  33.         {   sprintf(mes[1],"system being saved to disk");
  34.             FEMessage(2);
  35.         }
  36.         while(hangup) ;
  37.         WriteSoup(1);
  38.         exit(0);
  39.     }
  40. #endif
  41.     pc->q.n_time = ci; /* previous slice points to ce */
  42.     ce->q.p_time = tc->q.p_time; /* ce points back at previous slice */
  43.     ce->q.n_time = ThisSlice; /* ce points to this slice */
  44.     tc->q.p_time = ci; /* this slice points back at ce */
  45. }
  46.  
  47. void UpReaper(ci) /* move cell up the reaper queue */
  48. I32s  ci;
  49. {   I32s  pi2, pi, ni; /* 2 previous, previous and next cells in reaper */
  50.     Pcells  pe2;
  51.     Pcells  pe;
  52.     Pcells  ne;
  53.     Pcells  ce;
  54.  
  55.     if(ci == TopReap) return;
  56.     ce = cells + ci;    /* ce is cell to be moved up in reaper */
  57. #ifdef ERROR
  58.     if(ce->q.n_reap == ce->q.p_reap && NumCells > 1)
  59.     {   sprintf(mes[0],"Tierra UpReaper() error: cell not in reaper queue");
  60.         if (!hangup)
  61.             FEMessage(1);
  62.         else
  63.         {   sprintf(mes[1],"system being saved to disk");
  64.             FEMessage(2);
  65.         }
  66.         while(hangup) ;
  67.         WriteSoup(1);
  68.         exit(0);
  69.     }
  70. #endif
  71.     ni = ce->q.n_reap;  /* ni is index of next cell in reaper */
  72.     ne = cells + ni;    /* ne is next cell in reaper */
  73.     pi = ce->q.p_reap;  /* pi is index of previous cell in reaper */
  74.     pe = cells + pi;    /* pe is previous cell in reaper */
  75.     pi2 = pe->q.p_reap; /* pi2 is index of 2nd previous cell in reaper */
  76.     pe2 = cells + pi2;  /* pe2 is 2nd previous cell in reaper */
  77.     ne->q.p_reap = pi;  /* ni points back to pi */
  78.     ce->q.p_reap = pi2; /* ci points back to pi2 */
  79.     ce->q.n_reap = pi;  /* ci points ahead to pi */
  80.     pe->q.p_reap = ci;  /* pi points back to ci */
  81.     pe->q.n_reap = ni;  /* pi points ahead to ni */
  82.     pe2->q.n_reap = ci; /* pi2 points ahead to ci */
  83.     if(ci == BottomReap)
  84.         BottomReap = pi;
  85.     if(pi == TopReap)
  86.         TopReap = ci;
  87. }
  88.  
  89. void DownReaper(ci)
  90. I32s  ci;
  91. {   I32s  pi, ni, ni2; /* 2 previous, previous and next cells in reaper */
  92.     Pcells  pe;
  93.     Pcells  ce;
  94.     Pcells  ne;
  95.     Pcells  ne2;
  96.  
  97.     if(ci == BottomReap) return;
  98.     ce = cells + ci;    /* ce is cell to be moved down in reaper */
  99. #ifdef ERROR
  100.     if(ce->q.n_reap == ce->q.p_reap && NumCells > 1)
  101.     {   sprintf(mes[0],"Tierra DownReaper() error: cell not in reaper queue");
  102.         if (!hangup)
  103.             FEMessage(1);
  104.         else
  105.         {   sprintf(mes[1],"system being saved to disk");
  106.             FEMessage(2);
  107.         }
  108.         while(hangup) ;
  109.         WriteSoup(1);
  110.         exit(0);
  111.     }
  112. #endif
  113.     ni = ce->q.n_reap;  /* ni is index of next cell in reaper */
  114.     ne = cells + ni;    /* ne is next cell in reaper */
  115.     ni2 = ne->q.n_reap; /* ni2 is index of 2nd next cell in reaper */
  116.     ne2 = cells + ni2;  /* ne2 is 2nd next cell in reaper */
  117.     pi = ce->q.p_reap;  /* pi is index of previous cell in reaper */
  118.     pe = cells + pi;    /* pe is previous cell in reaper */
  119.     pe->q.n_reap = ni;  /* pi points ahead to ni */
  120.     ce->q.n_reap = ni2; /* ci points ahead to ni2 */
  121.     ce->q.p_reap = ni;  /* ci points back to ni */
  122.     ne->q.n_reap = ci;  /* ni points ahead to ci */
  123.     ne->q.p_reap = pi;  /* ni points back to pi */
  124.     ne2->q.p_reap = ci; /* ni2 points back to ci */
  125.     if(ci == TopReap)
  126.         TopReap = ni;
  127.     if(ni == BottomReap)
  128.         BottomReap = ci;
  129. }
  130.  
  131. void UpRprIf(ci)
  132. I32s  ci;
  133. {   if((cells + ci)->d.flags >= (cells + (cells + ci)->q.p_reap)->d.flags)
  134.     UpReaper(ci);
  135. }
  136.  
  137. void DownReperIf(ci)
  138. I32s  ci;
  139. {   if((cells + ci)->d.flags <= (cells + (cells + ci)->q.n_reap)->d.flags)
  140.     DownReaper(ci);
  141. }
  142.  
  143. void EntBotReaper(ci)
  144. I32s  ci;
  145. {   Pcells  ce; /* cell to be added to the bottom of reaper queue */
  146.     Pcells  be; /* cell presently at bottom of reaper queue */
  147.  
  148.     ce = cells + ci; be = cells + BottomReap;
  149. #ifdef ERROR
  150.     if(ce->q.n_reap != ce->q.p_reap && NumCells > 1)
  151.     {   sprintf(mes[0],
  152.             "Tierra EntBotReaper() error: cell already in reaper queue");
  153.         if (!hangup)
  154.             FEMessage(1);
  155.         else
  156.         {   sprintf(mes[1],"system being saved to disk");
  157.             FEMessage(2);
  158.         }
  159.         while(hangup) ;
  160.         WriteSoup(1);
  161.         exit(0);
  162.     }
  163. #endif
  164.     ce->q.p_reap = BottomReap; /* new cell points back to old BottomReap */
  165.     ce->q.n_reap = 1; /* new cell points ahead to dummy bottom */
  166.     be->q.n_reap = ci; /* old BottomReap cell now points ahead to ce */
  167.     (cells + 1)->q.p_reap = ci;
  168.     BottomReap = ci; /* BottomReap is now ci */
  169. }
  170.  
  171. void RmvFrmReaper(ci)
  172. I32s  ci;
  173. {   Pcells  ce; /* cell to be removed from reaper queue */
  174.     Pcells  nc; /* next cell in reaper queue */
  175.     Pcells  pc; /* previous cell in reaper queue */
  176.  
  177.     ce = cells + ci; nc = cells + ce->q.n_reap; pc = cells + ce->q.p_reap;
  178. #ifdef ERROR
  179.     if(ce->q.n_reap == ce->q.p_reap && NumCells > 1)
  180.     {   sprintf(mes[0],
  181.             "Tierra RmvFrmReaper() error: cell not in reaper queue");
  182.         if (!hangup)
  183.             FEMessage(1);
  184.         else
  185.         {   sprintf(mes[1],"system being saved to disk");
  186.             FEMessage(2);
  187.         }
  188.         while(hangup) ;
  189.         WriteSoup(1);
  190.         exit(0);
  191.     }
  192. #endif
  193.     if(ci == TopReap) /* TopReap changed to next cell in queue */
  194.         TopReap = ce->q.n_reap;
  195.     if(ci == BottomReap) /* BottomReap changed to previous cell in queue */
  196.         BottomReap = ce->q.p_reap;
  197.         /* previous cell points ahead to next cell: */
  198.     pc->q.n_reap = ce->q.n_reap;
  199.         /* next cell points back to previous cell: */
  200.     nc->q.p_reap = ce->q.p_reap;
  201.     ce->q.p_reap = ce->q.n_reap = ci; /* initialize reap queue this cell */
  202. #ifdef ERROR
  203.     if(ce->q.n_time != ce->q.p_time && NumCells > 1)
  204.     {   sprintf(mes[0],
  205.             "Tierra RmvFrmReaper() error: cell still in slicer queue");
  206.         if (!hangup)
  207.             FEMessage(1);
  208.         else
  209.         {   sprintf(mes[1],"system being saved to disk");
  210.             FEMessage(2);
  211.         }
  212.         while(hangup) ;
  213.         WriteSoup(1);
  214.         exit(0);
  215.     }
  216. #endif
  217. }
  218.  
  219. void RmvFrmSlicer(ci)
  220. I32s  ci;
  221. {   Pcells  ce; /* cell to be removed from slicer queue */
  222.     Pcells  nc; /* next cell in slicer queue */
  223.     Pcells  pc; /* previous cell in slicer queue */
  224.  
  225.     ce = cells + ci; nc = cells + ce->q.n_time; pc = cells + ce->q.p_time;
  226. #ifdef ERROR
  227.     if(ce->q.n_time == ce->q.p_time && NumCells > 1)
  228.     {   sprintf(mes[0],
  229.             "Tierra RmvFrmSlicer() error: cell not in slicer queue");
  230.         if (!hangup)
  231.             FEMessage(1);
  232.         else
  233.         {   sprintf(mes[1],"system being saved to disk");
  234.             FEMessage(2);
  235.         }
  236.         while(hangup) ;
  237.         WriteSoup(1);
  238.         exit(0);
  239.     }
  240. #endif
  241.         /* previous cell points ahead to next cell: */
  242.     pc->q.n_time = ce->q.n_time;
  243.         /* next cell points back to previous cell: */
  244.     nc->q.p_time = ce->q.p_time;
  245.     if(ci == ThisSlice)
  246.         ThisSlice = ce->q.n_time;
  247.     ce->q.n_time = ce->q.p_time = ci; /* initialize slice queue this cell */
  248. }
  249.