home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume5 / landmine / land_mine.c < prev    next >
C/C++ Source or Header  |  1988-09-21  |  7KB  |  266 lines
  1. /******************************************************************************/
  2. /***                                                                        ***/
  3. /**                                LAND MINE                                 **/
  4. /*                                                                            */
  5. /*    This program randomly generates  NUM_MINES number of points on a        */
  6. /*    SunView monitor.  When the mouse on the Sun Workstation comes within    */
  7. /*    PIXEL_AREA pixels of one of the "land mines", an animated sequence of   */
  8. /*    icons are generated to simulate an explosion at that location.  A new   */
  9. /*    set of coordinates are generated to replace the "exploded" location.    */
  10. /*    The number of "mines" to set is up to the person that compiles the      */
  11. /*    program, the more "mines" that are present the greater the occurrance   */
  12. /*    of "explosions", however, the greater the number of "mines", more CPU   */
  13. /*    time will be wasted on checking the mouse location.                     */
  14. /*                                                                            */
  15. /*    I make no waranty, have no responsibility, and have no regrets in       */
  16. /*    distributing this software.  If you use it, it's your problem!          */
  17. /*    Just to make sure its legal (Thanks to the legal department):           */
  18. /*                                                                            */
  19. /*                     Copyright (C) 1988 Rick Schneider                      */
  20. /*                                                                            */
  21. /*    Even though this code is mine, the algorithm for setting up the sun was */
  22. /*    was lifted from "eyecon" developed by Chuck Musciano of Harris so his   */
  23. /*    copyright notice and disclaimer appear here as well:                    */
  24. /*                                                                            */
  25. /*    Copyright 1988 by Chuck Musciano and Harris Corporation              */
  26. /*                                          */
  27. /*    Permission to use, copy, modify, and distribute this software          */
  28. /*    and its documentation for any purpose and without fee is          */
  29. /*    hereby granted, provided that the above copyright notice          */
  30. /*    appear in all copies and that both that copyright notice and          */
  31. /*    this permission notice appear in supporting documentation, and          */
  32. /*    that the name of Chuck Musciano and Harris Corporation not be          */
  33. /*    used in advertising or publicity pertaining to distribution          */
  34. /*    of the software without specific, written prior permission.          */
  35. /*    Chuck Musciano and Harris Corporation make no representations          */
  36. /*    about the suitability of this software for any purpose.  It is          */
  37. /*    provided "as is" without express or implied warranty.              */
  38. /**                                                                          **/
  39. /***                                                                        ***/
  40. /******************************************************************************/
  41.  
  42. #include <stdio.h>
  43. #include <suntool/sunview.h>
  44. #include <suntool/canvas.h>
  45. #include <suntool/fullscreen.h>
  46. #include <sys/file.h>
  47. #include <sys/time.h>
  48.  
  49. #define NUM_MINES        10
  50. #define    PIXEL_AREA        5
  51.  
  52. #define    OR            ( PIX_SRC | PIX_DST )
  53. #define    XOR            ( PIX_SRC ^ PIX_DST )
  54. #define    SLEEP_TIME        250000
  55. #define DEFAULT_DEVICE        "/dev/fb"
  56.  
  57. static short broken1_bits[] = 
  58. {
  59. #include "broken_window1.i"
  60. };
  61.  
  62. static short broken2_bits[] = 
  63. {
  64. #include "broken_window2.i"
  65. };
  66.  
  67. static short broken3_bits[] = 
  68. {
  69. #include "broken_window3.i"
  70. };
  71.  
  72. static short broken4_bits[] = 
  73. {
  74. #include "broken_window4.i"
  75. };
  76.  
  77. mpr_static( broken1, 64, 64, 1, broken1_bits );
  78. mpr_static( broken2, 64, 64, 1, broken2_bits );
  79. mpr_static( broken3, 64, 64, 1, broken3_bits );
  80. mpr_static( broken4, 64, 64, 1, broken4_bits );
  81.  
  82.  
  83. char *device = NULL;
  84. struct pixrect *background;
  85. static struct pixrect *broken;
  86. static int desktop_fd;
  87.  
  88. int last_x = -1;
  89. int last_y = -1;
  90.  
  91. typedef struct s_loc
  92. {
  93.     short x;
  94.     short y;
  95. } loc;
  96.  
  97. loc *mine_list;
  98.  
  99.  
  100. loc
  101. *init_mine_list( )
  102. {
  103.     loc *list;
  104.     loc *list_ptr;
  105.     int i;
  106.  
  107.     /* allocate list array structure */
  108.  
  109.     list = ( loc * )calloc( NUM_MINES, sizeof(*list) );
  110.  
  111.     if ( list == NULL )
  112.     {
  113.     fprintf( stderr, "unable to allocate land mine list\n" );
  114.     exit(0);
  115.     }
  116.  
  117.     list_ptr = list;
  118.  
  119.     srand( getpid( ) );
  120.  
  121.     for ( i = 0; i < NUM_MINES; i++ )
  122.     {
  123.     list_ptr->x = ( rand( ) % 1100 );
  124.     list_ptr->y = ( rand( ) % 900 );
  125.  
  126.     list_ptr++;
  127.     }
  128.     return( list );
  129. }
  130.  
  131. int
  132. found_land_mine( x, y, list )
  133. short x;
  134. short y;
  135. loc *list;
  136. {
  137.     int i;
  138.  
  139.     /* search the land mine list for an occurance of this location */
  140.  
  141.     for ( i = 0; i < NUM_MINES; i++ )
  142.     {
  143.     if ( ( ( x - PIXEL_AREA <= list[i].x ) && 
  144.            ( y - PIXEL_AREA <= list[i].y ) ) &&
  145.          ( ( list[i].x <= x + PIXEL_AREA ) && 
  146.            ( list[i].y <= y + PIXEL_AREA ) ) )
  147.     {
  148.         /* found a mine, generate a new (x,y) and return TRUE */
  149.  
  150.         list[i].x = ( rand( ) % 1100 );
  151.         list[i].y = ( rand( ) % 900 );
  152.  
  153.         return( TRUE );
  154.     }
  155.     }
  156.  
  157.     /* no mine found at current possition, return FALSE */
  158.  
  159.     return( FALSE );
  160. }
  161.  
  162. void
  163. mine_proc( )
  164. {    
  165.     int x;
  166.     int y;
  167.  
  168.     x = win_get_vuid_value( desktop_fd, LOC_X_ABSOLUTE );
  169.     y = win_get_vuid_value( desktop_fd, LOC_Y_ABSOLUTE );
  170.  
  171.     if ( ( x != last_x ) || ( y != last_y ) )
  172.     {
  173.         if ( found_land_mine( x,y,mine_list ) )
  174.         {
  175.         pr_rop( background, 
  176.             x - ( broken1.pr_width/2 ), 
  177.             y - ( broken1.pr_height/2 ), 
  178.             broken1.pr_width,
  179.             broken1.pr_height, 
  180.             OR, 
  181.             &broken1, 
  182.             0, 
  183.             0 );
  184.  
  185.             usleep( SLEEP_TIME );
  186.  
  187.         pr_rop( background, 
  188.             x - ( broken2.pr_width/2 ), 
  189.             y - ( broken2.pr_height/2 ), 
  190.             broken2.pr_width,
  191.             broken2.pr_height, 
  192.             OR, 
  193.             &broken2, 
  194.             0, 
  195.             0 );
  196.  
  197.             usleep( SLEEP_TIME );
  198.  
  199.         pr_rop( background, 
  200.             x - ( broken3.pr_width/2 ), 
  201.             y - ( broken3.pr_height/2 ), 
  202.             broken3.pr_width,
  203.             broken3.pr_height, 
  204.             OR, 
  205.             &broken3, 
  206.             0, 
  207.             0 );
  208.  
  209.             usleep( SLEEP_TIME );
  210.  
  211.         pr_rop( background, 
  212.             x - ( broken4.pr_width/2 ), 
  213.             y - ( broken4.pr_height/2 ), 
  214.             broken4.pr_width,
  215.             broken4.pr_height, 
  216.             XOR, 
  217.             &broken4, 
  218.             0, 
  219.             0 );
  220.         }
  221.         last_x = x;
  222.         last_y = y;
  223.     }
  224. }
  225.  
  226. main( argc, argv )
  227. int argc;
  228. char **argv;
  229. {
  230.     char *parent;
  231.     char *program;
  232.     char *getenv( );
  233.  
  234.     strcpy( program = ( char * )malloc( strlen( argv[0] ) + 1 ), 
  235.         argv[0] );
  236.     if ( ( parent = ( char * ) getenv( "WINDOW_PARENT" ) ) == NULL ) 
  237.     {
  238.         fprintf( stderr, 
  239.      "The Sun must be running Suntools inorder to run this program\n");
  240.         exit( 1 );
  241.     }
  242.     if ( ( desktop_fd = open( parent, O_RDWR ) ) == -1 ) 
  243.     {
  244.         fprintf( stderr, 
  245.          "%s: could not access desktop window device: %s\n", 
  246.          program, parent);
  247.         exit( 1 );
  248.     }
  249.  
  250.     if ( !( device ) && !( device = getenv( "DEV_FB" ) ) )
  251.         device = DEFAULT_DEVICE;
  252.  
  253.     if ( ! ( background = pr_open( device ) ) )
  254.         exit(1); 
  255.  
  256.     we_setparentwindow( "/dev/win0" );
  257.     we_setgfxwindow( "/dev/win3" );
  258.  
  259.     mine_list = init_mine_list( );
  260.     while( 1 )
  261.     {
  262.         mine_proc( );
  263.     }
  264. }
  265.  
  266.