home *** CD-ROM | disk | FTP | other *** search
/ ftp.ee.pdx.edu / 2014.02.ftp.ee.pdx.edu.tar / ftp.ee.pdx.edu / oss / cvs-2004 / psang / main.c,v < prev    next >
Text File  |  2003-07-07  |  19KB  |  748 lines
  1. head    1.2;
  2. access;
  3. symbols
  4.     Initial:1.1.1.1 psang:1.1.1;
  5. locks; strict;
  6. comment    @ * @;
  7.  
  8.  
  9. 1.2
  10. date    2003.07.07.19.44.13;    author jhoffman;    state Exp;
  11. branches;
  12. next    1.1;
  13.  
  14. 1.1
  15. date    2003.07.07.19.32.23;    author jhoffman;    state Exp;
  16. branches
  17.     1.1.1.1;
  18. next    ;
  19.  
  20. 1.1.1.1
  21. date    2003.07.07.19.32.23;    author jhoffman;    state Exp;
  22. branches;
  23. next    ;
  24.  
  25.  
  26. desc
  27. @@
  28.  
  29.  
  30. 1.2
  31. log
  32. @
  33.  
  34. Testing CVS
  35. @
  36. text
  37. @
  38.  
  39.  
  40. /* main.c - xtron v1.1  main source
  41.  *
  42.  *  Copyright (C) 1995 Rhett D. Jacobs <rhett@@hotel.canberra.edu.au>
  43.  *
  44.  *  This program is free software; you can redistribute it and/or modify
  45.  *  it under the terms of the GNU General Public License as published by
  46.  *  the Free Software Foundation; either version 1, or (at your option)
  47.  *  any later version.
  48.  *
  49.  *  This program is distributed in the hope that it will be useful,
  50.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  51.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  52.  *  GNU General Public License for more details.
  53.  *
  54.  *  You should have received a copy of the GNU General Public License
  55.  *  along with this program; if not, write to the Free Software
  56.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  57.  *
  58.  *  Last Modified: 16/4/95
  59.  */
  60.  
  61. #include "main.h"
  62.  
  63. Display    *display;
  64. int screen;
  65. Window main_window;
  66. GC gc;
  67. unsigned long foreground;
  68. unsigned long background;
  69. int p_state = 1;
  70.  
  71. int LookAHEAD;
  72.  
  73. char KEYS_PLR1_UP, KEYS_PLR1_DOWN, KEYS_PLR1_LEFT, KEYS_PLR1_RIGHT;
  74. char KEYS_PLR2_UP, KEYS_PLR2_DOWN, KEYS_PLR2_LEFT, KEYS_PLR2_RIGHT;
  75.  
  76. /* game windows */
  77. Window game_port, plr1_win, plr2_win, pause_win, again_win, quit_win;
  78. Window plr1_human, plr1_computer, plr2_human, plr2_computer;
  79.  
  80. /* set pixmap for interface */
  81. Pixmap human_pic, computer_pic, again_pic, againr_pic; 
  82. Pixmap pause_pic, pauser_pic, quit_pic, quitr_pic;
  83. Pixmap human_rev, computer_rev, score_pic, scorer_pic;
  84.  
  85. /* player pieces bitmaps */
  86. Pixmap p_im[3], board_im;
  87.  
  88.  
  89. void ButtonEvent(XButtonEvent *pEvent)
  90. {  
  91.   char score1[30];
  92.  
  93.   if (pEvent->subwindow == plr1_win) {
  94.     XCopyArea(display, scorer_pic, plr1_win, gc, 0, 0,
  95.           WBUTTON2, HBUTTON2, 0, 0);
  96.     XCopyArea(display, score_pic, plr1_win, gc, 0, 0,
  97.           WBUTTON2, HBUTTON2, 0, 0);
  98.     p[0].score = 0;
  99.     sprintf(score1,"Player 1 - Score: %d",p[0].score);
  100.     XDrawImageString(display, plr1_win, gc, 10, 20, score1, strlen(score1));
  101.   }
  102.   if (pEvent->subwindow == plr2_win) {
  103.     XCopyArea(display, scorer_pic, plr2_win, gc, 0, 0,
  104.           WBUTTON2, HBUTTON2, 0, 0);
  105.     XCopyArea(display, score_pic, plr2_win, gc, 0, 0,
  106.           WBUTTON2, HBUTTON2, 0, 0);
  107.     p[1].score = 0;
  108.     sprintf(score1,"Player 2 - Score: %d",p[1].score);
  109.     XDrawImageString(display, plr2_win, gc, 10, 20, score1, strlen(score1));
  110.   }
  111.     
  112.   /* player 1 options check */
  113.   if (pEvent->subwindow == plr1_human)
  114.  
  115.     /* if in computer mode, switch to human */ 
  116.     if (p[0].plr_type == computer) {
  117.       p[0].plr_type = human;
  118.       XCopyArea(display, human_rev, plr1_human, gc, 0, 0,
  119.          WBUTTON1, HBUTTON1, 0, 0);
  120.       XCopyArea(display, computer_pic, plr1_computer, gc, 0, 0,
  121.          WBUTTON1, HBUTTON1, 0, 0);
  122.     }
  123.  
  124.   if (pEvent->subwindow == plr1_computer)
  125.  
  126.     /* if in human mode, switch to computer */ 
  127.     if (p[0].plr_type == human) {
  128.       p[0].plr_type = computer;
  129.       XCopyArea(display, human_pic, plr1_human, gc, 0, 0,
  130.          WBUTTON1, HBUTTON1, 0, 0);
  131.       XCopyArea(display, computer_rev, plr1_computer, gc, 0, 0,
  132.          WBUTTON1, HBUTTON1, 0, 0);
  133.     }
  134.  
  135.   /* player 2 options check */
  136.   if (pEvent->subwindow == plr2_human)
  137.  
  138.     /* if in computer mode, switch to human */ 
  139.     if (p[1].plr_type == computer) {
  140.       p[1].plr_type = human;
  141.       XCopyArea(display, human_rev, plr2_human, gc, 0, 0,
  142.          WBUTTON1, HBUTTON1, 0, 0);
  143.       XCopyArea(display, computer_pic, plr2_computer, gc, 0, 0,
  144.          WBUTTON1, HBUTTON1, 0, 0);
  145.     }
  146.  
  147.   if (pEvent->subwindow == plr2_computer)
  148.  
  149.     /* if in human mode, switch to computer */ 
  150.     if (p[1].plr_type == human) {
  151.       p[1].plr_type = computer;
  152.       XCopyArea(display, human_pic, plr2_human, gc, 0, 0,
  153.          WBUTTON1, HBUTTON1, 0, 0);
  154.       XCopyArea(display, computer_rev, plr2_computer, gc, 0, 0,
  155.          WBUTTON1, HBUTTON1, 0, 0);
  156.     }
  157.  
  158.   /* play again */
  159.   if(pEvent->subwindow == again_win) {
  160.     XCopyArea(display, againr_pic, again_win, gc, 0, 0,
  161.           WBUTTON3, HBUTTON3, 0, 0);    
  162.     restart_game();
  163.     XCopyArea(display, again_pic, again_win, gc, 0, 0,
  164.           WBUTTON3, HBUTTON3, 0, 0);    
  165.  
  166.   }
  167.  
  168.   /* pause button */
  169.   if(pEvent->subwindow == pause_win)
  170.     if (p_state) {
  171.       p_state = 0;
  172.       XCopyArea(display, pauser_pic, pause_win, gc, 0, 0,
  173.           WBUTTON2, HBUTTON2, 0, 0);    
  174.     } else {
  175.       p_state = 1;
  176.       XCopyArea(display, pause_pic, pause_win, gc, 0, 0,
  177.           WBUTTON2, HBUTTON2, 0, 0);    
  178.     }
  179.  
  180.   /* quit */
  181.   if (pEvent->subwindow == quit_win) {
  182.     XCopyArea(display, quitr_pic, quit_win, gc, 0, 0,
  183.           WBUTTON2, HBUTTON2, 0, 0);    
  184.     win_shutdown();
  185.   }
  186. }
  187.  
  188.  
  189. void KeyEvent(XKeyEvent *pEvent)
  190. {
  191.   int key_buffer_size = 64;
  192.   char key_buffer[65];
  193.   XComposeStatus compose_status;
  194.   KeySym key_sym;
  195.  
  196.   XLookupString(pEvent, key_buffer, key_buffer_size,
  197.         &key_sym, &compose_status);
  198.   
  199.   if (p[0].plr_type == human) {
  200.     if (key_sym == KEYS_PLR1_UP)
  201.       plr_turn(0,up);
  202.     if (key_sym == KEYS_PLR1_DOWN)
  203.       plr_turn(0,down);
  204.     if (key_sym == KEYS_PLR1_LEFT)
  205.       plr_turn(0,left);
  206.     if (key_sym == KEYS_PLR1_RIGHT)
  207.       plr_turn(0,right);
  208.   }
  209.   if (p[1].plr_type == human) {
  210.     if (key_sym == KEYS_PLR2_UP || key_sym == XK_Up)
  211.       plr_turn(1,up);
  212.     if (key_sym == KEYS_PLR2_DOWN || key_sym == XK_Down)
  213.       plr_turn(1,down);
  214.     if (key_sym == KEYS_PLR2_LEFT || key_sym == XK_Left)
  215.       plr_turn(1,left);
  216.     if (key_sym == KEYS_PLR2_RIGHT || key_sym == XK_Right)
  217.       plr_turn(1,right);
  218.   }
  219. }
  220.  
  221.  
  222. void ExposeEvent(XExposeEvent *pEvent)
  223. {
  224.   int i, ic, j, jc;
  225.   char score1[28], score2[28];
  226.  
  227.   /* remove unused events etc... */
  228.   XSync(display,1);
  229.  
  230.   /* background */
  231.   for(i = 0; i < TOTAL_WIDTH; i+=WBOARD)
  232.     for(j = 0; j < TOTAL_HEIGHT; j+=HBOARD)
  233.       XCopyArea(display, board_im, game_port, gc, 0, 0,
  234.          WBOARD, HBOARD, i, j);
  235.         
  236.   /* refresh board */
  237.   for (i = 0, ic = 0; i < TOTAL_WIDTH; i+=WPIECE, ic++)
  238.     for(j = 0, jc = 0; j < TOTAL_WIDTH; j+=HPIECE, jc++)
  239.       switch (b.contents[ic][jc]) {
  240.       case 1:
  241.  
  242.     /* player 1 */
  243.     XCopyArea(display, p_im[0], game_port, gc, 0, 0,
  244.            WPIECE, HPIECE, i, j);
  245.     break;
  246.       case 2:
  247.  
  248.      /* player 2 */
  249.     XCopyArea(display, p_im[1], game_port, gc, 0, 0,
  250.            WPIECE, HPIECE, i, j);
  251.     break;
  252.       }
  253.   
  254.   /* human and computer icons */
  255.   /* check player setting to highlight appropriate window */
  256.   if(p[0].plr_type == human) {
  257.     XCopyArea(display, human_rev, plr1_human, gc, 0, 0,
  258.            WBUTTON1, HBUTTON1, 0, 0);
  259.     XCopyArea(display, computer_pic, plr1_computer, gc, 0, 0,
  260.            WBUTTON1, HBUTTON1, 0, 0);
  261.   } else {
  262.     XCopyArea(display, human_pic, plr1_human, gc, 0, 0,
  263.            WBUTTON1, HBUTTON1, 0, 0);
  264.     XCopyArea(display, computer_rev, plr1_computer, gc, 0, 0,
  265.            WBUTTON1, HBUTTON1, 0, 0);
  266.   }
  267.   
  268.   /* check player setting to highlight appropriate window */
  269.   if(p[1].plr_type == human) {
  270.     XCopyArea(display, human_rev, plr2_human, gc, 0, 0,
  271.            WBUTTON1, HBUTTON1, 0, 0);
  272.     XCopyArea(display, computer_pic, plr2_computer, gc, 0, 0,
  273.            WBUTTON1, HBUTTON1, 0, 0);
  274.   } else {
  275.     XCopyArea(display, human_pic, plr2_human, gc, 0, 0,
  276.            WBUTTON1, HBUTTON1, 0, 0);
  277.     XCopyArea(display, computer_rev, plr2_computer, gc, 0, 0,
  278.            WBUTTON1, HBUTTON1, 0, 0);
  279.   }
  280.   
  281.   /* again icon */
  282.   XCopyArea(display, again_pic, again_win, gc, 0, 0,
  283.          WBUTTON3, HBUTTON3, 0, 0);
  284.   
  285.   /* pause icon */
  286.   if (p_state)
  287.     XCopyArea(display, pause_pic, pause_win, gc, 0, 0,
  288.           WBUTTON2, HBUTTON2, 0, 0);    
  289.   else
  290.     XCopyArea(display, pauser_pic, pause_win, gc, 0, 0,
  291.           WBUTTON2, HBUTTON2, 0, 0);    
  292.   
  293.   /* quit icon */
  294.   XCopyArea(display, quit_pic, quit_win, gc, 0, 0,
  295.          WBUTTON2, HBUTTON2, 0, 0);  
  296.  
  297.   /* output current scores */
  298.   XCopyArea(display, score_pic, plr1_win, gc, 0, 0,
  299.         WBUTTON2, HBUTTON2, 0, 0);
  300.   XCopyArea(display, score_pic, plr2_win, gc, 0, 0,
  301.         WBUTTON2, HBUTTON2, 0, 0);
  302.  
  303.   sprintf(score1,"Player 1 - Score: %d",p[0].score);
  304.   sprintf(score2,"Player 2 - Score: %d",p[1].score);
  305.  
  306.   XDrawImageString(display, plr1_win, gc, 10, 20, score1, strlen(score1));
  307.   XDrawImageString(display, plr2_win, gc, 10, 20, score2, strlen(score2));
  308. }
  309.  
  310.  
  311. Window set_window(int x, int y, int width, int height)
  312. {
  313.   return(win_open(x, y, width, height, 1, main_window, 0, 0, 
  314.           NULL, NULL));
  315. }
  316.  
  317.  
  318. void mapwindows(void)
  319. {
  320.   XMapWindow(display,main_window);
  321.   XMapWindow(display,game_port);
  322.   XMapWindow(display,plr1_win);
  323.   XMapWindow(display,plr2_win);
  324.   XMapWindow(display,again_win);
  325.   XMapWindow(display,pause_win);
  326.   XMapWindow(display,quit_win);
  327.   XMapWindow(display,plr1_human);
  328.   XMapWindow(display,plr2_human);
  329.   XMapWindow(display,plr1_computer);
  330.   XMapWindow(display,plr2_computer);
  331. }
  332.  
  333.  
  334. Pixmap set_icon(char *filen)
  335. {
  336.   return(ReadXPM(filen));
  337. }
  338.  
  339.  
  340. int check_valid(int p_num, int x_inc, int y_inc)
  341. {
  342.   if (b.contents[p[p_num].co_ords[0]+x_inc][p[p_num].co_ords[1]+y_inc] != 0)
  343.     return (0);
  344.   
  345.   if (y_inc != 0) {
  346.     if ((p[p_num].co_ords[1]+y_inc) < MAXVERT &&
  347.     (p[p_num].co_ords[1]+y_inc)  >= MINVERT)  
  348.       return (1);
  349.   } else {
  350.     if (x_inc != 0)
  351.       if ((p[p_num].co_ords[0]+x_inc) < MAXHORZ &&
  352.       (p[p_num].co_ords[0]+x_inc) >= MINHORZ)
  353.     return (1);
  354.   }
  355.   return(0);
  356. }
  357.  
  358.  
  359. /* artificial intelligence routines for computer player */
  360. void think(int p_num)
  361. {
  362.   enum directions sides[2];
  363.   int flags[6] = {0,0,0,0,0,0};
  364.   int index[2];
  365.   int dis_forward,  dis_left, dis_right;
  366.  
  367.   dis_forward = dis_left = dis_right = 1;
  368.  
  369.   switch (p[p_num].plr_dir) {
  370.   case left:
  371.  
  372.     /* forward flags */
  373.     flags[0] = -1;
  374.     flags[1] = 0;
  375.  
  376.     /* left flags */
  377.     flags[2] = 0;
  378.     flags[3] = 1;
  379.  
  380.     /* right flags */
  381.     flags[4] = 0;
  382.     flags[5] = -1;
  383.  
  384.     /* turns to either side */
  385.     sides[0] = down;
  386.     sides[1] = up;
  387.     break;
  388.   case right:
  389.     flags[0] = 1;
  390.     flags[1] = 0;
  391.     flags[2] = 0;
  392.     flags[3] = -1;
  393.     flags[4] = 0;
  394.     flags[5] = 1;
  395.     sides[0] = up;
  396.     sides[1] = down;
  397.     break;
  398.   case up:
  399.     flags[0] = 0;
  400.     flags[1] = -1;
  401.     flags[2] = -1;
  402.     flags[3] = 0;
  403.     flags[4] = 1;
  404.     flags[5] = 0;
  405.     sides[0] = left;
  406.     sides[1] = right;
  407.     break;
  408.   case down:
  409.     flags[0] = 0;
  410.     flags[1] = 1;
  411.     flags[2] = 1;
  412.     flags[3] = 0;
  413.     flags[4] = -1;
  414.     flags[5] = 0;
  415.     sides[0] = right;
  416.     sides[1] = left;
  417.     break;
  418.   }
  419.  
  420.   /* check forward */
  421.   index[0] = p[p_num].co_ords[0]+flags[0];
  422.   index[1] = p[p_num].co_ords[1]+flags[1];
  423.   while (index[0] < MAXHORZ && index[0] >= MINHORZ &&
  424.      index[1] < MAXVERT && index[1] >= MINVERT &&
  425.      b.contents[index[0]][index[1]] == 0) {
  426.     dis_forward++;
  427.     index[0] += flags[0];
  428.     index[1] += flags[1];
  429.   }
  430.  
  431.   if (dis_forward < LookAHEAD) {
  432.     dis_forward = 100 - 100/dis_forward;
  433.  
  434.     /* check left */
  435.     index[0] = p[p_num].co_ords[0]+flags[2];
  436.     index[1] = p[p_num].co_ords[1]+flags[3];
  437.     while (index[0] < MAXHORZ && index[0] >= MINHORZ &&
  438.        index[1] < MAXVERT && index[1] >= MINVERT &&
  439.        b.contents[index[0]][index[1]] == 0) {
  440.       dis_left++;
  441.       index[0] += flags[2];
  442.       index[1] += flags[3];
  443.     } 
  444.     
  445.     /* check right */
  446.     index[0] = p[p_num].co_ords[0]+flags[4];
  447.     index[1] = p[p_num].co_ords[1]+flags[5];
  448.     while (index[0] < MAXHORZ && index[0] >= MINHORZ &&
  449.        index[1] < MAXVERT && index[1] >= MINVERT &&
  450.        b.contents[index[0]][index[1]] == 0) {
  451.       dis_right++;
  452.       index[0] += flags[4];
  453.       index[1] += flags[5];
  454.     } 
  455.     if(!(dis_left == 1 && dis_right == 1))
  456.       if ((int)rand()%100 >= dis_forward || dis_forward == 0) {
  457.        
  458.     /* change direction */
  459.     if ((int)rand()%100 <= (100*dis_left)/(dis_left+dis_right))
  460.       if (dis_left != 1)
  461.  
  462.         /* turn to the left */
  463.         p[p_num].plr_dir = sides[0];
  464.       else
  465.  
  466.         /* turn to the right */
  467.         p[p_num].plr_dir = sides[1];
  468.     else
  469.       if (dis_right != 1)
  470.  
  471.         /*  turn to the right */
  472.         p[p_num].plr_dir = sides[1];
  473.       else
  474.  
  475.         /* turn to the left */
  476.         p[p_num].plr_dir = sides[0];
  477.       }
  478.   }
  479. }
  480.  
  481.  
  482. int game_update(void)
  483. {
  484.   int i, ic, j , jc;
  485.   int x_inc = 0, y_inc = 0;
  486.  
  487.   for (i = 0; i< 2; i++) {
  488.     if (p[i].plr_type == computer)
  489.       think(i);
  490.     switch (p[i].plr_dir) {
  491.     case left:
  492.       if (check_valid(i,-1,0))
  493.     p[i].co_ords[0]--;
  494.       else
  495.     p[i].alive = 0;
  496.       break;
  497.     case right:
  498.       if (check_valid(i,1,0))
  499.     p[i].co_ords[0]++;
  500.       else
  501.     p[i].alive = 0;
  502.       break;
  503.     case up:
  504.       if (check_valid(i,0,-1))
  505.     p[i].co_ords[1]--;
  506.       else
  507.     p[i].alive = 0;
  508.       break;
  509.     case down:
  510.       if (check_valid(i,0,1))
  511.     p[i].co_ords[1]++;
  512.       else
  513.     p[i].alive = 0;
  514.       break;
  515.     }
  516.     b.contents[p[i].co_ords[0]][p[i].co_ords[1]] = i+1;
  517.   }
  518.   XCopyArea(display, p_im[0], game_port, gc, 0, 0, WPIECE, HPIECE, 
  519.          p[0].co_ords[0]*WPIECE, p[0].co_ords[1]*HPIECE);  
  520.   XCopyArea(display, p_im[1], game_port, gc, 0, 0, WPIECE, HPIECE, 
  521.          p[1].co_ords[0]*WPIECE, p[1].co_ords[1]*HPIECE);
  522.  
  523.   /* player collision check */
  524.   if(!p[1].alive) { 
  525.     switch(p[1].plr_dir) {
  526.     case left:
  527.       x_inc = -1; break;
  528.     case right:
  529.       x_inc = 1; break;
  530.     case up:
  531.       y_inc = -1; break;
  532.     case down:
  533.       y_inc = 1; break;
  534.     }
  535.     if ((p[1].co_ords[0]+x_inc) == p[0].co_ords[0])   
  536.       if ((p[1].co_ords[1]+y_inc) == p[0].co_ords[1]) {
  537.     for(i = 0, ic = 0; i < TOTAL_WIDTH; i+=WPIECE, ic++)
  538.       for(j = 0, jc = 0; j < TOTAL_WIDTH; j+=HPIECE, jc++)
  539.         if (b.contents[ic][jc])
  540.           XCopyArea(display, p_im[2], game_port, gc, 0, 0,
  541.              WPIECE, HPIECE, i, j);
  542.     return(0);
  543.       }
  544.   }
  545.  
  546.   if(!p[0].alive && !p[1].alive) {
  547.     for(i = 0, ic = 0; i < TOTAL_WIDTH; i+=WPIECE, ic++)
  548.       for(j = 0, jc = 0; j < TOTAL_WIDTH; j+=HPIECE, jc++)
  549.     if (b.contents[ic][jc])
  550.       XCopyArea(display, p_im[2], game_port, gc, 0, 0,
  551.              WPIECE, HPIECE, i, j);
  552.     return(0);
  553.   }
  554.   
  555.   if (!p[0].alive) {
  556.  
  557.     /* player 1 dead */
  558.     p[1].score++;
  559.     for(i = 0, ic = 0; i < TOTAL_WIDTH; i+=WPIECE, ic++)
  560.       for(j = 0, jc = 0; j < TOTAL_WIDTH; j+=HPIECE, jc++)
  561.     if (b.contents[ic][jc] == 1)
  562.       XCopyArea(display, p_im[1], game_port, gc, 0, 0,
  563.              WPIECE, HPIECE, i, j);
  564.     return(0);
  565.   }
  566.   if (!p[1].alive) {
  567.  
  568.     /* player 2 dead */
  569.     p[0].score++;
  570.     for(i = 0, ic = 0; i < TOTAL_WIDTH; i+=WPIECE, ic++)
  571.       for(j = 0, jc = 0; j < TOTAL_WIDTH; j+=HPIECE, jc++)
  572.     if (b.contents[ic][jc] == 2)
  573.       XCopyArea(display, p_im[0], game_port, gc, 0, 0,
  574.              WPIECE, HPIECE, i, j);
  575.     return(0);
  576.   }               
  577.   return(1);
  578. }
  579.  
  580.  
  581. void restart_game(void)
  582. {
  583.   int i;
  584.   XEvent event;
  585.  
  586.   p[0].plr_dir = left;
  587.   p[1].plr_dir = right;
  588.   for (i=0; i<2; i++) {
  589.     p[i].alive = 1;
  590.     p[i].co_ords[1] = MAXVERT/2;
  591.   }
  592.   p[0].co_ords[0] = (MAXHORZ/2)-3;
  593.   p[1].co_ords[0] = (MAXHORZ/2)+3;
  594.   brd_setup();
  595.   ExposeEvent(&event.xexpose);
  596. }
  597.  
  598.  
  599. void open_windows(int argc, char **argv)
  600. {
  601.   main_window = win_open(0, 0, TOTAL_WIDTH, TOTAL_HEIGHT, 5,
  602.               DefaultRootWindow(display), 1, argc, argv,
  603.              "xtron v1.1a - <rhett@@hotel.canberra.edu.au>");
  604.   game_port = set_window(0, 1, TOTAL_WIDTH, TOTAL_WIDTH);
  605.   plr1_win = set_window(0, TOTAL_WIDTH, (TOTAL_WIDTH/2),
  606.             ((TOTAL_HEIGHT-TOTAL_WIDTH)/2));
  607.   plr2_win = set_window((TOTAL_WIDTH/2), TOTAL_WIDTH,
  608.             (TOTAL_WIDTH/2), ((TOTAL_HEIGHT-TOTAL_WIDTH)/2));
  609.   again_win = set_window(0, (TOTAL_WIDTH+((TOTAL_HEIGHT-TOTAL_WIDTH)/2)),
  610.              TOTAL_WIDTH, (TOTAL_HEIGHT/16));
  611.   pause_win = set_window(0, (TOTAL_HEIGHT-(TOTAL_HEIGHT/16)),
  612.              (TOTAL_WIDTH/2), (TOTAL_HEIGHT/16));
  613.   quit_win = set_window((TOTAL_WIDTH/2),    
  614.             (TOTAL_HEIGHT-(TOTAL_HEIGHT/16)),
  615.             (TOTAL_WIDTH/2), (TOTAL_HEIGHT/16));
  616.   plr1_human = set_window(0, (TOTAL_WIDTH+TOTAL_HEIGHT/16),
  617.               (TOTAL_WIDTH/4), (TOTAL_HEIGHT/16));
  618.   plr1_computer = set_window((TOTAL_WIDTH/4), (TOTAL_WIDTH+TOTAL_HEIGHT/16),
  619.                  (TOTAL_WIDTH/4), (TOTAL_HEIGHT/16));
  620.   plr2_human = set_window((TOTAL_WIDTH/2), (TOTAL_WIDTH+TOTAL_HEIGHT/16),
  621.               (TOTAL_WIDTH/4), (TOTAL_HEIGHT/16));
  622.   plr2_computer = set_window((TOTAL_WIDTH-TOTAL_WIDTH/4),
  623.                  (TOTAL_WIDTH+TOTAL_HEIGHT/16),
  624.                  (TOTAL_WIDTH/4),(TOTAL_HEIGHT/16));
  625. }
  626.  
  627.  
  628. void assign_bitmaps(void) 
  629. {
  630.   /* assign bitmaps used for user interface */
  631.   human_pic = set_icon("human.xpm");
  632.   computer_pic = set_icon("computer.xpm");
  633.   human_rev = set_icon("humanr.xpm");
  634.   computer_rev = set_icon("comprr.xpm");
  635.   again_pic = set_icon("again.xpm");
  636.   againr_pic = set_icon("againr.xpm");
  637.   pause_pic = set_icon("pause.xpm");
  638.   pauser_pic = set_icon("pauser.xpm");
  639.   quit_pic = set_icon("quit.xpm");
  640.   quitr_pic = set_icon("quitr.xpm");
  641.   score_pic = set_icon("score.xpm");
  642.   scorer_pic = set_icon("scorer.xpm");
  643.   
  644.   /* assign bitmaps used for player pieces */
  645.   p_im[0] = set_icon("p1.xpm");
  646.   p_im[1] = set_icon("p2.xpm");
  647.   p_im[2] = set_icon("p3.xpm");
  648.   board_im = set_icon("back.xpm");
  649. }
  650.  
  651.  
  652. void delay(int len)
  653. {
  654.   struct timeval tm;
  655.   
  656.   tm.tv_sec  = len/1000000;
  657.   tm.tv_usec = len%1000000;
  658.   select(0,0,0,0,&tm);
  659. }
  660.  
  661.  
  662. void assign_keys(void)
  663. {
  664.   KEYS_PLR1_UP = KeyRESOURCE(1,0);
  665.   KEYS_PLR2_UP = KeyRESOURCE(2,0);
  666.   KEYS_PLR1_DOWN = KeyRESOURCE(1,1);
  667.   KEYS_PLR2_DOWN = KeyRESOURCE(2,1);
  668.   KEYS_PLR1_LEFT = KeyRESOURCE(1,2);
  669.   KEYS_PLR2_LEFT = KeyRESOURCE(2,2);
  670.   KEYS_PLR1_RIGHT = KeyRESOURCE(1,3);
  671.   KEYS_PLR2_RIGHT = KeyRESOURCE(2,3);
  672.  
  673.   LookAHEAD = LookAhead();
  674. }
  675.  
  676.  
  677. int main (int argc, char *argv[])    
  678. {    
  679.   int i = 0;
  680.   XEvent event; 
  681.   
  682.   InitialiseResource();
  683.   assign_keys();
  684.  
  685.   win_setup();
  686.   plr_setup();
  687.   brd_setup();
  688.   srand(time(0));
  689.  
  690.    open_windows(argc, argv);
  691.    gc = win_getGC();
  692.    mapwindows();
  693.    assign_bitmaps();
  694.    
  695.   XNextEvent(display, &event);
  696.    if (event.type == Expose)
  697.      ExposeEvent(&event.xexpose);
  698.  
  699.   /* game loop */
  700.   for(;;) {
  701.     delay(5000);
  702.     if (p_state)
  703.       if (i++ == 4) {
  704.     if(!(game_update())) {
  705.       XFlush(display);
  706.       delay(1500000);
  707.       restart_game();
  708.     }
  709.     i = 0;
  710.       }
  711.     
  712.     if (XCheckWindowEvent(display,main_window,
  713.               ExposureMask | KeyPressMask | ButtonPressMask |
  714.               VisibilityChangeMask,
  715.               &event))
  716.       switch (event.type) {
  717.       case Expose:
  718.     ExposeEvent(&event.xexpose); break;
  719.       case VisibilityNotify:
  720.         ExposeEvent(&event.xexpose); break;
  721.       case KeyPress:
  722.     KeyEvent(&event.xkey); break;
  723.       case ButtonPress:
  724.     ButtonEvent(&event.xbutton); break;
  725.       case MappingNotify:
  726.     XRefreshKeyboardMapping(&event.xmapping); break;
  727.       }
  728.   }
  729. }
  730. @
  731.  
  732.  
  733. 1.1
  734. log
  735. @Initial revision
  736. @
  737. text
  738. @d1 3
  739. @
  740.  
  741.  
  742. 1.1.1.1
  743. log
  744. @Protocol for Simple Arcade-Style Network Gaming
  745. @
  746. text
  747. @@
  748.