home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / games / volume13 / x4war / part02 < prev    next >
Encoding:
Text File  |  1992-04-09  |  55.0 KB  |  1,835 lines
  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: v13i078:  x4war - An X11 version of Chinese four-state war game, Part02/03
  5. Message-ID: <2650@master.CNA.TEK.COM>
  6. Date: 23 Mar 92 22:50:25 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 1824
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: Xiaobing Chen <xiaobing@cs.sfu.ca>
  12. Posting-number: Volume 13, Issue 78
  13. Archive-name: x4war/Part02
  14. Environment: X11, Xlib, Xt
  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 2 (of 3)."
  25. # Contents:  Makefile.simple bgbitmap.c bitmaps/go.xbm bitmaps/stop.xbm
  26. #   war.c war.h x4war.man
  27. # Wrapped by billr@saab on Mon Mar 23 14:49:05 1992
  28. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  29. if test -f 'Makefile.simple' -a "${1}" != "-c" ; then 
  30.   echo shar: Will not clobber existing file \"'Makefile.simple'\"
  31. else
  32. echo shar: Extracting \"'Makefile.simple'\" \(345 characters\)
  33. sed "s/^X//" >'Makefile.simple' <<'END_OF_FILE'
  34. X#Makefile for x4war, under SunOS 4.1.1
  35. X#
  36. X# x4war
  37. X#
  38. X
  39. XLDLIBS= -lXt -lX11
  40. XCC= cc
  41. X
  42. X#CFLAGS= -g
  43. XCFLAGS= -O
  44. X
  45. XOBJS= x4war.o war.o
  46. X
  47. Xx4war: $(OBJS)
  48. X    $(CC) $(CFLAGS) -o $@ $(OBJS) $(LDLIBS)
  49. X
  50. Xx4war.o: x4war.c war.h
  51. X    $(CC) $(CFLAGS) -c x4war.c
  52. X
  53. Xwar.o: war.c war.h
  54. X    $(CC) $(CFLAGS) -c war.c
  55. X
  56. X
  57. Xbgbitmap: bgbitmap.c war.h
  58. X    $(CC) -o bgbitmap bgbitmap.c -lX11
  59. X
  60. X
  61. END_OF_FILE
  62. if test 345 -ne `wc -c <'Makefile.simple'`; then
  63.     echo shar: \"'Makefile.simple'\" unpacked with wrong size!
  64. fi
  65. # end of 'Makefile.simple'
  66. fi
  67. if test -f 'bgbitmap.c' -a "${1}" != "-c" ; then 
  68.   echo shar: Will not clobber existing file \"'bgbitmap.c'\"
  69. else
  70. echo shar: Extracting \"'bgbitmap.c'\" \(14463 characters\)
  71. sed "s/^X//" >'bgbitmap.c' <<'END_OF_FILE'
  72. X#include <X11/Xlib.h>
  73. X#include <X11/Xutil.h>
  74. X#include <X11/Xos.h>
  75. X#include <X11/Xatom.h>
  76. X
  77. X#include <stdio.h>
  78. X
  79. X#include "war.h"
  80. X
  81. XDisplay *display;
  82. Xint screen_num;
  83. XGC gc, undraw_gc;
  84. XPixmap pixmap;
  85. X
  86. X
  87. Xvoid main(argc, argv)
  88. Xint argc;
  89. Xchar **argv;
  90. X{
  91. X    XFontStruct *font_info;
  92. X    XGCValues values;
  93. X
  94. X    if ((display = XOpenDisplay(NULL)) == NULL) {
  95. X        fprintf(stderr, "cannot open display\n");
  96. X        exit(-1);
  97. X    }
  98. X    screen_num = DefaultScreen(display);
  99. X
  100. X    pixmap = XCreatePixmap(display, RootWindow(display, screen_num),
  101. X        DIMENSION, DIMENSION, 1);
  102. X
  103. X    font_info = XLoadQueryFont(display, "9x15bold");
  104. X
  105. X    values.arc_mode = ArcChord;
  106. X
  107. X    values.foreground = 0;
  108. X    values.background = 1;
  109. X    undraw_gc = XCreateGC(display, pixmap, GCForeground | GCBackground |
  110. X        GCArcMode, &values);
  111. X
  112. X    values.foreground = 1;
  113. X    values.background = 0;
  114. X
  115. X    values.font = font_info->fid;
  116. X    gc = XCreateGC(display, pixmap, GCForeground|GCBackground|GCFont,
  117. X        &values);
  118. X
  119. X    printf("'war_background.xbm' file will be created at ./bitmaps\n");
  120. X    printf("please wait a second...\n");
  121. X    draw();
  122. X
  123. X    XWriteBitmapFile(display, "war_background", pixmap,
  124. X            DIMENSION, DIMENSION, -1, -1);
  125. X    system("mv ./war_background ./bitmaps/war_background.xbm");
  126. X
  127. X    printf("completed!\n");
  128. X
  129. X    XUnloadFont(display, font_info->fid);
  130. X    XFreeGC(display, gc);
  131. X    XFreeGC(display, undraw_gc);
  132. X    XCloseDisplay(display);
  133. X    exit(0);
  134. X}
  135. X
  136. X
  137. X
  138. Xdraw()
  139. X{
  140. X    static unsigned char dash_list[] = {10, 10};
  141. X    int i, j;
  142. X
  143. X    XFillRectangle(display, pixmap, undraw_gc, 0, 0, DIMENSION, DIMENSION);
  144. X
  145. X    XDrawString(display, pixmap, gc, 110, 575, "DEATH ANGEL", 11);
  146. X    XDrawString(display, pixmap, gc, 695, 628, "NEW GAME", 8);
  147. X    XDrawString(display, pixmap, gc, 695, 668, "START WAR", 9);
  148. X    XDrawString(display, pixmap, gc, 695, 708, "REDEPLOY", 8);
  149. X    XDrawString(display, pixmap, gc, 695, 748, "PEACE", 5);
  150. X    XDrawString(display, pixmap, gc, 695, 788, "SURRENDER", 9);
  151. X    XDrawString(display, pixmap, gc, 695, 828, "QUIT", 4);
  152. X
  153. X    XSetLineAttributes(display, gc, 5, LineOnOffDash, CapButt, JoinMiter);
  154. X    XSetDashes(display, gc, 0, dash_list, 2);
  155. X
  156. X    XDrawLine(display, pixmap, gc, P3, P1+50, P3, P6-50);
  157. X    XDrawLine(display, pixmap, gc, P4, P1+50, P4, P6-50);
  158. X    XDrawLine(display, pixmap, gc, P1+50, P3, P6-50, P3);
  159. X    XDrawLine(display, pixmap, gc, P1+50, P4, P6-50, P4);
  160. X
  161. X    XDrawLine(display, pixmap, gc, P3, P1+50, P4, P1+50);
  162. X    XDrawLine(display, pixmap, gc, P3, P2, P4, P2);
  163. X    XDrawLine(display, pixmap, gc, P3, P5, P4, P5);
  164. X    XDrawLine(display, pixmap, gc, P3, P6-50, P4, P6-50);
  165. X
  166. X    XDrawLine(display, pixmap, gc, P1+50, P3, P1+50, P4);
  167. X    XDrawLine(display, pixmap, gc, P2, P3, P2, P4);
  168. X    XDrawLine(display, pixmap, gc, P5, P3, P5, P4);
  169. X    XDrawLine(display, pixmap, gc, P6-50, P3, P6-50, P4);
  170. X
  171. X    XDrawLine(display, pixmap, gc, P2, P3+100, P5, P3+100);
  172. X    XDrawLine(display, pixmap, gc, P3+100, P2, P3+100, P5);
  173. X
  174. X    XSetLineAttributes(display, gc, 5, LineSolid, CapButt, JoinRound);
  175. X    XDrawArc(display, pixmap, gc, P2-50, P2-50, 100, 100, 0, -90*64);
  176. X    XDrawArc(display, pixmap, gc, P4, P2-50, 100, 100, 180*64, 90*64);
  177. X    XDrawArc(display, pixmap, gc, P2-50, P4, 100, 100, 0, 90*64);
  178. X    XDrawArc(display, pixmap, gc, P4, P4, 100, 100, 90*64, 90*64);
  179. X
  180. X    XSetLineAttributes(display, gc, 1, LineSolid, CapButt, JoinRound);
  181. X
  182. X    XDrawLine(display, pixmap, gc, P3-2, P1+50, P3-2, P6-50);
  183. X    XDrawLine(display, pixmap, gc, P3+2, P1+50, P3+2, P6-50);
  184. X    XDrawLine(display, pixmap, gc, P4-2, P1+50, P4-2, P6-50);
  185. X    XDrawLine(display, pixmap, gc, P4+2, P1+50, P4+2, P6-50);
  186. X    XDrawLine(display, pixmap, gc, P1+50, P3-2, P6-50, P3-2);
  187. X    XDrawLine(display, pixmap, gc, P1+50, P3+2, P6-50, P3+2);
  188. X    XDrawLine(display, pixmap, gc, P1+50, P4-2, P6-50, P4-2);
  189. X    XDrawLine(display, pixmap, gc, P1+50, P4+2, P6-50, P4+2);
  190. X
  191. X    XDrawLine(display, pixmap, gc, P3, P1+48, P4, P1+48);
  192. X    XDrawLine(display, pixmap, gc, P3, P1+52, P4, P1+52);
  193. X    XDrawLine(display, pixmap, gc, P3, P2-2, P4, P2-2);
  194. X    XDrawLine(display, pixmap, gc, P3, P2+2, P4, P2+2);
  195. X    XDrawLine(display, pixmap, gc, P3, P5-2, P4, P5-2);
  196. X    XDrawLine(display, pixmap, gc, P3, P5+2, P4, P5+2);
  197. X    XDrawLine(display, pixmap, gc, P3, P6-52, P4, P6-52);
  198. X    XDrawLine(display, pixmap, gc, P3, P6-48, P4, P6-48);
  199. X
  200. X    XDrawLine(display, pixmap, gc, P1+48, P3, P1+48, P4);
  201. X    XDrawLine(display, pixmap, gc, P1+52, P3, P1+52, P4);
  202. X    XDrawLine(display, pixmap, gc, P2-2, P3, P2-2, P4);
  203. X    XDrawLine(display, pixmap, gc, P2+2, P3, P2+2, P4);
  204. X    XDrawLine(display, pixmap, gc, P5-2, P3, P5-2, P4);
  205. X    XDrawLine(display, pixmap, gc, P5+2, P3, P5+2, P4);
  206. X    XDrawLine(display, pixmap, gc, P6-48, P3, P6-48, P4);
  207. X    XDrawLine(display, pixmap, gc, P6-52, P3, P6-52, P4);
  208. X
  209. X    XDrawLine(display, pixmap, gc, P2, P3+98, P5, P3+98);
  210. X    XDrawLine(display, pixmap, gc, P2, P3+102, P5, P3+102);
  211. X    XDrawLine(display, pixmap, gc, P3+98, P2, P3+98, P5);
  212. X    XDrawLine(display, pixmap, gc, P3+102, P2, P3+102, P5);
  213. X
  214. X    for (i=RIP_Y+50; i<RIP_Y+RIP_DIMENSION; i += 50)
  215. X    XDrawLine(display, pixmap, gc, P1, i, P1+RIP_DIMENSION, i);
  216. X    for (i=P1+50; i<P1+RIP_DIMENSION; i += 50)
  217. X    XDrawLine(display, pixmap, gc, i, RIP_Y, i, RIP_Y+RIP_DIMENSION);
  218. X
  219. X    for (i=P3+50; i<P4; i += 50)
  220. X    XDrawLine(display, pixmap, gc, i, P5, i, P6);
  221. X    for (i=P5+50; i<P6-50; i += 50)
  222. X    XDrawLine(display, pixmap, gc, P3, i, P4, i);
  223. X    XDrawLine(display, pixmap, gc, P3, P5, P4, P6-50);
  224. X    XDrawLine(display, pixmap, gc, P3, P5+100, P3+100, P6-50);
  225. X    XDrawLine(display, pixmap, gc, P3+100, P5, P4, P5+100);
  226. X    XDrawLine(display, pixmap, gc, P3, P6-50, P4, P5);
  227. X    XDrawLine(display, pixmap, gc, P3, P5+100, P3+100, P5);
  228. X    XDrawLine(display, pixmap, gc, P3+100, P6-50, P4, P5+100);
  229. X
  230. X    for (i=P3+50; i<P4; i += 50)
  231. X    XDrawLine(display, pixmap, gc, i, P1, i, P2);
  232. X    for (i=P1+100; i<P2; i += 50)
  233. X    XDrawLine(display, pixmap, gc, P3, i, P4, i);
  234. X    XDrawLine(display, pixmap, gc, P3, P1+50, P4, P2);
  235. X    XDrawLine(display, pixmap, gc, P3, P2-100, P3+100, P2);
  236. X    XDrawLine(display, pixmap, gc, P3+100, P1+50, P4, P2-100);
  237. X    XDrawLine(display, pixmap, gc, P3, P2-100, P3+100, P1+50);
  238. X    XDrawLine(display, pixmap, gc, P3, P2, P4, P1+50);
  239. X    XDrawLine(display, pixmap, gc, P3+100, P2, P4, P2-100);
  240. X
  241. X    for (i=P3+50; i<P4; i += 50)
  242. X    XDrawLine(display, pixmap, gc, P1, i, P2, i);
  243. X    for (i=P1+100; i<P2; i += 50)
  244. X    XDrawLine(display, pixmap, gc, i, P3, i, P4);
  245. X    XDrawLine(display, pixmap, gc, P1+50, P3+100, P2-100, P4);
  246. X    XDrawLine(display, pixmap, gc, P1+50, P3, P2, P4);
  247. X    XDrawLine(display, pixmap, gc, P2-100, P3, P2, P3+100);
  248. X    XDrawLine(display, pixmap, gc, P1+50, P3+100, P2-100, P3);
  249. X    XDrawLine(display, pixmap, gc, P2, P3, P1+50, P4);
  250. X    XDrawLine(display, pixmap, gc, P2-100, P4, P2, P3+100);
  251. X
  252. X    for (i=P3+50; i<P4; i += 50)
  253. X    XDrawLine(display, pixmap, gc, P5, i, P6, i);
  254. X    for (i=P5+50; i<P6-50; i += 50)
  255. X    XDrawLine(display, pixmap, gc, i, P3, i, P4);
  256. X    XDrawLine(display, pixmap, gc, P5, P3+100, P5+100, P4);
  257. X    XDrawLine(display, pixmap, gc, P5, P3, P6-50, P4);
  258. X    XDrawLine(display, pixmap, gc, P5+100, P3, P6-50, P3+100);
  259. X    XDrawLine(display, pixmap, gc, P5, P3+100, P5+100, P3);
  260. X    XDrawLine(display, pixmap, gc, P5, P4, P6-50, P3);
  261. X    XDrawLine(display, pixmap, gc, P5+100, P4, P6-50, P3+100);
  262. X
  263. X    XSetLineAttributes(display, gc, 3, LineSolid, CapButt, JoinRound);
  264. X
  265. X    XDrawRectangle(display, pixmap, gc, TALK_L_X,TALK_Y,TALK_WIDTH,TALK_HEIGHT);
  266. X    XDrawRectangle(display, pixmap, gc, TALK_L_X, TALK_Y+90,
  267. X        TALK_WIDTH, TALK_HEIGHT);
  268. X    XDrawRectangle(display, pixmap, gc, TALK_R_X,TALK_Y,TALK_WIDTH,TALK_HEIGHT);
  269. X    XDrawRectangle(display, pixmap, gc, TALK_R_X, TALK_Y+90,
  270. X        TALK_WIDTH, TALK_HEIGHT);
  271. X
  272. X    XDrawRectangle(display, pixmap, gc, P1, P1, 66, 66);
  273. X    XDrawRectangle(display, pixmap, gc, MSG_BOX_X, MSG_BOX_Y,
  274. X        MSG_WIDTH, MSG_HEIGHT);
  275. X
  276. X    XDrawLine(display, pixmap, gc, P3-1, P1-1, P3-1, P1+50);
  277. X    XDrawLine(display, pixmap, gc, P4+1, P1-1, P4+1, P1+50);
  278. X    XDrawLine(display, pixmap, gc, P3-1, P1-1, P4+1, P1-1);
  279. X
  280. X    XDrawLine(display, pixmap, gc, P3-1, P6-50, P3-1, P6+1);
  281. X    XDrawLine(display, pixmap, gc, P4+1, P6-50, P4+1, P6+1);
  282. X    XDrawLine(display, pixmap, gc, P3-1, P6+1, P4+1, P6+1);
  283. X
  284. X    XDrawLine(display, pixmap, gc, P6-50, P3-1, P6+1, P3-1);
  285. X    XDrawLine(display, pixmap, gc, P6-50, P4+1, P6+1, P4+1);
  286. X    XDrawLine(display, pixmap, gc, P6+1, P3-1, P6+1, P4+1);
  287. X
  288. X    XDrawLine(display, pixmap, gc, P1-1, P3-1, P1+50, P3-1);
  289. X    XDrawLine(display, pixmap, gc, P1-1, P4+1, P1+50, P4+1);
  290. X    XDrawLine(display, pixmap, gc, P1-1, P3-1, P1-1, P4+1);
  291. X
  292. X    XDrawRectangle(display, pixmap, gc, P1, RIP_Y, 
  293. X    RIP_DIMENSION-1,RIP_DIMENSION-1);
  294. X
  295. X    for (i=NEW_Y; i<=NEW_Y+BUTTON_DIS*5; i += BUTTON_DIS)
  296. X    XDrawRectangle(display, pixmap, gc, BUTTON_X, i,
  297. X        BUTTON_WIDTH, BUTTON_HEIGHT);
  298. X
  299. X    XSetLineAttributes(display, gc, 2, LineSolid, CapButt, JoinRound);
  300. X
  301. X    XFillArc(display, pixmap, undraw_gc, P3+30, P1+80, 40, 40, 0, 360*64);
  302. X    XDrawArc(display, pixmap, gc, P3+30, P1+80, 40, 40, 0, 360*64);
  303. X    XFillArc(display, pixmap, undraw_gc, P4-70, P1+80, 40, 40, 0, 360*64);
  304. X    XDrawArc(display, pixmap, gc, P4-70, P1+80, 40, 40, 0, 360*64);
  305. X    XFillArc(display, pixmap, undraw_gc, P3+80, P2-120, 40, 40, 0, 360*64);
  306. X    XDrawArc(display, pixmap, gc, P3+80, P2-120, 40, 40, 0, 360*64);
  307. X    XFillArc(display, pixmap, undraw_gc, P3+30, P2-70, 40, 40, 0, 360*64);
  308. X    XDrawArc(display, pixmap, gc, P3+30, P2-70, 40, 40, 0, 360*64);
  309. X    XFillArc(display, pixmap, undraw_gc, P4-70, P2-70, 40, 40, 0, 360*64);
  310. X    XDrawArc(display, pixmap, gc, P4-70, P2-70, 40, 40, 0, 360*64);
  311. X
  312. X    XFillArc(display, pixmap, undraw_gc, P5+30, P3+30, 40, 40, 0, 360*64);
  313. X    XDrawArc(display, pixmap, gc, P5+30, P3+30, 40, 40, 0, 360*64);
  314. X    XFillArc(display, pixmap, undraw_gc, P5+30, P4-70, 40, 40, 0, 360*64);
  315. X    XDrawArc(display, pixmap, gc, P5+30, P4-70, 40, 40, 0, 360*64);
  316. X    XFillArc(display, pixmap, undraw_gc, P5+80, P3+80, 40, 40, 0, 360*64);
  317. X    XDrawArc(display, pixmap, gc, P5+80, P3+80, 40, 40, 0, 360*64);
  318. X    XFillArc(display, pixmap, undraw_gc, P6-120, P3+30, 40, 40, 0, 360*64);
  319. X    XDrawArc(display, pixmap, gc, P6-120, P3+30, 40, 40, 0, 360*64);
  320. X    XFillArc(display, pixmap, undraw_gc, P6-120, P4-70, 40, 40, 0, 360*64);
  321. X    XDrawArc(display, pixmap, gc, P6-120, P4-70, 40, 40, 0, 360*64);
  322. X
  323. X    XFillArc(display, pixmap, undraw_gc, P1+80, P3+30, 40, 40, 0, 360*64);
  324. X    XDrawArc(display, pixmap, gc, P1+80, P3+30, 40, 40, 0, 360*64);
  325. X    XFillArc(display, pixmap, undraw_gc, P1+80, P4-70, 40, 40, 0, 360*64);
  326. X    XDrawArc(display, pixmap, gc, P1+80, P4-70, 40, 40, 0, 360*64);
  327. X    XFillArc(display, pixmap, undraw_gc, P1+130, P3+80, 40, 40, 0, 360*64);
  328. X    XDrawArc(display, pixmap, gc, P1+130, P3+80, 40, 40, 0, 360*64);
  329. X    XFillArc(display, pixmap, undraw_gc, P2-70, P3+30, 40, 40, 0, 360*64);
  330. X    XDrawArc(display, pixmap, gc, P2-70, P3+30, 40, 40, 0, 360*64);
  331. X    XFillArc(display, pixmap, undraw_gc, P2-70, P4-70, 40, 40, 0, 360*64);
  332. X    XDrawArc(display, pixmap, gc, P2-70, P4-70, 40, 40, 0, 360*64);
  333. X
  334. X    XFillArc(display, pixmap, undraw_gc, P3+30, P5+30, 40, 40, 0, 360*64);
  335. X    XDrawArc(display, pixmap, gc, P3+30, P5+30, 40, 40, 0, 360*64);
  336. X    XFillArc(display, pixmap, undraw_gc, P3+30, P6-120, 40, 40, 0, 360*64);
  337. X    XDrawArc(display, pixmap, gc, P3+30, P6-120, 40, 40, 0, 360*64);
  338. X    XFillArc(display, pixmap, undraw_gc, P3+80, P5+80, 40, 40, 0, 360*64);
  339. X    XDrawArc(display, pixmap, gc, P3+80, P5+80, 40, 40, 0, 360*64);
  340. X    XFillArc(display, pixmap, undraw_gc, P4-70, P5+30, 40, 40, 0, 360*64);
  341. X    XDrawArc(display, pixmap, gc, P4-70, P5+30, 40, 40, 0, 360*64);
  342. X    XFillArc(display, pixmap, undraw_gc, P4-70, P6-120, 40, 40, 0, 360*64);
  343. X    XDrawArc(display, pixmap, gc, P4-70, P6-120, 40, 40, 0, 360*64);
  344. X
  345. X    for (i=P3-15; i<P4; i += 100)
  346. X      for (j=P3-15; j<P4; j += 100) {
  347. X    XFillRectangle(display, pixmap, undraw_gc, i, j, 30, 30);
  348. X    XDrawRectangle(display, pixmap, gc, i, j, 29, 29);
  349. X    }
  350. X
  351. X    for (i=P3-20; i<P4; i += 50)
  352. X      for (j=P5-10; j<P6; j += 50)
  353. X    if (i==P3+30 && j==P5+40 || i==P4-70 && j==P5+40 ||
  354. X        i==P3+80 && j==P5+90 ||
  355. X        i==P3+30 && j==P6-110 || i==P4-70 && j==P6-110 )
  356. X        ;
  357. X    else {
  358. X        XFillRectangle(display, pixmap, undraw_gc, i, j, 40, 20);
  359. X        XDrawRectangle(display, pixmap, gc, i, j, 40, 20);
  360. X    }
  361. X
  362. X    for (i=P3-20; i<P4; i += 50)
  363. X      for (j=P1-10; j<P2; j += 50)
  364. X    if (i==P3+30 && j==P1+90 || i==P4-70 && j==P1+90 ||
  365. X        i==P3+80 && j==P2-110 ||
  366. X        i==P3+30 && j==P2-60 || i==P4-70 && j==P2-60 )
  367. X        ;
  368. X    else {
  369. X        XFillRectangle(display, pixmap, undraw_gc, i, j, 40, 20);
  370. X        XDrawRectangle(display, pixmap, gc, i, j, 40, 20);
  371. X    }
  372. X
  373. X    for (i=P1-10; i<P2; i += 50)
  374. X      for (j=P3-20; j<P4; j += 50)
  375. X    if (i==P1+90 && j==P3+30 || i==P2-60 && j==P3+30 ||
  376. X        i==P2-110 && j==P3+80 ||
  377. X        i==P1+90 && j==P4-70 || i==P2-60 && j==P4-70)
  378. X        ;
  379. X    else {
  380. X        XFillRectangle(display, pixmap, undraw_gc, i, j, 20, 40);
  381. X        XDrawRectangle(display, pixmap, gc, i, j, 20, 40);
  382. X    }
  383. X
  384. X    for (i=P5-10; i<P6; i += 50)
  385. X      for (j=P3-20; j<P4; j += 50)
  386. X    if (i==P5+40 && j==P3+30 || i==P6-110 && j==P3+30 ||
  387. X        i==P5+90 && j==P3+80 ||
  388. X        i==P5+40 && j==P4-70 || i==P6-110 && j==P4-70)
  389. X        ;
  390. X    else {
  391. X        XFillRectangle(display, pixmap, undraw_gc, i, j, 20, 40);
  392. X        XDrawRectangle(display, pixmap, gc, i, j, 20, 40);
  393. X    }
  394. X
  395. X    XFillArc(display, pixmap, undraw_gc, P3+35, P1-14, 30, 30, 210*64, 120*64);
  396. X    XDrawArc(display, pixmap, gc, P3+35, P1-14, 30, 30, 215*64, 110*64);
  397. X    XFillArc(display, pixmap, undraw_gc, P4-65, P1-14, 30, 30, 210*64, 120*64);
  398. X    XDrawArc(display, pixmap, gc, P4-65, P1-14, 30, 30, 215*64, 110*64);
  399. X
  400. X    XFillArc(display, pixmap, undraw_gc, P3+35, P6-16, 30, 30, 30*64, 120*64);
  401. X    XDrawArc(display, pixmap, gc, P3+35, P6-16, 30, 30, 35*64, 110*64);
  402. X    XFillArc(display, pixmap, undraw_gc, P4-65, P6-16, 30, 30, 30*64, 120*64);
  403. X    XDrawArc(display, pixmap, gc, P4-65, P6-16, 30, 30, 35*64, 110*64);
  404. X
  405. X    XFillArc(display, pixmap, undraw_gc, P1-14, P3+35, 30, 30, 60*64, -120*64);
  406. X    XDrawArc(display, pixmap, gc, P1-14, P3+35, 30, 30, 55*64, -110*64);
  407. X    XFillArc(display, pixmap, undraw_gc, P1-14, P4-65, 30, 30, 60*64, -120*64);
  408. X    XDrawArc(display, pixmap, gc, P1-14, P4-65, 30, 30, 55*64, -110*64);
  409. X
  410. X    XFillArc(display, pixmap, undraw_gc, P6-16, P3+35, 30, 30, 120*64, 120*64);
  411. X    XDrawArc(display, pixmap, gc, P6-16, P3+35, 30, 30, 125*64, 110*64);
  412. X    XFillArc(display, pixmap, undraw_gc, P6-16, P4-65, 30, 30, 120*64, 120*64);
  413. X    XDrawArc(display, pixmap, gc, P6-16, P4-65, 30, 30, 125*64, 110*64);
  414. X}
  415. X
  416. X
  417. X
  418. END_OF_FILE
  419. if test 14463 -ne `wc -c <'bgbitmap.c'`; then
  420.     echo shar: \"'bgbitmap.c'\" unpacked with wrong size!
  421. fi
  422. # end of 'bgbitmap.c'
  423. fi
  424. if test -f 'bitmaps/go.xbm' -a "${1}" != "-c" ; then 
  425.   echo shar: Will not clobber existing file \"'bitmaps/go.xbm'\"
  426. else
  427. echo shar: Extracting \"'bitmaps/go.xbm'\" \(3271 characters\)
  428. sed "s/^X//" >'bitmaps/go.xbm' <<'END_OF_FILE'
  429. X#define go_width 64
  430. X#define go_height 64
  431. Xstatic char go_bits[] = {
  432. X   0x00, 0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff,
  433. X   0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x0f, 0x00, 0x00,
  434. X   0x00, 0x00, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff,
  435. X   0xff, 0xff, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x83, 0xe0, 0xff, 0x01, 0x00,
  436. X   0x00, 0xf0, 0x7f, 0x80, 0x00, 0xff, 0x07, 0x00, 0x00, 0xf8, 0x0f, 0xc0,
  437. X   0x01, 0xf8, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0xc0, 0x01, 0xe0, 0x1f, 0x00,
  438. X   0x00, 0xfe, 0x00, 0xe0, 0x03, 0x80, 0x3f, 0x00, 0x00, 0x7f, 0x00, 0xf0,
  439. X   0x07, 0x00, 0x7f, 0x00, 0x80, 0x3f, 0x00, 0xf0, 0x07, 0x00, 0xfe, 0x00,
  440. X   0xc0, 0x1f, 0x00, 0xf0, 0x07, 0x00, 0xfc, 0x01, 0xc0, 0x0f, 0x00, 0xf8,
  441. X   0x0f, 0x00, 0xf8, 0x01, 0xe0, 0x07, 0x00, 0xfc, 0x1f, 0x00, 0xf0, 0x03,
  442. X   0xf0, 0x03, 0x00, 0xfc, 0x1f, 0x00, 0xe0, 0x07, 0xf0, 0x01, 0x00, 0xfe,
  443. X   0x3f, 0x00, 0xc0, 0x07, 0xf8, 0x01, 0x00, 0xfe, 0x3f, 0x00, 0xc0, 0x0f,
  444. X   0xf8, 0x00, 0x00, 0xff, 0x7f, 0x00, 0x80, 0x0f, 0xfc, 0x00, 0x00, 0xff,
  445. X   0x7f, 0x00, 0x80, 0x1f, 0x7c, 0x00, 0x00, 0xff, 0x7f, 0x00, 0x00, 0x1f,
  446. X   0x7c, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x1f, 0x7e, 0x00, 0x00, 0xe0,
  447. X   0x03, 0x00, 0x00, 0x3f, 0x3e, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x3e,
  448. X   0x3e, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x3e, 0x3e, 0x00, 0x00, 0xe0,
  449. X   0x03, 0x00, 0x00, 0x3e, 0x1f, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x7c,
  450. X   0x1f, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x7c, 0x1f, 0x00, 0x00, 0xe0,
  451. X   0x03, 0x00, 0x00, 0x7c, 0x1f, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x7c,
  452. X   0x1f, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x7c, 0x1f, 0x00, 0x00, 0xe0,
  453. X   0x03, 0x00, 0x00, 0x7c, 0x1f, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x7c,
  454. X   0x1f, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x7c, 0x1f, 0x00, 0x00, 0xe0,
  455. X   0x03, 0x00, 0x00, 0x7c, 0x1f, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x7c,
  456. X   0x1f, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x7c, 0x3e, 0x00, 0x00, 0xe0,
  457. X   0x03, 0x00, 0x00, 0x3e, 0x3e, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x3e,
  458. X   0x3e, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x3e, 0x7e, 0x00, 0x00, 0xe0,
  459. X   0x03, 0x00, 0x00, 0x3f, 0x7c, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x1f,
  460. X   0x7c, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x1f, 0xfc, 0x00, 0x00, 0xe0,
  461. X   0x03, 0x00, 0x80, 0x1f, 0xf8, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x80, 0x0f,
  462. X   0xf8, 0x01, 0x00, 0xe0, 0x03, 0x00, 0xc0, 0x0f, 0xf0, 0x01, 0x00, 0xe0,
  463. X   0x03, 0x00, 0xc0, 0x07, 0xf0, 0x03, 0x00, 0xe0, 0x03, 0x00, 0xe0, 0x07,
  464. X   0xe0, 0x07, 0x00, 0xe0, 0x03, 0x00, 0xf0, 0x03, 0xc0, 0x0f, 0x00, 0xe0,
  465. X   0x03, 0x00, 0xf8, 0x01, 0xc0, 0x1f, 0x00, 0xe0, 0x03, 0x00, 0xfc, 0x01,
  466. X   0x80, 0x3f, 0x00, 0xe0, 0x03, 0x00, 0xfe, 0x00, 0x80, 0x7f, 0x00, 0xe0,
  467. X   0x03, 0x00, 0x7f, 0x00, 0x00, 0xfe, 0x00, 0xe0, 0x03, 0x80, 0x3f, 0x00,
  468. X   0x00, 0xfc, 0x03, 0xe0, 0x03, 0xe0, 0x1f, 0x00, 0x00, 0xf8, 0x0f, 0xe0,
  469. X   0x03, 0xf8, 0x0f, 0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0xff, 0x07, 0x00,
  470. X   0x00, 0xc0, 0xff, 0x03, 0xe0, 0xff, 0x01, 0x00, 0x00, 0x80, 0xff, 0xff,
  471. X   0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00,
  472. X   0x00, 0x00, 0xf8, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff,
  473. X   0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0x00,
  474. X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  475. X
  476. X
  477. END_OF_FILE
  478. if test 3271 -ne `wc -c <'bitmaps/go.xbm'`; then
  479.     echo shar: \"'bitmaps/go.xbm'\" unpacked with wrong size!
  480. fi
  481. # end of 'bitmaps/go.xbm'
  482. fi
  483. if test -f 'bitmaps/stop.xbm' -a "${1}" != "-c" ; then 
  484.   echo shar: Will not clobber existing file \"'bitmaps/stop.xbm'\"
  485. else
  486. echo shar: Extracting \"'bitmaps/stop.xbm'\" \(3277 characters\)
  487. sed "s/^X//" >'bitmaps/stop.xbm' <<'END_OF_FILE'
  488. X#define stop_width 64
  489. X#define stop_height 64
  490. Xstatic char stop_bits[] = {
  491. X   0x00, 0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff,
  492. X   0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x0f, 0x00, 0x00,
  493. X   0x00, 0x00, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff,
  494. X   0xff, 0xff, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x03, 0xe0, 0xff, 0x01, 0x00,
  495. X   0x00, 0xf0, 0x7f, 0x00, 0x00, 0xff, 0x07, 0x00, 0x00, 0xf8, 0x0f, 0x00,
  496. X   0x00, 0xf8, 0x0f, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00, 0xe0, 0x1f, 0x00,
  497. X   0x00, 0xfe, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x7f, 0x00, 0x00,
  498. X   0x00, 0x00, 0x7f, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00,
  499. X   0xc0, 0x1f, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x01, 0xc0, 0x0f, 0x00, 0x00,
  500. X   0x00, 0x00, 0xf8, 0x01, 0xe0, 0x07, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x03,
  501. X   0xf0, 0x03, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0xf0, 0x01, 0x00, 0x00,
  502. X   0x00, 0x00, 0xc0, 0x07, 0xf8, 0x01, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f,
  503. X   0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0f, 0xfc, 0x00, 0x00, 0x00,
  504. X   0x00, 0x00, 0x80, 0x1f, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f,
  505. X   0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x7e, 0x00, 0x00, 0x00,
  506. X   0x00, 0x00, 0x00, 0x3f, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e,
  507. X   0x3e, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0x00, 0x00, 0x60,
  508. X   0x48, 0x00, 0x00, 0x3e, 0x1f, 0x00, 0x00, 0x20, 0xf9, 0x00, 0x00, 0x7c,
  509. X   0x1f, 0x00, 0x00, 0x60, 0xf3, 0x81, 0x00, 0x7c, 0x1f, 0x00, 0x00, 0xe0,
  510. X   0xff, 0xc3, 0x00, 0x7c, 0x1f, 0x00, 0x00, 0xe0, 0xff, 0xe7, 0x01, 0x7c,
  511. X   0x1f, 0x00, 0x00, 0xe0, 0xfb, 0xff, 0x01, 0x7c, 0x1f, 0x00, 0x00, 0xe0,
  512. X   0xf3, 0xff, 0x01, 0x7c, 0x1f, 0x00, 0x00, 0xe0, 0xe3, 0xff, 0x01, 0x7c,
  513. X   0x1f, 0x00, 0x00, 0xe0, 0xc3, 0xff, 0x01, 0x7c, 0x1f, 0x00, 0x00, 0xe0,
  514. X   0x83, 0xff, 0x01, 0x7c, 0x1f, 0x00, 0x00, 0xe0, 0xc3, 0xff, 0x01, 0x7c,
  515. X   0x1f, 0x00, 0x00, 0xe0, 0xe3, 0xff, 0x03, 0x7c, 0x3e, 0x00, 0x00, 0xe0,
  516. X   0xf3, 0xff, 0x03, 0x3e, 0x3e, 0x00, 0x00, 0xe0, 0x03, 0xff, 0x03, 0x3e,
  517. X   0x3e, 0x00, 0x00, 0xe0, 0x03, 0xe0, 0x07, 0x3e, 0x7e, 0x00, 0x00, 0xe0,
  518. X   0x03, 0x80, 0x07, 0x3f, 0x7c, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x04, 0x1f,
  519. X   0x7c, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0x1f, 0xfc, 0x00, 0x00, 0xe0,
  520. X   0x03, 0x00, 0x80, 0x1f, 0xf8, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x80, 0x0f,
  521. X   0xf8, 0x01, 0x00, 0xe0, 0x03, 0x00, 0xc0, 0x0f, 0xf0, 0x01, 0x00, 0xe0,
  522. X   0x03, 0x00, 0xc0, 0x07, 0xf0, 0x03, 0x00, 0xe0, 0x03, 0x00, 0xe0, 0x07,
  523. X   0xe0, 0x07, 0x00, 0xe0, 0x03, 0x00, 0xf0, 0x03, 0xc0, 0x0f, 0x00, 0xe0,
  524. X   0x03, 0x00, 0xf8, 0x01, 0xc0, 0x1f, 0x00, 0xe0, 0x03, 0x00, 0xfc, 0x01,
  525. X   0x80, 0x3f, 0x00, 0xe0, 0x03, 0x00, 0xfe, 0x00, 0x80, 0x7f, 0x00, 0xe0,
  526. X   0x03, 0x00, 0x7f, 0x00, 0x00, 0xfe, 0x00, 0xe0, 0x03, 0x80, 0x3f, 0x00,
  527. X   0x00, 0xfc, 0x03, 0xe0, 0x03, 0xe0, 0x1f, 0x00, 0x00, 0xf8, 0x0f, 0xe0,
  528. X   0x03, 0xf8, 0x0f, 0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0xff, 0x07, 0x00,
  529. X   0x00, 0xc0, 0xff, 0x03, 0xe0, 0xff, 0x01, 0x00, 0x00, 0x80, 0xff, 0xff,
  530. X   0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00,
  531. X   0x00, 0x00, 0xf8, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff,
  532. X   0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0x00,
  533. X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  534. X
  535. X
  536. END_OF_FILE
  537. if test 3277 -ne `wc -c <'bitmaps/stop.xbm'`; then
  538.     echo shar: \"'bitmaps/stop.xbm'\" unpacked with wrong size!
  539. fi
  540. # end of 'bitmaps/stop.xbm'
  541. fi
  542. if test -f 'war.c' -a "${1}" != "-c" ; then 
  543.   echo shar: Will not clobber existing file \"'war.c'\"
  544. else
  545. echo shar: Extracting \"'war.c'\" \(21847 characters\)
  546. sed "s/^X//" >'war.c' <<'END_OF_FILE'
  547. X#include "war.h"
  548. X
  549. Xextern Arr arr[4][6][5], mid[3][3];
  550. X
  551. Xextern Sapper_path sap[];
  552. X
  553. Xextern int round;
  554. X
  555. X/*******************************************************************
  556. X*
  557. X*   Synopsis
  558. X*    fatal_error(s)
  559. X*        char *s;
  560. X*
  561. X*   Description
  562. X*    it prints s as an error message and exit.
  563. X*
  564. X*******************************************************************/
  565. X
  566. Xfatal_error(s)
  567. Xchar *s;
  568. X{
  569. X    printf("%s\n", s);
  570. X    exit(-1);
  571. X}
  572. X
  573. X
  574. X
  575. X/****************************************************************
  576. X*
  577. X*   Synopsis
  578. X*    syntax(s)
  579. X*        char *s;
  580. X*
  581. X*   Argument
  582. X*    s    the program name, usually x4war;
  583. X*
  584. X*   Description
  585. X*    x4war command line arguments specification
  586. X*
  587. X****************************************************************/
  588. X
  589. Xsyntax(s)
  590. Xchar *s;
  591. X{
  592. X    printf("Usage: %s [options ...]\n\n", s);
  593. X    printf("where options include:\n");
  594. X    printf("\t-p0 string\t\tplayer0's name\n");
  595. X    printf("\t-d0 string\t\tplayer0's display\n");
  596. X    printf("\t-c0 string\t\tplayer0's node color\n");
  597. X    printf("\t-p1 string\t\tplayer1's name\n");
  598. X    printf("\t-d1 string\t\tplayer1's display\n");
  599. X    printf("\t-c1 string\t\tplayer1's node color\n");
  600. X    printf("\t-p2 string\t\tplayer2's name\n");
  601. X    printf("\t-d2 string\t\tplayer2's display\n");
  602. X    printf("\t-c2 string\t\tplayer2's node color\n");
  603. X    printf("\t-p3 string\t\tplayer3's name\n");
  604. X    printf("\t-d3 string\t\tplayer3's display\n");
  605. X    printf("\t-c3 string\t\tplayer3's node color\n");
  606. X    printf("\t-debug\t\t\ta default deploy\n");
  607. X    printf("\t-usage\t\t\tthis usage list\n\n");
  608. X}
  609. X
  610. X
  611. X
  612. X/***********************************************************************
  613. X *
  614. X *  Synopsis
  615. X *    int fight(x, y)
  616. X *        int x, y;
  617. X *
  618. X *  Arguments
  619. X *    x, y    representing two node values between COLOURS and BOMB.
  620. X *        x must be a movable, i.e., not COLOURS and MINE.
  621. X *
  622. X *  Return values
  623. X *    x < y: return 2;
  624. X *    x = y: return 3;
  625. X *    x > y: return 4;
  626. X *
  627. X *  Description
  628. X *    it returns the fighting result when node x moved to meet node y.
  629. X *
  630. X ***********************************************************************/
  631. X
  632. Xint fight(x, y)
  633. Xint x, y;
  634. X{
  635. X    if (x==SAPPER && y==MINE)  return(4);
  636. X    if (x==BOMB || y==BOMB)  return(3);
  637. X    if (x==y) return(3);
  638. X    if (x<y)  return(2);
  639. X    if (x>y)  return(4);
  640. X}
  641. X
  642. X
  643. X/**********************************************************************
  644. X*
  645. X*   Synopsis
  646. X*    int boardtofield(x, y, i, j)
  647. X*        int x, y;
  648. X*        int *i, *j;        return values
  649. X*
  650. X*   Arguments
  651. X*    x, y    coordinates of a point on board;
  652. X*    *i, *j  contain the converted field coordinates;
  653. X*
  654. X*   Return values
  655. X*    return a value from F0 to OTHERPLACE according to the position (x,y),
  656. X*    i and j are set if returned values between F0 and RIP.
  657. X*
  658. X***********************************************************************/
  659. X
  660. Xint boardtofield(x, y, i, j)
  661. Xint x, y, *i, *j;
  662. X{
  663. X    if (x>=315 && x<=555 && y>=565 && y<=855) {
  664. X    *j = (x-310)/50;
  665. X    *i = (y-560)/50;
  666. X    return(F0);
  667. X    }
  668. X    if (x>=565 && x<=855 && y>=315 && y<=555) {
  669. X    *i = (x-560)/50;
  670. X    *j = 4-(y-310)/50;
  671. X    return(F1);
  672. X    }
  673. X    if (x>=315 && x<=555 && y>=15 && y<=305) {
  674. X    *i = 5-(y-10)/50;
  675. X    *j = 4-(x-310)/50;
  676. X    return(F2);
  677. X    }
  678. X    if (x>=15 && x<=305 && y>=315 && y<=555) {
  679. X    *i = 5-(x-10)/50;
  680. X    *j = (y-310)/50;
  681. X    return(F3);
  682. X    }
  683. X    if (x>=315 && x<=555 && y>=315 && y<=555) {
  684. X    *j = (x-310)/100;
  685. X    *i = (y-310)/100;
  686. X    return(MIDFIELD);
  687. X    }
  688. X    if (x>=35 && x<=285 && y>=585 && y<=835) {
  689. X    *j = (x-35)/50;
  690. X    *i = (y-585)/50;
  691. X    return(RIP);
  692. X    }
  693. X
  694. X    if (x>=BUTTON_X && x<=BUTTON_X + BUTTON_WIDTH) {
  695. X    if (y>=610 && y<=635)  return(NEW);
  696. X    if (y>=650 && y<=675)  return(READY);
  697. X    if (y>=690 && y<=715)  return(REDEPLOY);
  698. X    if (y>=730 && y<=755)  return(PEACE);
  699. X    if (y>=770 && y<=795)  return(SURRENDER);
  700. X    if (y>=810 && y<=835)  return(QUIT);
  701. X    }
  702. X    return(OTHERPLACE);
  703. X}
  704. X
  705. X
  706. X
  707. X/********************************************************************
  708. X*
  709. X*   Synopsis
  710. X*    fieldtoboard(f, i, j, x, y)
  711. X*        int f, i, j;
  712. X*        int *x, *y;        return
  713. X*
  714. X*   Arguments
  715. X*    f    field id between F0 and RIP;
  716. X*    i, j    coordinates of the field;
  717. X*    *x, *y    contains returned values of coordinates of the board;
  718. X*
  719. X*********************************************************************/
  720. X
  721. Xfieldtoboard(f, i, j, x, y)
  722. Xint f, i, j, *x, *y;
  723. X{
  724. X    switch (f) {
  725. X      case F0:
  726. X    *x = 335+j*50;
  727. X    *y = 585+i*50;
  728. X    break;
  729. X      case F1:
  730. X    *x = 585+i*50;
  731. X    *y = 335+(4-j)*50;
  732. X    break;
  733. X      case F2:
  734. X    *x = 335+(4-j)*50;
  735. X    *y = 35+(5-i)*50;
  736. X    break;
  737. X      case F3:
  738. X    *x = 35+(5-i)*50;
  739. X    *y = 335+j*50;
  740. X    break;
  741. X      case MIDFIELD:
  742. X    *x = 335+j*100;
  743. X    *y = 335+i*100;
  744. X    break;
  745. X      case RIP:
  746. X    *x = 60+j*50;
  747. X    *y = 610+i*50;
  748. X    }
  749. X}
  750. X
  751. X
  752. X
  753. X/**********************************************************************
  754. X*
  755. X*   Synopsis
  756. X*    arrtoboard(id, g, i, j, x, y)
  757. X*        int id, g, i, j;
  758. X*        int *x, *y;        return
  759. X*
  760. X*   Arguments
  761. X*    id    0-3, specifies the player of the board;
  762. X*    g    F0 - RIP, which array;
  763. X*    i, j    coordinates of the array;
  764. X*    *x, *y  contains the results;
  765. X*
  766. X**********************************************************************/
  767. X
  768. Xarrtoboard(id, g, i, j, x, y)
  769. Xint id, g, i, j, *x, *y;
  770. X{
  771. X    int k;
  772. X
  773. X    if (g==MIDFIELD)
  774. X    switch (id) {
  775. X      case 1:
  776. X        k = i;  i = j;  j = 2-k;
  777. X        break;
  778. X      case 2:
  779. X        i = 2-i;  j = 2-j;
  780. X        break;
  781. X      case 3:
  782. X        k = i;  i = 2-j; j = k;
  783. X    }
  784. X    else if (g != RIP) {
  785. X    g -= id;
  786. X    if (g<0) g += 4;
  787. X    }
  788. X    fieldtoboard(g,i,j,x,y);
  789. X}
  790. X
  791. X
  792. X
  793. X
  794. X
  795. X/*********************************************************************
  796. X*
  797. X*   Synopsis
  798. X*    int fieldtoarr(id, f, fi, fj, ai, aj)
  799. X*        int id, f, fi, fj;
  800. X*        int *ai, *aj;
  801. X*
  802. X*   Arguments
  803. X*    id    0-3, the player of the board;
  804. X*    f    F0 - RIP, field number;
  805. X*    fi, fj    coordinates in the field;
  806. X*    *ai, *aj    result coordinates of the array;
  807. X*
  808. X*   Return value
  809. X*    returns which array is resulted
  810. X*
  811. X**********************************************************************/
  812. X
  813. Xint fieldtoarr(id, f, fi, fj, ai, aj)
  814. Xint id, f, fi, fj, *ai, *aj;
  815. X{
  816. X    *ai = fi;
  817. X    *aj = fj;
  818. X    if ( f==MIDFIELD )
  819. X    switch (id) {
  820. X      case 1:
  821. X        *ai = 2-fj; *aj = fi;
  822. X        break;
  823. X      case 2:
  824. X        *ai = 2 - fi; *aj = 2 - fj;
  825. X        break;
  826. X      case 3:
  827. X        *ai = fj;  *aj = 2 - fi;
  828. X    }
  829. X    return((f>=F0 && f<MIDFIELD) ? (f+id)%4 : f);
  830. X}
  831. X
  832. X
  833. X
  834. X/*********************************************************************
  835. X*
  836. X*   Synopsis
  837. X*    int boardtoarr(f, x, y, i, j)
  838. X*        int f, x, y, *i, *j;
  839. X*
  840. X*   Arguments
  841. X*    f    specifies who's board;
  842. X*    x, y    the coordinates on board;
  843. X*    *i, *j    return the coordinates in the array;
  844. X*
  845. X*   Return value
  846. X*    it returns which array the point corresponds.
  847. X*    returns -1 if no array to match.
  848. X*
  849. X**********************************************************************/
  850. X
  851. Xint boardtoarr(f, x, y, i, j)
  852. Xint f, x, y, *i, *j;
  853. X{
  854. X    int m, n, s;
  855. X
  856. X    s = boardtofield(x, y, &m, &n);
  857. X    if (s > RIP) return(-1);
  858. X    s = fieldtoarr(f, s, m, n, i, j);
  859. X    return(s);
  860. X}
  861. X
  862. X
  863. X
  864. X
  865. X/************************************************************************
  866. X*
  867. X*   Synopsis
  868. X*    int area_intersection(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2,
  869. X*        cx1, cy1, cx2, cy2)
  870. X*        int ax1, ay1, ax2, ay2, bx1, by1, bx2, by2;
  871. X*        int *cx1, *cy1, *cx2, *cy2;        return
  872. X*
  873. X*   Arguments
  874. X*    a's and b's:    coordinates of two rectangles;
  875. X*    c's        contains the coordinates of the intersection area;
  876. X*
  877. X*   Return values
  878. X*    1    if the two rectangles intersect, and c's are set;
  879. X*    0    if the two rectangles not intersect;
  880. X*
  881. X**************************************************************************/
  882. X
  883. Xint area_intersection(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2,
  884. X        cx1, cy1, cx2, cy2)
  885. Xint ax1, ay1, ax2, ay2, bx1, by1, bx2, by2, *cx1, *cy1, *cx2, *cy2;
  886. X{
  887. X    int k;
  888. X
  889. X    if (ax1>ax2) {
  890. X    k = ax1; ax1 = ax2; ax2 = k;
  891. X    }
  892. X    if (ay1>ay2) {
  893. X    k = ay1; ay1 = ay2; ay2 = k;
  894. X    }
  895. X    if (bx1>bx2) {
  896. X    k = bx1; bx1 = bx2; bx2 = k;
  897. X    }
  898. X    if (by1>by2) {
  899. X    k = by1; by1 = by2; by2 = k;
  900. X    }
  901. X    *cx2 = (ax2<bx2) ? ax2 : bx2;
  902. X    *cy2 = (ay2<by2) ? ay2 : by2;
  903. X    if (ax1<=bx1 && ay1<=by1 && bx1<ax2 && by1<ay2) {
  904. X    *cx1 = bx1;  *cy1 = by1;
  905. X    return(1);
  906. X    }
  907. X    if (ax1<=bx1 && ay1>by1 && ay1<by2 && ax2>bx1) {
  908. X    *cx1 = bx1; *cy1 = ay1;
  909. X    return(1);
  910. X    }
  911. X    if (ax1>bx1 && ay1>by1 && ax1<bx2 && ay1<by2) {
  912. X    *cx1 = ax1; *cy1 = ay1;
  913. X    return(1);
  914. X    }
  915. X    if (ax1>bx1 && ay1<by1 && ax1<bx2 && ay2>by1) {
  916. X    *cx1 = ax1; *cy1 = by1;
  917. X    return(1);
  918. X    }
  919. X    return(0);
  920. X}
  921. X
  922. X
  923. X
  924. X
  925. X/**********************************************************************
  926. X*
  927. X*   Synopsis
  928. X*    int sapper_check(i, x, y, z)
  929. X*        int i, x, y, z;
  930. X*
  931. X*   Arguments
  932. X*    i    start check from i of sap[];
  933. X*    x, y, z the destination;
  934. X*
  935. X*   Return values
  936. X*    0    if cannot reach destination;
  937. X*    1    if can reach destination;
  938. X*
  939. X*   Side effect
  940. X*    mark all visited nodes to round.
  941. X*
  942. X*   Description
  943. X*    it recursively checks if a SAPPER can reach a destination, starting
  944. X*    from a position in sap[i]; sap[i] must not have been visited, and
  945. X*    the starting position must not be the destination.
  946. X*
  947. X***********************************************************************/
  948. X
  949. Xint sapper_check(i, x, y, z)
  950. Xint i, x, y, z;
  951. X{
  952. X    int m, n, a, b, c, j;
  953. X
  954. X    sap[i].visited = round;
  955. X    m = 0;
  956. X    if (i<12) {
  957. X    a = i/3;
  958. X    c = 2*(i%3);
  959. X    if (c==0) {
  960. X        n = (a-1);
  961. X        if (n<0)  n = 3;
  962. X        if (y==0 && z==4 && x==n)  return(1);
  963. X        if (sap[n*3+2].visited != round && arr[n][0][4].value == EMPTY)
  964. X        m = sapper_check(n*3+2, x, y, z);
  965. X        if (m) return(1);
  966. X
  967. X        n = sap[i].neighbor[0];
  968. X        b = (n-12)/3;
  969. X        c = (n-12)%3;
  970. X        if (x==MIDFIELD && y==b && z==c)  return(1);
  971. X        if (sap[n].visited != round && mid[b][c].value == EMPTY)
  972. X        m = sapper_check(n, x, y, z);
  973. X        if (m) return(1);
  974. X
  975. X        if (x==a && y==0 && z==1)  return(1);
  976. X        if (arr[a][0][1].value == EMPTY) {
  977. X        if (x==a && y==0 && z==2)  return(1);
  978. X        if (sap[a*3+1].visited != round && arr[a][0][2].value == EMPTY)
  979. X            m = sapper_check(a*3+1, x, y, z);
  980. X        if (m) return(1);
  981. X        }
  982. X
  983. X        if (a==x || sap[a*3+2].visited != round) {
  984. X        if (a==x && z==0) {
  985. X            for (j=1; j<y; j++)
  986. X            if (arr[a][j][0].value != EMPTY) return(0);
  987. X            return(1);
  988. X        }
  989. X        for (j=1; j<5; j++)
  990. X            if (arr[a][j][0].value != EMPTY) return(0);
  991. X        if (a==x && y==4) {
  992. X            for (j=1; j<z; j++)
  993. X            if (arr[a][4][j].value != EMPTY) return(0);
  994. X            return(1);
  995. X        }
  996. X        for (j=1; j<5; j++)
  997. X            if (arr[a][4][j].value != EMPTY) return(0);
  998. X        if (a==x && z==4) {
  999. X            for (j=y+1; j<4; j++)
  1000. X            if (arr[a][j][4].value != EMPTY) return(0);
  1001. X            return(1);
  1002. X        }
  1003. X        if (sap[a*3+2].visited == round) return(0);
  1004. X        for (j=0; j<4; j++)
  1005. X            if (arr[a][j][4].value != EMPTY) return(0);
  1006. X        return(sapper_check(a*3+2, x, y, z));
  1007. X        }
  1008. X        return(0);
  1009. X    }
  1010. X    if (c==2) {
  1011. X        if (a==x && y==0 && z==1)  return(1);
  1012. X        if (arr[a][0][1].value == EMPTY) {
  1013. X        if (a==x && y==0 && z==0)  return(1);
  1014. X        if (sap[a*3].visited != round && arr[a][0][0].value == EMPTY)
  1015. X            m = sapper_check(a*3, x, y, z);
  1016. X        if (m) return(1);
  1017. X        }
  1018. X        n = sap[i].neighbor[0];
  1019. X        b = (n-12)/3;
  1020. X        c = (n-12)%3;
  1021. X        if (x==MIDFIELD && y==b && z==c)  return(1);
  1022. X        if (sap[n].visited != round && mid[b][c].value == EMPTY)
  1023. X        m = sapper_check(n, x, y, z);
  1024. X        if (m) return(1);
  1025. X
  1026. X        if (a==x && y==0 && z==3)  return(1);
  1027. X        if (arr[a][0][3].value == EMPTY) {
  1028. X        if (a==x && y==0 && z==4)  return(1);
  1029. X        if (sap[a*3+2].visited != round && arr[a][0][4].value == EMPTY)
  1030. X            m = sapper_check(a*3+2, x, y, z);
  1031. X        if (m) return(1);
  1032. X        }
  1033. X        return(0);
  1034. X    }
  1035. X    /* now c==4 */
  1036. X    if (a==x && y==0 && z==3)  return(1);
  1037. X    if (arr[a][0][3].value == EMPTY) {
  1038. X        if (a==x && y==0 && z==2)  return(1);
  1039. X        if (sap[a*3+1].visited != round && arr[a][0][2].value == EMPTY)
  1040. X        m = sapper_check(a*3+1, x, y, z);
  1041. X        if (m) return(1);
  1042. X    }
  1043. X    n = sap[i].neighbor[0];
  1044. X    b = (n-12)/3;
  1045. X    c = (n-12)%3;
  1046. X    if (x==MIDFIELD && b==y && c==z)  return(1);
  1047. X    if (sap[n].visited != round && mid[b][c].value == EMPTY)
  1048. X        m = sapper_check(n, x, y, z);
  1049. X    if (m) return(1);
  1050. X    n = (a+1)%4;
  1051. X    if (x==n && y==0 && z==0)  return(1);
  1052. X    if (sap[n*3].visited != round && arr[n][0][0].value == EMPTY)
  1053. X        m = sapper_check(n*3, x, y, z);
  1054. X    if (m) return(1);
  1055. X
  1056. X    if (sap[a*3].visited != round || a==x) {
  1057. X        if (a==x && z==4) {
  1058. X        for (j=1; j<y; j++)
  1059. X            if (arr[a][j][4].value != EMPTY) return(0);
  1060. X        return(1);
  1061. X        }
  1062. X        for (j=1; j<5; j++)
  1063. X        if (arr[a][j][4].value != EMPTY) return(0);
  1064. X        if (a==x && y==4) {
  1065. X        for (j=z+1; j<4; j++)
  1066. X            if (arr[a][4][j].value != EMPTY) return(0);
  1067. X        return(1);
  1068. X        }
  1069. X        for (j=0; j<4; j++)
  1070. X        if (arr[a][4][j].value != EMPTY) return(0);
  1071. X        if (a==x && z==0) {
  1072. X        for (j=y+1; j<4; j++)
  1073. X            if (arr[a][j][0].value != EMPTY) return(0);
  1074. X        return(1);
  1075. X        }
  1076. X        if (sap[a*3].visited == round) return(0);
  1077. X        for (j=0; j<4; j++)
  1078. X        if (arr[a][j][0].value != EMPTY) return(0);
  1079. X        return(sapper_check(a*3, x, y, z));
  1080. X    }
  1081. X    return(0);
  1082. X    }
  1083. X    else {    /* starting position in the MIDFIELD */
  1084. X    j = 0;
  1085. X    while (!m && j<4) {
  1086. X        n = sap[i].neighbor[j];
  1087. X        if (sap[n].visited != round)
  1088. X        if (n<12) {
  1089. X            a = n/3;
  1090. X            c = 2*(n%3);
  1091. X            if (x==a && y==0 && z==c) return(1);
  1092. X            if (arr[a][0][c].value == EMPTY)
  1093. X            m = sapper_check(n, x, y, z);
  1094. X        }
  1095. X        else {
  1096. X            b = (n-12)/3;
  1097. X            c = (n-12)%3;
  1098. X            if (x==MIDFIELD && y==b && z==c)  return(1);
  1099. X            if (mid[b][c].value == EMPTY)
  1100. X            m = sapper_check(n, x, y, z);
  1101. X        }
  1102. X        j++;
  1103. X    }
  1104. X    return(m);
  1105. X    }
  1106. X}
  1107. X
  1108. X
  1109. X
  1110. X
  1111. X
  1112. X
  1113. X
  1114. X
  1115. X/**********************************************************************
  1116. X*
  1117. X*   Synopsis
  1118. X*    int valid_move(a, b, c, x, y, z)
  1119. X*        int a, b, c, x, y, z;
  1120. X*
  1121. X*   Return values
  1122. X*    1    for valid move;
  1123. X*    0    for invalid move;
  1124. X*
  1125. X*   Description
  1126. X*    It checks if a move as (a,b,c)=>(x,y,z) is valid according to
  1127. X*    the positions;
  1128. X*
  1129. X***********************************************************************/
  1130. X
  1131. Xint valid_move(a, b, c, x, y, z)
  1132. Xint a, b, c, x, y, z;
  1133. X{
  1134. X    int m, n, i, l;
  1135. X
  1136. X    if ((a<MIDFIELD && x<MIDFIELD) && (b==5 || y==5 ||
  1137. X        (0<b && b<4 && 0<c && c<4) || (0<y && y<4 && 0<z && z<4))) {
  1138. X    /* can move only one step far */
  1139. X    if (a != x) return(0);
  1140. X    m = abs(b-y) + abs(c-z);
  1141. X    if (m<=2 && (((b==1 || b==3) && (c==1 || c==3)) || (b==2 && c==2) ||
  1142. X             ((y==1 || y==3) && (z==1 || z==3)) || (y==2 && z==2)))
  1143. X        return(1);
  1144. X    if (m == 1) return(1);
  1145. X    else return(0);
  1146. X    }
  1147. X
  1148. X/* from now on, the source and the destination are both on the railway */
  1149. X    if (a==MIDFIELD && mid[b][c].value == SAPPER ||
  1150. X    a<MIDFIELD && arr[a][b][c].value == SAPPER) {
  1151. X    round++;
  1152. X    m = 0;
  1153. X    if (a<MIDFIELD && (b!=0 || (b==0 && (c==1 || c==3)))) {
  1154. X        if (b==0)
  1155. X        if (c==1) {
  1156. X            if (x==a && y==0 && (z==0 || z==2)) return(1);
  1157. X            if (arr[a][0][0].value == EMPTY)
  1158. X            m = sapper_check(a*3, x, y, z);
  1159. X            if (m) return(1);
  1160. X            if (sap[a*3+1].visited!=round && arr[a][0][2].value==EMPTY)
  1161. X            m = sapper_check(a*3+1, x, y, z);
  1162. X            return(m);
  1163. X        }
  1164. X        else {
  1165. X            if (x==a && y==0 && (z==2 || z==4)) return(1);
  1166. X            if (arr[a][0][2].value != EMPTY)
  1167. X            m = sapper_check(a*3+1, x, y, z);
  1168. X            if (m) return(1);
  1169. X            if (sap[a*3+2].visited!=round && arr[a][0][4].value==EMPTY)
  1170. X            m = sapper_check(a*3+2, x, y, z);
  1171. X            return(m);
  1172. X        }
  1173. X        else
  1174. X        if (c==0 || c==4) {
  1175. X            if (a==x && z==c && y<b) {
  1176. X            for (i=y+1; i<b; i++)
  1177. X                if (arr[a][i][c].value != EMPTY) break;
  1178. X            if (i==b) return(1);
  1179. X            }
  1180. X            else {
  1181. X            for (i=0; i<b; i++)
  1182. X                if (arr[a][i][c].value != EMPTY) break;
  1183. X            if (i==b)
  1184. X                m = sapper_check(a*3+(c/2), x, y, z);
  1185. X            if (m) return(1);
  1186. X            }
  1187. X            if (a==x || sap[a*3].visited != round ||
  1188. X                sap[a*3+2].visited != round) {
  1189. X            if (a==x && z==c && y>b) {
  1190. X                for (i=b+1; i<y; i++)
  1191. X                if (arr[a][i][c].value != EMPTY) return(0);
  1192. X                return(1);
  1193. X            }
  1194. X            for (i=b+1; i<5; i++)
  1195. X                if (arr[a][i][c].value != EMPTY) return(0);
  1196. X            if (a==x && y==4)
  1197. X                if (c==0) {
  1198. X                for (i=1; i<z; i++)
  1199. X                    if (arr[a][4][i].value != EMPTY) return(0);
  1200. X                return(1);
  1201. X                }
  1202. X                else {
  1203. X                for (i=z+1; i<4; i++)
  1204. X                    if (arr[a][4][i].value != EMPTY) return(0);
  1205. X                return(1);
  1206. X                }
  1207. X            n = (c==0) ? 1 : 0;
  1208. X            for (i=0; i<4; i++)
  1209. X                if (arr[a][4][i+n].value != EMPTY) return(0);
  1210. X            n = (c==0) ? 4 : 0;
  1211. X            if (a==x && n==z) {
  1212. X                for (i=y+1; i<4; i++)
  1213. X                if (arr[a][i][n].value != EMPTY) return(0);
  1214. X                return(1);
  1215. X            }
  1216. X            if (sap[a*3+n/2].visited == round) return(0);
  1217. X            for (i=0; i<4; i++)
  1218. X                if (arr[a][i][n].value != EMPTY) return(0);
  1219. X            return(sapper_check(a*3+n/2, x, y, z));
  1220. X            }
  1221. X            return(0);
  1222. X        }
  1223. X        else {        /* starting point is at the second bottom line */
  1224. X            if (a==x && y==4 && z<c) {
  1225. X            for (i=z+1; i<c; i++)
  1226. X                if (arr[a][4][i].value != EMPTY) break;
  1227. X            if (i==c) return(1);
  1228. X            }
  1229. X            else
  1230. X            for (i=0; i<c; i++)
  1231. X                if (arr[a][4][i].value != EMPTY) break;
  1232. X            if (i==c) {
  1233. X            if (a==x && y<4 && z==0) {
  1234. X                for (i=y+1; i<4; i++)
  1235. X                if (arr[a][i][0].value != EMPTY) break;
  1236. X                if (i==4) return(1);
  1237. X            }
  1238. X            else
  1239. X                for (i=0; i<4; i++)
  1240. X                if (arr[a][i][0].value != EMPTY) break;
  1241. X            if (i==4) {
  1242. X                m = sapper_check(a*3, x, y, z);
  1243. X                if (m) return(1);
  1244. X            }
  1245. X            }
  1246. X            if (a==x || sap[a*3].visited != round ||
  1247. X                sap[a*3+2].visited != round) {
  1248. X            if (a==x && y==4 && z>c) {
  1249. X                for (i=c+1; i<z; i++)
  1250. X                if (arr[a][4][i].value != EMPTY) return(0);
  1251. X                return(1);
  1252. X            }
  1253. X            for (i=c+1; i<5; i++)
  1254. X                if (arr[a][4][i].value != EMPTY) return(0);
  1255. X            if (a==x && y<4 && z==4) {
  1256. X                for (i=y+1; i<4; i++)
  1257. X                if (arr[a][i][4].value != EMPTY) return(0);
  1258. X                return(1);
  1259. X            }
  1260. X            if (sap[a*3+2].visited==round) return(0);
  1261. X            for (i=0; i<4; i++)
  1262. X                if (arr[a][i][4].value != EMPTY) return(0);
  1263. X            return(sapper_check(a*3+2, x, y, z));
  1264. X            }
  1265. X            return(0);
  1266. X        }
  1267. X    }
  1268. X    else
  1269. X        if (a<4)  return(sapper_check(a*3+c/2, x, y, z));
  1270. X        else return(sapper_check(12+b*3+c, x, y, z));
  1271. X    }
  1272. X
  1273. X
  1274. X/* now the moving node is not a SAPPER */
  1275. X
  1276. X    if (a<MIDFIELD && a==x) {
  1277. X    if (b==y && (b==0 || b==4)) {
  1278. X        if (c < z) {
  1279. X        m = c;  n = z;
  1280. X        }
  1281. X        else {
  1282. X        m = z;  n = c;
  1283. X        }
  1284. X        for (i=m+1; i<n; i++)
  1285. X        if (arr[a][b][i].value != EMPTY)  return(0);
  1286. X        return(1);
  1287. X    }
  1288. X    else if (c==z && (c==0 || c==4)) {
  1289. X        if (b < y) {
  1290. X        m = b;  n = y;
  1291. X        }
  1292. X        else {
  1293. X        m = y;  n = b;
  1294. X        }
  1295. X        for (i=m+1; i<n; i++)
  1296. X        if (arr[a][i][c].value != EMPTY) return(0);
  1297. X        return(1);
  1298. X    }
  1299. X    else return(0);
  1300. X    }
  1301. X
  1302. X/* from now on the source and the destination are on different fields */
  1303. X    if (a != MIDFIELD)
  1304. X    if (c==0 || c==4) {
  1305. X        for (i=0; i<b; i++)
  1306. X        if (arr[a][i][c].value != EMPTY) return(0);
  1307. X    }
  1308. X    else
  1309. X        if (b!=0 || c!=2) return(0);
  1310. X    if (x != MIDFIELD)
  1311. X    if (z==0 || z==4) {
  1312. X        for (i=0; i<y; i++)
  1313. X        if (arr[x][i][z].value != EMPTY) return(0);
  1314. X    }
  1315. X    else
  1316. X        if (y!=0 || z!=2) return(0);
  1317. X
  1318. X    if (a<MIDFIELD && x<MIDFIELD) {
  1319. X    if ((x+1)%4 == a)
  1320. X        if (z==4 && c==0)  return(1);
  1321. X        else return(0);
  1322. X    else if ((a+1)%4 == x)
  1323. X        if (z==0 && c==4) return(1);
  1324. X        else return(0);
  1325. X    if (!((c==0 && z==4) || (c==4 && z==0) || (c==2 && z==2)))
  1326. X        return(0);
  1327. X    }
  1328. X
  1329. X/* now the move has to go across the MIDFIELD */
  1330. X    if ((a<MIDFIELD && a%2==0) || (x<MIDFIELD && x%2==0) ||
  1331. X    (a==MIDFIELD && x==MIDFIELD && c==z)) {
  1332. X    if (a != MIDFIELD) {
  1333. X        if (a==F0) {
  1334. X        l = c/2;
  1335. X        n = 2;
  1336. X        m = (x==MIDFIELD) ? (y+1) : 0;
  1337. X        }
  1338. X        else {
  1339. X        l = (4-c)/2;
  1340. X        m = 0;
  1341. X        n = (x==MIDFIELD) ? (y-1) : 2;
  1342. X        }
  1343. X        if (x==MIDFIELD && l!=z) return(0);
  1344. X    }
  1345. X    else
  1346. X        if (x != MIDFIELD) {
  1347. X        if (x==F0) {
  1348. X            l = z/2;
  1349. X            m = b+1;
  1350. X            n = 2;
  1351. X        }
  1352. X        else {
  1353. X            l = (4-z)/2;
  1354. X            m = 0;
  1355. X            n = b-1;
  1356. X        }
  1357. X        if (l != c)  return(0);
  1358. X        }
  1359. X        else {
  1360. X        l = z;
  1361. X        if (b<y) {
  1362. X            m = b+1; n = y-1;
  1363. X        }
  1364. X        else {
  1365. X            m = y+1; n = b-1;
  1366. X        }
  1367. X        }
  1368. X
  1369. X    for (i=m; i<=n; i++)
  1370. X        if (mid[i][l].value != EMPTY) return(0);
  1371. X    return(1);
  1372. X    }
  1373. X
  1374. X    if ((a<MIDFIELD && a%2!=0) || (x<MIDFIELD && x%2!=0) ||
  1375. X    (a==MIDFIELD && x==MIDFIELD && b==y)) {
  1376. X    if (a != MIDFIELD) {
  1377. X        if (a==F1) {
  1378. X        l = (4-c)/2;
  1379. X        n = 2;
  1380. X        m = (x==MIDFIELD) ? (z+1) : 0;
  1381. X        }
  1382. X        else {
  1383. X        l = c/2;
  1384. X        m = 0;
  1385. X        n = (x==MIDFIELD) ? (z-1) : 2;
  1386. X        }
  1387. X        if (x == MIDFIELD && l != y) return(0);
  1388. X    }
  1389. X    else
  1390. X        if (x != MIDFIELD) {
  1391. X        if (x==F1) {
  1392. X            l = (4-z)/2;
  1393. X            m = c+1;
  1394. X            n = 2;
  1395. X        }
  1396. X        else {
  1397. X            l = z/2;
  1398. X            m = 0;
  1399. X            n = c-1;
  1400. X        }
  1401. X        if (l != b)  return(0);
  1402. X        }
  1403. X        else {
  1404. X        l = b;
  1405. X        if (c<z) {
  1406. X            m = c+1; n = z-1;
  1407. X        }
  1408. X        else {
  1409. X            m = z+1; n = c-1;
  1410. X        }
  1411. X        }
  1412. X
  1413. X
  1414. X    for (i=m; i<=n; i++)
  1415. X        if (mid[l][i].value != EMPTY) return(0);
  1416. X    return(1);
  1417. X    }
  1418. X
  1419. X    return(0);
  1420. X}
  1421. X
  1422. X
  1423. X/*************************************************************************
  1424. X*
  1425. X*   Synopsis
  1426. X*    initial_sapper()
  1427. X*
  1428. X*   Description
  1429. X*    initializes the array 'sap' of the sapper move checking path.
  1430. X*
  1431. X**************************************************************************/
  1432. X
  1433. Xinitial_sapper()
  1434. X{
  1435. X    int i;
  1436. X
  1437. X    round = 0;
  1438. X
  1439. X    for (i=0; i<21; i++)
  1440. X    sap[i].visited = 0;
  1441. X
  1442. X    sap[0].neighbor[0] = 18;
  1443. X    sap[1].neighbor[0] = 19;
  1444. X    sap[2].neighbor[0] = 20;
  1445. X    sap[3].neighbor[0] = 20;
  1446. X    sap[4].neighbor[0] = 17;
  1447. X    sap[5].neighbor[0] = 14;
  1448. X    sap[6].neighbor[0] = 14;
  1449. X    sap[7].neighbor[0] = 13;
  1450. X    sap[8].neighbor[0] = 12;
  1451. X    sap[9].neighbor[0] = 12;
  1452. X    sap[10].neighbor[0] = 15;
  1453. X    sap[11].neighbor[0] = 18;
  1454. X
  1455. X    sap[12].neighbor[0] = 9;
  1456. X    sap[12].neighbor[1] = 8;
  1457. X    sap[12].neighbor[2] = 13;
  1458. X    sap[12].neighbor[3] = 15;
  1459. X    sap[13].neighbor[0] = 12;
  1460. X    sap[13].neighbor[1] = 7;
  1461. X    sap[13].neighbor[2] = 14;
  1462. X    sap[13].neighbor[3] = 16;
  1463. X    sap[14].neighbor[0] = 13;
  1464. X    sap[14].neighbor[1] = 6;
  1465. X    sap[14].neighbor[2] = 5;
  1466. X    sap[14].neighbor[3] = 17;
  1467. X
  1468. X    sap[15].neighbor[0] = 10;
  1469. X    sap[15].neighbor[1] = 12;
  1470. X    sap[15].neighbor[2] = 16;
  1471. X    sap[15].neighbor[3] = 18;
  1472. X    sap[16].neighbor[0] = 15;
  1473. X    sap[16].neighbor[1] = 13;
  1474. X    sap[16].neighbor[2] = 17;
  1475. X    sap[16].neighbor[3] = 19;
  1476. X    sap[17].neighbor[0] = 16;
  1477. X    sap[17].neighbor[1] = 14;
  1478. X    sap[17].neighbor[2] = 4;
  1479. X    sap[17].neighbor[3] = 20;
  1480. X
  1481. X    sap[18].neighbor[0] = 11;
  1482. X    sap[18].neighbor[1] = 15;
  1483. X    sap[18].neighbor[2] = 19;
  1484. X    sap[18].neighbor[3] = 0;
  1485. X    sap[19].neighbor[0] = 18;
  1486. X    sap[19].neighbor[1] = 16;
  1487. X    sap[19].neighbor[2] = 20;
  1488. X    sap[19].neighbor[3] = 1;
  1489. X    sap[20].neighbor[0] = 19;
  1490. X    sap[20].neighbor[1] = 17;
  1491. X    sap[20].neighbor[2] = 3;
  1492. X    sap[20].neighbor[3] = 2;
  1493. X}
  1494. X
  1495. X
  1496. X
  1497. END_OF_FILE
  1498. if test 21847 -ne `wc -c <'war.c'`; then
  1499.     echo shar: \"'war.c'\" unpacked with wrong size!
  1500. fi
  1501. # end of 'war.c'
  1502. fi
  1503. if test -f 'war.h' -a "${1}" != "-c" ; then 
  1504.   echo shar: Will not clobber existing file \"'war.h'\"
  1505. else
  1506. echo shar: Extracting \"'war.h'\" \(1767 characters\)
  1507. sed "s/^X//" >'war.h' <<'END_OF_FILE'
  1508. X#define DEFAULT_BOARD_BG "gray"
  1509. X#define DEFAULT_BOARD_FG "black"
  1510. X#define PLAYER0_COLOR "red"
  1511. X#define PLAYER1_COLOR "black"
  1512. X#define PLAYER2_COLOR "blue"
  1513. X#define PLAYER3_COLOR "purple"
  1514. X
  1515. X#define DIMENSION 870
  1516. X
  1517. X#define P1    35
  1518. X#define P2    285
  1519. X#define P3    335
  1520. X#define P4    535
  1521. X#define P5    585
  1522. X#define P6    835
  1523. X
  1524. X#define TALK_WIDTH 250
  1525. X#define TALK_HEIGHT 60
  1526. X#define TALK_Y    135        /* the y-coordinate for the upper talk
  1527. X                 * boxes. the lower talk box's is
  1528. X                 * TALK_Y+TALK_HEIGHT+30.
  1529. X                 */
  1530. X#define TALK_L_X P1
  1531. X#define TALK_R_X P5
  1532. X#define TALK_X_INC 9        /* char gap in x-direction of talk
  1533. X                 * string.
  1534. X                 */
  1535. X#define TALK_Y_INC 20
  1536. X#define TALK0_X  P1+5        /* talk string's x-coordinate for
  1537. X                 * player 0
  1538. X                 */
  1539. X#define TALK0_Y  TALK_Y+15
  1540. X#define TALK1_X  P5+5
  1541. X#define TALK1_Y  TALK_Y+15
  1542. X#define TALK2_X  P1+5
  1543. X#define TALK2_Y  TALK_Y+105
  1544. X#define TALK3_X  P5+5
  1545. X#define TALK3_Y  TALK_Y+105
  1546. X
  1547. X#define RIP_Y    585
  1548. X#define RIP_DIMENSION 250
  1549. X
  1550. X#define BUTTON_WIDTH 100
  1551. X#define BUTTON_HEIGHT 25
  1552. X#define BUTTON_X  685
  1553. X#define NEW_Y    610
  1554. X#define BUTTON_DIS  40
  1555. X
  1556. X#define MSG_BOX_X P5
  1557. X#define MSG_BOX_Y P1
  1558. X#define MSG_WIDTH 250
  1559. X#define MSG_HEIGHT 50
  1560. X#define MSG_X    592
  1561. X#define MSG_Y    53
  1562. X
  1563. X#define MAX_MSG 27
  1564. X
  1565. X#define SIGN_DIMENSION 64
  1566. X
  1567. X#define EMPTY -1
  1568. X#define COLOURS 0
  1569. X#define SAPPER 1
  1570. X#define F_LIEUTENANT 2
  1571. X#define CAPTAIN 3
  1572. X#define MAJOR 4
  1573. X#define COLONEL 5
  1574. X#define BRIGADIER 6
  1575. X#define M_GENERAL 7
  1576. X#define GENERAL 8
  1577. X#define MARSHAL 9
  1578. X#define MINE 10
  1579. X#define BOMB 11
  1580. X
  1581. X#define F0 0
  1582. X#define F1 1
  1583. X#define F2 2
  1584. X#define F3 3
  1585. X#define MIDFIELD 4
  1586. X#define RIP 5
  1587. X#define NEW 6
  1588. X#define READY 7
  1589. X#define REDEPLOY 8
  1590. X#define PEACE 9
  1591. X#define SURRENDER 10
  1592. X#define QUIT 11
  1593. X#define OTHERPLACE 12
  1594. X
  1595. X
  1596. Xtypedef struct {
  1597. X    int id;
  1598. X    int value;
  1599. X} Arr;
  1600. X
  1601. X
  1602. Xtypedef struct {
  1603. X    int neighbor[4];
  1604. X    int visited;
  1605. X} Sapper_path;
  1606. X
  1607. X
  1608. X
  1609. END_OF_FILE
  1610. if test 1767 -ne `wc -c <'war.h'`; then
  1611.     echo shar: \"'war.h'\" unpacked with wrong size!
  1612. fi
  1613. # end of 'war.h'
  1614. fi
  1615. if test -f 'x4war.man' -a "${1}" != "-c" ; then 
  1616.   echo shar: Will not clobber existing file \"'x4war.man'\"
  1617. else
  1618. echo shar: Extracting \"'x4war.man'\" \(5622 characters\)
  1619. sed "s/^X//" >'x4war.man' <<'END_OF_FILE'
  1620. X.TH X4WAR 6 "3-Mar-92"
  1621. X.SH NAME
  1622. Xx4war \- An X version of the Chinese four-state-war game.
  1623. X.SH SYNOPSIS
  1624. X.B x4war
  1625. X\ [options]
  1626. X.br
  1627. X.SH DESCRIPTION
  1628. X.I x4war
  1629. Xis a game like the Chinese board game, four-state-war. It involves four players,
  1630. Xtwo players at the opposite position of the board play an ally and are against the
  1631. Xother two. It runs under X Window environment. At First, players deploy their
  1632. Xarmy on their own fields, then a war can be started after all have deployed
  1633. Xtheir army correctly. During the war, each moves one of his/her node in turn.
  1634. XThe goal of the war is to capture the COLOURS of the opponents.
  1635. X.LP
  1636. XBy default, players are named 'PLAYER 0' through 'PLAYER 3', their positions on
  1637. Xthe board are sequenced counter-clockwise, PLAYER 0 and PLAYER 2 forms an ally
  1638. Xand are against the ally of PLAYER 1 and PLAYER 3.
  1639. X.PP
  1640. X.SH OPTIONS
  1641. X.TP
  1642. X.BI \-p "i string"
  1643. XSpecifies player
  1644. X.I i
  1645. X\'s name.
  1646. X.I i
  1647. Xis between 0 - 3, default to "PLAYER \fIi".
  1648. X.TP
  1649. X.BI \-c "i string"
  1650. XSpecifies the color of player
  1651. X.I i
  1652. X\'s node.
  1653. X.I i
  1654. Xis between 0 - 3.
  1655. X.TP
  1656. X.BI \-d "i string"
  1657. XSpecifies the display of player
  1658. X.I i.
  1659. X.TP
  1660. X.BI \-debug
  1661. XA default deploy.
  1662. X.TP
  1663. X.BI \-usage
  1664. XGives the command options.
  1665. X.PP
  1666. X.SH USAGE
  1667. XPress a button on your own node to move it, release the button at a position
  1668. Xand the node will be placed there if it constitutes a valid move. When a war
  1669. Xhas started, the players take turns to make a move. You can move your node if
  1670. Xan arrow is shown in the upper-left corner of the board. A broken arrow there
  1671. Xmeans that it's not your turn to move.
  1672. X.LP
  1673. XSome rules during a war session are set by the program:
  1674. X.RS
  1675. X.IP
  1676. XThe COLOURS and MINEs can not be moved; a node deployed in the 'base'(the two
  1677. Xnon-rectangular positions at the button line of the board) cannot be moved.
  1678. X.IP
  1679. XA node moved into the base will be killed.
  1680. X.IP
  1681. XA SAPPER can safely remove a MINE.
  1682. X.IP
  1683. XA BOMB will go with any node including a MINE.
  1684. X.IP
  1685. XAny nodes other than a SAPPER or a BOMB meet a MINE will be killed and the
  1686. XMINE is not destroyed.
  1687. X.IP
  1688. XIf a player's MARSHAL is killed, his/her COLOURS will be shown faced up at
  1689. Xother player's board.
  1690. X.IP
  1691. XA node in 'safe depot'(circled positions on the board) cannot be attacked.
  1692. X.IP
  1693. XA node cannot move over other nodes.
  1694. X.IP
  1695. XA node can go only one step if not moving on the railway, it can move several
  1696. Xsteps on the railway.
  1697. X.IP
  1698. XExcept for a SAPPER, the direction of a move cannot be changed. (the direction
  1699. Xis a straight line, or from your left line to the right line of the field on
  1700. Xyour left, or from your right line to the left line of the field on your right)
  1701. X.RE
  1702. X.LP
  1703. XOther rules can be set by players.
  1704. X.LP
  1705. XThe message box at the upper-right corner of the board shows each move and the
  1706. Xfighting result. For a coordinates
  1707. X.I (w, x, y),
  1708. Xit is defined from the view of the player 0's board as follows:
  1709. X.RS
  1710. X.TP 3
  1711. X.I w
  1712. Xspecifies which field. Player
  1713. X.I i
  1714. X\'s field is numbered
  1715. X.I i (i in 0-3),
  1716. Xthe middle field is numbered 4.
  1717. X.LP
  1718. X.I x
  1719. Xand
  1720. X.I y
  1721. Xspecify rows and columns in each field,
  1722. Xrespectively, which are in 0-6 and 0-5 for rows and columns in players fields
  1723. Xand 0-2 for both rows and columns in the middle field.
  1724. X.RE
  1725. X.LP
  1726. XThe four talk boxes can be used for talking purposes. key input is shown in the
  1727. Xcorresponding box at all players screen.
  1728. X.LP
  1729. XThe functions of buttons at the bottom-right of the board are as follows:
  1730. X.TP
  1731. X.B NEW GAME
  1732. XStarts a new game after one game of war is over, then players can deploy their
  1733. Xnodes to their field for the new war.
  1734. X.IP
  1735. XSome deploy restrictions:
  1736. X.RS
  1737. X.IP .
  1738. Xthe COLOURS can be deployed only in one of the 'base's;
  1739. X.IP .
  1740. Xa MINE can be deployed only at the bottom two lines;
  1741. X.IP .
  1742. Xno node can be deployed in the 'safe depot'.
  1743. X.RE
  1744. X.IP
  1745. XOther restrictions can be set by players. (such as: a BOMB cannot be at the
  1746. Xfirst line)
  1747. X.TP
  1748. X.B START WAR
  1749. XAfter you have deployed your army, you press this button to get ready for the
  1750. Xwar. After all four players have pressed the button, the war gets started and
  1751. Xthe one in his/her turn can move a node.
  1752. X.TP
  1753. X.B REDEPLOY
  1754. XRe-deploy your army after you pressed
  1755. X.B "START WAR"
  1756. Xbutton and before all players have pressed that button. After re-deploy, you
  1757. Xshould press
  1758. X.B "START WAR"
  1759. Xagain.
  1760. X.TP
  1761. X.B PEACE
  1762. XRequesting for peace during the war. Then a dialog box is shown on the other
  1763. Xplayer's screen, the others have to answer the request. If one answered NO,
  1764. Xthe war will continue.
  1765. X.TP
  1766. X.B SURRENDER
  1767. XIf you surrender, all your nodes are moved and all nodes on your board will be
  1768. Xshown faced up so that you can watch the rest of the war. (seems not a bad
  1769. Xchoice to enjoy other players battle tactics at the lose of your dignity)
  1770. X.TP
  1771. X.B QUIT   
  1772. XIf you have been defeated, your quit will not affect the battle, otherwise you
  1773. Xcan only use it in your turn, and it will cause every one to quit.
  1774. X.LP
  1775. XA brief example session is like:
  1776. X.RS
  1777. X.IP 1.
  1778. Xget four people and four displays.
  1779. X.IP 2.
  1780. Xrun the program, set the board to different displays.
  1781. X.IP 3.
  1782. Xeach deploys his/her army correctly and then presses START WAR.
  1783. X.IP 4.
  1784. Xafter all have pressed START WAR, the war began and the first one can move.
  1785. X.IP 5.
  1786. Xfight a decisive battle, have fun!
  1787. X.RE
  1788. X.LP
  1789. XOne way to play a two persons game.
  1790. X.RS
  1791. X.IP 1.
  1792. Xstart the program with '-debug' option, this will cause a default deploy to
  1793. Xappear on four boards.
  1794. X.IP 2.
  1795. Xre-deploy the army in your field.
  1796. X.IP 3.
  1797. Xpress START WAR on all four boards to start a war.
  1798. X.IP 4.
  1799. Xsurrender the two armies you don't play.
  1800. X.IP 5.
  1801. Xnow have a two players game.
  1802. X.RE
  1803. X.PP
  1804. X.SH SEE ALSO
  1805. XA Chinese guy or anybody who can read Chinese characters and knows the
  1806. Xconventional rules about the war game.
  1807. X.PP
  1808. X.SH AUTHOR
  1809. XXiaobing Chen, xiaobing@cs.sfu.ca  Feb. 25, 1992
  1810. X
  1811. X
  1812. END_OF_FILE
  1813. if test 5622 -ne `wc -c <'x4war.man'`; then
  1814.     echo shar: \"'x4war.man'\" unpacked with wrong size!
  1815. fi
  1816. # end of 'x4war.man'
  1817. fi
  1818. echo shar: End of archive 2 \(of 3\).
  1819. cp /dev/null ark2isdone
  1820. MISSING=""
  1821. for I in 1 2 3 ; do
  1822.     if test ! -f ark${I}isdone ; then
  1823.     MISSING="${MISSING} ${I}"
  1824.     fi
  1825. done
  1826. if test "${MISSING}" = "" ; then
  1827.     echo You have unpacked all 3 archives.
  1828.     rm -f ark[1-9]isdone
  1829. else
  1830.     echo You still need to unpack the following archives:
  1831.     echo "        " ${MISSING}
  1832. fi
  1833. ##  End of shell archive.
  1834. exit 0
  1835.