home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume15 / xstratego / part01 / setup.c < prev    next >
C/C++ Source or Header  |  1993-01-27  |  8KB  |  388 lines
  1. /*
  2.  * Setup.c
  3.  */
  4.  
  5. #include "stratego.h"
  6.  
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9.  
  10. /*    HJV:    Normally found in stdlib.h, but some systems do not
  11.         have this include file, or have it at another location.
  12.         Hoping they will not change the value of F_OK, I hereby
  13.         declare it as zero, as it should be.
  14. */
  15.  
  16. #ifndef F_OK
  17. #define F_OK 0
  18. #endif
  19.  
  20. static void SelectBoardCursor ();
  21.  
  22. /*
  23.  * Setup buttonbox Callback routines.
  24.  */
  25.  
  26. /*
  27.  * WipeCursor Button Callback Routine.
  28.  */
  29. XtCallbackProc WipeCursor (widget)
  30. Widget widget;
  31. {
  32.     SelectBoardCursor (&tiles[FREE]);
  33. }
  34.  
  35.  
  36. /*
  37.  * Clear Button Callback Routine.
  38.  */
  39. XtCallbackProc Clear (widget)
  40. Widget widget;
  41. {
  42.     int y, x;
  43.  
  44.     for (y = MAX_ROWS - 4; y < MAX_ROWS; y++) {
  45.         for (x = 0; x < MAX_COLS; x++) { 
  46.             if (board[y][x].value != FREE) {
  47.                 UpdateTileCount (&tiles[board[y][x].value],
  48.                          1);
  49.                 AssignBoardPosition (&board[y][x], &tiles[FREE],
  50.                              O_NOBODY);
  51.             }
  52.         }
  53.     }
  54.     send_clear_board ();
  55.  
  56.     SelectBoardCursor (&tiles[FREE]);
  57. }
  58.  
  59.  
  60. /*
  61.  * Message Button Callback Routine.
  62.  */
  63.  
  64. XtCallbackProc Mail (widget)
  65. Widget widget;
  66. {
  67.     char msg_buf[100];
  68.  
  69.     msg_buf[0] = '\0';
  70.     if (DialogBoxResult ("Enter Message", msg_buf, 80, ADD_CANCEL) == True)
  71.         send_mail (msg_buf);
  72. }
  73.  
  74.  
  75. /*
  76.  * Ready Button Callback Routine.
  77.  */
  78. static BUTTON ready_buttons[] = {
  79.     " Message ", Mail, TRUE, NULL,
  80.     "  Quit   ", Quit, TRUE, NULL,
  81. };
  82.  
  83. XtCallbackProc Ready (widget)
  84. Widget widget;
  85. {
  86.     char msg_buf[100];
  87.     int i;
  88.  
  89.     for (i = FLAG; i <= BOMB; i++) {
  90.         if (tiles[i].count) {
  91.             display_error (finished_premature);
  92.             return;
  93.         }
  94.     }
  95.  
  96.     sprintf (msg_buf, "You will no longer be able to change your setup.");
  97.     if (DialogBoxResult (msg_buf, NULL, 0, ADD_CANCEL) == True) {
  98.         players[0].status = PL_SETUP_READY;
  99.         send_ready ();
  100.  
  101.         if (players[1].status != PL_SETUP_READY) {
  102.             message ("Waiting for %s to finish his setup...",
  103.                  players[1].name);
  104.             new_button_box (ready_buttons, XtNumber(ready_buttons));
  105.         }
  106.         else
  107.             start_play ();
  108.     }
  109. }
  110.  
  111.  
  112. /*
  113.  * Quit Button Callback Routine.
  114.  */
  115. XtCallbackProc Quit (widget)
  116. Widget widget;
  117. {
  118.     if (DialogBoxResult ("Please Confirm Quit", NULL, 0,
  119.                             ADD_CANCEL) == True) {
  120.         send_quit ();
  121.         XtDestroyApplicationContext (app_con);
  122.         exit (0);
  123.     }
  124. }
  125.  
  126.  
  127. /*
  128.  * Store Button Callback Routine.
  129.  */
  130. static char filename[NAME_LENGTH] = "board.dat";
  131.  
  132. XtCallbackProc Store (widget)
  133. Widget widget;
  134. {
  135.     char file_buf[80];
  136.     char msg_buf[100];
  137.     FILE *fp;
  138.     int x, y;
  139.  
  140.     strcpy (file_buf, filename);
  141.  
  142.     if (DialogBoxResult ("Enter Filename to Store", file_buf, 50,
  143.                             ADD_CANCEL) == False)
  144.         return;
  145.     
  146.     if (access (file_buf, F_OK) == 0) {
  147.         sprintf (msg_buf, "\"%s\" already exists. Overwrite?",file_buf);
  148.         if (DialogBoxResult (msg_buf, NULL, 0, ADD_CANCEL) == False)
  149.             return;
  150.     }
  151.  
  152.     if ((fp = fopen (file_buf, "w")) == NULL) {
  153.         message ("Cannot open datafile \"%s\".", file_buf);
  154.         return;
  155.     }
  156.  
  157.     strcpy (filename, file_buf);
  158.  
  159.     for (y = 6; y < MAX_ROWS; y++)
  160.         for (x = 0; x < MAX_COLS; x++)
  161.             fprintf (fp, "%d ", board[y][x].value);
  162.     fclose (fp);
  163.  
  164.     chmod (filename, 0600);
  165.     
  166.     message ("Board setup saved in \"%s\".", filename);
  167. }
  168.  
  169.  
  170. /*
  171.  * Load Button Callback Routine.
  172.  */
  173. XtCallbackProc Load (widget)
  174. Widget widget;
  175. {
  176.     char file_buf[80];
  177.     FILE *fp;
  178.     int y, x, tile_value;
  179.     TILE *tile;
  180.     BOARD_POS *board_pos;
  181.     Boolean failed = FALSE;
  182.  
  183.     strcpy (file_buf, filename);
  184.  
  185.     if (DialogBoxResult ("Enter Filename to Load", file_buf, 50,
  186.                                ADD_CANCEL) == False)
  187.         return;
  188.  
  189.     strcpy (filename, file_buf);
  190.  
  191.     if ((fp = fopen (filename, "r")) == NULL) {
  192.         extern int errno, sys_nerr;
  193.         extern char *sys_errlist[];
  194.  
  195.         message ("Cannot open datafile \"%s\": %s", filename,
  196.              (errno < 0 || errno >= sys_nerr) ? "Unknown error" :
  197.                                 sys_errlist[errno]);
  198.         return;
  199.     }
  200.  
  201.     Clear (widget, (XtPointer) NULL, (XtPointer) NULL);
  202.  
  203.     for (y = 6; y < MAX_ROWS && failed == False; y++) {
  204.         for (x = 0; x < MAX_COLS && failed == False; x++) {
  205.             if (fscanf (fp, "%d ", &tile_value) != 1) {
  206.                 message ("Datafile damaged!");
  207.                 failed = True;
  208.             }
  209.             else if (tile_value >= FLAG && tile_value <= BOMB) {
  210.                 board_pos = &board[y][x];
  211.                 tile = &tiles[tile_value];
  212.                 if (tile->count == 0) {
  213.                     message ("Hmmm, seems like a cheat file to me %s!", players[0].name);
  214.                     failed = True;
  215.                 }
  216.                 AssignBoardPosition (board_pos, tile, O_PLAYER);
  217.                 UpdateTileCount (tile, -1);
  218.                 send_tile_placed (board_pos);
  219.             }
  220.             else if (tile_value != 0) {
  221.                 message ("Datafile damaged!");
  222.                 failed = True;
  223.             }
  224.         }
  225.     }
  226.  
  227.     fclose (fp);
  228.  
  229.     if (failed == True)
  230.         Clear (widget, (XtPointer) NULL, (XtPointer) NULL);
  231.     else
  232.         message ("Board setup loaded from \"%s\".", filename);
  233. }
  234.  
  235.  
  236. /*
  237.  * TileBitmap widget class callback routines.
  238.  */
  239. static void SelectBoardCursor (tile)
  240. TILE *tile;
  241. {
  242.     int y, x, limit;
  243.     Arg args[1];
  244.  
  245.     if (players[0].status == PL_ENDGAME) {    /* Opponent quitted the game */
  246.         message ("The game has ended!");
  247.         return;
  248.     }
  249.  
  250.     limit = (players[0].status == PL_SETUP) ? MAX_ROWS - 4 : 0;
  251.  
  252.     XtSetArg (args[0], XtNcursor, tile->cursor);
  253.     for (y = MAX_ROWS - 1; y >= limit; y--)
  254.         for (x = MAX_COLS - 1; x >= 0; x--)
  255.             XtSetValues (board[y][x].widget, args, 1);
  256.     
  257.     players[0].tile_select = tile->value;
  258. }
  259.  
  260. XtCallbackProc SelectSetupBoardCursor (widget, tile)
  261. Widget widget;
  262. TILE *tile;
  263. {
  264.     if (players[0].status != PL_SETUP)
  265.         return;
  266.  
  267.     if (tile->count == 0) {
  268.         message ("You have no more %ss left!", tile->name);
  269.         return;
  270.     }
  271.  
  272.     SelectBoardCursor (tile);
  273. }
  274.  
  275.  
  276. /*
  277.  * Called from callback routine of BoardPosition widget class.
  278.  */
  279. void setup_tile (board_pos)
  280. BOARD_POS *board_pos;
  281. {
  282.     TILE *tile;
  283.  
  284.     if (board_pos->value == WATER) {
  285.         message ("Splash blup blup.");
  286.         return;
  287.     }
  288.  
  289.     if (board_pos->y < MAX_ROWS - 4) {
  290.         message ("You cannot put a tile on enemy territory.");
  291.         return;
  292.     }
  293.  
  294.     if (board_pos->value != FREE) {
  295.         UpdateTileCount (&tiles[board_pos->value], 1);
  296.         AssignBoardPosition (board_pos, &tiles[FREE], O_NOBODY);
  297.         send_tile_placed (board_pos);
  298.         if (players[0].tile_select == FREE)
  299.             return; /* Erasing */
  300.     }
  301.  
  302.     tile = &tiles[players[0].tile_select];
  303.     if (tile->value < FLAG || tile->value > BOMB) {
  304.         /* No tile selected */
  305.         message ("You must select a tile first.");
  306.         return;
  307.     }
  308.  
  309.     AssignBoardPosition (board_pos, tile, O_PLAYER);
  310.     UpdateTileCount (tile, -1);
  311.     send_tile_placed (board_pos);
  312.  
  313.     if (tile->count == 0)
  314.         SelectBoardCursor (&tiles[FREE]);
  315. }
  316.  
  317. #ifdef DEBUG
  318. XtCallbackProc Debug ()
  319. {
  320.     char file_buf[80];
  321.     FILE *fp;
  322.     int y, x, tile_value;
  323.     TILE *tile;
  324.     BOARD_POS *board_pos;
  325.     Boolean failed = FALSE;
  326.     char msg_buf[100];
  327.     int i;
  328.     char filename[100];
  329.  
  330.     strcpy (filename, "board.dat");
  331.     if (DialogBoxResult ("Enter file", filename, sizeof(filename), ADD_CANCEL) == False)
  332.         return;
  333.  
  334.     if ((fp = fopen (filename, "r")) == NULL) {
  335.         extern int errno, sys_nerr;
  336.         extern char *sys_errlist[];
  337.  
  338.         message ("Cannot open datafile \"%s\": %s", filename,
  339.              (errno < 0 || errno >= sys_nerr) ? "Unknown error" :
  340.                                 sys_errlist[errno]);
  341.         return;
  342.     }
  343.  
  344.     Clear ();
  345.  
  346.     for (y = 6; y < MAX_ROWS && failed == False; y++) {
  347.         for (x = 0; x < MAX_COLS && failed == False; x++) {
  348.             if (fscanf (fp, "%d ", &tile_value) != 1) {
  349.                 message ("Datafile damaged!");
  350.                 failed = True;
  351.             }
  352.             else if (tile_value >= FLAG && tile_value <= BOMB) {
  353.                 board_pos = &board[y][x];
  354.                 tile = &tiles[tile_value];
  355.                 if (tile->count == 0) {
  356.                     message ("Hmmm, seems like a cheat file to me %s!", players[0].name);
  357.                     failed = True;
  358.                 }
  359.                 AssignBoardPosition (board_pos, tile, O_PLAYER);
  360.                 UpdateTileCount (tile, -1);
  361.                 send_tile_placed (board_pos);
  362.             }
  363.             else if (tile_value != 0) {
  364.                 message ("Datafile damaged!");
  365.                 failed = True;
  366.             }
  367.         }
  368.     }
  369.  
  370.     fclose (fp);
  371.  
  372.     if (failed == True)
  373.         Clear ();
  374.     else
  375.         message ("Board setup loaded from \"%s\".", filename);
  376.  
  377.         players[0].status = PL_SETUP_READY;
  378.         send_ready ();
  379.  
  380.     if (players[1].status != PL_SETUP_READY) {
  381.         message ("Waiting for %s to finish his setup...",
  382.              players[1].name);
  383.     }
  384.     else
  385.         start_play ();
  386. }
  387. #endif
  388.