home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d5xx / d557 / warp.lha / WarpSpeed / Warp_Speed.c < prev    next >
C/C++ Source or Header  |  1991-10-28  |  12KB  |  436 lines
  1. /*    Warp_Speed
  2.       An Experimental Test Program in C
  3.       Written December 24, 1990
  4.       By Doug Petercsak
  5.       
  6.       Program generates a display similiar to what would be seen
  7.       if one were to be moving through the stars at 'Warp Speed.'
  8.       
  9.       Velocity can be controlled by the up / down arrow keys.
  10.       
  11.       Compiled on SAS / Lattice C 5.10   
  12.       
  13.       Version 1.0 / Revised January 11, 1991 
  14.       
  15.       I can be reached at : Apartment E-4
  16.                             30856 Agoura Road
  17.                             Agoura Hills, CA
  18.                             91301
  19.                             
  20. */
  21.  
  22. #include <exec/types.h>                /* Long list of includes */
  23. #include <exec/memory.h>
  24. #include <exec/devices.h>
  25. #include <devices/keymap.h>
  26. #include <graphics/gfx.h>
  27. #include <graphics/gfxmacros.h>
  28. #include <graphics/gfxbase.h>
  29. #include <graphics/rastport.h>
  30. #include <graphics/text.h>
  31. #include <graphics/regions.h>
  32. #include <graphics/gels.h>
  33. #include <graphics/copper.h>
  34. #include <hardware/blit.h>
  35. #include <intuition/intuition.h>
  36. #include <math.h>
  37. #include <stdlib.h>
  38. #include "Warp_Speed.h"
  39.  
  40. #define WIDTH        640               /* Screen Width     */
  41. #define HEIGHT       400               /* Screen Height    */
  42. #define DEPTH        4                 /* Screen Depth     */
  43. #define MODES        1                 /* Graphics Mode    */
  44. #define MSTARS       20                /* Moving Stars     */
  45. #define BSTARS       0                 /* Background Stars */
  46. #define BIGINT       2147483647.0      /* Largest Integer  */
  47. #define OBSERVER_X   0                 /* Observer's X pos */
  48. #define OBSERVER_Y   0                 /* Observer's Y pos */
  49. #define OBSERVER_Z  -100               /* Observer's Z pos */
  50. #define MAX_WARP     35                /* Top Speed        */
  51.  
  52. struct GfxBase       *GfxBase;         /* Pointer to GfxBase       */
  53. struct IntuitionBase *IntuitionBase;   /*    "    "  IntuitionBase */
  54. struct Screen        *FirstScreen;     /*    "    "  Screen struct */
  55. struct Window        *FirstWindow;     /*    "    "  Window struct */
  56. struct Window        *AboutWindow;     /*    "    "  Window struct */
  57. struct IntuiMessage  *message;         /*    "    "  IntuiMessage  */
  58. struct RastPort      *RPort;           /*    "    "  RastPort      */
  59. struct RastPort      *ARPort;          /*    "    "  RastPort      */
  60.  
  61. struct TextAttr Font =                 /* Define Text Attributes   */
  62. {
  63.    (STRPTR)"topaz.font",
  64.    TOPAZ_EIGHTY,
  65.    FS_NORMAL,
  66.    FPF_ROMFONT
  67. };
  68.  
  69. struct NewScreen FirstNewScreen =
  70. {
  71.    0, 0,                    /* LeftEdge, TopEdge   */
  72.    WIDTH, HEIGHT,           /* Width, Height       */
  73.    DEPTH,                   /* Depth               */
  74.    0, 1,                    /* DetailPen, BlockPen */
  75.    HIRES |                  /* ViewModes           */
  76.    LACE,
  77.    CUSTOMSCREEN,            /* Type                */
  78.    &Font,                   /* Font                */
  79.    NULL,
  80.    NULL,                    /* Gadgets             */
  81.    NULL,                    /* CustomBitMap        */
  82. };
  83.  
  84. struct NewWindow FirstNewWindow =
  85. {
  86.    0, 0,                    /* LeftEdge, TopEdge   */
  87.    WIDTH, HEIGHT,           /* Width, Height       */
  88.    5, 0,                    /* DetailPen, BlockPen */
  89.    MENUPICK |               /* IDCMP Flags         */
  90.    RAWKEY,
  91.    BORDERLESS |             /* Flags               */
  92.    ACTIVATE |
  93.    NOCAREREFRESH,
  94.    NULL,                    /* First Gadget        */
  95.    NULL,                    /* CheckMark           */
  96.    NULL,
  97.    NULL,                    /* Screen  */
  98.    NULL,                    /* BitMap              */
  99.    0, 0,                    /* Min Width, Height   */
  100.    0, 0,                    /* Max Width, Height   */
  101.    CUSTOMSCREEN,            /* Type                */
  102. };
  103.  
  104. struct NewWindow FirstAboutWindow =
  105. {
  106.    (WIDTH - 393) / 2,       /* LeftEdge            */
  107.    (HEIGHT - 133) / 2,      /* TopEdge             */
  108.    393, 133,                /* Width, Height       */
  109.    5, 0,                    /* DetailPen, BlockPen */
  110.    NULL,                    /* IDCMP Flags         */
  111.    WINDOWDRAG |             /* Flags               */
  112.    ACTIVATE |
  113.    NOCAREREFRESH,
  114.    NULL,                    /* First Gadget        */
  115.    NULL,                    /* CheckMark           */
  116.    NULL,
  117.    NULL,                    /* Screen  */
  118.    NULL,                    /* BitMap              */
  119.    0, 0,                    /* Min Width, Height   */
  120.    WIDTH, HEIGHT,           /* Max Width, Height   */
  121.    CUSTOMSCREEN,            /* Type                */
  122. };
  123.  
  124. struct IntuiText AboutText =
  125. {
  126.    10, 1, JAM2, 1, 1, &Font, (UBYTE *)"About..", NULL
  127. };
  128.  
  129. struct IntuiText QuitText =
  130. {
  131.    10, 1, JAM2, 1, 1, &Font, (UBYTE *)"Quit", NULL
  132. };
  133.  
  134. struct MenuItem Quit =
  135. {
  136.    NULL,
  137.    1, 12,
  138.    70, 10,
  139.    ITEMTEXT | ITEMENABLED | HIGHCOMP,
  140.    0,
  141.    (APTR)&QuitText,
  142.    NULL,
  143.    0,
  144.    NULL,
  145.    0
  146. };
  147.  
  148. struct MenuItem About =
  149. {
  150.    &Quit,
  151.    1, 2,
  152.    70, 10,
  153.    ITEMTEXT | ITEMENABLED | HIGHCOMP,
  154.    0,
  155.    (APTR)&AboutText,
  156.    NULL,
  157.    0,
  158.    NULL,
  159.    0
  160. };
  161.  
  162. struct Menu Menus =
  163. {
  164.    NULL,
  165.    10, 0,
  166.    70, 10,
  167.    MENUENABLED,
  168.    (BYTE *)"Menu",
  169.    &About
  170. };
  171.  
  172. USHORT Colors[16] =              /* Initial color table */
  173. {
  174.    0x000, 0x111, 0x222, 0x333,   /* Black, Dark Grey, ... */
  175.    0x444, 0x555, 0x666, 0x777,         
  176.    0x888, 0x999, 0xaaa, 0xbbb,
  177.    0xccc, 0xddd, 0xeee, 0xfff    /* ... Light Grey, White */
  178. };
  179.  
  180. UWORD Sprite[2][2] =
  181. {
  182.    {0x0000, 0x0000},
  183.    {0x0000, 0x0000}
  184. };
  185.  
  186. VOID Open_All();                 /* Function Prototypes */
  187. VOID Close_All();                
  188. VOID Background_Stars();
  189. VOID StarInit();
  190. VOID Menu_Analysis();
  191. VOID AboutWarp();
  192. int StarColor();
  193.  
  194. int i, xp1, yp1, xp2, yp2, star_color, Range, st[MSTARS][5];
  195. Range = 2 * (HEIGHT * (500 + HEIGHT - OBSERVER_Z)) / ( -2 * OBSERVER_Z);
  196. int warp_factor = 10;
  197.  
  198. main(argc, argv)
  199. int argc;
  200. char *argv[];
  201.    {
  202.    ULONG MessageClass;
  203.    USHORT code;
  204.    
  205.    struct Message *GetMsg();
  206.    
  207.    Open_All();                      /* Open Libraries, Screen & Window */
  208.    
  209.    LoadRGB4(&FirstScreen->ViewPort, &Colors[0], 16);
  210.    RemakeDisplay();                 /* Load and Display Pallete */
  211.    
  212.    AboutWarp(200L);
  213.    
  214.    Background_Stars();              /* Generate Background Stars */
  215.    
  216.    for ( i = 0; i < MSTARS; i++ )   /* Initialize Moving Stars */
  217.          StarInit(i);
  218.          
  219.    FOREVER
  220.       {
  221.          for( i = 0; i < MSTARS && warp_factor != 0; i++) /* Start Star Motion Loop */
  222.          {
  223.             xp2 = st[i][3];
  224.             yp2 = st[i][4];
  225.             st[i][2] = st[i][2] - 3 * warp_factor;
  226.             if (st[i][2] == OBSERVER_Z)
  227.                st[i][2] = st[i][2] - 1;
  228.             xp1 = st[i][3] = OBSERVER_X + (OBSERVER_X - st[i][0]) * (OBSERVER_Z) / 
  229.                (st[i][2] - (OBSERVER_Z)) + WIDTH / 2;
  230.             yp1 = st[i][4] = OBSERVER_Y + (OBSERVER_Y - st[i][1]) * (OBSERVER_Z) /
  231.                (st[i][2] - (OBSERVER_Z)) + HEIGHT / 2;
  232.             SetAPen ( RPort, 0);
  233.             WritePixel ( RPort, xp2, yp2); 
  234.             if ( xp1 > 0 && xp1 < WIDTH && yp1 > 0 && yp1 < HEIGHT && st[i][2] > OBSERVER_Z)
  235.             {
  236.                SetAPen ( RPort, StarColor(st[i][2]));
  237.                WritePixel ( RPort, xp1, yp1); 
  238.             }
  239.             else
  240.             {
  241.                StarInit(i);
  242.             }
  243.          }
  244.                            
  245.       if (message = (struct IntuiMessage *)
  246.           GetMsg(FirstWindow->UserPort))
  247.          {
  248.          MessageClass = message->Class;
  249.          code = message->Code;
  250.          ReplyMsg(message);
  251.          switch (MessageClass)
  252.             {
  253.             case RAWKEY :
  254.                switch (code)
  255.                {
  256.                      case 0x4c:  /* Faster */
  257.                         warp_factor = warp_factor + 1;
  258.                         if (warp_factor > MAX_WARP)
  259.                            warp_factor = MAX_WARP;
  260.                         break;
  261.                         
  262.                      case 0x4d:  /* Slower */
  263.                         warp_factor = warp_factor - 1;
  264.                         if (warp_factor < 0)
  265.                            warp_factor = 0;
  266.                         break;
  267.  
  268.                }
  269.                break;
  270.             
  271.             case MENUPICK    : Menu_Analysis(code);
  272.                                break;
  273.             }
  274.          }
  275.       }
  276.    }
  277.  
  278. /*    Function: Open_All
  279.       Opens libraries, screen and window. */
  280.  
  281. /*    Refer to 'Amiga C for Advanced Programmers' by Abacus.  */
  282.       
  283. VOID Open_All()
  284. {
  285.    void          *OpenLibrary();
  286.    struct Window *OpenWindow();
  287.    struct Screen *OpenScreen();
  288.    
  289.    if (!(GfxBase = (struct GfxBase *)
  290.    OpenLibrary("graphics.library",0L)))
  291.    {
  292.       Close_All();
  293.       exit(FALSE);
  294.    } 
  295.    
  296.    if (!(IntuitionBase = (struct IntuitionBase *)
  297.        OpenLibrary("intuition.library", 0L)))
  298.    {
  299.       Close_All();
  300.       exit(FALSE);
  301.    }
  302.    
  303.    if (!(FirstScreen = (struct Screen *)
  304.        OpenScreen(&FirstNewScreen)))
  305.    {
  306.       Close_All();
  307.       exit(FALSE);
  308.    }
  309.    
  310.    FirstNewWindow.Screen = FirstScreen;
  311.    
  312.    if (!(FirstWindow = (struct Window *)
  313.        OpenWindow(&FirstNewWindow)))
  314.    {
  315.       Close_All();
  316.       exit(FALSE);
  317.    }
  318.    
  319.    RPort = FirstWindow->RPort;
  320.    
  321.    SetMenuStrip(FirstWindow, &Menus);
  322.    
  323.    SetPointer(FirstWindow, Sprite, 2, 2, 0, 0);
  324. }
  325.    
  326. /*    Function: Close_All
  327.       Closes libraries, screen and window. */
  328.  
  329.  
  330. VOID Close_All()
  331. {
  332.    if (FirstWindow)     ClearMenuStrip(FirstWindow);
  333.    if (FirstWindow)     CloseWindow(FirstWindow);
  334.    if (FirstScreen)     CloseScreen(FirstScreen);
  335.    if (IntuitionBase)   CloseLibrary(IntuitionBase);
  336.    if (GfxBase)         CloseLibrary(GfxBase);
  337. }
  338.  
  339. /*    Function: Random
  340.       Generates floating point random numbers between 0 and Max. */
  341.  
  342. int Random(int Max)
  343. {
  344.    return (int) (( Max * (float) rand()) / BIGINT );
  345. }
  346.  
  347. /*    Function: Background_Stars
  348.       Generates distant stationary stars. */
  349.       
  350. VOID Background_Stars()
  351.  
  352. {
  353.    for (i = 0; i <= BSTARS; i++)
  354.    {
  355.       SetAPen ( RPort, 1 + (int) Random(5));
  356.       WritePixel ( RPort, (int) Random(WIDTH), (int) Random(HEIGHT)); 
  357.  
  358.    }
  359. }
  360.  
  361. /*    Function: StarColor
  362.       Sets the star color based on the star's velocity. */
  363.       
  364. int StarColor(int Star_Z)
  365. {
  366.    int Clr;
  367.    Clr = (-14 * Star_Z ) / (3 * HEIGHT) + 25;
  368.    if (Clr < 3)
  369.       Clr = 3;
  370.    if (Clr > 15)
  371.       Clr = 15;
  372.    return Clr;
  373. }
  374.  
  375. /*    Function: StarInit
  376.       Initializes new stars.  */
  377.  
  378. VOID StarInit(int j)
  379. {
  380.    st[j][0] = Range - Random(2 * Range);
  381.    st[j][1] = Range - Random(2 * Range);
  382.    st[j][2] = 2000 + Random(HEIGHT);
  383. }  
  384.  
  385. /*    Function: Menu_Analysis
  386.       Performs menu analysis and decides course of action. */
  387.    
  388. VOID Menu_Analysis(USHORT Menunumber)
  389. {
  390.    USHORT Menu, MenuItem;
  391.  
  392.    Menu     = MENUNUM(Menunumber);
  393.    MenuItem = ITEMNUM(Menunumber);
  394.    
  395.    switch(Menu)
  396.    {
  397.       case 0 : switch(MenuItem) /* File Menu */
  398.                {
  399.                      case 0 : AboutWarp(400L);   /* About */
  400.                               break;   
  401.                      
  402.                      case 1 : Close_All();   /* Quit */
  403.                               exit(TRUE);
  404.                               break;
  405.                }
  406.                break;
  407.   
  408.    }
  409. }   
  410.  
  411. /*    Function: AboutWarp
  412.       Opens 'About' window and displays image for (400 / 60) seconds. */
  413.  
  414. VOID AboutWarp(long Time)
  415. {
  416.    struct Window *OpenWindow();
  417.    
  418.    FirstAboutWindow.Screen = FirstScreen;
  419.    
  420.    if (!(AboutWindow = (struct Window *)
  421.       OpenWindow(&FirstAboutWindow)))
  422.       {
  423.          Close_All();
  424.          exit(FALSE);
  425.       }
  426.       
  427.    ARPort = AboutWindow->RPort;
  428.    
  429.    DrawImage(ARPort, &AboutWSImage, 0L, 0L);
  430.    
  431.    Delay(Time);
  432.    
  433.    if (AboutWindow)    CloseWindow(AboutWindow);
  434.    
  435. }
  436.