home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / games / volume14 / xbattle / part04 < prev    next >
Encoding:
Internet Message Format  |  1993-01-26  |  53.0 KB
  1. Path: uunet!zephyr.ens.tek.com!master!saab!billr
  2. From: billr@saab.CNA.TEK.COM (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v14i075:  xbattle - multi-player battle strategy game for X-Windows, Part04/07
  5. Message-ID: <3514@master.CNA.TEK.COM>
  6. Date: 7 Sep 92 21:23:07 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 1709
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: slehar@cns.bu.edu
  12. Posting-number: Volume 14, Issue 75
  13. Archive-name: xbattle/Part04
  14. Environment: Xlib
  15.  
  16.  
  17.  
  18. #! /bin/sh
  19. # This is a shell archive.  Remove anything before this line, then unpack
  20. # it by saving it into a file and typing "sh file".  To overwrite existing
  21. # files, type "sh file -c".  You can also feed this as standard input via
  22. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  23. # will see the following message at the end:
  24. #        "End of archive 4 (of 7)."
  25. # Contents:  draw.c extern.h
  26. # Wrapped by billr@saab on Mon Sep  7 14:18:50 1992
  27. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  28. if test -f 'draw.c' -a "${1}" != "-c" ; then 
  29.   echo shar: Will not clobber existing file \"'draw.c'\"
  30. else
  31. echo shar: Extracting \"'draw.c'\" \(43247 characters\)
  32. sed "s/^X//" >'draw.c' <<'END_OF_FILE'
  33. X#include <stdio.h>
  34. X  
  35. X/**** x include files ****/
  36. X#include <X11/Xlib.h>
  37. X#include <X11/Xutil.h>
  38. X#include <X11/Xatom.h>
  39. X#include <X11/keysym.h>
  40. X#include <X11/keysymdef.h>
  41. X
  42. X#include "extern.h"
  43. X
  44. X/*************************************************************************/
  45. X/**    drawboard                            **/
  46. X/** draw the game board                            **/
  47. X/**    Steve Lehar (slehar@park.bu.edu)                **/
  48. X/**    Greg Lesher (lesher@park.bu.edu)                **/
  49. X/*************************************************************************/
  50. Xdrawboard(board, player,justboard)
  51. X  square_type *board;
  52. X  int player,
  53. X      justboard;
  54. X{
  55. X  int i, j, k;
  56. X
  57. X  if (winopen[player])
  58. X  {
  59. X    if (enable_hex)
  60. X      XFillRectangle(xwindow[player]->display, xwindow[player]->window, xwindow[player]->hue[dark],
  61. X                  0, 0, (boardsizex-1)*3*hex_halfside + 2*hex_side, boardsizey*2*hex_vert + hex_vert);
  62. X
  63. X    /**** paint the pieces ****/
  64. X    for (i=0; i<boardsizex; i++)
  65. X    {
  66. X      for (j=0; j<boardsizey; j++)
  67. X      {
  68. X        if (enable_hex)
  69. X      blanksquare(xwindow[player],SQUARE(board,i,j),colorarray[player],
  70. X                                         squaresize[colorarray[player]], TRUE);
  71. X
  72. X        if (visible(board,colorarray[player],i,j))
  73. X      drawsquare(xwindow[player],SQUARE(board,i,j),colorarray[player],
  74. X                                         squaresize[colorarray[player]]);
  75. X        else
  76. X          drawblank(xwindow[player], i, j, SQUARE(board,i,j)->value[none],
  77. X                          SQUARE(board,i,j)->seen[colorarray[player]],
  78. X                          SQUARE(board,i,j)->growth, colorarray[player],
  79. X                          squaresize[colorarray[player]], SQUARE(board,i,j));
  80. X
  81. X        if (enable_storage && player == 0)
  82. X          storedrawsquare(SQUARE(board,i,j), squaresize[0], TRUE);
  83. X      }
  84. X    }
  85. X  }
  86. X
  87. X  /**** write the text ****/
  88. X
  89. X  if (!justboard)
  90. X  {
  91. X    for (i=0; i<nplayers; i++)
  92. X    {
  93. X      XDrawImageString(xwindow[i]->display,xwindow[i]->window,
  94. X               xwindow[i]->hue[0],
  95. X               TEXTX,textyh[colorarray[i]][colorarray[i]],
  96. X               blankline,strlen(blankline));
  97. X      XDrawImageString(xwindow[i]->display,xwindow[i]->window,
  98. X               xwindow[i]->hue[0],
  99. X               TEXTX,textyh[colorarray[i]][colorarray[i]],
  100. X               messagestr,strlen(messagestr));
  101. X    }
  102. X  }
  103. X}
  104. X
  105. X
  106. X/*************************************************************************/
  107. X/**    blanksquare                              **/
  108. X/** Draw blank hexagon                            **/ 
  109. X/**    Greg Lesher (lesher@cns.bu.edu)                    **/
  110. X/*************************************************************************/
  111. Xblanksquare (xwindow, square, windowcolor, squaresize, flag)
  112. X  xwindow_type *xwindow;
  113. X  square_type *square;
  114. X  int windowcolor,
  115. X      squaresize,
  116. X      flag;
  117. X{
  118. X  int  xpos, ypos;
  119. X
  120. X  xpos = square->xpos;
  121. X  ypos = square->ypos;
  122. X
  123. X  hex_points[0].x = xpos - hex_halfside;
  124. X  hex_points[0].y = ypos - hex_vert; 
  125. X
  126. X  if (flag)
  127. X    XFillPolygon(xwindow->display,xwindow->window,xwindow->hue[none],
  128. X                               hex_points, 6, Convex, CoordModePrevious);
  129. X  if (enable_grid[windowcolor])
  130. X    XDrawLines(xwindow->display,xwindow->window,xwindow->hue[dark], hex_points, 7, CoordModePrevious);
  131. X}
  132. X
  133. X
  134. X/*************************************************************************/
  135. X/**    drawmarch                              **/
  136. X/** Draw passive march markers                        **/
  137. X/**    Greg Lesher (lesher@park.bu.edu)                **/
  138. X/*************************************************************************/
  139. Xdrawmarch(board)
  140. X  square_type *board;
  141. X{
  142. X  int x, y, k;
  143. X
  144. X  for (x=0; x<boardsizex; x++)
  145. X  {
  146. X    for (y=0; y<boardsizey; y++)
  147. X    {
  148. X      if (SQUARE(board,x,y)->anymarch == ACTIVE)
  149. X        drawmarcharrows (SQUARE(board,x,y),SQUARE(board,x,y)->marchcolor,ACTIVE);
  150. X      else
  151. X      {
  152. X        for (k=0; k<nsides; k++)
  153. X        {
  154. X          if (SQUARE(board,x,y)->march[k] == PASSIVE)
  155. X            if (SQUARE(board,x,y)->color == none)
  156. X            {
  157. X              drawmarcharrows(SQUARE(board,x,y),k,PASSIVE);
  158. X            }
  159. X            else if (!visible(board,k,x,y))
  160. X              drawmarcharrows(SQUARE(board,x,y),k,PASSIVE);
  161. X        }
  162. X      }
  163. X    }
  164. X  }
  165. X}
  166. X
  167. X
  168. X/*************************************************************************/
  169. X/**    drawmarcharrows                              **/
  170. X/** Draw passive march markers                        **/
  171. X/**    Greg Lesher (lesher@park.bu.edu)                **/
  172. X/*************************************************************************/
  173. Xdrawmarcharrows (square,marchcolor,type)
  174. X  square_type *square;
  175. X  int marchcolor,
  176. X      type;
  177. X{
  178. X  int k,
  179. X      xpos, ypos,
  180. X      hafsquare;
  181. X
  182. X  if (enable_hex)
  183. X  {
  184. X    xpos = square->xpos;
  185. X    ypos = square->ypos;
  186. X
  187. X    for (k=0; k<nplayers; k++)
  188. X    {
  189. X      if (colorarray[k] == marchcolor)
  190. X      {
  191. X        if(square->marchdir[marchcolor][HEX_UP])
  192. X        {
  193. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  194. X            xpos+2, ypos, xpos+2, ypos-hex_vert+2);
  195. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  196. X            xpos+3, ypos, xpos+3, ypos-hex_vert+2);
  197. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  198. X            xpos-2, ypos, xpos-2, ypos-hex_vert+2);
  199. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  200. X            xpos-3, ypos, xpos-3, ypos-hex_vert+2);
  201. X        }
  202. X        if(square->marchdir[marchcolor][HEX_DOWN])
  203. X        {
  204. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  205. X            xpos+2, ypos, xpos+2, ypos+hex_vert-2);
  206. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  207. X            xpos+3, ypos, xpos+3, ypos+hex_vert-2);
  208. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  209. X            xpos-2, ypos, xpos-2, ypos+hex_vert-2);
  210. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  211. X            xpos-3, ypos, xpos-3, ypos+hex_vert-2);
  212. X        }
  213. X        if(square->marchdir[marchcolor][HEX_RIGHT_UP])
  214. X        {
  215. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  216. X            xpos-2, ypos-2, xpos+hex_3quarterside-2, ypos-hex_halfvert-2);
  217. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  218. X            xpos-3, ypos-3, xpos+hex_3quarterside-3, ypos-hex_halfvert-3);
  219. X
  220. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  221. X            xpos+2, ypos+2, xpos+hex_3quarterside+2, ypos-hex_halfvert+2);
  222. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  223. X            xpos+3, ypos+3, xpos+hex_3quarterside+3, ypos-hex_halfvert+3);
  224. X        }
  225. X        if(square->marchdir[marchcolor][HEX_RIGHT_DOWN])
  226. X        {
  227. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  228. X            xpos+2, ypos-2, xpos+hex_3quarterside+2, ypos+hex_halfvert-2);
  229. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  230. X            xpos+3, ypos-3, xpos+hex_3quarterside+3, ypos+hex_halfvert-3);
  231. X
  232. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  233. X            xpos-2, ypos+2, xpos+hex_3quarterside-2, ypos+hex_halfvert+2);
  234. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  235. X            xpos-3, ypos+3, xpos+hex_3quarterside-3, ypos+hex_halfvert+3);
  236. X        }
  237. X        if(square->marchdir[marchcolor][HEX_LEFT_UP])
  238. X        {
  239. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  240. X            xpos+2, ypos-2, xpos-hex_3quarterside+2, ypos-hex_halfvert-2);
  241. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  242. X            xpos+3, ypos-3, xpos-hex_3quarterside+3, ypos-hex_halfvert-3);
  243. X
  244. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  245. X            xpos-2, ypos+2, xpos-hex_3quarterside-2, ypos-hex_halfvert+2);
  246. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  247. X            xpos-3, ypos+3, xpos-hex_3quarterside-3, ypos-hex_halfvert+3);
  248. X        }
  249. X        if(square->marchdir[marchcolor][HEX_LEFT_DOWN])
  250. X        {
  251. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  252. X            xpos-2, ypos-2, xpos-hex_3quarterside-2, ypos+hex_halfvert-2);
  253. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  254. X            xpos-3, ypos-3, xpos-hex_3quarterside-3, ypos+hex_halfvert-3);
  255. X
  256. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  257. X            xpos+2, ypos+2, xpos-hex_3quarterside+2, ypos+hex_halfvert+2);
  258. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  259. X            xpos+3, ypos+3, xpos-hex_3quarterside+3, ypos+hex_halfvert+3);
  260. X        }
  261. X  
  262. X        if (type == PASSIVE)
  263. X          XDrawRectangle(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  264. X              xpos-DSIZE, ypos-DSIZE, 2*DSIZE, 2*DSIZE);
  265. X      }
  266. X    }
  267. X  }
  268. X  else
  269. X  {
  270. X    hafsquare=squaresize[marchcolor]/2;
  271. X    xpos = square->x*squaresize[marchcolor]+hafsquare;
  272. X    ypos = square->y*squaresize[marchcolor]+hafsquare;
  273. X
  274. X    for (k=0; k<nplayers; k++)
  275. X    {
  276. X      if (colorarray[k] == marchcolor)
  277. X      {
  278. X        if(square->marchdir[marchcolor][UP])
  279. X        {
  280. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  281. X            xpos+2, ypos, xpos+2, ypos-hafsquare);
  282. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  283. X            xpos+3, ypos, xpos+3, ypos-hafsquare);
  284. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  285. X            xpos-2, ypos, xpos-2, ypos-hafsquare);
  286. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  287. X            xpos-3, ypos, xpos-3, ypos-hafsquare);
  288. X        }
  289. X        if(square->marchdir[marchcolor][DOWN])
  290. X        {
  291. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  292. X            xpos+2, ypos, xpos+2, ypos+hafsquare-1);
  293. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  294. X            xpos+3, ypos, xpos+3, ypos+hafsquare-1);
  295. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  296. X            xpos-2, ypos, xpos-2, ypos+hafsquare-1);
  297. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  298. X            xpos-3, ypos, xpos-3, ypos+hafsquare-1);
  299. X        }
  300. X        if(square->marchdir[marchcolor][RIGHT])
  301. X        {
  302. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  303. X            xpos, ypos+2, xpos+hafsquare-1, ypos+2);
  304. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  305. X            xpos, ypos+3, xpos+hafsquare-1, ypos+3);
  306. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  307. X            xpos, ypos-2, xpos+hafsquare-1, ypos-2);
  308. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  309. X            xpos, ypos-3, xpos+hafsquare-1, ypos-3);
  310. X        }
  311. X        if(square->marchdir[marchcolor][LEFT])
  312. X        {
  313. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  314. X            xpos, ypos+2, xpos-hafsquare, ypos+2);
  315. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  316. X            xpos, ypos+3, xpos-hafsquare, ypos+3);
  317. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  318. X            xpos, ypos-2, xpos-hafsquare, ypos-2);
  319. X          XDrawLine(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  320. X            xpos, ypos-3, xpos-hafsquare, ypos-3);
  321. X        }
  322. X  
  323. X        if (type == PASSIVE)
  324. X          XDrawRectangle(xwindow[k]->display,xwindow[k]->window,xwindow[k]->hue[marchcolor],
  325. X              xpos-DSIZE, ypos-DSIZE, 2*DSIZE, 2*DSIZE);
  326. X      }
  327. X    }
  328. X  }
  329. X}
  330. X
  331. X
  332. X/*************************************************************************/
  333. X/**    drawsquare                              **/
  334. X/** Draw one square of the game board                    **/
  335. X/**    Greg Lesher (lesher@park.bu.edu)                **/
  336. X/*************************************************************************/
  337. Xdrawsquare(xwindow,square,windowcolor,squaresize)
  338. X  xwindow_type *xwindow;
  339. X  square_type *square;
  340. X  int windowcolor,
  341. X      squaresize;
  342. X{
  343. X  int i, j, k,
  344. X      offset,
  345. X      ipos, jpos,
  346. X      hafsquare, psize, bsize, hafpsize, psize1, hafpsize1,
  347. X      value,
  348. X      terrain_type,
  349. X      max, smax, max_pos, smax_pos,
  350. X      csize,hafc;
  351. X  static GC onhue, offhue;
  352. X
  353. X  hafsquare=squaresize/2;
  354. X
  355. X  /**** get square coordinates ****/
  356. X  i = square->x;
  357. X  j = square->y;
  358. X
  359. X  if (enable_hex)
  360. X  {
  361. X    ipos = square->xpos;
  362. X    jpos = square->ypos;
  363. X  }
  364. X  else
  365. X  {
  366. X    ipos = i*squaresize;
  367. X    jpos = j*squaresize;
  368. X  }
  369. X
  370. X  /**** set drawing color & value ****/
  371. X
  372. X  if (square->color == none || square->color == FIGHT)
  373. X    value=0;
  374. X  else
  375. X  {
  376. X    onhue = xwindow->hue[square->color];
  377. X    if ((xwindow->depth==1 && color2bw[sidemap[square->color]]<=GRAY3) ||
  378. X        (xwindow->depth==8 && sidemap[square->color]==BLACK))
  379. X      offhue = xwindow->hue[light];
  380. X    else
  381. X      offhue = xwindow->hue[dark];
  382. X    value = square->value[square->color];
  383. X  }
  384. X
  385. X  if (square->color == none)
  386. X  {
  387. X    onhue = xwindow->hue[none];
  388. X    offhue = xwindow->hue[dark];
  389. X    value = 0;
  390. X  }
  391. X  
  392. X  /**** compute piece size ****/
  393. X
  394. X  if (enable_hex)
  395. X    bsize = 11*hex_vert/6;
  396. X  else
  397. X    bsize = squaresize;
  398. X  psize = (int)(bsize * areavalue[value]);
  399. X  hafpsize = psize/2;
  400. X
  401. X  /**** clear with appropriately colored square ****/
  402. X
  403. X  if (enable_terrain)
  404. X  {
  405. X    terrain_type = square->value[none];
  406. X
  407. X    if (enable_hex)
  408. X    {
  409. X      offset = -2 * square->value[none];
  410. X
  411. X      if (terrain_type < 0)
  412. X      {
  413. X        double_copy (xwindow, square, windowcolor, squaresize, terrain_type, 0);
  414. X        terrain_type = 0;
  415. X      }
  416. X      else
  417. X        offset = 0;
  418. X
  419. X      if (terrain_type == 1 && !enable_hills && !enable_forest)
  420. X        XFillArc (xwindow->display,xwindow->window, xwindow->hue[none],
  421. X           ipos-(hex_vert-1), jpos-(hex_vert-1), 2*(hex_vert-1), 2*(hex_vert-1), 0, 23040);
  422. X      else
  423. X        double_copy (xwindow, square, windowcolor, squaresize, terrain_type, offset);
  424. X    }
  425. X    else
  426. X    {
  427. X      offset = ((double)(-terrain_type) * squaresize)/(2*fillnumber);
  428. X
  429. X      if (terrain_type < 0)
  430. X        terrain_type = 0;
  431. X      else
  432. X        offset = 0;
  433. X
  434. X      if (offset != 0)
  435. X        XCopyArea (xwindow->display, xwindow->terrain[1], xwindow->window,
  436. X                    xwindow->hue[dark], 0, 0, squaresize, squaresize, i*squaresize, j*squaresize);
  437. X
  438. X      XCopyArea (xwindow->display, xwindow->terrain[terrain_type], xwindow->window,
  439. X                          xwindow->hue[dark], 0, 0, squaresize-2*offset, squaresize-2*offset,
  440. X                          i*squaresize+offset, j*squaresize+offset);
  441. X    }
  442. X  }
  443. X  else
  444. X  {
  445. X    if (enable_hex)
  446. X    {
  447. X      XFillArc (xwindow->display,xwindow->window, xwindow->hue[none],
  448. X           ipos-(hex_vert-1), jpos-(hex_vert-1), 2*(hex_vert-1), 2*(hex_vert-1), 0, 23040);
  449. X
  450. X/**
  451. X      blanksquare(xwindow, square, windowcolor, squaresize, TRUE);
  452. X**/
  453. X    }
  454. X    else
  455. X      XFillRectangle(xwindow->display,xwindow->window, xwindow->hue[none],
  456. X           i*squaresize,j*squaresize, squaresize, squaresize);
  457. X  }
  458. X
  459. X  if (!enable_hex && enable_grid[windowcolor])
  460. X  {
  461. X     XDrawLine(xwindow->display,xwindow->window,xwindow->hue[dark],
  462. X           ipos, jpos, ipos+squaresize, jpos);
  463. X     XDrawLine(xwindow->display,xwindow->window,xwindow->hue[dark],
  464. X           ipos, jpos, ipos, jpos+squaresize);
  465. X  }
  466. X
  467. X  
  468. X  /**** singularly occupied square ****/
  469. X  if (square->color != none && square->color != FIGHT)
  470. X  {
  471. X
  472. X    /**** draw center marker ****/
  473. X    if (enable_hex)
  474. X    {
  475. X      XFillArc (xwindow->display,xwindow->window, onhue,
  476. X                          ipos-hafpsize, jpos-hafpsize, psize, psize, 0, 23040);
  477. X 
  478. X      if (xwindow->drawletter[square->color])
  479. X        XDrawString(xwindow->display,xwindow->window, xwindow->flip,
  480. X                     ipos-xwindow->charwidth/2, jpos+xwindow->charheight/2,
  481. X                     xwindow->letter[square->color], 1);
  482. X    }
  483. X    else
  484. X    {
  485. X      if (!xwindow->drawletter[square->color] && !enable_grid[windowcolor])
  486. X          XDrawRectangle(xwindow->display,xwindow->window,xwindow->hue[dark],
  487. X           ipos+hafsquare-CSIZE, jpos+hafsquare-CSIZE, 2*CSIZE, 2*CSIZE);
  488. X
  489. X      XFillRectangle(xwindow->display,xwindow->window,onhue,
  490. X           ipos+hafsquare-hafpsize, jpos+hafsquare-hafpsize, psize, psize);
  491. X
  492. X      if (xwindow->drawletter[square->color])
  493. X        XDrawString(xwindow->display,xwindow->window, xwindow->flip,
  494. X                   ipos+squaresize/2-xwindow->charwidth/2, jpos+squaresize/2+xwindow->charheight/2,
  495. X                   xwindow->letter[square->color], 1);
  496. X    }
  497. X
  498. X    /**** draw arrows ****/
  499. X    if (enable_hidden[windowcolor])
  500. X    {
  501. X      if (square->color == windowcolor)
  502. X      {
  503. X#if SHOWFLOW
  504. X        if (value == 0)
  505. X          drawarrows(xwindow,square,onhue,offhue,i,j,hafpsize,squaresize,TRUE);
  506. X        else
  507. X          drawarrows(xwindow,square,onhue,offhue,i,j,hafpsize,squaresize,FALSE);
  508. X#else
  509. X        drawarrows(xwindow,square,onhue,offhue,i,j,hafpsize,squaresize,FALSE);
  510. X#endif
  511. X      }
  512. X    }
  513. X    else
  514. X    {
  515. X#if SHOWFLOW
  516. X      if (value == 0)
  517. X        drawarrows(xwindow,square,onhue,offhue,i,j,hafpsize,squaresize,TRUE);
  518. X      else
  519. X        drawarrows(xwindow,square,onhue,offhue,i,j,hafpsize,squaresize,FALSE);
  520. X#else
  521. X      drawarrows(xwindow,square,onhue,offhue,i,j,hafpsize,squaresize,FALSE);
  522. X#endif
  523. X    }
  524. X  }
  525. X  else if(square->color == FIGHT)       /**** draw fight square ****/
  526. X  {
  527. X    /**** find two largest components of square ****/
  528. X    max = -1;
  529. X    smax = -1; 
  530. X    max_pos = 0;
  531. X    for (k=0;k<nsides;k++)
  532. X    {
  533. X      if (square->value[k] > max)
  534. X      {
  535. X        smax = max; 
  536. X        smax_pos = max_pos;
  537. X        max = square->value[k];
  538. X        max_pos = k;
  539. X      }
  540. X      else if (square->value[k] > smax)
  541. X      {
  542. X        smax = square->value[k];
  543. X        smax_pos = k;
  544. X      }
  545. X    }
  546. X    onhue = xwindow->hue[max_pos];
  547. X    offhue = xwindow->hue[smax_pos];
  548. X    psize = (int)(bsize * areavalue[square->value[max_pos]]);
  549. X    hafpsize = psize/2;
  550. X    psize1 = (int)(bsize * areavalue[square->value[smax_pos]]);
  551. X    hafpsize1 = psize1/2;
  552. X
  553. X    if (enable_hex)
  554. X    {
  555. X      XFillArc (xwindow->display,xwindow->window, onhue,
  556. X           ipos-hafpsize, jpos-hafpsize, psize, psize, 0, 23040);
  557. X      XFillArc (xwindow->display,xwindow->window, offhue,
  558. X           ipos-hafpsize1, jpos-hafpsize1, psize1, psize1, 0, 23040);
  559. X
  560. X      XDrawLine(xwindow->display, xwindow->window, onhue, ipos - hex_halfside, jpos - hex_halfvert,
  561. X                  ipos + hex_halfside, jpos + hex_halfvert);
  562. X      XDrawLine(xwindow->display, xwindow->window, onhue, ipos - hex_halfside, jpos + hex_halfvert,
  563. X                  ipos + hex_halfside, jpos - hex_halfvert);
  564. X    }
  565. X    else
  566. X    {
  567. X      XFillRectangle(xwindow->display,xwindow->window,onhue,
  568. X             ipos+hafsquare-hafpsize, jpos+hafsquare-hafpsize, psize, psize);
  569. X      XFillRectangle(xwindow->display,xwindow->window,offhue,
  570. X             ipos+hafsquare-hafpsize1, jpos+hafsquare-hafpsize1, psize1, psize1);
  571. X
  572. X      /**** draw battle cross ****/
  573. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  574. X                  ipos+2,jpos+2, ipos+squaresize-2,jpos+squaresize-2);
  575. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  576. X                  ipos+squaresize-2,jpos+2, ipos+2,jpos+squaresize-2);
  577. X    }
  578. X  }
  579. X
  580. X  /**** draw circle for town or base ****/
  581. X  if(square->angle > 0)
  582. X  {
  583. X
  584. X    if (enable_hex)
  585. X    {
  586. X      if (square->angle < 23040)
  587. X        csize = ((square->oldgrowth - 52)*7*hex_vert)/200;
  588. X      else
  589. X        csize = ((square->growth - 52)*7*hex_vert)/200;
  590. X
  591. X      hafc = csize/2;
  592. X
  593. X      XDrawArc(xwindow->display,xwindow->window,offhue,
  594. X           ipos-hafc, jpos-hafc, csize, csize, 0, square->angle);
  595. X
  596. X      XDrawArc(xwindow->display,xwindow->window,offhue,
  597. X           ipos-hafc + 1, jpos-hafc + 1, csize - 2, csize - 2, 0, square->angle);
  598. X    }
  599. X    else
  600. X    {
  601. X      if (square->angle < 23040)
  602. X        csize = ((square->oldgrowth - 52)*squaresize)/50;
  603. X      else
  604. X        csize = ((square->growth - 52)*squaresize)/50;
  605. X
  606. X      hafc = (squaresize - csize)/2;
  607. X
  608. X      XDrawArc(xwindow->display,xwindow->window,offhue,
  609. X               ipos+hafc, jpos+hafc, csize, csize, 0, square->angle);
  610. X
  611. X      XDrawArc(xwindow->display,xwindow->window,offhue,
  612. X               ipos+hafc + 1, jpos+hafc + 1, csize - 2, csize - 2, 0, square->angle);
  613. X    }
  614. X  }
  615. X}
  616. X
  617. X
  618. X/*************************************************************************/
  619. X/**    double_copy                              **/
  620. X/** do flickerless pixmap copy for hexagonal board            **/ 
  621. X/**    Greg Lesher (lesher@cns.bu.edu)                    **/
  622. X/*************************************************************************/
  623. Xdouble_copy (xwindow, square, windowcolor, squaresize, terrain_type, offset)
  624. X  xwindow_type *xwindow;
  625. X  square_type *square;
  626. X  int windowcolor,
  627. X      squaresize,
  628. X      terrain_type,
  629. X      offset;
  630. X{
  631. X  if (terrain_type < 0)
  632. X  {
  633. X    if (enable_hills || enable_forest)
  634. X    {
  635. X      double_copy (xwindow, square, windowcolor, squaresize, 1, 0);
  636. X      if (enable_grid[windowcolor])
  637. X        blanksquare(xwindow, square, windowcolor, squaresize, FALSE);
  638. X    }
  639. X    else
  640. X      blanksquare(xwindow, square, windowcolor, squaresize, TRUE);
  641. X    return;
  642. X  }
  643. X
  644. X  XCopyArea (xwindow->display, xwindow->window, xwindow->terrain[terrain_type], xwindow->hue[light],
  645. X                     square->xpos - hex_side, square->ypos - hex_vert, 2*hex_side, 2*hex_vert,
  646. X                     0, 4*hex_vert);
  647. X
  648. X  XCopyArea (xwindow->display, xwindow->terrain[terrain_type], xwindow->terrain[terrain_type],
  649. X                     xwindow->gc_clear, offset*hex_side, 2*hex_vert, 2*hex_side, 2*hex_vert,
  650. X                     0, 4*hex_vert);
  651. X
  652. X  XCopyArea (xwindow->display, xwindow->terrain[terrain_type], xwindow->terrain[terrain_type],
  653. X                     xwindow->gc_or, offset*hex_side, 0, 2*hex_side, 2*hex_vert,
  654. X                     0, 4*hex_vert);
  655. X
  656. X  XCopyArea (xwindow->display, xwindow->terrain[terrain_type], xwindow->window, xwindow->hue[light],
  657. X                     0, 4*hex_vert, 2*hex_side, 2*hex_vert, square->xpos - hex_side,
  658. X                     square->ypos - hex_vert);
  659. X
  660. X  if (enable_grid[windowcolor])
  661. X    blanksquare(xwindow, square, windowcolor, squaresize, FALSE);
  662. X}
  663. X
  664. X
  665. X/*************************************************************************/
  666. X/**     drawarrows                                                      **/
  667. X/**  Draws appropriate movement arrows                    **/
  668. X/**     Greg Lesher (lesher@park.bu.edu)                                **/
  669. X/*************************************************************************/
  670. Xdrawarrows(xwindow,square,onhue,offhue,i,j,hafpsize, squaresize, halfsize)
  671. X  xwindow_type *xwindow;
  672. X  square_type *square;
  673. X  GC onhue, offhue;
  674. X  int i, j,
  675. X      hafpsize,
  676. X      squaresize,
  677. X      halfsize;
  678. X{
  679. X  int ipos, jpos,
  680. X      vert, horiz, halfvert,
  681. X      hafsquare;
  682. X
  683. X  if (enable_hex)
  684. X  {
  685. X    ipos = square->xpos;
  686. X    jpos = square->ypos;
  687. X
  688. X    vert = hex_vert;
  689. X    halfvert = hex_halfvert;
  690. X    horiz = hex_3quarterside;
  691. X
  692. X    if (halfsize)
  693. X    {
  694. X      vert = vert/2;
  695. X      halfvert = halfvert/2;
  696. X      horiz = horiz/2;
  697. X    }
  698. X
  699. X    /**** draw direction arrows ****/
  700. X    if(square->dir[HEX_UP])
  701. X    {
  702. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos, ipos, jpos - vert + 2); 
  703. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos+1, jpos, ipos+1, jpos - vert + 2); 
  704. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos-1, jpos, ipos-1, jpos - vert + 2); 
  705. X    }
  706. X    if(square->dir[HEX_DOWN])
  707. X    {
  708. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos, ipos, jpos + vert - 2); 
  709. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos+1, jpos, ipos+1, jpos + vert - 2); 
  710. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos-1, jpos, ipos-1, jpos + vert - 2); 
  711. X    }
  712. X    if(square->dir[HEX_RIGHT_UP])
  713. X    {
  714. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos, ipos + horiz - 1,
  715. X                                                jpos - halfvert + 1); 
  716. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos+1, jpos, ipos+1 + horiz - 1,
  717. X                                                jpos - halfvert + 1); 
  718. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos-1, ipos+1 + horiz - 1,
  719. X                                                jpos-1 - halfvert + 1); 
  720. X    }
  721. X    if(square->dir[HEX_RIGHT_DOWN])
  722. X    {
  723. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos, ipos + horiz - 1,
  724. X                                                jpos + halfvert - 1); 
  725. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos+1, jpos, ipos+1 + horiz - 1,
  726. X                                                jpos + halfvert - 1); 
  727. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos+1, ipos + horiz - 1,
  728. X                                                jpos+1 + halfvert - 1); 
  729. X    }    
  730. X    if(square->dir[HEX_LEFT_UP])
  731. X    {
  732. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos, ipos - horiz + 1,
  733. X                                                jpos - halfvert + 1); 
  734. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos-1, jpos, ipos-1 - horiz + 1,
  735. X                                                jpos - halfvert + 1); 
  736. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos-1, ipos - horiz + 1,
  737. X                                                jpos-1 - halfvert + 1); 
  738. X    }
  739. X    if(square->dir[HEX_LEFT_DOWN])
  740. X    {
  741. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos, ipos - horiz + 1,
  742. X                                                jpos + halfvert - 1); 
  743. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos-1, jpos, ipos-1 - horiz + 1,
  744. X                                                jpos + halfvert - 1); 
  745. X      XDrawLine(xwindow->display,xwindow->window,onhue, ipos, jpos+1, ipos - horiz + 1,
  746. X                                                jpos+1 + halfvert - 1); 
  747. X    }    
  748. X  }
  749. X  else
  750. X  {
  751. X    hafsquare=squaresize/2;
  752. X
  753. X    ipos = i*squaresize+hafsquare;
  754. X    jpos = j*squaresize+hafsquare;
  755. X
  756. X    if (halfsize)
  757. X      hafsquare /= 2;
  758. X
  759. X    /**** draw direction arrows ****/
  760. X    if(square->dir[UP])
  761. X    {
  762. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  763. X                  ipos-1, jpos, ipos-1, jpos-hafsquare);
  764. X#if INVERT
  765. X      XDrawLine(xwindow->display,xwindow->window,offhue,
  766. X                  ipos, jpos, ipos, jpos-hafpsize);
  767. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  768. X                  ipos, jpos-hafpsize, ipos, jpos-hafsquare);
  769. X#else
  770. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  771. X                  ipos, jpos, ipos, jpos-hafsquare);
  772. X#endif
  773. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  774. X                  ipos+1, jpos, ipos+1, jpos-hafsquare);
  775. X    }
  776. X    if(square->dir[DOWN])
  777. X    {
  778. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  779. X                  ipos-1, jpos, ipos-1, jpos+hafsquare-1);
  780. X#if INVERT
  781. X      XDrawLine(xwindow->display,xwindow->window,offhue,
  782. X                  ipos, jpos, ipos, jpos+hafpsize);
  783. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  784. X                  ipos, jpos+hafpsize, ipos, jpos+hafsquare-1);
  785. X#else
  786. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  787. X                  ipos, jpos, ipos, jpos+hafsquare-1);
  788. X#endif
  789. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  790. X                  ipos+1, jpos, ipos+1, jpos+hafsquare-1);
  791. X    }
  792. X    if(square->dir[RIGHT])
  793. X    {
  794. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  795. X                  ipos, jpos-1, ipos+hafsquare-1, jpos-1);
  796. X#if INVERT
  797. X      XDrawLine(xwindow->display,xwindow->window,offhue,
  798. X                  ipos, jpos, ipos+hafpsize, jpos);
  799. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  800. X                  ipos+hafpsize, jpos, ipos+hafsquare-1, jpos);
  801. X#else
  802. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  803. X                  ipos, jpos, ipos+hafsquare-1, jpos);
  804. X#endif
  805. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  806. X                  ipos, jpos+1, ipos+hafsquare-1, jpos+1);
  807. X    }
  808. X    if(square->dir[LEFT])
  809. X    {
  810. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  811. X                  ipos, jpos-1, ipos-hafsquare, jpos-1);
  812. X#if INVERT
  813. X      XDrawLine(xwindow->display,xwindow->window,offhue,
  814. X                  ipos, jpos, ipos-hafpsize, jpos);
  815. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  816. X                  ipos-hafpsize, jpos, ipos-hafsquare, jpos);
  817. X#else
  818. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  819. X                  ipos, jpos, ipos-hafsquare, jpos);
  820. X#endif
  821. X      XDrawLine(xwindow->display,xwindow->window,onhue,
  822. X                  ipos, jpos+1, ipos-hafsquare, jpos+1);
  823. X    }
  824. X  }
  825. X}
  826. X
  827. X
  828. X/*************************************************************************/
  829. X/**     drawblank                                                       **/
  830. X/**  Draws a blank square                                               **/
  831. X/**     Mark Lauer (elric@cs.su.oz.au)                                  **/
  832. X/**     Greg Lesher (lesher@park.bu.edu)                                **/
  833. X/*************************************************************************/
  834. Xdrawblank (xwindow, i, j, terrain_type, seen, growth, windowcolor, squaresize, square)
  835. X  xwindow_type *xwindow;
  836. X  int i, j,
  837. X      terrain_type,
  838. X      seen,
  839. X      growth,
  840. X      windowcolor,
  841. X      squaresize;
  842. X  square_type *square;
  843. X{
  844. X  int csize, hafc,
  845. X      ipos, jpos,
  846. X      offset;
  847. X
  848. X  if (enable_hex)
  849. X  {
  850. X    ipos = square->xpos;
  851. X    jpos = square->ypos;
  852. X  }
  853. X  else
  854. X  {
  855. X    ipos = i*squaresize;
  856. X    jpos = j*squaresize;
  857. X  }
  858. X
  859. X  /**** clear with appropriately colored square ****/
  860. X  if (enable_terrain)
  861. X  {
  862. X    if (seen && !enable_localmap[windowcolor])
  863. X    {
  864. X      if (enable_hex)
  865. X      {
  866. X        offset = -2 * square->value[none];
  867. X
  868. X        if (terrain_type < 0)
  869. X        {
  870. X          double_copy (xwindow, square, windowcolor, squaresize, terrain_type, 0);
  871. X          terrain_type = 0;
  872. X        }
  873. X        else
  874. X          offset = 0;
  875. X
  876. X        if (terrain_type == 1 && !enable_hills && !enable_forest)
  877. X          XFillArc (xwindow->display,xwindow->window, xwindow->hue[none],
  878. X             ipos-(hex_vert-1), jpos-(hex_vert-1), 2*(hex_vert-1), 2*(hex_vert-1), 0, 23040);
  879. X        else
  880. X          double_copy (xwindow, square, windowcolor, squaresize, terrain_type, offset);
  881. X      }
  882. X      else
  883. X      {
  884. X        offset = ((double)(-terrain_type) * squaresize)/(2*fillnumber);
  885. X
  886. X        if (terrain_type < 0)
  887. X          terrain_type = 0;
  888. X        else
  889. X          offset = 0;
  890. X
  891. X        if (offset != 0)
  892. X          XCopyArea (xwindow->display, xwindow->terrain[1], xwindow->window,
  893. X                      xwindow->hue[dark], 0, 0, squaresize, squaresize, ipos, jpos);
  894. X  
  895. X        XCopyArea (xwindow->display, xwindow->terrain[terrain_type], xwindow->window,
  896. X                          xwindow->hue[dark], 0, 0, squaresize-2*offset, squaresize-2*offset,
  897. X                          ipos+offset, jpos+offset);
  898. X      }
  899. X
  900. X      if (enable_basemap[windowcolor] && growth > 50)
  901. X      {
  902. X        if (enable_hex)
  903. X        {
  904. X          csize = ((growth - 52)*7*hex_vert)/200;
  905. X          hafc = csize/2;
  906. X
  907. X          XDrawArc(xwindow->display,xwindow->window,xwindow->hue[dark],
  908. X               ipos-hafc, jpos-hafc, csize, csize, 0, square->angle);
  909. X 
  910. X          XDrawArc(xwindow->display,xwindow->window,xwindow->hue[dark],
  911. X               ipos-hafc + 1, jpos-hafc + 1, csize - 2, csize - 2, 0, square->angle);
  912. X        }
  913. X        else
  914. X        {
  915. X          csize = ((growth - 52)*squaresize)/50;
  916. X          hafc = (squaresize - csize)/2;
  917. X          XDrawArc(xwindow->display,xwindow->window,xwindow->hue[dark],
  918. X               ipos+hafc, jpos+hafc, csize, csize, 0, 23040);
  919. X
  920. X          XDrawArc(xwindow->display,xwindow->window,xwindow->hue[dark],
  921. X                   ipos+hafc + 1, jpos+hafc + 1, csize - 2, csize - 2, 0, 23040);
  922. X        }
  923. X      }
  924. X    }
  925. X    else
  926. X    {
  927. X      if (enable_hex)
  928. X      {
  929. X        /** Using double copy results in some aliasing due to fact that hue[none] is **/
  930. X        /** usually drawn not copied and is a stipple.                     **/ 
  931. X/**
  932. X        double_copy (xwindow, square, windowcolor, squaresize, 1, 0);
  933. X**/
  934. X
  935. X        blanksquare(xwindow, square, windowcolor, squaresize, TRUE);
  936. X      }
  937. X      else
  938. X        XFillRectangle(xwindow->display,xwindow->window,
  939. X                       xwindow->hue[none], ipos,jpos, squaresize, squaresize);
  940. X    }
  941. X  }
  942. X  else
  943. X  {
  944. X     if (enable_hex) 
  945. X     {
  946. X        XFillArc (xwindow->display,xwindow->window, xwindow->hue[none],
  947. X           ipos-(hex_vert-1), jpos-(hex_vert-1), 2*(hex_vert-1), 2*(hex_vert-1), 0, 23040);
  948. X/**
  949. X        blanksquare(xwindow, square, windowcolor, squaresize, TRUE);
  950. X**/
  951. X     }
  952. X     else
  953. X       XFillRectangle(xwindow->display,xwindow->window,
  954. X                     xwindow->hue[none],
  955. X                     ipos,jpos, squaresize, squaresize);
  956. X
  957. X    if (enable_basemap[windowcolor])
  958. X    {
  959. X      if (growth > 50 && !enable_localmap[windowcolor] && seen)
  960. X      {
  961. X        if (enable_hex) 
  962. X        {
  963. X          csize = ((growth - 52)*7*hex_vert)/200;
  964. X          hafc = csize/2;
  965. X
  966. X          XDrawArc(xwindow->display,xwindow->window,xwindow->hue[dark],
  967. X               ipos-hafc, jpos-hafc, csize, csize, 0, square->angle);
  968. X 
  969. X          XDrawArc(xwindow->display,xwindow->window,xwindow->hue[dark],
  970. X               ipos-hafc + 1, jpos-hafc + 1, csize - 2, csize - 2, 0, square->angle);
  971. X        }
  972. X        else
  973. X        {
  974. X          csize = ((growth - 52)*squaresize)/50;
  975. X          hafc = (squaresize - csize)/2;
  976. X
  977. X          XDrawArc(xwindow->display,xwindow->window,xwindow->hue[dark],
  978. X             ipos+hafc, jpos+hafc, csize, csize, 0, 23040);
  979. X
  980. X          XDrawArc(xwindow->display,xwindow->window,xwindow->hue[dark],
  981. X               ipos+hafc + 1, jpos+hafc + 1, csize - 2, csize - 2, 0, 23040);
  982. X        }
  983. X      }
  984. X    }
  985. X  }
  986. X
  987. X  if (!enable_hex && enable_grid[windowcolor])
  988. X  {
  989. X     XDrawLine(xwindow->display,xwindow->window,xwindow->hue[dark],
  990. X           ipos,jpos,
  991. X           ipos+squaresize,jpos);
  992. X     XDrawLine(xwindow->display,xwindow->window,xwindow->hue[dark],
  993. X           ipos,jpos,
  994. X           ipos,jpos+squaresize);
  995. X  }
  996. X}
  997. X
  998. X
  999. X/*************************************************************************/
  1000. X/**    storedrawsquare                              **/
  1001. X/** Draw one square of the game board to a file                **/
  1002. X/**    Greg Lesher (lesher@park.bu.edu)                **/
  1003. X/*************************************************************************/
  1004. Xstoredrawsquare(square, squaresize, special_flag)
  1005. X  square_type *square;
  1006. X  int squaresize,
  1007. X      special_flag;
  1008. X{
  1009. X  int i, j, k,
  1010. X      bsize, csize, psize, psize1,
  1011. X      value,
  1012. X      max, smax, max_pos, smax_pos;
  1013. X
  1014. X  i = square->x;
  1015. X  j = square->y;
  1016. X
  1017. X  if (enable_hex)
  1018. X    bsize = 9*hex_vert/5;
  1019. X  else
  1020. X    bsize = squaresize;
  1021. X
  1022. X  if (enable_terrain)
  1023. X  {
  1024. X    if (enable_hex && special_flag)
  1025. X    {
  1026. X      if (!enable_hills && !enable_forest && square->value[none] == 1)
  1027. X        fprintf (fpout,"b%c%c",i,j);
  1028. X      else
  1029. X        fprintf (fpout,"A%c%c%c",i,j,square->value[none]);
  1030. X    }
  1031. X    else
  1032. X      fprintf (fpout,"A%c%c%c",i,j,square->value[none]);
  1033. X  }
  1034. X  else
  1035. X  {
  1036. X    if (enable_hex && special_flag)
  1037. X      fprintf (fpout,"b%c%c",i,j);
  1038. X    else
  1039. X      fprintf (fpout,"B%c%c",i,j);
  1040. X  }
  1041. X  
  1042. X  /**** singularly occupied square ****/
  1043. X  if (square->color != none && square->color != FIGHT)
  1044. X  {
  1045. X    storedrawarrows(square,i,j,square->color);
  1046. X
  1047. X    value = square->value[square->color];
  1048. X    if (value < 0)
  1049. X      value = 0;
  1050. X    psize = (int)(bsize * areavalue[value]);
  1051. X    
  1052. X    fprintf (fpout,"D%c%c%c%c",i,j,psize,square->color);
  1053. X  }
  1054. X  else if(square->color == FIGHT)
  1055. X  {
  1056. X    /**** find two largest components of square ****/
  1057. X    max = -1;
  1058. X    smax = -1; 
  1059. X    for (k=0;k<nsides;k++)
  1060. X    {
  1061. X      if (square->value[k] > max)
  1062. X      {
  1063. X        smax = max; 
  1064. X        smax_pos = max_pos;
  1065. X        max = square->value[k];
  1066. X        max_pos = k;
  1067. X      }
  1068. X      else if (square->value[k] > smax)
  1069. X      {
  1070. X        smax = square->value[k];
  1071. X        smax_pos = k;
  1072. X      }
  1073. X    }
  1074. X    psize = (int)(bsize * areavalue[square->value[max_pos]]);
  1075. X    psize1 = (int)(bsize * areavalue[square->value[smax_pos]]);
  1076. X
  1077. X    fprintf (fpout,"E%c%c%c%c%c%c",i,j,psize,max_pos,psize1,smax_pos);
  1078. X  }
  1079. X
  1080. X  /**** draw circle for town or base ****/
  1081. X  if(square->angle > 0)
  1082. X  {
  1083. X    if (enable_hex)
  1084. X    {
  1085. X      if (square->angle < 23040)
  1086. X        csize = ((square->oldgrowth - 52)*7*hex_vert)/200;
  1087. X      else
  1088. X        csize = ((square->growth - 52)*7*hex_vert)/200;
  1089. X    }
  1090. X    else
  1091. X    {
  1092. X      if (square->angle < 23040)
  1093. X        csize = ((square->oldgrowth - 52)*squaresize)/50;
  1094. X      else
  1095. X        csize = ((square->growth - 52)*squaresize)/50;
  1096. X    }
  1097. X
  1098. X    fprintf (fpout,"F%c%c%c%c",i,j,csize,(square->angle*255)/23040);
  1099. X  }
  1100. X}
  1101. X
  1102. X
  1103. X/*************************************************************************/
  1104. X/**     storedrawarrows                                                 **/
  1105. X/**  Draws appropriate movement arrows to file                **/
  1106. X/**     Greg Lesher (lesher@park.bu.edu)                                **/
  1107. X/*************************************************************************/
  1108. Xstoredrawarrows(square,i,j,colornumber)
  1109. X  square_type *square;
  1110. X  int i, j,
  1111. X      colornumber;
  1112. X{
  1113. X  if (enable_hex)
  1114. X  {
  1115. X    if(square->dir[HEX_UP])
  1116. X      fprintf (fpout,"G%c%c%cu",i,j,colornumber);
  1117. X
  1118. X    if(square->dir[HEX_DOWN])
  1119. X      fprintf (fpout,"G%c%c%cd",i,j,colornumber);
  1120. X
  1121. X    if(square->dir[HEX_RIGHT_UP])
  1122. X      fprintf (fpout,"G%c%c%cR",i,j,colornumber);
  1123. X
  1124. X    if(square->dir[HEX_RIGHT_DOWN])
  1125. X      fprintf (fpout,"G%c%c%cr",i,j,colornumber);
  1126. X
  1127. X    if(square->dir[HEX_LEFT_UP])
  1128. X      fprintf (fpout,"G%c%c%cL",i,j,colornumber);
  1129. X
  1130. X    if(square->dir[HEX_LEFT_DOWN])
  1131. X      fprintf (fpout,"G%c%c%cl",i,j,colornumber);
  1132. X  }
  1133. X  else
  1134. X  {
  1135. X    if(square->dir[UP])
  1136. X      fprintf (fpout,"G%c%c%cu",i,j,colornumber);
  1137. X
  1138. X    if(square->dir[DOWN])
  1139. X      fprintf (fpout,"G%c%c%cd",i,j,colornumber);
  1140. X
  1141. X    if(square->dir[RIGHT])
  1142. X      fprintf (fpout,"G%c%c%cr",i,j,colornumber);
  1143. X
  1144. X    if(square->dir[LEFT])
  1145. X      fprintf (fpout,"G%c%c%cl",i,j,colornumber);
  1146. X  }
  1147. X}
  1148. X
  1149. X
  1150. X/*************************************************************************/
  1151. X/**    print_message                            **/
  1152. X/** Print the latest message to the screen.  The message is purposely    **/
  1153. X/** allowed to flash in order to attract attention.  Further attention    **/
  1154. X/** can be called by use of ^g to ring the bell.            **/
  1155. X/**    Steve Lehar (slehar@park.bu.edu)                **/
  1156. X/**    Greg Lesher (lesher@park.bu.edu)                **/
  1157. X/*************************************************************************/
  1158. Xprint_message(text,textcount,newcolor,player,board)
  1159. X  char text[];
  1160. X  int textcount,
  1161. X      newcolor,
  1162. X      player;
  1163. X  square_type *board;
  1164. X{
  1165. X  int i,
  1166. X      scroll, scrollandprint;
  1167. X
  1168. X  static oldcolor=0,
  1169. X         veryfirst=TRUE,
  1170. X         firsttime[MAXSIDES];
  1171. X
  1172. X  char oldmessage[512],
  1173. X       line[100];
  1174. X
  1175. X  if (veryfirst)
  1176. X  {
  1177. X    for (i=0; i<MAXSIDES; i++)
  1178. X      firsttime[i] = TRUE;
  1179. X    veryfirst = FALSE;
  1180. X  }
  1181. X
  1182. X  scroll = FALSE;
  1183. X  scrollandprint = FALSE;
  1184. X
  1185. X#if !MULTITEXT
  1186. X  /**** copy old message ****/
  1187. X  strcpy (oldmessage,messagestr);
  1188. X  if (newcolor != oldcolor)
  1189. X    strcpy(messagestr,"");
  1190. X#endif
  1191. X
  1192. X  /**** remove control, shift & meta ****/
  1193. X  if (textcount==0)
  1194. X    return;
  1195. X
  1196. X  text[textcount] = 0;
  1197. X
  1198. X  if (firsttime[newcolor])
  1199. X  {
  1200. X    strcpy(personal_messagestr[newcolor], "");
  1201. X    firsttime[newcolor] = FALSE;
  1202. X  }
  1203. X  
  1204. X  switch (text[0])
  1205. X  {
  1206. X    /**** backspace ****/
  1207. X    case BACKSPACE:
  1208. X    case DELETE:
  1209. X#if MULTITEXT
  1210. X      if (strlen(personal_messagestr[newcolor]) > 0)
  1211. X        personal_messagestr[newcolor][(strlen(personal_messagestr[newcolor]))-1] =
  1212. X                                                  messagestr[(strlen(personal_messagestr[newcolor]))];
  1213. X#else
  1214. X      if (strlen(messagestr) > 0)
  1215. X        messagestr[(strlen(messagestr))-1] = messagestr[(strlen(messagestr))];
  1216. X#endif
  1217. X      break;
  1218. X
  1219. X    /**** newline ****/
  1220. X    case RETURN:
  1221. X#if MULTITEXT
  1222. X      strcpy(personal_messagestr[newcolor],"");
  1223. X#else
  1224. X      scroll = TRUE;
  1225. X#endif
  1226. X      break;
  1227. X    
  1228. X    case CTRLC:
  1229. X    case CTRLQ:
  1230. X      firsttime[newcolor] = TRUE;
  1231. X      removeplayer (player, board);
  1232. X      break;
  1233. X
  1234. X    case CTRLP:
  1235. X      gamestats (board);
  1236. X      dump_board (board, "xbattle.xbt");
  1237. X      break;
  1238. X
  1239. X    case CTRLW:
  1240. X      winwatch[player] = TRUE;
  1241. X      enable_personalhorizon[colorarray[player]] = FALSE;
  1242. X      drawboard (board, player, TRUE);
  1243. X      firsttime[newcolor] = TRUE;
  1244. X      sprintf (line, "%s has quit the game", huename[sidemap[colorarray[player]]]);
  1245. X      print_message(line,strlen(line),colorarray[player],player,board);
  1246. X      for (i=0; i<nplayers; i++)
  1247. X        if (winopen[i]) XBell(xwindow[i]->display,100);
  1248. X      break;
  1249. X
  1250. X    case CTRLG:
  1251. X      for (i=0; i<nplayers; i++)
  1252. X        if (winopen[i])
  1253. X          XBell(xwindow[i]->display,100);
  1254. X      break;
  1255. X
  1256. X    case SPACE:
  1257. X#if MULTITEXT
  1258. X      if ((strlen(personal_messagestr[newcolor]) + 1) > 511)
  1259. X      {
  1260. X        scroll = TRUE;
  1261. X      }
  1262. X      else
  1263. X        strcat(personal_messagestr[newcolor]," ");
  1264. X#else
  1265. X      if ((strlen(messagestr) + 1) > 511)
  1266. X      {
  1267. X        scroll = TRUE;
  1268. X      }
  1269. X      else
  1270. X        strcat(messagestr," ");
  1271. X#endif
  1272. X
  1273. X      break;
  1274. X
  1275. X    default:
  1276. X#if MULTITEXT
  1277. X      if ((strlen(personal_messagestr[newcolor]) + strlen(text)) > 511)
  1278. X      {
  1279. X        scroll = TRUE;
  1280. X      }
  1281. X      else
  1282. X        strcat(personal_messagestr[newcolor],text);
  1283. X#else
  1284. X      if ((strlen(messagestr) + strlen(text)) > 511)
  1285. X      {
  1286. X        scroll = TRUE;
  1287. X      }
  1288. X      else
  1289. X        strcat(messagestr,text);
  1290. X#endif
  1291. X
  1292. X      break;
  1293. X  }
  1294. X
  1295. X#if !MULTITEXT
  1296. X  if (newcolor != oldcolor)
  1297. X    scrollandprint = TRUE;
  1298. X#endif
  1299. X
  1300. X  /**** print the string on all xwindows ****/
  1301. X  for (i=0; i<nplayers; i++)
  1302. X  {
  1303. X    if (!winopen[i])
  1304. X      continue;
  1305. X#if !MULTITEXT
  1306. X    /**** scroll bottom text line up ****/
  1307. X    if (scroll || scrollandprint)
  1308. X    {
  1309. X      XDrawImageString(xwindow[i]->display,xwindow[i]->window,
  1310. X               xwindow[i]->hue[oldcolor],
  1311. X               TEXTX,textyh[colorarray[i]][newcolor],
  1312. X               blankline,strlen(blankline));
  1313. X      XDrawImageString(xwindow[i]->display,xwindow[i]->window,
  1314. X               xwindow[i]->hue[oldcolor],
  1315. X               TEXTX,textyh[colorarray[i]][newcolor],
  1316. X               oldmessage,strlen(oldmessage));
  1317. X      XDrawImageString(xwindow[i]->display,xwindow[i]->window,
  1318. X               xwindow[i]->hue[newcolor],
  1319. X               TEXTX,textyl[colorarray[i]][newcolor],
  1320. X               blankline,strlen(blankline));
  1321. X    }
  1322. X
  1323. X    /**** print new text line ****/
  1324. X    if (scrollandprint || !scroll)
  1325. X    {
  1326. X      XDrawImageString(xwindow[i]->display,xwindow[i]->window,
  1327. X               xwindow[i]->hue[newcolor],
  1328. X               TEXTX,textyl[colorarray[i]][newcolor],
  1329. X               blankline,strlen(blankline));
  1330. X      XDrawImageString(xwindow[i]->display,xwindow[i]->window,
  1331. X               xwindow[i]->hue[newcolor],
  1332. X               TEXTX,textyl[colorarray[i]][newcolor],
  1333. X               messagestr,strlen(messagestr));
  1334. X    }
  1335. X#else
  1336. X    /**** print new text line ****/
  1337. X    if (scrollandprint || !scroll)
  1338. X    {
  1339. X      XDrawImageString(xwindow[i]->display,xwindow[i]->window,
  1340. X               xwindow[i]->hue[newcolor],
  1341. X               TEXTX,textyh[colorarray[i]][newcolor],
  1342. X               blankline,strlen(blankline));
  1343. X      XDrawImageString(xwindow[i]->display,xwindow[i]->window,
  1344. X               xwindow[i]->hue[newcolor],
  1345. X               TEXTX,textyh[colorarray[i]][newcolor],
  1346. X               personal_messagestr[newcolor],strlen(personal_messagestr[newcolor]));
  1347. X    }
  1348. X#endif
  1349. X  }
  1350. X
  1351. X#if !MULTITEXT
  1352. X  if (scrollandprint || !scroll)
  1353. X    oldcolor=newcolor;
  1354. X#endif
  1355. X
  1356. X  if (scroll)
  1357. X    strcpy(messagestr,"");
  1358. X}
  1359. END_OF_FILE
  1360. if test 43247 -ne `wc -c <'draw.c'`; then
  1361.     echo shar: \"'draw.c'\" unpacked with wrong size!
  1362. fi
  1363. # end of 'draw.c'
  1364. fi
  1365. if test -f 'extern.h' -a "${1}" != "-c" ; then 
  1366.   echo shar: Will not clobber existing file \"'extern.h'\"
  1367. else
  1368. echo shar: Extracting \"'extern.h'\" \(7347 characters\)
  1369. sed "s/^X//" >'extern.h' <<'END_OF_FILE'
  1370. X/**** game static parameters ****/
  1371. X
  1372. X#define BOARDSIZE     15
  1373. X#define SQUARESIZE     45
  1374. X#define MAXBOARDSIZE     50
  1375. X#define MAXSQUARESIZE     75
  1376. X#define TEXTSIZE     16
  1377. X#define CSIZE         5
  1378. X#define DSIZE         7
  1379. X#define TEXTX         0
  1380. X#define NGREYTONES     3
  1381. X#define NHILLTONES     5
  1382. X#define NFORESTTONES     5
  1383. X#define NSEATONES     2
  1384. X#define SEAVALUE    0.87840
  1385. X#define MAXPLAYERS     11
  1386. X#define MAXSIDES       11
  1387. X#define MAXHUES       11
  1388. X
  1389. X#define NOPTS        49
  1390. X#define POPTS        26
  1391. X#define PVOPTS        6
  1392. X
  1393. X#define SET        0
  1394. X#define FORCE        1
  1395. X
  1396. X#define ACTIVE        1
  1397. X#define PASSIVE        2
  1398. X#define TEMP        3
  1399. X
  1400. X/**** game dynamic parameters ****/
  1401. X#define MAXVAL         20
  1402. X#define FIREPOWER    5.0
  1403. X#define SLOWFACTOR      3.0
  1404. X#define SHELL        1
  1405. X#define SHELL_COST    1
  1406. X#define PARA        1
  1407. X#define PARA_COST    3
  1408. X#define VIEWRANGE      2
  1409. X#define BASERANGE    2
  1410. X#define MARCH        3
  1411. X#define ERODETHRESH    0.04
  1412. X
  1413. X#define SQ3D2        0.8660254
  1414. X
  1415. X/**** x window default parameters ****/
  1416. X#define FONT          "-adobe-courier-bold-r-normal--*-100-*-*-*-*-iso8859-1"
  1417. X#define BORDER         1
  1418. X#define XPOS        0
  1419. X#define YPOS        0
  1420. X
  1421. X/**** necessary constants ****/
  1422. X#define MAXCOLORS      MAXSIDES+NHILLTONES+3
  1423. X#define ALL        MAXHUES+2
  1424. X#define TRUE           1
  1425. X#define FALSE           0
  1426. X#define OK        -1
  1427. X#define GLOBAL        MAXSIDES+2
  1428. X#define NOT_TAKEN    -1
  1429. X
  1430. X/**** COMPILE TIME OPTIONS ****/
  1431. X
  1432. X#define UNIX        TRUE
  1433. X#define INVERT        TRUE
  1434. X#define PAUSE        TRUE
  1435. X#define VARMOUSE    FALSE
  1436. X#define NODRAND48    FALSE
  1437. X#define SHOWFLOW    TRUE
  1438. X#define MULTITEXT    TRUE
  1439. X#define NEWCOLORMAP    FALSE
  1440. X#define MULTIFLUSH    FALSE
  1441. X
  1442. X/**** special flags ****/
  1443. X#define DIRS           6
  1444. X
  1445. X#define HEX_UP      0
  1446. X#define HEX_RIGHT_UP     1
  1447. X#define HEX_RIGHT_DOWN     2
  1448. X#define HEX_DOWN    3
  1449. X#define HEX_LEFT_DOWN     4
  1450. X#define HEX_LEFT_UP     5
  1451. X
  1452. X#define UP          0
  1453. X#define DOWN          2
  1454. X#define RIGHT         1
  1455. X#define LEFT          3
  1456. X
  1457. X/**
  1458. X#define UP          0
  1459. X#define DOWN          2
  1460. X#define RIGHT         1
  1461. X#define LEFT          3
  1462. X**/
  1463. X
  1464. X/**** board square access routine ****/
  1465. X#define SQUARE(board,x,y) ((board)+(y)*boardsizex+(x))
  1466. X
  1467. X
  1468. X/**** window structure ****/
  1469. Xtypedef struct{
  1470. X    Display         *display;
  1471. X    Window         window;
  1472. X    int            xsize,ysize;
  1473. X    XSizeHints         hint;
  1474. X    XWMHints         xwmh;
  1475. X    int         depth,screen;
  1476. X    GC             hue[MAXSIDES+3], flip, gc_clear, gc_or;
  1477. X    Pixmap        terrain[NHILLTONES];
  1478. X    XFontStruct     *font_struct;
  1479. X    Colormap         cmap;
  1480. X    XColor         xcolor[MAXCOLORS];
  1481. X    char        drawletter[MAXSIDES+1];
  1482. X    char        letter[MAXSIDES+1][2];
  1483. X    unsigned long    charwidth, charheight;
  1484. X} xwindow_type;
  1485. X
  1486. X/**** game square structure ****/
  1487. Xtypedef struct SquareType {
  1488. X    char         color;
  1489. X    char         move,dir[DIRS];
  1490. X    char        anymarch, marchcolor, marchcount;
  1491. X    char        march[MAXSIDES],marchdir[MAXSIDES][DIRS],marchtype[MAXSIDES];
  1492. X    short         value[MAXHUES+3];
  1493. X    short        lowbound;
  1494. X    char         growth;
  1495. X    char         oldgrowth;
  1496. X    char         oldcolor;
  1497. X    char        age;
  1498. X    char         x, y;
  1499. X    int            xpos, ypos;
  1500. X    struct SquareType    *connect[DIRS];
  1501. X    char        seen[MAXSIDES];
  1502. X    int            angle;
  1503. X} square_type;
  1504. X
  1505. X/**** square colors ****/
  1506. X#define NONE          0
  1507. X#define BLACK         1
  1508. X#define GRAY3         2
  1509. X#define GRAY2         3
  1510. X#define GRAY1         4
  1511. X#define WHITE         5
  1512. X#define RED        6
  1513. X#define CYAN        7
  1514. X#define MAGENTA        8
  1515. X#define GREEN        9
  1516. X#define BLUE        10
  1517. X#define YELLOW        11
  1518. X#define FIGHT          MAXHUES+1
  1519. X
  1520. X/**** wraparound routine ****/
  1521. X#define MODX(x)  (x+boardsizex)%boardsizex
  1522. X#define MODY(y)  (y+boardsizey)%boardsizey
  1523. X
  1524. X/**** ascii codes ****/
  1525. X#define RETURN 13
  1526. X#define BACKSPACE 8
  1527. X#define DELETE 127
  1528. X#define CTRLC 03
  1529. X#define CTRLQ 17
  1530. X#define CTRLG 07
  1531. X#define CTRLW 23
  1532. X#define SPACE 32
  1533. X#define CTRLF 6
  1534. X#define CTRLD 4
  1535. X#define CTRLS 19
  1536. X#define CTRLB 2
  1537. X#define CTRLP 16
  1538. X
  1539. X/**** global variables ****/
  1540. Xextern xwindow_type *xwindow[MAXPLAYERS];
  1541. X
  1542. Xextern int colorarray[MAXPLAYERS],
  1543. X           rcolorarray[MAXHUES],
  1544. X           sidemap[MAXPLAYERS];
  1545. X 
  1546. Xextern char lettermap[MAXSIDES][2];
  1547. X
  1548. Xextern int winopen[MAXPLAYERS],
  1549. X           winwatch[MAXPLAYERS];
  1550. X
  1551. Xextern FILE *fpout, *fopen();
  1552. Xextern char filename[50];
  1553. X
  1554. X/**** default mappings from color to b/w ****/
  1555. Xextern int color2bw[MAXHUES+1];
  1556. X
  1557. Xextern double     towns,
  1558. X        sea,
  1559. X        gamespeed,
  1560. X         farms;
  1561. X
  1562. Xextern double    slowfactor[MAXSIDES],
  1563. X        artillery[MAXSIDES],
  1564. X        paratroops[MAXSIDES],
  1565. X        firepower[MAXSIDES],
  1566. X        militia[MAXSIDES],
  1567. X        hillfactor[MAXSIDES],
  1568. X        forest[MAXSIDES],
  1569. X        areavalue[MAXVAL+5],
  1570. X        decayrate[MAXSIDES],
  1571. X        eroderate[MAXSIDES],
  1572. X                shuntval[MAXSIDES];
  1573. X
  1574. Xextern int    delay,
  1575. X        boardsizex,
  1576. X        boardsizey,
  1577. X        paused,
  1578. X        seed;
  1579. X
  1580. Xextern int     nplayers,
  1581. X        nsides,    
  1582. X        none,
  1583. X        dark,
  1584. X        light,    
  1585. X        maxviewrange,
  1586. X        fillcost,
  1587. X        digcost,
  1588. X        fillnumber,
  1589. X        directions,
  1590. X                oldx[MAXPLAYERS],
  1591. X                oldy[MAXPLAYERS],
  1592. X                dir[MAXPLAYERS][DIRS],
  1593. X                dirtype[MAXPLAYERS];
  1594. X
  1595. Xextern int    armies[MAXSIDES],
  1596. X        bases[MAXSIDES],
  1597. X        rbases[MAXSIDES],
  1598. X        buildrate[MAXSIDES],
  1599. X        scuttlerate[MAXSIDES],
  1600. X        marchrate[MAXSIDES],
  1601. X        viewrange[MAXSIDES],
  1602. X        squaresize[MAXSIDES],
  1603. X               textyh[MAXSIDES][MAXSIDES],
  1604. X                textyl[MAXSIDES][MAXSIDES];
  1605. X
  1606. Xextern int     enable_anywrap,
  1607. X                enable_horizon,
  1608. X                enable_march,
  1609. X                enable_bound,
  1610. X            enable_hills,
  1611. X            enable_forest,
  1612. X            enable_sea,
  1613. X            enable_hex,
  1614. X            enable_border,
  1615. X            enable_terrain,
  1616. X        enable_decay,
  1617. X        enable_anylocalmap,
  1618. X                enable_storage,
  1619. X                enable_replay,
  1620. X                enable_area,
  1621. X                enable_edit,
  1622. X                enable_load,
  1623. X        enable_farms,
  1624. X        enable_towns,
  1625. X        enable_rbases,
  1626. X        enable_bases,
  1627. X        enable_militia,
  1628. X        enable_armies;
  1629. X
  1630. Xextern int     enable_fill[MAXSIDES],
  1631. X            enable_dig[MAXSIDES],
  1632. X            enable_scuttle[MAXSIDES],
  1633. X            enable_build[MAXSIDES],
  1634. X            enable_artillery[MAXSIDES],
  1635. X            enable_paratroops[MAXSIDES],
  1636. X                enable_personalmarch[MAXSIDES],
  1637. X                enable_grid[MAXSIDES],
  1638. X                enable_manpos[MAXSIDES],
  1639. X                enable_wrap[MAXSIDES],
  1640. X                enable_personalhorizon[MAXSIDES],
  1641. X                enable_personalbound[MAXSIDES],
  1642. X                enable_erode[MAXSIDES],
  1643. X                enable_repeat[MAXSIDES],
  1644. X                enable_map[MAXSIDES],
  1645. X                enable_basemap[MAXSIDES],
  1646. X                enable_localmap[MAXSIDES],
  1647. X            enable_hidden[MAXSIDES],
  1648. X            enable_attack[MAXSIDES],
  1649. X            enable_nospigot[MAXSIDES],
  1650. X                enable_disrupt[MAXSIDES],
  1651. X        enable_reserve[MAXSIDES],
  1652. X        enable_digin[MAXSIDES];
  1653. X        
  1654. Xextern char outdated[MAXBOARDSIZE][MAXBOARDSIZE],
  1655. X            oldvalue[MAXBOARDSIZE][MAXBOARDSIZE];
  1656. X
  1657. Xdouble drand48();
  1658. Xvoid srand48();
  1659. X
  1660. Xextern char graytitle[MAXSIDES+1][40];
  1661. Xextern char huetitle[MAXSIDES+1][40];
  1662. Xextern char grayname[MAXHUES+1][10];
  1663. Xextern char huename[MAXHUES+1][10];
  1664. Xextern char personal_messagestr[MAXSIDES][512],
  1665. X            messagestr[512],
  1666. X            storagename[100],
  1667. X            replayname[100],
  1668. X            mapname[100],
  1669. X            blankline[150];
  1670. X
  1671. Xextern int palette[MAXSIDES+1][3];
  1672. Xextern double hillslope[3];
  1673. Xextern double hillintersect[3];
  1674. X
  1675. Xextern int hillpalette[3],
  1676. X           forestpalette[3],
  1677. X           seapalette[3];
  1678. X/**
  1679. X           seapalette[3] =    {  0,   0, 150};
  1680. X**/
  1681. X
  1682. Xextern char *usage;
  1683. X
  1684. Xextern char options[NOPTS][10];
  1685. X
  1686. Xextern int hex_side,
  1687. X           hex_halfside,
  1688. X           hex_quarterside,
  1689. X           hex_3quarterside,
  1690. X           hex_vert,
  1691. X           hex_halfvert,
  1692. X           hex_chart[2*MAXSQUARESIZE][2*MAXSQUARESIZE][2],
  1693. X           hex_horizon_even[200][2], hex_horizon_odd[200][2],
  1694. X           hex_horizon_number;
  1695. Xextern double hex_slope;
  1696. Xextern XPoint hex_points[7]; 
  1697. END_OF_FILE
  1698. if test 7347 -ne `wc -c <'extern.h'`; then
  1699.     echo shar: \"'extern.h'\" unpacked with wrong size!
  1700. fi
  1701. # end of 'extern.h'
  1702. fi
  1703. echo shar: End of archive 4 \(of 7\).
  1704. cp /dev/null ark4isdone
  1705. MISSING=""
  1706. for I in 1 2 3 4 5 6 7 ; do
  1707.     if test ! -f ark${I}isdone ; then
  1708.     MISSING="${MISSING} ${I}"
  1709.     fi
  1710. done
  1711. if test "${MISSING}" = "" ; then
  1712.     echo You have unpacked all 7 archives.
  1713.     rm -f ark[1-9]isdone
  1714. else
  1715.     echo You still need to unpack the following archives:
  1716.     echo "        " ${MISSING}
  1717. fi
  1718. ##  End of shell archive.
  1719. exit 0
  1720.