home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format 105 / af105sub.adf / Beyondthedark.LZX / BeyondTheDark / Developer / Source / Boxes / Boxes.c next >
C/C++ Source or Header  |  1990-09-06  |  17KB  |  928 lines
  1. /*
  2.  * 1995; Gary Duncan (gduncan@werple.net.au)
  3.  *
  4.  *      - based on boxes code from DlineArt (released with DMouse)
  5.  *
  6.  *      - this is freeware.
  7.  *
  8.  *
  9.  */
  10. /*-------------------------------------------------------------*/
  11.  
  12. /*-------------------------------------------------------------
  13. Functions:-
  14.  
  15.  
  16. PenCountMyBlanker (TAGITEM * TagList)
  17. QueryMyBlanker (void)
  18. InitMyBlanker (TAGITEM * TagList)
  19. EndMyBlanker (BOXES * BX)
  20. AnimMyBlanker (BOXES * BX)
  21. MyBlankerLibFree (void)
  22. MyBlankerLibInit (void)
  23. do_box (RASTPORT * rp, XY * start, XY * end, XY * limit)
  24. checkbounce_start (XY * start, XY * limmax, XY * limmin)
  25. checkbounce_end (XY * end, XY * limmax, XY * limmin)
  26. get_rand_point (int min, int max)
  27. get_rand_dir ()
  28. get_rand_scale ()
  29. my_ran (int lim)
  30. time_diff (ULONG e_freq, ECLOCKVAL * e_val1, ECLOCKVAL * e_val2)
  31. open_timer (void)
  32. close_timer (void)
  33. DrawBounds (RASTPORT * rp, XY * tlhc, XY * brhc)
  34. init_array (BOXES * BX)
  35.  
  36. -------------------------------------------------------------*/
  37.  
  38. #include <stdlib.h>
  39. #include <stdio.h>
  40. #include <exec/types.h>
  41. #include <ctype.h>
  42. #include <fcntl.h>
  43. #include <string.h>
  44.  
  45. #include <clib/dos_protos.h>
  46. #include <clib/intuition_protos.h>
  47. #include <clib/graphics_protos.h>
  48. #include <clib/macros.h>
  49. #include <clib/timer_protos.h>
  50. #include <devices/timer.h>
  51. #include <dos/dos.h>
  52. #include <exec/memory.h>
  53. #include <exec/lists.h>
  54. #include <exec/nodes.h>
  55. #include <exec/execbase.h>
  56. #include <graphics/text.h>
  57. #include <graphics/gfxbase.h>
  58. #include <intuition/preferences.h>
  59. #include <intuition/screens.h>
  60. #include <intuition/intuitionbase.h>
  61. #include <libraries/dos.h>
  62. #include <libraries/dosextens.h>
  63. #include <libraries/iffparse.h>
  64. #include <proto/dos.h>
  65. #include <proto/exec.h>
  66. #include <proto/graphics.h>
  67. #include <proto/intuition.h>
  68. #include <proto/utility.h>
  69. #include <time.h>
  70. #include <utility/tagitem.h>
  71.  
  72. #include "/BTD.h"
  73.  
  74. #include "typedefs.h"        /* GMD */
  75. /*-------------------------------------------------------------*/
  76.  
  77. #if 0
  78. #define DPUTSTR(x) DPutStr(x)
  79. void DPutStr (char *p);
  80. #else
  81. #define DPUTSTR(x)
  82. #endif
  83.  
  84. #define DTAG(o) (BTD_Client+(o))
  85.  
  86. #define BX_Boxes DTAG(0)
  87. #define BX_Speed DTAG(1)
  88.  
  89. #define DEF_BOXES 10L
  90. #define MAX_BOXES 20L
  91. #define MINBOUND 10
  92.  
  93. #define MIN_SPEED 1L
  94. #define MAX_SPEED 10L
  95.  
  96. typedef struct BTDInfo BTDINFO;
  97. typedef struct BTDDrawInfo BTDDRAWINFO;
  98.  
  99. typedef struct XY
  100.   {
  101.     LONG x;
  102.     LONG y;
  103.   }
  104. XY;
  105.  
  106. typedef struct DIRECTION
  107.   {
  108.     XY start;
  109.     XY end;
  110.   }
  111. DIRECTION;
  112.  
  113.  
  114.  
  115. #define FindTagData(l,t,d) GetTagData((t),(d),(l))
  116.  
  117. INTUITIONBASE *IntuitionBase;
  118. GFXBASE *GfxBase;
  119. TIMERBASE *TimerBase;
  120. TIMEREQUEST box_timer;
  121. TIMEREQUEST *t_ptr = &box_timer;
  122. ECLOCKVAL e_then, e_now, e_lcolch;
  123. ULONG e_freq;
  124.  
  125. typedef struct
  126.   {
  127.     UBYTE r;
  128.     UBYTE g;
  129.     UBYTE b;
  130.   }
  131. MY_RGB;
  132.  
  133. #define MY_SIX 6
  134.  
  135. MY_RGB col_ray[MY_SIX] =
  136. {
  137.   0, 0, 255,
  138.   0, 255, 0,
  139.   255, 0, 0,
  140.   0, 255, 255,
  141.   255, 255, 0,
  142.   255, 0, 255
  143. };
  144.  
  145. int delay[MAX_SPEED] =
  146. {
  147.   0,
  148.   5,
  149.   10,
  150.   20,
  151.   30,
  152.   40,
  153.   50,
  154.   80,
  155.   90,
  156.   100
  157. };
  158.  
  159.  
  160. struct BTDInteger BoxesIntParams[] =
  161. {
  162.   BX_Speed, "Delay", BTDPT_INTEGER, 2L, MIN_SPEED, MAX_SPEED, TRUE,
  163. };
  164.  
  165. struct BTDNode *BoxesParams[] =
  166. {
  167.   &BoxesIntParams[0].BI_Node,
  168.   NULL
  169. };
  170.  
  171. BTDINFO BoxesInfo =
  172. {
  173.   BTDI_Revision,
  174.   MAKE_ID ('B', 'O', 'X', ' '),
  175.   "Boxes Blanker",
  176.   "little boxes, full of ticky-tack...",
  177.   "Gary Duncan 1997(1.2)",
  178.   BoxesParams
  179. };
  180.  
  181. typedef struct
  182.   {
  183.     BTDDRAWINFO *BTDDrawInfo;
  184.     LONG entry_count;
  185.     LONG col_count;
  186.     LONG xoffs;
  187.     LONG g_Count;
  188.     LONG g_scale1;
  189.     LONG g_scale2;
  190.     LONG speed;
  191.     LONG n_boxes;
  192.     LONG debug_count;
  193.     LONG init_count;
  194.     XY tlhc;
  195.     XY brhc;
  196.     XY p_stt[MAX_BOXES];
  197.     XY p_end[MAX_BOXES];
  198.     DIRECTION dir;
  199.   }
  200. BOXES;
  201.  
  202. /*
  203.  * func prototypes
  204.  */
  205. static USHORT my_ran (int);
  206. static int get_rand_scale (void);
  207. static int get_rand_dir (void);
  208. static int get_rand_point (int min, int max);
  209. static BOOL checkbounce_start (XY * end, XY * limmax, XY * limmin);
  210. static BOOL checkbounce_end (XY * end, XY * limmax, XY * limmin);
  211. static void do_box (BOXES * BX, XY * start, XY * end, XY * limit);
  212. static LONG time_diff (ULONG e_freq, ECLOCKVAL * e_val1, ECLOCKVAL * e_val2);
  213. static BOOL open_timer (void);
  214. static void close_timer (void);
  215. static void DrawBounds (RASTPORT * rp, XY * p1, XY * p2);
  216. static void init_array (BOXES * BX);
  217. void dbg (BOXES * BX, char *ptr);
  218.  
  219. /* library stuff */
  220.  
  221. char MyBlankerName[] = "boxes.btd";
  222. char MyBlankerID[] = "Boxes Blanker V" VERSION "." REVISION " for BTD";
  223.  
  224. /*
  225.  * DEBUG stuff (13 Oct 97)
  226.  */
  227.  
  228. long DBFh;
  229. int gBDI_Left;
  230. int gBDI_Top;
  231. int gBDI_Width;
  232. int gBDI_Height;
  233.  
  234. /*
  235.  *******************************************************************
  236.  */
  237.  
  238. ULONG
  239. PenCountMyBlanker (TAGITEM * TagList)
  240.  
  241. {
  242. //
  243.   // debug
  244.   //
  245.   DPUTSTR ("PenCountMyBlanker\n");
  246.  
  247.   return 1;
  248.  
  249. }
  250. /*
  251.  *******************************************************************
  252.  */
  253.  
  254. BTDINFO *
  255. QueryMyBlanker (void)
  256.  
  257. {
  258. //
  259.   // debug
  260.   //
  261.   DPUTSTR ("QueryMyBlanker\n");
  262.  
  263.   return &BoxesInfo;
  264. }
  265. /*
  266.  *******************************************************************
  267.  */
  268.  
  269. BOXES *
  270. InitMyBlanker (TAGITEM * TagList)
  271.  
  272. {
  273.   BOXES *BX;
  274.   BTDDRAWINFO *BTDDrawInfo;
  275.   UWORD pen, col;
  276.   ULONG *Error, Dummy, Instance;
  277.  
  278. //
  279.   // debug
  280.   //
  281.   DPUTSTR ("InitMyBlanker\n");
  282.  
  283.  
  284.  
  285.   if ((BTDDrawInfo = (BTDDRAWINFO *)
  286.        FindTagData (TagList, BTD_DrawInfo, NULL)) == NULL)
  287.     return NULL;
  288.  
  289.   Error = (LONG *) FindTagData (TagList, BTD_Error, (ULONG) & Dummy);
  290.  
  291.   if ((BX = AllocVec (sizeof (BOXES), MEMF_PUBLIC | MEMF_CLEAR)) == NULL)
  292.     {
  293.       *Error = BTDERR_Memory;
  294.       return NULL;
  295.     }
  296.  
  297.  
  298.   BX->BTDDrawInfo = BTDDrawInfo;
  299.  
  300.   Instance = FindTagData (TagList, BTD_Instance, 0L);
  301.   BX->speed = FindTagData (TagList, BX_Speed, 0L);
  302.  
  303.   /*
  304.    * define the rectangle (shrink a bit)
  305.    */
  306.  
  307.   BX->tlhc.x = BX->BTDDrawInfo->BDI_Left + MINBOUND;
  308.   BX->tlhc.y = BX->BTDDrawInfo->BDI_Top + MINBOUND;
  309.   BX->brhc.x = BX->BTDDrawInfo->BDI_Width + BX->tlhc.x - 2 * MINBOUND;
  310.   BX->brhc.y = BX->BTDDrawInfo->BDI_Height + BX->tlhc.y - 2 * MINBOUND;
  311.  
  312.   /* (DEBUG) */
  313.   gBDI_Left = BX->tlhc.x;
  314.   gBDI_Top = BX->tlhc.y;
  315.   gBDI_Width = BX->brhc.x;
  316.   gBDI_Height = BX->brhc.y;
  317.  
  318.  
  319.   /*
  320.    * Init array
  321.    */
  322.   init_array (BX);
  323.  
  324.   col = BX->col_count;
  325.  
  326.   pen = BTDDrawInfo->BDI_Pens[0];
  327.  
  328.   BTDDrawInfo->BDI_Red[pen] = col_ray[col].r;
  329.   BTDDrawInfo->BDI_Green[pen] = col_ray[col].g;
  330.   BTDDrawInfo->BDI_Blue[pen] = col_ray[col].b;
  331.  
  332.   BTDDrawInfo->BDI_Changed[pen] = TRUE;
  333.   SetAPen (BTDDrawInfo->BDI_RPort, pen);
  334.  
  335.   /*
  336.    * get and save current E-clock value
  337.    */
  338.   e_freq = ReadEClock (&e_now);
  339.   e_freq = ReadEClock (&e_then);
  340.   e_freq = ReadEClock (&e_lcolch);
  341.  
  342.   return BX;
  343. }
  344.  
  345.  
  346. /*
  347.  *******************************************************************
  348.  */
  349.  
  350. void
  351. EndMyBlanker (BOXES * BX)
  352.  
  353. {
  354. //
  355.   // debug
  356.   //
  357.   DPUTSTR ("EndMyBlanker\n");
  358.  
  359.   FreeVec (BX);
  360. }
  361.  
  362.  
  363. /*
  364.  *******************************************************************
  365.  */
  366.  
  367. void
  368. AnimMyBlanker (BOXES * BX)
  369.  
  370. {
  371.   int new_offs, erase_offs, loop;
  372.   XY *sxy, *exy, t_sxy, t_exy;
  373.   int xmax, ymax;
  374.   int curr_offs;
  375.   UWORD pen;
  376.   int col, j;
  377.  
  378.   XY *tlhc = &BX->tlhc;
  379.   XY *brhc = &BX->brhc;
  380.   RASTPORT *rp = BX->BTDDrawInfo->BDI_RPort;
  381.   BTDDRAWINFO *BTDDrawInfo = BX->BTDDrawInfo;
  382.  
  383.   //
  384.   // debug
  385.   //
  386.   if (BX->debug_count++ == 0)
  387.     DPUTSTR ("AnimMyBlanker\n");
  388.  
  389.  
  390.  
  391.   /*
  392.    * get current E-clock value ; return if < delay 
  393.    */
  394.   e_freq = ReadEClock (&e_now);
  395.  
  396.   if (time_diff (e_freq, &e_then, &e_now) < delay[BX->speed - 1])
  397.     {
  398.       return;
  399.     }
  400.  
  401.   /*
  402.    * reset box array after 1000 loops (arbitary)
  403.    */
  404.   if ((BX->init_count++ % 1000) == 0)
  405.     {
  406.       /*
  407.        * erase existing boxes
  408.        */
  409.       for (j = 0; j < MAX_BOXES; ++j)
  410.     {
  411.       if (BX->p_stt[j].x != -1)
  412.         {
  413.           SetAPen (rp, BTD_BgPen);
  414.  
  415.           do_box (BX, &BX->p_stt[j], &BX->p_end[j], brhc);
  416.  
  417.           SetAPen (rp, BTDDrawInfo->BDI_Pens[0]);
  418.         }
  419.     }
  420.       init_array (BX);
  421.     }
  422.   /*
  423.    * draw Bounds (Debug feature - visually check boxes don't overlap)
  424.    */
  425.  
  426.   t_sxy.x = BX->BTDDrawInfo->BDI_Left;
  427.   t_sxy.y = BX->BTDDrawInfo->BDI_Top;
  428.   t_exy.x = BX->BTDDrawInfo->BDI_Width + t_sxy.x - 1;
  429.   t_exy.y = BX->BTDDrawInfo->BDI_Height + t_sxy.y - 1;
  430.  
  431.   //DrawBounds (rp, &t_sxy, &t_exy);
  432.  
  433.   /*
  434.    * time to change colour (2 secs) ?
  435.    */
  436.   if (time_diff (e_freq, &e_lcolch, &e_now) > 2000)
  437.     {
  438.       ++BX->col_count;        /* cycle colours */
  439.       e_lcolch = e_now;
  440.     }
  441.  
  442.   col = BX->col_count % MY_SIX;    /* cycle colours */
  443.  
  444.   pen = BTDDrawInfo->BDI_Pens[0];
  445.  
  446.   BTDDrawInfo->BDI_Red[pen] = col_ray[col].r;
  447.   BTDDrawInfo->BDI_Green[pen] = col_ray[col].g;
  448.   BTDDrawInfo->BDI_Blue[pen] = col_ray[col].b;
  449.  
  450.   BTDDrawInfo->BDI_Changed[pen] = TRUE;
  451.  
  452.   for (loop = 0; loop < 1; ++loop)    /* change loop count later ?? */
  453.     {
  454.       curr_offs = BX->xoffs;
  455.       sxy = &BX->p_stt[curr_offs];
  456.       exy = &BX->p_end[curr_offs];
  457.  
  458.       xmax = brhc->x;
  459.       ymax = brhc->y;
  460.       /*
  461.        * draw a box...
  462.        */
  463.       SetAPen (rp, pen);
  464.  
  465.       do_box (BX, sxy, exy, brhc);
  466.  
  467.       /*
  468.        * start x,y
  469.        */
  470.       if (checkbounce_start (sxy, brhc, tlhc))
  471.     {
  472.       if (sxy->x <= tlhc->x)
  473.         {
  474.           BX->dir.start.x = 1;
  475.         }
  476.       else
  477.         {
  478.           if (sxy->x >= brhc->x)
  479.         BX->dir.start.x = -1;
  480.           else
  481.         BX->dir.start.x = get_rand_dir ();
  482.         }
  483.  
  484.       if (sxy->y <= tlhc->y)
  485.         {
  486.           BX->dir.start.y = 1;
  487.         }
  488.       else
  489.         {
  490.           if (sxy->y >= brhc->y)
  491.         BX->dir.start.y = -1;
  492.           else
  493.         BX->dir.start.y = get_rand_dir ();
  494.         }
  495.  
  496.       BX->g_scale1 = get_rand_scale ();
  497.     }
  498.  
  499.       /*
  500.        * end x,y
  501.        */
  502.       if (checkbounce_end (exy, brhc, tlhc))
  503.     {
  504.       if (exy->x <= tlhc->x)
  505.         {
  506.           BX->dir.end.x = 1;
  507.         }
  508.       else
  509.         {
  510.           if (exy->x >= brhc->x)
  511.         BX->dir.end.x = -1;
  512.           else
  513.         BX->dir.end.x = get_rand_dir ();
  514.         }
  515.  
  516.       if (exy->y <= tlhc->y)
  517.         {
  518.           BX->dir.end.y = 1;
  519.         }
  520.       else
  521.         {
  522.           if (exy->y >= brhc->y)
  523.         BX->dir.end.y = -1;
  524.           else
  525.         BX->dir.end.y = get_rand_dir ();
  526.         }
  527.  
  528.       BX->g_scale2 = get_rand_scale ();
  529.     }
  530.  
  531.       if (++BX->xoffs == MAX_BOXES)
  532.     BX->xoffs = 0;
  533.  
  534.       erase_offs = new_offs = BX->xoffs;
  535.  
  536.       /*
  537.        * Erase the oldest line (if entry valid)
  538.        */
  539.  
  540.       if (BX->p_stt[erase_offs].x != -1)
  541.     {
  542.       SetAPen (rp, BTD_BgPen);
  543.  
  544.       do_box (BX, &BX->p_stt[erase_offs], &BX->p_end[erase_offs], brhc);
  545.  
  546.       SetAPen (rp, BTDDrawInfo->BDI_Pens[0]);
  547.     }
  548.  
  549.       /* Calculate the next point */
  550.  
  551.       BX->p_stt[new_offs].x =
  552.     (BX->g_scale1 * BX->dir.start.x) + BX->p_stt[curr_offs].x;
  553.  
  554.       BX->p_stt[new_offs].y =
  555.     (BX->g_scale1 * BX->dir.start.y) + BX->p_stt[curr_offs].y;
  556.  
  557.       BX->p_end[new_offs].x =
  558.     (BX->g_scale2 * BX->dir.end.x) + BX->p_end[curr_offs].x;
  559.  
  560.       BX->p_end[new_offs].y =
  561.     (BX->g_scale2 * BX->dir.end.y) + BX->p_end[curr_offs].y;
  562.     }
  563.   /*
  564.    * get and save current E-clock value
  565.    */
  566.   e_freq = ReadEClock (&e_then);
  567.  
  568. }
  569.  
  570. /*
  571.  *******************************************************************
  572.  */
  573.  
  574. void
  575. MyBlankerLibFree (void)
  576.  
  577. {
  578.   //
  579.   // debug
  580.   //
  581.   DPUTSTR ("MyBlankerLibFree\n");
  582.  
  583.   CloseLibrary (UtilityBase);
  584.   CloseLibrary (&IntuitionBase->LibNode);
  585.   CloseLibrary (&GfxBase->LibNode);
  586.  
  587.   close_timer ();
  588.  
  589. }
  590.  
  591. /*
  592.  *******************************************************************
  593.  */
  594.  
  595. LONG
  596. MyBlankerLibInit (void)
  597.  
  598. {
  599. //
  600.   // debug
  601.   //
  602.   DPUTSTR ("MyBlankerLibInit\n");
  603.  
  604.   if (open_timer () == FALSE)
  605.     {
  606.       return FALSE;
  607.     }
  608.  
  609.   if (GfxBase = (GFXBASE *) OpenLibrary ("graphics.library", 37L))
  610.     {
  611.       if (IntuitionBase = (INTUITIONBASE *) OpenLibrary ("intuition.library", 37L))
  612.     {
  613.       if (UtilityBase = OpenLibrary ("utility.library", 37L))
  614.         return TRUE;
  615.       CloseLibrary (&IntuitionBase->LibNode);
  616.     }
  617.       CloseLibrary (&GfxBase->LibNode);
  618.     }
  619.   return FALSE;
  620. }
  621.  
  622. /*
  623.  *********************************************************************
  624.  */
  625.  
  626. static void
  627. do_box (BOXES * BX, XY * start, XY * end, XY * limit)
  628.  
  629. {
  630.   RASTPORT *rp = BX->BTDDrawInfo->BDI_RPort;
  631.  
  632.   int tempx_s = limit->x - start->x;
  633.   int tempy_s = limit->y - start->y;
  634.   int tempx_e = limit->x - end->x;
  635.   int tempy_e = limit->y - end->y;
  636.  
  637.   /*
  638.    * DEBUG-start
  639.    */
  640.  
  641.  
  642.   if (start->x > gBDI_Width)
  643.     {
  644.       dbg (BX, "X1\n");
  645.       return;
  646.     }
  647.   if (start->y > gBDI_Height)
  648.     {
  649.       dbg (BX, "Y1\n");
  650.       return;
  651.     }
  652.   if (end->x > gBDI_Width)
  653.     {
  654.       dbg (BX, "X2\n");
  655.       return;
  656.     }
  657.   if (end->y > gBDI_Height)
  658.     {
  659.       dbg (BX, "Y1\n");
  660.       return;
  661.     }
  662.  
  663.  
  664.   /*
  665.    * check x coords
  666.    */
  667.   if ((tempx_s < 0) || (tempx_s > gBDI_Width))
  668.     {
  669.       dbg (BX, "ST1\n");
  670.       return;
  671.     }
  672.   if ((tempx_e < 0) || (tempx_e > gBDI_Width))
  673.     {
  674.       dbg (BX, "ST2\n");
  675.       return;
  676.     }
  677.   /*
  678.    * check y coords
  679.    */
  680.   if ((tempx_e < 0) || (tempx_e > gBDI_Height))
  681.     {
  682.       dbg (BX, "ET1\n");
  683.       return;
  684.     }
  685.   if ((tempy_e < 0) || (tempy_e > gBDI_Height))
  686.     {
  687.       dbg (BX, "ET2\n");
  688.       return;
  689.     }
  690.  
  691.  
  692.  
  693.   /*
  694.    * DEBUG-end
  695.    */
  696.  
  697.   Move (rp, start->x, start->y);
  698.   Draw (rp, end->x, end->y);
  699.  
  700.   Draw (rp, tempx_s, tempy_s);
  701.  
  702.   Draw (rp, tempx_e, tempy_e);
  703.  
  704.   Draw (rp, start->x, start->y);
  705.  
  706. }
  707.  
  708. /*
  709.  *********************************************************************
  710.  */
  711.  
  712. static BOOL
  713. checkbounce_start (XY * start, XY * limmax, XY * limmin)
  714. {
  715.  
  716.   if ((start->x >= limmax->x) || (start->y >= limmax->y)
  717.       || (start->x <= limmin->x) || (start->y <= limmin->y))
  718.     return TRUE;
  719.   else
  720.     return FALSE;
  721. }
  722.  
  723. /*
  724.  *********************************************************************
  725.  */
  726.  
  727. static BOOL
  728. checkbounce_end (XY * end, XY * limmax, XY * limmin)
  729. {
  730.  
  731.   if ((end->x >= limmax->x) || (end->y >= limmax->y)
  732.       || (end->x <= limmin->x) || (end->y <= limmin->y))
  733.     return TRUE;
  734.   else
  735.     return FALSE;
  736. }
  737.  
  738. /*
  739.  *********************************************************************
  740.  */
  741.  
  742. static int
  743. get_rand_point (int min, int max)
  744. {
  745.   SHORT temp;
  746.  
  747.   temp = my_ran (max - min);
  748.  
  749.   return (temp + min);
  750. }
  751.  
  752. /*
  753.  *********************************************************************
  754.  */
  755.  
  756. static int
  757. get_rand_dir ()
  758. {
  759.   SHORT num;
  760.  
  761.   num = my_ran (15000);
  762.  
  763.   return (num < 5000) ? -1 : (num > 10000) ? 1 : 0;
  764. }
  765.  
  766. /*
  767.  *********************************************************************
  768.  */
  769.  
  770. static int
  771. get_rand_scale ()
  772. {
  773.   SHORT temp;
  774.  
  775.   temp = my_ran (MINBOUND);
  776.  
  777.   if (temp == 0)
  778.     ++temp;
  779.  
  780.   return temp;
  781. }
  782. /*
  783.  *********************************************************************
  784.  */
  785.  
  786. static USHORT
  787. my_ran (int lim)
  788. {
  789.   USHORT retval = RangeRand (lim);
  790.  
  791.   if (retval == 0)
  792.     return 1;
  793.   else
  794.     return retval;
  795.  
  796. }
  797.  
  798. /*
  799.  *********************************************************************
  800.  */
  801.  
  802.  
  803. /*
  804.  * returns number of msecs between first ECLOCK and second ECLOCK 
  805.  * - second ECLOCK is later.
  806.  *
  807.  * - not precise, but a hack ; divides (shifts) by 1024 not 1000. 
  808.  *
  809.  */
  810.  
  811. static LONG
  812. time_diff (ULONG e_freq, ECLOCKVAL * e_val1, ECLOCKVAL * e_val2)
  813.  
  814. {
  815.   LONG temp, msecs;
  816.  
  817.   if (e_val2->ev_lo > e_val1->ev_lo)
  818.     {
  819.       temp = e_val2->ev_lo - e_val1->ev_lo;
  820.     }
  821.   else
  822.     {
  823.       temp = e_val1->ev_lo - e_val2->ev_lo;
  824.     }
  825.  
  826.   /*
  827.    * convert to msecs
  828.    */
  829.  
  830.   e_freq = e_freq >> 10;    /* roughly ,  /1024 */
  831.  
  832.   msecs = temp / e_freq;
  833.  
  834.   return msecs;
  835. }
  836. /*
  837.  *********************************************************************
  838.  */
  839.  
  840. static BOOL
  841. open_timer (void)
  842. {
  843.  
  844.   if (OpenDevice (TIMERNAME, UNIT_ECLOCK, (IOREQUEST *) t_ptr, 0L) != 0)
  845.     {
  846.       return FALSE;
  847.     }
  848.  
  849.   TimerBase = (TIMERBASE *) t_ptr->tr_node.io_Device;
  850.  
  851.   return TRUE;
  852. }
  853. /*
  854.  *********************************************************************
  855.  */
  856.  
  857. static void
  858. close_timer (void)
  859. {
  860.   if (t_ptr)
  861.     {
  862.       CloseDevice ((IOREQUEST *) t_ptr);
  863.       t_ptr = NULL;
  864.     }
  865. }
  866. /*
  867.  *********************************************************************
  868.  */
  869. static void
  870. DrawBounds (RASTPORT * rp, XY * tlhc, XY * brhc)
  871. {
  872.  
  873.   Move (rp, tlhc->x, tlhc->y);
  874.  
  875.   Draw (rp, brhc->x - 1, tlhc->y);
  876.   Draw (rp, brhc->x - 1, brhc->y - 1);
  877.   Draw (rp, tlhc->x, brhc->y - 1);
  878.   Draw (rp, tlhc->x, tlhc->y);
  879. }
  880. /*
  881.  *********************************************************************
  882.  */
  883. static void
  884. init_array (BOXES * BX)
  885. {
  886.   int j;
  887.  
  888.   /*
  889.    * Init array with inactive values 
  890.    */
  891.   for (j = 0; j < MAX_BOXES; ++j)
  892.     {
  893.       BX->p_stt[j].x = -1;
  894.       BX->p_stt[j].y = -1;
  895.     }
  896.   /*
  897.    * Init starting points with random x,y values
  898.    */
  899.  
  900.   BX->xoffs = 0;
  901.   BX->p_stt[0].x = get_rand_point (BX->tlhc.x, BX->brhc.x);
  902.   BX->p_stt[0].y = get_rand_point (BX->tlhc.y, BX->brhc.y);
  903.  
  904.   BX->p_end[0].x = get_rand_point (BX->tlhc.x, BX->brhc.x);
  905.   BX->p_end[0].y = get_rand_point (BX->tlhc.y, BX->brhc.y);
  906.  
  907.   BX->dir.start.x = get_rand_dir ();
  908.   BX->dir.start.y = get_rand_dir ();
  909.  
  910.   BX->dir.end.x = get_rand_dir ();
  911.   BX->dir.end.y = get_rand_dir ();
  912.  
  913.   BX->g_scale1 = 2;
  914.   BX->g_scale2 = 2;
  915.  
  916.   BX->col_count = my_ran (MY_SIX - 1);
  917. }
  918. /*
  919.  *********************************************************************
  920.  */
  921.  
  922. void
  923. dbg (BOXES * BX, char *ptr)
  924. {
  925.  
  926.   /* DEBUG CODE COMES HERE :) */
  927. }
  928.