home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / games / volume13 / engarde / part01 < prev    next >
Encoding:
Internet Message Format  |  1992-02-10  |  55.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: v13i024:  engarde - an X/MOTIF strategy game involving "magnets", Part01/02
  5. Message-ID: <2343@masterCNA.TEK.COM>
  6. Date: 25 Jan 92 01:24:03 GMT
  7. Sender: news@masterCNA.TEK.COM
  8. Lines: 1693
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: Bill James <wjames@Jupiter.SAIC.COM>
  12. Posting-number: Volume 13, Issue 24
  13. Archive-name: engarde/Part01
  14. Environment: SUNOS SYSVR4 X11R4 MOTIF Sun HP
  15.  
  16. [From the author...]
  17. [[  This game is evolved from a board game called Touche, with
  18. some changes in rules and concepts that make the game harder
  19. to master and easier to play.  It's my first project in X/MOTIF,
  20. so enjoy it.]]
  21.  
  22. #! /bin/sh
  23. # This is a shell archive.  Remove anything before this line, then unpack
  24. # it by saving it into a file and typing "sh file".  To overwrite existing
  25. # files, type "sh file -c".  You can also feed this as standard input via
  26. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  27. # will see the following message at the end:
  28. #        "End of archive 1 (of 2)."
  29. # Contents:  README MANIFEST bitmaps.h board.c engarde.c help.h
  30. #   xboard.c xboard.h
  31. # Wrapped by billr@saab on Fri Jan 24 17:21:01 1992
  32. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  33. if test -f 'README' -a "${1}" != "-c" ; then 
  34.   echo shar: Will not clobber existing file \"'README'\"
  35. else
  36. echo shar: Extracting \"'README'\" \(2884 characters\)
  37. sed "s/^X//" >'README' <<'END_OF_FILE'
  38. X            Engarde v1.0
  39. X                           by Bill James, 1992
  40. X-----------------------------------------------------------------------
  41. X
  42. XThis game was written in C, compiled by the SUN C compiler (cc), and
  43. Xuses X11R4 and OSF/MOTIF v1.1 function calls.  The current list of
  44. Xarchitectures under which it has been run are:
  45. X
  46. XSun SparcStation (1,2,SLC,ELC)
  47. XHewlett-Packard Series 9000/300
  48. XHewlett-Packard Apollo Series 700
  49. X
  50. X
  51. XSome lines you may want to add to your .Xdefaults are:
  52. X
  53. XEnGarde.geometry:    700x500+100+100
  54. XEnGarde*Menu*fontList: -adobe-helvetica-bold-o-normal--17-120-100-100-p-92-iso8859-1
  55. XEnGarde*Message.fontList: -adobe-new century schoolbook-medium-i-normal--17-120-100-100-p-92-iso8859-1
  56. XEnGarde*HelpText.fontList: -b&h-lucidatypewriter-medium-r-normal-sans-17-120-100-100-m-100-iso8859-1
  57. XEnGarde*HelpOk*fontList: -adobe-new century schoolbook-medium-i-normal--17-120-100-100-p-92-iso8859-1
  58. XEnGarde*About*fontList: -sony-fixed-medium-r-normal--24-170-100-100-c-120-iso8859-1
  59. X
  60. XNOTE: the HelpText.fontList font MUST be fixed width.
  61. XNOTE: the geometry MUST be bigger than 200x200 for the game to 
  62. X        work correctly, you'll want it bigger if you want it
  63. X        to look good.
  64. X
  65. XIf you don't have the fonts listed, feel free to change them.
  66. X
  67. XNOTE: changing other resources has not been tested, so if it doesn't
  68. Xwork, send me a suggestion about adding that to the list of changeable
  69. Xresources.
  70. X
  71. X
  72. X
  73. X/********************DISCLAIMER*************************************/
  74. X
  75. XThis software is distributed AS IS, and no guarantees about it's 
  76. Xperformance or compatibility are issued.  If you find bugs or
  77. Xhave suggestions (other than "make it color",etc. I can come up
  78. Xwith those myself), please send them to wjames@jupiter.saic.com .
  79. X
  80. X/*******************************************************************/
  81. X/*******************DISTRIBUTION INSTRUCTIONS***********************/
  82. X
  83. XThis software is distributed in source code form, and is to be
  84. Xdistributed only in the original form and in it's entirety.  Changes
  85. Xto code can be documented and sent to the author, and any such changes may
  86. Xbe incorporated into a new version without notice.
  87. X
  88. X/*******************************************************************/
  89. X
  90. X
  91. XFeatures to come in future releases:
  92. X
  93. X1.  Computer player for 1-player games.
  94. X2.  Save game ability.
  95. X3.  Win-loss record keeping.
  96. X4.  Faster drawing, better-looking pieces.
  97. X
  98. X
  99. X***************NOTES FROM THE AUTHOR******************************
  100. X
  101. XThanx for trying this out, this is my first X/MOTIF program,
  102. Xand I think the game is a decent idea.  
  103. X
  104. XBill James
  105. Xwjames@jupiter.saic.com
  106. X
  107. XLook for B J Products computer utilities on MS-DOS BBS's in California.
  108. X
  109. X
  110. X******************SPECIAL THANKS:*********************************
  111. X
  112. XMark Botta:  HP play-and-compile-tester, aesthetics.
  113. XKral Ferch:  MOTIF widget help.
  114. X 
  115. X******************************************************************
  116. END_OF_FILE
  117. if test 2884 -ne `wc -c <'README'`; then
  118.     echo shar: \"'README'\" unpacked with wrong size!
  119. fi
  120. # end of 'README'
  121. fi
  122. if test -f 'MANIFEST' -a "${1}" != "-c" ; then 
  123.   echo shar: Will not clobber existing file \"'MANIFEST'\"
  124. else
  125. echo shar: Extracting \"'MANIFEST'\" \(579 characters\)
  126. sed "s/^X//" >'MANIFEST' <<'END_OF_FILE'
  127. X   File Name        Archive #    Description
  128. X-----------------------------------------------------------
  129. X MANIFEST                   1    This shipping list
  130. X Makefile                   2    
  131. X README                     1    
  132. X bitmaps.h                  1    
  133. X board.c                    1    
  134. X board.h                    2    
  135. X engarde.RULES              2    
  136. X engarde.c                  1    
  137. X help.h                     1    
  138. X menus.c                    2    
  139. X menus.h                    2    
  140. X patchlevel.h               2    
  141. X sun40add.c                 2    
  142. X xboard.c                   1    
  143. X xboard.h                   1    
  144. END_OF_FILE
  145. if test 579 -ne `wc -c <'MANIFEST'`; then
  146.     echo shar: \"'MANIFEST'\" unpacked with wrong size!
  147. fi
  148. # end of 'MANIFEST'
  149. fi
  150. if test -f 'bitmaps.h' -a "${1}" != "-c" ; then 
  151.   echo shar: Will not clobber existing file \"'bitmaps.h'\"
  152. else
  153. echo shar: Extracting \"'bitmaps.h'\" \(8067 characters\)
  154. sed "s/^X//" >'bitmaps.h' <<'END_OF_FILE'
  155. X/* My logo */
  156. X#define BJ_width 40
  157. X#define BJ_height 40
  158. Xstatic char BJ_bits[] = {
  159. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
  160. X   0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00,
  161. X   0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0xe3, 0xff, 0xff, 0xff, 0xc7, 0x83,
  162. X   0xff, 0xff, 0xff, 0xc1, 0x03, 0x00, 0xf0, 0x03, 0xc0, 0x03, 0x00, 0xc0,
  163. X   0x01, 0xc0, 0x03, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xe0, 0x80, 0x01, 0xc0,
  164. X   0x03, 0xb0, 0x81, 0x01, 0xc0, 0x03, 0x10, 0x83, 0x01, 0xc0, 0x03, 0x10,
  165. X   0x82, 0x03, 0xc0, 0x03, 0x10, 0x02, 0x03, 0xc0, 0x03, 0x10, 0x03, 0x03,
  166. X   0xc0, 0x03, 0xf0, 0x01, 0x03, 0xc0, 0x03, 0xf0, 0x01, 0x03, 0xc0, 0x03,
  167. X   0x10, 0x03, 0x03, 0xc0, 0x03, 0x10, 0x06, 0x03, 0xc0, 0x03, 0x10, 0x04,
  168. X   0x07, 0xc0, 0x03, 0x10, 0x04, 0x06, 0xc0, 0x03, 0x10, 0x04, 0x06, 0xc0,
  169. X   0x03, 0x10, 0x06, 0x06, 0xc0, 0x03, 0x30, 0x03, 0x06, 0xc0, 0x03, 0xe0,
  170. X   0x01, 0x06, 0xc0, 0x03, 0x00, 0x00, 0x06, 0xc0, 0x03, 0x00, 0x00, 0x07,
  171. X   0xc0, 0x03, 0x03, 0x00, 0x03, 0xc0, 0x03, 0x07, 0x80, 0x03, 0xc0, 0x03,
  172. X   0x3e, 0xc0, 0x01, 0xc0, 0x03, 0xfc, 0xff, 0x00, 0xc0, 0x03, 0xe0, 0x7f,
  173. X   0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0,
  174. X   0x03, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff,
  175. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  176. X
  177. X/* En Garde Label */
  178. X#define Emblem_width 40
  179. X#define Emblem_height 40
  180. Xstatic char Emblem_bits[] = {
  181. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
  182. X   0x00, 0x00, 0xc0, 0x03, 0x00, 0x7e, 0x00, 0xc0, 0x03, 0x00, 0x7f, 0x00,
  183. X   0xc0, 0x03, 0x00, 0x03, 0x00, 0xc0, 0x03, 0x80, 0x03, 0x00, 0xc0, 0x03,
  184. X   0x80, 0x01, 0x00, 0xc0, 0x03, 0xc0, 0x01, 0x00, 0xc0, 0x03, 0xc0, 0x00,
  185. X   0x00, 0xc0, 0x03, 0xc0, 0x07, 0x02, 0xc0, 0x03, 0xe0, 0x07, 0x1e, 0xc0,
  186. X   0x03, 0x60, 0x00, 0x36, 0xc0, 0x03, 0x70, 0x00, 0x23, 0xc0, 0x03, 0x30,
  187. X   0x00, 0x21, 0xc0, 0x03, 0x38, 0x80, 0x31, 0xc0, 0x03, 0x18, 0x80, 0x10,
  188. X   0xc0, 0x03, 0xf8, 0xc7, 0x18, 0xc0, 0x03, 0xf0, 0x47, 0x08, 0xc0, 0x03,
  189. X   0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00,
  190. X   0x00, 0xc0, 0xc3, 0x03, 0x00, 0x00, 0xc0, 0xf3, 0x07, 0x00, 0x00, 0xc0,
  191. X   0x33, 0x06, 0x00, 0x30, 0xc0, 0x3b, 0x00, 0x00, 0x30, 0xc0, 0x1b, 0x00,
  192. X   0x00, 0x30, 0xc0, 0x1b, 0x00, 0x00, 0x30, 0xc0, 0x1b, 0x00, 0x00, 0x30,
  193. X   0xcf, 0x1b, 0xe0, 0x74, 0xbe, 0xd9, 0x9b, 0xb7, 0x7d, 0xbf, 0xd9, 0x9b,
  194. X   0x97, 0x0d, 0xb3, 0xcf, 0x1b, 0x16, 0x0d, 0xb3, 0xc1, 0x3b, 0x96, 0x0d,
  195. X   0xb3, 0xc1, 0x33, 0xf7, 0x0d, 0xbf, 0xcf, 0xf3, 0x63, 0x0d, 0x3e, 0xcf,
  196. X   0xe3, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff,
  197. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  198. X
  199. X#define winright_width 40
  200. X#define winright_height 40
  201. Xstatic char winright_bits[] = {
  202. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
  203. X   0x00, 0x00, 0xc0, 0x03, 0x80, 0xff, 0x01, 0xc0, 0x03, 0xe0, 0xff, 0x07,
  204. X   0xc0, 0x03, 0x78, 0xf0, 0x1f, 0xc0, 0x03, 0x1e, 0xf0, 0x7f, 0xc0, 0x03,
  205. X   0x07, 0xf0, 0xff, 0xc0, 0x83, 0x01, 0xf0, 0xff, 0xc1, 0xc3, 0x00, 0xf0,
  206. X   0xff, 0xc3, 0xc3, 0xf0, 0xf0, 0xf0, 0xc3, 0x63, 0xf0, 0xf0, 0xf0, 0xc7,
  207. X   0x63, 0xf0, 0xf0, 0xf0, 0xc7, 0x33, 0xf0, 0xf0, 0xf0, 0xcf, 0x33, 0x00,
  208. X   0xf0, 0xff, 0xcf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff,
  209. X   0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b,
  210. X   0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0,
  211. X   0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf,
  212. X   0x1b, 0x00, 0xf0, 0x9f, 0xdf, 0x33, 0x00, 0xf0, 0x8f, 0xcf, 0x33, 0x00,
  213. X   0xf0, 0xc7, 0xcf, 0x63, 0xe0, 0x0f, 0xe0, 0xc7, 0x63, 0xf0, 0x0f, 0xf0,
  214. X   0xc7, 0xc3, 0x38, 0xf0, 0xff, 0xc3, 0xc3, 0x1c, 0xf0, 0xff, 0xc3, 0x83,
  215. X   0x0d, 0xf0, 0xff, 0xc1, 0x03, 0x07, 0xf0, 0xff, 0xc0, 0x03, 0x1e, 0xf0,
  216. X   0x7f, 0xc0, 0x03, 0x78, 0xf0, 0x1f, 0xc0, 0x03, 0xe0, 0xff, 0x07, 0xc0,
  217. X   0x03, 0x80, 0xff, 0x01, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff,
  218. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  219. X
  220. X#define winleft_width 40
  221. X#define winleft_height 40
  222. Xstatic char winleft_bits[] = {
  223. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
  224. X   0x00, 0x00, 0xc0, 0x03, 0x80, 0xff, 0x01, 0xc0, 0x03, 0xe0, 0xff, 0x07,
  225. X   0xc0, 0x03, 0x78, 0xf0, 0x1f, 0xc0, 0x03, 0x1e, 0xf0, 0x7f, 0xc0, 0x03,
  226. X   0x07, 0xf0, 0xff, 0xc0, 0x83, 0x01, 0xf0, 0xff, 0xc1, 0xc3, 0x00, 0xf0,
  227. X   0xff, 0xc3, 0xc3, 0xf0, 0xf0, 0xf0, 0xc3, 0x63, 0xf0, 0xf0, 0xf0, 0xc7,
  228. X   0x63, 0xf0, 0xf0, 0xf0, 0xc7, 0x33, 0xf0, 0xf0, 0xf0, 0xcf, 0x33, 0x00,
  229. X   0xf0, 0xff, 0xcf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff,
  230. X   0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b,
  231. X   0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0,
  232. X   0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf, 0x1b, 0x00, 0xf0, 0xff, 0xdf,
  233. X   0x1b, 0x0c, 0xf0, 0xff, 0xdf, 0x33, 0x1c, 0xf0, 0xff, 0xcf, 0x33, 0x38,
  234. X   0xf0, 0xff, 0xcf, 0x63, 0xf0, 0x0f, 0xf8, 0xc7, 0x63, 0xe0, 0x0f, 0xf0,
  235. X   0xc7, 0xc3, 0x00, 0xf0, 0xe3, 0xc3, 0xc3, 0x00, 0xf0, 0xc7, 0xc3, 0x83,
  236. X   0x01, 0xf0, 0xcf, 0xc1, 0x03, 0x07, 0xf0, 0xff, 0xc0, 0x03, 0x1e, 0xf0,
  237. X   0x7f, 0xc0, 0x03, 0x78, 0xf0, 0x1f, 0xc0, 0x03, 0xe0, 0xff, 0x07, 0xc0,
  238. X   0x03, 0x80, 0xff, 0x01, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff,
  239. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  240. X
  241. X
  242. X/* Left players turn */
  243. X#define lturn_width 40
  244. X#define lturn_height 40
  245. Xstatic char lturn_bits[] = {
  246. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
  247. X   0x00, 0x00, 0xc0, 0x03, 0x00, 0x30, 0x00, 0xc0, 0x03, 0x00, 0x38, 0x00,
  248. X   0xc0, 0x03, 0x00, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0x36, 0x00, 0xc0, 0x03,
  249. X   0x00, 0x33, 0x00, 0xc0, 0x03, 0x80, 0x31, 0x00, 0xc0, 0x03, 0xc0, 0x30,
  250. X   0x00, 0xc0, 0x03, 0x60, 0x30, 0x00, 0xc0, 0x03, 0x30, 0x30, 0x00, 0xc0,
  251. X   0x03, 0x18, 0x30, 0x00, 0xc0, 0x03, 0x0c, 0xf0, 0xff, 0xcf, 0x03, 0x06,
  252. X   0xf0, 0xff, 0xcf, 0x03, 0x03, 0x00, 0x00, 0xcc, 0x83, 0x01, 0x00, 0x00,
  253. X   0xcc, 0xc3, 0x00, 0x00, 0x00, 0xcc, 0x63, 0x00, 0x00, 0x00, 0xcc, 0x33,
  254. X   0x00, 0x00, 0x00, 0xcc, 0x33, 0x00, 0x00, 0x00, 0xcc, 0x63, 0x00, 0x00,
  255. X   0x00, 0xcc, 0xc3, 0x00, 0x00, 0x00, 0xcc, 0x83, 0x01, 0x00, 0x00, 0xcc,
  256. X   0x03, 0x03, 0x00, 0x00, 0xcc, 0x03, 0x06, 0xf0, 0xff, 0xcf, 0x03, 0x0c,
  257. X   0xf0, 0xff, 0xcf, 0x03, 0x18, 0x30, 0x00, 0xc0, 0x03, 0x30, 0x30, 0x00,
  258. X   0xc0, 0x03, 0x60, 0x30, 0x00, 0xc0, 0x03, 0xc0, 0x30, 0x00, 0xc0, 0x03,
  259. X   0x80, 0x31, 0x00, 0xc0, 0x03, 0x00, 0x33, 0x00, 0xc0, 0x03, 0x00, 0x36,
  260. X   0x00, 0xc0, 0x03, 0x00, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0x38, 0x00, 0xc0,
  261. X   0x03, 0x00, 0x30, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff,
  262. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  263. X
  264. X/* Right players turn */
  265. X#define rturn_width 40
  266. X#define rturn_height 40
  267. Xstatic char rturn_bits[] = {
  268. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
  269. X   0x00, 0x00, 0xc0, 0x03, 0x00, 0x0c, 0x00, 0xc0, 0x03, 0x00, 0x1c, 0x00,
  270. X   0xc0, 0x03, 0x00, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0x7c, 0x00, 0xc0, 0x03,
  271. X   0x00, 0xfc, 0x00, 0xc0, 0x03, 0x00, 0xfc, 0x01, 0xc0, 0x03, 0x00, 0xfc,
  272. X   0x03, 0xc0, 0x03, 0x00, 0xfc, 0x07, 0xc0, 0x03, 0x00, 0xfc, 0x0f, 0xc0,
  273. X   0x03, 0x00, 0xfc, 0x1f, 0xc0, 0xf3, 0xff, 0xff, 0x3f, 0xc0, 0xf3, 0xff,
  274. X   0xff, 0x7f, 0xc0, 0xf3, 0xff, 0xff, 0xff, 0xc0, 0xf3, 0xff, 0xff, 0xff,
  275. X   0xc1, 0xf3, 0xff, 0xff, 0xff, 0xc3, 0xf3, 0xff, 0xff, 0xff, 0xc7, 0xf3,
  276. X   0xff, 0xff, 0xff, 0xcf, 0xf3, 0xff, 0xff, 0xff, 0xcf, 0xf3, 0xff, 0xff,
  277. X   0xff, 0xc7, 0xf3, 0xff, 0xff, 0xff, 0xc3, 0xf3, 0xff, 0xff, 0xff, 0xc1,
  278. X   0xf3, 0xff, 0xff, 0xff, 0xc0, 0xf3, 0xff, 0xff, 0x7f, 0xc0, 0xf3, 0xff,
  279. X   0xff, 0x3f, 0xc0, 0x03, 0x00, 0xfc, 0x1f, 0xc0, 0x03, 0x00, 0xfc, 0x0f,
  280. X   0xc0, 0x03, 0x00, 0xfc, 0x07, 0xc0, 0x03, 0x00, 0xfc, 0x03, 0xc0, 0x03,
  281. X   0x00, 0xfc, 0x01, 0xc0, 0x03, 0x00, 0xfc, 0x00, 0xc0, 0x03, 0x00, 0x7c,
  282. X   0x00, 0xc0, 0x03, 0x00, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0x1c, 0x00, 0xc0,
  283. X   0x03, 0x00, 0x0c, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff,
  284. X   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  285. END_OF_FILE
  286. if test 8067 -ne `wc -c <'bitmaps.h'`; then
  287.     echo shar: \"'bitmaps.h'\" unpacked with wrong size!
  288. fi
  289. # end of 'bitmaps.h'
  290. fi
  291. if test -f 'board.c' -a "${1}" != "-c" ; then 
  292.   echo shar: Will not clobber existing file \"'board.c'\"
  293. else
  294. echo shar: Extracting \"'board.c'\" \(5055 characters\)
  295. sed "s/^X//" >'board.c' <<'END_OF_FILE'
  296. X/*********************************************************************
  297. X                                Engarde
  298. X                             File: board.c
  299. X
  300. X  This file contains the routines for the data of the board, magnet
  301. X  comparisons, and movement legality.
  302. X
  303. X  Version 1:  1/9/92  (Bill James)
  304. X*********************************************************************/
  305. X#include <malloc.h>
  306. X#include <stdio.h>
  307. X#include <sys/types.h>
  308. X#include <time.h>
  309. X#include "board.h"
  310. X
  311. Xextern int H,W;
  312. Xchar *SIGNSTRING[] = {"-","*","+"};
  313. XBoardType *b;
  314. X
  315. X/* 
  316. X   Flips piece from black to white or vice versa 
  317. X*/
  318. Xvoid FlipPiece(p)
  319. XPieceType *p;
  320. X{
  321. X   p->color = (p->color == PIECE_BLACK)? PIECE_WHITE:PIECE_BLACK;
  322. X}
  323. X
  324. X
  325. X/* 
  326. X   Mallocs and initializes board entity items
  327. X*/
  328. Xvoid InitBoard(s, h, w) 
  329. XSideType *s;
  330. Xint h,w;
  331. X{
  332. X    int i,j;
  333. X    PieceType *pc;
  334. X       b = (BoardType *) malloc (sizeof (BoardType));
  335. X       b->magnets = (char **) malloc (sizeof(char*) * h);
  336. X       b->pieces = (PieceType ***) malloc (sizeof(PieceType**) * h);
  337. X       for (i = 0; i < h; i++) {
  338. X          b->magnets[i] = (char *) malloc (w);
  339. X          b->pieces[i] = (PieceType **) malloc (w * sizeof(PieceType*));
  340. X          for (j = 0; j < w; j++) {
  341. X              b->magnets[i][j] = 0;
  342. X              b->pieces[i][j] = NULL;
  343. X          }
  344. X       }
  345. X       for (i = 0; i < NPIECES; i++) {
  346. X          pc = (PieceType *) malloc (sizeof(PieceType));
  347. X          s[PIECE_ROUND].p[i] = pc;
  348. X          s[PIECE_ROUND].p[i]->type = PIECE_ROUND;
  349. X          s[PIECE_ROUND].p[i]->color = PIECE_ROUND;
  350. X          pc = (PieceType *) malloc (sizeof(PieceType));
  351. X          s[PIECE_SQUARE].p[i] = pc;
  352. X          s[PIECE_SQUARE].p[i]->type = PIECE_SQUARE;
  353. X          s[PIECE_SQUARE].p[i]->color = PIECE_SQUARE;
  354. X       }
  355. X       b->height = h;
  356. X       b->width = w;
  357. X}
  358. X
  359. X
  360. X/*
  361. X   Deletes board memory items
  362. X*/
  363. Xvoid KillBoard(s) 
  364. XSideType s[2];
  365. X{
  366. X    int i,j;
  367. X    for (i = 0 ; i < b->height; i++) {
  368. X       if (s[0].p[i]) free(s[0].p[i]);
  369. X       if (s[1].p[i]) free(s[1].p[i]);
  370. X       for (j = 0; j < b->width; j++) {
  371. X          if (b->pieces[i][j]) free(b->pieces[i][j]);
  372. X       }
  373. X       free((char *) b->magnets[i]);
  374. X    }
  375. X    free((char *) b->magnets);
  376. X    free((char *) b->pieces);
  377. X}
  378. X
  379. X
  380. X#define GetPiece(b,h,w) (b)->pieces[(h)][(w)]
  381. X#define GetPolarity(b,h,w) (b)->magnets[(h)][(w)]
  382. X#define CKHW(b,h1,w1) (((h1) < (b)->height) && ((w1) < (b)->width))
  383. X
  384. X/*
  385. X   Move piece from h1,w1 to h2,w2
  386. X*/
  387. Xint MovePiece(h1, w1, h2, w2) 
  388. Xint h1,h2,w1,w2;
  389. X{
  390. X    if (!(CKHW(b,h1,w1))) return(1);
  391. X    if (!(CKHW(b,h2,w2))) return(1);
  392. X    if (b->pieces[h1][w1]) {
  393. X       if (b->pieces[h2][w2]) return(1);
  394. X       b->pieces[h2][w2] = b->pieces[h1][w1];
  395. X       Magnetize(h2,w2);
  396. X       b->pieces[h1][w1] = NULL;
  397. X       return(0);
  398. X    }
  399. X    else return (1);
  400. X}
  401. X
  402. X
  403. X/*
  404. X    Randomly shuffles board magnets
  405. X*/
  406. Xvoid BoardShuffle() 
  407. X{
  408. X    int i,j;
  409. X    char k;
  410. X    for ( i = 0; i < b->height; i++) 
  411. X       for (j = 0; j < b->width; j++) {
  412. X           k = (char) (random() % 2);
  413. X           if (k) b->magnets[i][j] = 1;
  414. X           else b->magnets[i][j] = -1;
  415. X           k = (char) (random() % 10);
  416. X           if (!k) b->magnets[i][j] = 0;
  417. X           Magnetize(i,j);
  418. X       }
  419. X}
  420. X
  421. X
  422. X
  423. X/*
  424. X   Sets piece color to correct color for it's shape/position
  425. X*/
  426. Xvoid Magnetize(h, w) 
  427. Xint h,w;
  428. X{
  429. X   PieceType *p;
  430. X   p = b->pieces[h][w];
  431. X   if (!(b->magnets[h][w])) return;
  432. X   if (p) {
  433. X      if ((p->type == PIECE_ROUND) && (b->magnets[h][w] == POSITIVE))
  434. X          p->color = PIECE_BLACK;
  435. X      if ((p->type == PIECE_ROUND) && (b->magnets[h][w] == NEGATIVE))
  436. X          p->color = PIECE_WHITE;
  437. X      if ((p->type == PIECE_SQUARE) && (b->magnets[h][w] == POSITIVE))
  438. X          p->color = PIECE_WHITE;
  439. X      if ((p->type == PIECE_SQUARE) && (b->magnets[h][w] == NEGATIVE))
  440. X          p->color = PIECE_BLACK;
  441. X   }
  442. X}
  443. X
  444. X
  445. X
  446. X/*
  447. X   Sums the colors of the set of four pieces (i,j),(i+dx,j+dy),
  448. X   (i+2dx,j+2dy),(i+3dx,j+3dy), or returns -1 if any of the 
  449. X   spaces have no piece.
  450. X*/
  451. Xint SumSet(i,j,dx,dy) 
  452. Xint i,j,dx,dy;
  453. X{
  454. Xint s,l,m,r;
  455. X  s = 0;
  456. X  for (r = 0, l = i, m = j; ((r < 4) && (l < W) && (l >= 0)) &&
  457. X                            ((m < H) && (m >= 0)); r++, l+=dx, m+=dy) {
  458. X     if (!b->pieces[l][m]) return(-1);
  459. X     s += b->pieces[l][m]->color;
  460. X  }
  461. X  if (((l >= W) || (l < 0) || (m >= H) || (m < 0)) && (r < 4)) return(-1);
  462. X  return(s);
  463. X}
  464. X
  465. X
  466. X/*
  467. X   Checks the board to find any set of 4 spaces in a row,column,diag
  468. X   that are the same color.
  469. X*/
  470. Xint CheckWinner(i, j, dx, dy)
  471. Xint *i,*j,*dx,*dy;
  472. X{
  473. Xint c,d,x,y,g;
  474. Xfor (c = 0; c < W; c++) 
  475. X   for (d = 0; d < H; d++) 
  476. X      for (x = -1; x < 2; x++) {
  477. X         for (y = -1; y < 2; y++) {
  478. X            if ((!x) && (!y)) continue;
  479. X            g = SumSet(c,d,x,y);
  480. X            if (g == (4 * PIECE_BLACK)) {
  481. X                *dx = x; *dy = y; 
  482. X                *i = c; *j = d;
  483. X        return(1);
  484. X            }
  485. X            if (g == (4 * PIECE_WHITE)) {
  486. X                *dx = x; *dy = y; 
  487. X                *i = c; *j = d;
  488. X        return(1);
  489. X            }
  490. X         }
  491. X      }
  492. Xreturn(0);
  493. X}
  494. X
  495. X
  496. Xvoid Randomize()
  497. X{
  498. Xtime_t g;
  499. Xint *h;
  500. X
  501. X  g = time();
  502. X  h = (int *) &g;
  503. X  srandom(*h);
  504. X}
  505. END_OF_FILE
  506. if test 5055 -ne `wc -c <'board.c'`; then
  507.     echo shar: \"'board.c'\" unpacked with wrong size!
  508. fi
  509. # end of 'board.c'
  510. fi
  511. if test -f 'engarde.c' -a "${1}" != "-c" ; then 
  512.   echo shar: Will not clobber existing file \"'engarde.c'\"
  513. else
  514. echo shar: Extracting \"'engarde.c'\" \(14872 characters\)
  515. sed "s/^X//" >'engarde.c' <<'END_OF_FILE'
  516. X/*********************************************************************
  517. X                                Engarde
  518. X                            File: engarde.c
  519. X
  520. X  This file contains startup routines and widget initializations
  521. X  for the display of the game.  It also calls functions to initialize
  522. X  the board magnets, etc.
  523. X
  524. X  Version 1:  1/9/92  (Bill James)
  525. X*********************************************************************/
  526. X#include <X11/Intrinsic.h>
  527. X#include <X11/StringDefs.h>
  528. X#include <X11/Xutil.h>
  529. X#include <Xm/Xm.h>
  530. X#include <Xm/RowColumn.h>
  531. X#include <Xm/Form.h>
  532. X#include <Xm/DrawingA.h>
  533. X#include <Xm/Text.h>
  534. X#include <Xm/Label.h>
  535. X#include <Xm/PushB.h>
  536. X#include <Xm/DrawnB.h>
  537. X#include "menus.h"
  538. X#include "board.h"
  539. X#include "xboard.h"
  540. X#include "bitmaps.h"
  541. X#include "help.h"
  542. X
  543. XWidget draw;
  544. XWidget lt; 
  545. XWidget rt; 
  546. XWidget mess;
  547. XWidget help;
  548. XWidget about;
  549. Xint n, H, W;
  550. XSideType s[2];
  551. XPixel fore, back;
  552. XPixmap lturn, rturn, goveright, goverleft;
  553. X
  554. Xvoid AddPixmap();
  555. XWidget MakeAboutWidget();
  556. X
  557. X
  558. Xstatic void quit(w, client_data, call_data)
  559. XWidget w;
  560. Xcaddr_t client_data;
  561. XXmAnyCallbackStruct *call_data;
  562. X{
  563. X     XtCloseDisplay(XtDisplay(w));
  564. X     exit(0);
  565. X}
  566. X
  567. Xstatic xs_menu_struct menuData_Quit[] = {
  568. X  {"Quit", quit, NULL, NULL, 0, NULL}
  569. X};
  570. X
  571. Xstatic xs_menu_struct menuData_Game[] = {
  572. X  {"New", ResetBoard, NULL, NULL, 0, NULL}
  573. X};
  574. X
  575. Xstatic xs_menu_struct menuData_Help[] = {
  576. X  {"Help", ShowHelp, NULL, NULL, 0, NULL},
  577. X  {"About...", ShowAbout, NULL, NULL, 0, NULL}
  578. X};
  579. X
  580. Xstatic xs_menu_struct menuData[] = {
  581. X  {"Game", NULL, NULL, menuData_Game, XtNumber(menuData_Game), NULL},
  582. X  {"Help", NULL, NULL, menuData_Help, XtNumber(menuData_Help), NULL},
  583. X  {"Quit", NULL, NULL, menuData_Quit, XtNumber(menuData_Quit), NULL}
  584. X};
  585. X
  586. X
  587. X
  588. Xmain(argc, argv)
  589. Xint argc;
  590. Xchar *argv[];
  591. X{
  592. XWidget menu, form, toplevel, emb, bj, helptext, helpquit; 
  593. XArg wargs[20];
  594. XPixmap embpix, bjpix;
  595. Xint i,j;
  596. XXmString str;
  597. Xstatic XtActionsRec draw_actions[] = {
  598. X         {"ButtonPress1",        ButtonPress1},
  599. X};
  600. X static char draw_translations[] =
  601. X         "<Btn1Down>:            ButtonPress1()";
  602. X
  603. X
  604. X   toplevel = XtInitialize(argv[0], "EnGarde", NULL, 0, &argc, argv);
  605. X   form = XtCreateManagedWidget("Form", xmFormWidgetClass, toplevel, NULL, 0);
  606. X   help = XmCreateFormDialog(toplevel,"Help", NULL, 0);
  607. X
  608. X   n = 0;
  609. X   XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_FORM); n++;
  610. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  611. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  612. X   XtSetArg(wargs[n], XmNrightOffset, 10); n++;
  613. X   XtSetArg(wargs[n], XmNleftOffset, 10); n++;
  614. X   XtSetArg(wargs[n], XmNtopOffset, 5); n++;
  615. X   menu = XmCreateMenuBar(form, "Menu", wargs, n); XtManageChild(menu);
  616. X
  617. X   xs_create_menu_buttons(NULL, menu, menuData, XtNumber(menuData));
  618. X   
  619. X   n = 0;
  620. X   XtSetArg(wargs[n], XmNlabelType, XmPIXMAP); n++;
  621. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  622. X   XtSetArg(wargs[n], XmNleftOffset, 10); n++;
  623. X   XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  624. X   XtSetArg(wargs[n], XmNbottomOffset, 20); n++;
  625. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  626. X   emb = (Widget) XmCreateLabel(form, "Emblem", wargs, n);
  627. X   XtManageChild(emb);
  628. X   AddPixmap(emb, &embpix, Emblem_bits, Emblem_width, Emblem_height);
  629. X   n = 0;
  630. X   XtSetArg(wargs[n], XmNlabelPixmap, embpix); n++;
  631. X   XtSetValues(emb, wargs, n);
  632. X
  633. X   n = 0;
  634. X   XtSetArg(wargs[n], XmNlabelType, XmPIXMAP); n++;
  635. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  636. X   XtSetArg(wargs[n], XmNrightOffset, 10); n++;
  637. X   XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  638. X   XtSetArg(wargs[n], XmNbottomOffset, 20); n++;
  639. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  640. X   bj = (Widget) XmCreateLabel(form, "Bj", wargs, n);
  641. X   XtManageChild(bj);
  642. X   AddPixmap(bj, &bjpix, BJ_bits, BJ_width, BJ_height);
  643. X   n = 0;
  644. X   XtSetArg(wargs[n], XmNlabelPixmap, bjpix); n++;
  645. X   XtSetValues(bj, wargs, n);
  646. X
  647. X   n = 0;
  648. X   XtSetArg(wargs[n], XmNlabelType, XmPIXMAP); n++;
  649. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  650. X   XtSetArg(wargs[n], XmNleftOffset, 10); n++;
  651. X   XtSetArg(wargs[n], XmNleftWidget, emb); n++;
  652. X   XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  653. X   XtSetArg(wargs[n], XmNbottomOffset, 20); n++;
  654. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  655. X   lt = (Widget) XmCreateLabel(form, "Lturn", wargs, n);
  656. X   XtManageChild(lt);
  657. X   AddPixmap(lt, <urn, lturn_bits, lturn_width, lturn_height);
  658. X   n = 0;
  659. X   XtSetArg(wargs[n], XmNlabelPixmap, lturn); n++;
  660. X   XtSetValues(lt, wargs, n);
  661. X
  662. X   n = 0;
  663. X   XtSetArg(wargs[n], XmNlabelType, XmPIXMAP); n++;
  664. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  665. X   XtSetArg(wargs[n], XmNrightWidget, bj); n++;
  666. X   XtSetArg(wargs[n], XmNrightOffset, 10); n++;
  667. X   XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  668. X   XtSetArg(wargs[n], XmNbottomOffset, 20); n++;
  669. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  670. X   rt = (Widget) XmCreateLabel(form, "Rturn", wargs, n);
  671. X   XtManageChild(rt);
  672. X   AddPixmap(rt, &goveright, winright_bits, winright_width, winright_height);
  673. X   AddPixmap(rt, &goverleft, winleft_bits, 
  674. X                          winleft_width, winleft_height);
  675. X   AddPixmap(rt, &rturn, rturn_bits, rturn_width, rturn_height);
  676. X   n = 0;
  677. X   XtSetArg(wargs[n], XmNlabelPixmap, lturn); n++;
  678. X   XtSetValues(rt, wargs, n);
  679. X
  680. X   n = 0;
  681. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  682. X   XtSetArg(wargs[n], XmNleftWidget, lt); n++;
  683. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  684. X   XtSetArg(wargs[n], XmNrightWidget, rt); n++;
  685. X   XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  686. X   XtSetArg(wargs[n], XmNbottomOffset, 10); n++;
  687. X   /*XtSetArg(wargs[n], XmNcolumns, 60); n++;*/
  688. X   XtSetArg(wargs[n], XmNrows, 2); n++;
  689. X   XtSetArg(wargs[n], XmNwordWrap, True); n++;
  690. X   XtSetArg(wargs[n], XmNscrollVertical, True); n++;
  691. X   XtSetArg(wargs[n], XmNscrollHorizontal, False); n++;
  692. X   XtSetArg(wargs[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
  693. X   XtSetArg(wargs[n], XmNeditable, False); n++;
  694. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  695. X   XtSetArg(wargs[n], XmNcursorPositionVisible, False); n++;
  696. X   mess = (Widget) XmCreateScrolledText(form, "Message", wargs, n);
  697. X   XtManageChild(mess);
  698. X
  699. X   n = 0;
  700. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  701. X   XtSetArg(wargs[n], XmNleftOffset, 70); n++;
  702. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  703. X   XtSetArg(wargs[n], XmNrightOffset, 70); n++;
  704. X   XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  705. X   XtSetArg(wargs[n], XmNbottomOffset, 10); n++;
  706. X   str = XmStringCreate("OK",XmSTRING_DEFAULT_CHARSET);
  707. X   XtSetArg(wargs[n], XmNlabelString, str); n++;
  708. X   helpquit = (Widget) XmCreatePushButton(help, "HelpOk", wargs, n);
  709. X   XtManageChild(helpquit);
  710. X
  711. X   n = 0;
  712. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  713. X   XtSetArg(wargs[n], XmNleftWidget, lt); n++;
  714. X   XtSetArg(wargs[n], XmNleftOffset, 10); n++;
  715. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  716. X   XtSetArg(wargs[n], XmNrightWidget, rt); n++;
  717. X   XtSetArg(wargs[n], XmNrightOffset, 10); n++;
  718. X   XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_FORM); n++;
  719. X   XtSetArg(wargs[n], XmNtopOffset, 10); n++;
  720. X   XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
  721. X   XtSetArg(wargs[n], XmNbottomWidget, helpquit); n++;
  722. X   XtSetArg(wargs[n], XmNbottomOffset, 10); n++;
  723. X   XtSetArg(wargs[n], XmNcolumns, 80); n++;
  724. X   XtSetArg(wargs[n], XmNrows, 20); n++;
  725. X   XtSetArg(wargs[n], XmNwordWrap, False); n++;
  726. X   XtSetArg(wargs[n], XmNscrollVertical, True); n++;
  727. X   XtSetArg(wargs[n], XmNscrollHorizontal, False); n++;
  728. X   XtSetArg(wargs[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
  729. X   XtSetArg(wargs[n], XmNeditable, False); n++;
  730. X   helptext = (Widget) XmCreateScrolledText(help, "HelpText", wargs, n);
  731. X   XtManageChild(helptext);
  732. X
  733. X   j = 0;
  734. X   for (i = 0; i < HELPLINES; i++) {
  735. X      XmTextInsert(helptext, j, helpstr[i]);
  736. X      j += strlen(helpstr[i]);
  737. X   }
  738. X
  739. X   n = 0;
  740. X   XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  741. X   XtSetArg(wargs[n], XmNtopWidget, menu); n++;
  742. X   XtSetArg(wargs[n], XmNtopOffset, 10); n++;
  743. X   XtSetArg(wargs[n], XmNleftOffset, 10); n++;
  744. X   XtSetArg(wargs[n], XmNrightOffset, 10); n++;
  745. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  746. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  747. X   XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
  748. X   XtSetArg(wargs[n], XmNbottomWidget, mess); n++;
  749. X   XtSetArg(wargs[n], XmNbottomOffset, 10); n++;
  750. X   XtSetArg(wargs[n], XmNwidth, 300); n++;
  751. X   XtSetArg(wargs[n], XmNheight, 200); n++;
  752. X   XtSetArg(wargs[n], XmNresizePolicy, XmRESIZE_ANY); n++;
  753. X  draw = XtCreateManagedWidget("Canvas",xmDrawingAreaWidgetClass, form,wargs,n);
  754. X
  755. X   MakeAboutWidget(toplevel, bjpix, embpix);
  756. X
  757. X   n = 0;
  758. X   XtSetArg(wargs[n], XmNforeground, &fore); n++;
  759. X   XtSetArg(wargs[n], XmNbackground, &back); n++;
  760. X   XtGetValues(draw, wargs, n);
  761. X
  762. X   XtAddCallback(draw, XmNexposeCallback, DrawGame, NULL);
  763. X   XtAddCallback(draw, XmNresizeCallback, DrawGame, NULL);
  764. X   XtAddCallback(helpquit, XmNactivateCallback, CloseHelp, NULL);
  765. X   XtOverrideTranslations (draw, XtParseTranslationTable (draw_translations));
  766. X   XtAppAddActions (XtWidgetToApplicationContext (draw), draw_actions,
  767. X                         XtNumber (draw_actions));
  768. X
  769. X   W = 6; H = 6;
  770. X   Randomize();
  771. X   InitBoard(s,W,H);
  772. X   BoardShuffle();
  773. X   XtRealizeWidget(toplevel);
  774. X   XtMainLoop();
  775. X}
  776. X
  777. X
  778. Xvoid AddPixmap(w, pix, b, wid, hgt)
  779. XWidget w;
  780. XPixmap *pix;
  781. Xchar * b;
  782. Xint wid, hgt;
  783. X{
  784. XPixmap bitmap;
  785. XXGCValues vals;
  786. XGC gc;
  787. XArg wargs[10];
  788. Xint n;
  789. X   bitmap = XCreateBitmapFromData(XtDisplay(w), 
  790. X              RootWindowOfScreen(XtScreen(w)), b, wid, hgt);
  791. X   *pix = XCreatePixmap(XtDisplay(w),
  792. X              RootWindowOfScreen(XtScreen(w)), 
  793. X              wid, hgt, DefaultDepthOfScreen(XtScreen(w)));
  794. X   n = 0;
  795. X   XtSetArg(wargs[n],XtNforeground, &vals.foreground); n++;
  796. X   XtSetArg(wargs[n],XtNbackground, &vals.background); n++;
  797. X   XtGetValues(w,wargs,n);
  798. X   gc = XtGetGC(w, GCForeground|GCBackground, &vals);
  799. X   XCopyPlane(XtDisplay(w), bitmap, *pix, gc, 0, 0,
  800. X              wid, hgt, 0, 0, 1);
  801. X   XFreePixmap(XtDisplay(w), bitmap);
  802. X   XtReleaseGC(w, gc);
  803. X}
  804. X
  805. X
  806. XWidget MakeAboutWidget(w, bjpix, embpix)
  807. XWidget w;
  808. XPixmap bjpix, embpix;
  809. X{
  810. XWidget label1,label2,label3,label4,label5,label6,button;
  811. XArg wargs[20];
  812. Xint n;
  813. XXmString str[7];
  814. XDimension x,j;
  815. X
  816. X
  817. X   about = XmCreateFormDialog(w,"About", NULL, 0);
  818. X   
  819. X   n = 0;
  820. X   XtSetArg(wargs[n], XmNlabelType, XmSTRING); n++;
  821. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  822. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  823. X   XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_FORM); n++;
  824. X   XtSetArg(wargs[n], XmNtopOffset, 20); n++;
  825. X   XtSetArg(wargs[n], XmNrightOffset, 20); n++;
  826. X   XtSetArg(wargs[n], XmNleftOffset, 20); n++;
  827. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  828. X   str[0] = XmStringCreate("En Garde",XmSTRING_DEFAULT_CHARSET);
  829. X   XtSetArg(wargs[n], XmNlabelString, str[0]); n++;
  830. X   label1 = (Widget) XmCreateLabel(about, "AboutTitle", wargs, n);
  831. X   XtManageChild(label1);
  832. X
  833. X   n = 0;
  834. X   XtSetArg(wargs[n], XmNlabelType, XmSTRING); n++;
  835. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  836. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  837. X   XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  838. X   XtSetArg(wargs[n], XmNtopWidget, label1); n++;
  839. X   XtSetArg(wargs[n], XmNtopOffset, 10); n++;
  840. X   XtSetArg(wargs[n], XmNrightOffset, 20); n++;
  841. X   XtSetArg(wargs[n], XmNleftOffset, 20); n++;
  842. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  843. X   str[1] = XmStringCreate("Version 1.0",XmSTRING_DEFAULT_CHARSET);
  844. X   XtSetArg(wargs[n], XmNlabelString, str[1]); n++;
  845. X   label2 = (Widget) XmCreateLabel(about, "AboutVersion", wargs, n);
  846. X   XtManageChild(label2);
  847. X
  848. X   n = 0;
  849. X   XtSetArg(wargs[n], XmNlabelType, XmSTRING); n++;
  850. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  851. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  852. X   XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  853. X   XtSetArg(wargs[n], XmNtopWidget, label2); n++;
  854. X   XtSetArg(wargs[n], XmNtopOffset, 10); n++;
  855. X   XtSetArg(wargs[n], XmNrightOffset, 20); n++;
  856. X   XtSetArg(wargs[n], XmNleftOffset, 20); n++;
  857. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  858. X   str[2] = XmStringCreate("January, 1992",XmSTRING_DEFAULT_CHARSET);
  859. X   XtSetArg(wargs[n], XmNlabelString, str[2]); n++;
  860. X   label3 = (Widget) XmCreateLabel(about, "AboutDate", wargs, n);
  861. X   XtManageChild(label3);
  862. X
  863. X   n = 0;
  864. X   XtSetArg(wargs[n], XmNlabelType, XmSTRING); n++;
  865. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  866. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  867. X   XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  868. X   XtSetArg(wargs[n], XmNtopWidget, label3); n++;
  869. X   XtSetArg(wargs[n], XmNtopOffset, 10); n++;
  870. X   XtSetArg(wargs[n], XmNrightOffset, 20); n++;
  871. X   XtSetArg(wargs[n], XmNleftOffset, 20); n++;
  872. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  873. X   str[3] = XmStringCreate("Bill James",XmSTRING_DEFAULT_CHARSET);
  874. X   XtSetArg(wargs[n], XmNlabelString, str[3]); n++;
  875. X   label4 = (Widget) XmCreateLabel(about, "AboutAuthor", wargs, n);
  876. X   XtManageChild(label4);
  877. X
  878. X   n = 0;
  879. X   XtSetArg(wargs[n], XmNlabelType, XmSTRING); n++;
  880. X   XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
  881. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  882. X   XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  883. X   XtSetArg(wargs[n], XmNtopWidget, label4); n++;
  884. X   XtSetArg(wargs[n], XmNtopOffset, 10); n++;
  885. X   XtSetArg(wargs[n], XmNrightOffset, 20); n++;
  886. X   XtSetArg(wargs[n], XmNleftOffset, 20); n++;
  887. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  888. X   str[4] = XmStringCreate("wjames@jupiter.SAIC.COM",XmSTRING_DEFAULT_CHARSET);
  889. X   XtSetArg(wargs[n], XmNlabelString, str[4]); n++;
  890. X   label6 = (Widget) XmCreateLabel(about, "AboutMail", wargs, n);
  891. X   XtManageChild(label6);
  892. X
  893. X   n = 0;
  894. X   XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
  895. X   XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  896. X   XtSetArg(wargs[n], XmNtopWidget, label6); n++;
  897. X   XtSetArg(wargs[n], XmNtopOffset, 20); n++;
  898. X   XtSetArg(wargs[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  899. X   XtSetArg(wargs[n], XmNbottomOffset, 20); n++;
  900. X   XtSetArg(wargs[n], XmNentryAlignment, XmALIGNMENT_CENTER); n++;
  901. X   XtSetArg(wargs[n], XmNlabelPixmap, embpix); n++;
  902. X   XtSetArg(wargs[n], XmNlabelType, XmPIXMAP); n++;
  903. X   XtSetArg(wargs[n], XmNwidth, 100); n++;
  904. X   XtSetArg(wargs[n], XmNheight, 60); n++;
  905. X   XtSetArg(wargs[n], XmNresize, False); n++;
  906. X   button = XmCreateDrawnButton(about, "AboutButton", wargs, n);
  907. X   XtManageChild(button);
  908. X
  909. X   XtAddCallback(button, XmNactivateCallback, CloseAbout, NULL);
  910. X
  911. X   XtRealizeWidget (about);
  912. X   n = 0;
  913. X   XtSetArg(wargs[n], XmNwidth, &x); n++;
  914. X   XtGetValues(about, wargs, n);
  915. X   j = (x - 100) / 2;
  916. X   if (j < 0) j = 0;
  917. X   n = 0;
  918. X   XtSetArg(wargs[n], XmNleftOffset, j); n++;
  919. X   XtSetValues(button, wargs, n);
  920. X
  921. X}
  922. X
  923. END_OF_FILE
  924. if test 14872 -ne `wc -c <'engarde.c'`; then
  925.     echo shar: \"'engarde.c'\" unpacked with wrong size!
  926. fi
  927. # end of 'engarde.c'
  928. fi
  929. if test -f 'help.h' -a "${1}" != "-c" ; then 
  930.   echo shar: Will not clobber existing file \"'help.h'\"
  931. else
  932. echo shar: Extracting \"'help.h'\" \(4562 characters\)
  933. sed "s/^X//" >'help.h' <<'END_OF_FILE'
  934. X/*********************************************************************
  935. X                                Engarde
  936. X                            File: help.h
  937. X
  938. X  This file contains the a C version of the engarde.RULES file to
  939. X  be included into the help window of the game.
  940. X
  941. X  Version 1:  1/9/92  (Bill James)
  942. X*********************************************************************/
  943. X#define HELPLINES    93
  944. Xchar *helpstr[HELPLINES] = {
  945. X"\n",
  946. X"                             ENGARDE v1.0\n",
  947. X"--------------------------------------------------------------------------\n",
  948. X"      A game written for X11R4 with OSF/MOTIF widgets by Bill James.\n",
  949. X"--------------------------------------------------------------------------\n",
  950. X"\n",
  951. X"OBJECT:\n",
  952. X"\n",
  953. X"To have 4 pieces in a row, column, diagonal that are all of one player's \n",
  954. X"color, that player is to be considered the winner.\n",
  955. X"\n",
  956. X"\n",
  957. X"DESIGNATIONS:\n",
  958. X"\n",
  959. X" -  The center set of squares is know as the \"grid\".\n",
  960. X" -  The single columns to the right and left of the grid are\n",
  961. X"      called \"side-bars\", possible preceded by a \"left\" or \"right\".\n",
  962. X" -  The squares and circles are called \"pieces\", with the unfilled\n",
  963. X"      piece being \"white\", and the filled piece being \"black\".\n",
  964. X"\n",
  965. X"\n",
  966. X"CHARACTERISTICS OF THE BOARD:\n",
  967. X"\n",
  968. X"    Each piece is to be considered a magnet with one pole painted \n",
  969. X"white, and the other painted black.  A piece is considered to be\n",
  970. X"white if the white side is face up, else it is black.  On circular \n",
  971. X"pieces the positive side is painted white, while on the squares it \n",
  972. X"is the negative side.  The grid is also merely a set of magnetized \n",
  973. X"squares, with either the positive or negative side facing upwards.\n",
  974. X"The grid also contains spaces that are not magnets at all, but are \n",
  975. X"merely null spots, and do not affect the pieces at all.  \n",
  976. X"\n",
  977. X"Examples:\n",
  978. X"Sample Grid :\n",
  979. X"    \n",
  980. X"   + + - + O -     + = positive grid face up\n",
  981. X"   - - + - + -     - = negative grid face up\n",
  982. X"   O - + - - +     O = null grid space\n",
  983. X"   + + - + + -\n",
  984. X"   - + + O - -\n",
  985. X"   - - - - + +\n",
  986. X"\n",
  987. X"Every new game, the board shuffles it's magnets to form a new\n",
  988. X"grid.\n",
  989. X"\n",
  990. X"When a player moves a piece onto the grid, the magnetic interactions\n",
  991. X"cause the piece to show the color painted on the magnet side with\n",
  992. X"the same polarity as the grid place.  e.g. when a piece moves on\n",
  993. X"a positive grid place, the positive side of the magnet is repulsed, \n",
  994. X"and is therefore face up.\n",
  995. X"\n",
  996. X"  Before Move          After Move Piece is:\n",
  997. X"   Piece is:      When moved onto grid with magnet:\n",
  998. X"--------------------------------------------------\n",
  999. X"| Shape | Color ||| Positive | Negative |  Null  |\n",
  1000. X"--------------------------------------------------\n",
  1001. X"|  SQU  |  Wh   |||    Bl    |    Wh    |   Wh   |   \n",
  1002. X"|  SQU  |  Bl   |||    Bl    |    Wh    |   Bl   |\n",
  1003. X"|  CIR  |  Wh   |||    Wh    |    Bl    |   Wh   |\n",
  1004. X"|  CIR  |  Bl   |||    Wh    |    Bl    |   Bl   |\n",
  1005. X"--------------------------------------------------\n",
  1006. X"\n",
  1007. X"RULES OF MOVEMENT:\n",
  1008. X"\n",
  1009. X"The arrows to either side of the message box designate whose turn it is.\n",
  1010. X"This player has the following options:\n",
  1011. X"\n",
  1012. X"1.  The player may take a piece from his side-bar and place it\n",
  1013. X"    on any space on the center grid where there is no other piece.\n",
  1014. X"\n",
  1015. X"2.  The player may move any piece that is currently on the grid\n",
  1016. X"    EXCEPT the last piece moved to another spot guided by these rules:\n",
  1017. X"    2a.  Piece cannot move to occupied place.\n",
  1018. X"    2b.  Piece may only move in one direction.\n",
  1019. X"    2c.  Piece cannot move more than 2 spaces in a single direction,\n",
  1020. X"           either Up, Down, Left, Right, or the Diagonals.\n",
  1021. X"    2d.  Piece may only be moved 2 spaces in a direction if the first\n",
  1022. X"           space in that direction is occupied (it jumps the first piece).\n",
  1023. X"    2e.  Piece may not be placed back onto side-bar.\n",
  1024. X"    \n",
  1025. X"\n",
  1026. X"STRATEGY HINTS:\n",
  1027. X"\n",
  1028. X" - Try to save a piece on your side-bar, being able to place it anywhere\n",
  1029. X"      on the grid may save your neck.\n",
  1030. X"\n",
  1031. X" - Try to keep track of what polarity the grid locations are as you find\n",
  1032. X"      them out, they won't change until the next game.\n",
  1033. X"\n",
  1034. X" - Don't forget about the null spaces.  If a piece keeps the same color\n",
  1035. X"      when it moves, a null space is always a possibility.\n",
  1036. X"\n",
  1037. X"----------------------------------------------------------------------------\n"
  1038. X};
  1039. END_OF_FILE
  1040. if test 4562 -ne `wc -c <'help.h'`; then
  1041.     echo shar: \"'help.h'\" unpacked with wrong size!
  1042. fi
  1043. # end of 'help.h'
  1044. fi
  1045. if test -f 'xboard.c' -a "${1}" != "-c" ; then 
  1046.   echo shar: Will not clobber existing file \"'xboard.c'\"
  1047. else
  1048. echo shar: Extracting \"'xboard.c'\" \(13185 characters\)
  1049. sed "s/^X//" >'xboard.c' <<'END_OF_FILE'
  1050. X/*********************************************************************
  1051. X                                Engarde
  1052. X                            File: xboard.c
  1053. X
  1054. X  This file contains functions to initialize board size data, display
  1055. X  board, and generally deal with all display changes during a game.
  1056. X
  1057. X  Version 1:  1/9/92  (Bill James)
  1058. X*********************************************************************/
  1059. X#include <X11/Intrinsic.h>
  1060. X#include <X11/StringDefs.h>
  1061. X#include <X11/Xutil.h>
  1062. X#include <Xm/Xm.h>
  1063. X#include <Xm/RowColumn.h>
  1064. X#include <Xm/Form.h>
  1065. X#include <Xm/DrawingA.h>
  1066. X#include <Xm/Text.h>
  1067. X#include "board.h"
  1068. X#include "xboard.h"
  1069. X
  1070. Xextern int H,W;
  1071. Xextern SideType s[2];
  1072. Xextern BoardType *b;
  1073. Xextern Widget help; 
  1074. Xextern Widget about; 
  1075. Xextern Widget draw; 
  1076. Xextern Widget mess;
  1077. Xextern Widget lt;
  1078. Xextern Widget rt;
  1079. Xextern Pixel fore, back;
  1080. Xextern Pixmap lturn, rturn, goveright, goverleft;
  1081. X
  1082. X/*  
  1083. X   s1bxx1,bxy1 to s1bxx2,bxy2 =  left side outline.
  1084. X   s2bxx1,bxy1 to s2bxx2,bxy2 =  right side outline.
  1085. X   bxx1,bxy1 to bxx2,bxy2 =  center outline.
  1086. X   delta = size of empty space in grid box.
  1087. X   oy,ox = offsets from left and top side of window to center grid.
  1088. X   wid, hgt = width and height of window.
  1089. X   selected = whether a box is selected or not.
  1090. X   selpt = grid location of selection.
  1091. X   hold = don't allow selections until game is reset.
  1092. X   turn = 0 for left side, 1 for right side.
  1093. X   Last = location of last piece moved
  1094. X*/
  1095. X   
  1096. Xstatic int s1bxx1, s1bxx2, s2bxx1, s2bxx2;  
  1097. Xstatic int bxx1, bxy1, bxx2, bxy2;
  1098. Xstatic int delta, oy, ox; 
  1099. Xstatic Dimension wid, hgt;
  1100. Xstatic int selected = 0;
  1101. Xstatic Pt selpt;
  1102. Xstatic int hold = 0;
  1103. Xstatic int turn = 0;
  1104. Xstatic Pt Last;
  1105. X
  1106. X
  1107. X/*
  1108. X   Draws rectangle from x1,y1 to x2,y2
  1109. X*/
  1110. Xvoid DrawRect(d, w, gc, x1, y1, x2, y2)
  1111. XDisplay *d;
  1112. XWindow w;
  1113. XGC gc;
  1114. Xint x1, y1, x2, y2;
  1115. X{
  1116. X   XDrawLine(d, w, gc, x1, y1, x1, y2);
  1117. X   XDrawLine(d, w, gc, x1, y2, x2, y2);
  1118. X   XDrawLine(d, w, gc, x2, y2, x2, y1);
  1119. X   XDrawLine(d, w, gc, x2, y1, x1, y1);
  1120. X}
  1121. X
  1122. X
  1123. X/*
  1124. X   Figures the scalings necessary to fit the new size of the
  1125. X   window.
  1126. X*/
  1127. Xvoid GetXVals() 
  1128. X{
  1129. XArg wargs[20];
  1130. Xint n, i;
  1131. Xint bx, by;
  1132. X
  1133. X  n = 0;
  1134. X  hgt = 0;
  1135. X  XtSetArg(wargs[n], XmNheight, &hgt); n++;
  1136. X  XtSetArg(wargs[n], XmNwidth, &wid); n++;
  1137. X  XtGetValues(draw, wargs, n); n = 0;
  1138. X
  1139. X  bx = (wid - 22) / 12;
  1140. X  by = (hgt - 14) / 8;
  1141. X  delta = MIN2(bx,by);
  1142. X  if (delta < 0) delta = 0;
  1143. X  ox = (wid - 22 - (delta *12)) / 2 ;
  1144. X  oy = (hgt - 14 - (delta *8)) / 2;
  1145. X
  1146. X  s1bxx1 = ox + delta + 1;
  1147. X  s1bxx2 = s1bxx1 + delta + 3;
  1148. X  s2bxx1 = ox + 10 * delta + 19;
  1149. X  s2bxx2 = s2bxx1 + delta + 3;
  1150. X  bxx1 = ox + 3 * delta + 5;
  1151. X  bxx2 = bxx1 + 6 * delta + 13;
  1152. X  bxy1 = oy + delta + 1;
  1153. X  bxy2 = bxy1 + 6 * delta + 13;
  1154. X
  1155. X
  1156. X}
  1157. X
  1158. X
  1159. X/*
  1160. X   Callback function for resize and expose callbacks.  Draws the
  1161. X   game based upon window size data.
  1162. X*/
  1163. Xvoid DrawGame(w, client_data, call_data)
  1164. XWidget w;
  1165. Xcaddr_t client_data;
  1166. XXmDrawingAreaCallbackStruct call_data;
  1167. X{
  1168. XWindow win;
  1169. XDisplay *display;
  1170. XGC gc;
  1171. XXGCValues gcvals;
  1172. XXtGCMask gc_mask;
  1173. Xint i,j;
  1174. X
  1175. X  GetXVals();
  1176. X  gc_mask = 0;
  1177. X  gc = XtGetGC(draw, gc_mask, &gcvals);
  1178. X  display = XtDisplay(draw);
  1179. X  win = XtWindow(draw);
  1180. X  if (!win) return;
  1181. X
  1182. X  XClearArea(display, win, 0, 0, wid, hgt, 0);
  1183. X
  1184. X  DrawRect(display, win, gc, s1bxx1, bxy1, s1bxx2, bxy2);
  1185. X  DrawRect(display, win, gc, s2bxx1, bxy1, s2bxx2, bxy2);
  1186. X  DrawRect(display, win, gc, bxx1, bxy1, bxx2, bxy2);
  1187. X  for (i = 0; i < H; i++) {
  1188. X     DrawSpace(display, win, gc, DRAWLEFTSIDE, i);
  1189. X     DrawSpace(display, win, gc, DRAWRIGHTSIDE, i);
  1190. X     for (j = 0; j < W; j++) 
  1191. X        DrawSpace(display, win, gc, j, i);
  1192. X  }
  1193. X  for (i = 0; i < H; i++) {
  1194. X     DrawPiece(display, win, gc, DRAWLEFTSIDE, i);
  1195. X     DrawPiece(display, win, gc, DRAWRIGHTSIDE, i);
  1196. X     for (j = 0; j < W; j++) 
  1197. X        DrawPiece(display, win, gc, j, i);
  1198. X  }
  1199. X  XtReleaseGC(draw, gc);
  1200. X}
  1201. X
  1202. X
  1203. X/*
  1204. X   returns the x,y pixel location of grid spot i,j
  1205. X*/
  1206. Xvoid GetSpace(i, j, xy1, xy2)
  1207. Xint i,j;
  1208. XPt *xy1, *xy2;
  1209. X{
  1210. Xint sx;
  1211. X   if (i == DRAWLEFTSIDE) {sx = s1bxx1; i = 0;}
  1212. X   else if (i == DRAWRIGHTSIDE) {sx = s2bxx1; i = 0;}
  1213. X   else sx = bxx1;
  1214. X     
  1215. X   xy1->x = sx + (i * (delta + 2)) + 1;
  1216. X   xy2->x = xy1->x + delta + 1;
  1217. X   xy1->y = bxy1 + (j * (delta + 2)) + 1;
  1218. X   xy2->y = xy1->y + delta + 1;
  1219. X}
  1220. X
  1221. X
  1222. X/*
  1223. X   Draws grid squard i,j
  1224. X*/
  1225. Xvoid DrawSpace(d, w, gc, i, j)
  1226. XDisplay * d;
  1227. XWindow w;
  1228. XGC gc;
  1229. Xint i,j;
  1230. X{
  1231. XPt one, two;
  1232. X   GetSpace(i, j, &one, &two);
  1233. X   DrawRect(d, w, gc, one.x, one.y, two.x, two.y);
  1234. X}
  1235. X
  1236. X
  1237. X/*
  1238. X   Selects grid square i,j
  1239. X*/
  1240. Xvoid SelectSpace(i,j)
  1241. Xint i,j;
  1242. X{
  1243. XPt one, two;
  1244. XDisplay * d;
  1245. XWindow w;
  1246. XGC gc;
  1247. XXGCValues gcvals;
  1248. XXtGCMask gc_mask;
  1249. X  gc_mask = GCForeground | GCBackground;
  1250. X  gcvals.foreground = fore;
  1251. X  gcvals.background = back;
  1252. X  gc = XtGetGC(draw, gc_mask, &gcvals);
  1253. X  d = XtDisplay(draw);
  1254. X  w = XtWindow(draw);
  1255. X  GetSpace(i, j, &one, &two);
  1256. X  DrawRect(d, w, gc, one.x+1, one.y+1, two.x-1, two.y-1);
  1257. X  selected = 1;
  1258. X  XtReleaseGC(draw,gc);
  1259. X  if (!hold) XmTextSetString(mess,"");
  1260. X}
  1261. X
  1262. X
  1263. X/*
  1264. X   Unselects grid square i,j
  1265. X*/
  1266. Xvoid UnselectSpace(i,j)
  1267. Xint i,j;
  1268. X{
  1269. XPt one, two;
  1270. XDisplay * d;
  1271. XWindow w;
  1272. XGC gc;
  1273. Xint l;
  1274. XXGCValues gcvals;
  1275. XXtGCMask gc_mask;
  1276. X  gc_mask = GCForeground | GCBackground;
  1277. X  gcvals.foreground = back;
  1278. X  gcvals.background = fore;
  1279. X  gc = XtGetGC(draw, gc_mask, &gcvals);
  1280. X  d = XtDisplay(draw);
  1281. X  w = XtWindow(draw);
  1282. X  GetSpace(i, j, &one, &two);
  1283. X  DrawRect(d, w, gc, one.x+1, one.y+1, two.x-1, two.y-1);
  1284. X  selected = 0;
  1285. X  XtReleaseGC(draw,gc);
  1286. X}
  1287. X
  1288. X
  1289. X/*
  1290. X   Draws piece depending on shape and color
  1291. X*/
  1292. Xvoid DrawPiece(d, w, gc, i, j) 
  1293. XDisplay * d;
  1294. XWindow w;
  1295. XGC gc;
  1296. Xint i;
  1297. Xint j;
  1298. X{
  1299. XPt one, two;
  1300. Xint x1, y1, x2, y2, ht, wd;
  1301. X  GetSpace(i, j, &one, &two);
  1302. X  x1 = one.x+5;
  1303. X  y1 = one.y+5;
  1304. X  x2 = two.x-5;
  1305. X  y2 = two.y-5;
  1306. X  ht =  y2 - y1+1;
  1307. X  wd =  x2 - x1+1;
  1308. X  if (i == DRAWLEFTSIDE) {
  1309. X     if (s[0].p[j]) {
  1310. X        if (s[0].p[j]->type == PIECE_SQUARE) {
  1311. X           DrawRect(d, w, gc, x1, y1, x2, y2);
  1312. X           if (s[0].p[j]->color == PIECE_BLACK) 
  1313. X              XFillRectangle(d, w, gc, x1, y1, wd, ht);
  1314. X        }
  1315. X        if (s[0].p[j]->type == PIECE_ROUND) {
  1316. X           XDrawArc(d, w, gc, x1, y1, wd, ht, 0, 64*360);
  1317. X           if (s[0].p[j]->color == PIECE_BLACK) 
  1318. X              XFillArc(d, w, gc, x1, y1, wd, ht, 0, 64*360);
  1319. X        }
  1320. X     }
  1321. X  }
  1322. X  else if (i == DRAWRIGHTSIDE) { 
  1323. X     if (s[1].p[j]) {
  1324. X        if (s[1].p[j]->type == PIECE_SQUARE) {
  1325. X           DrawRect(d, w, gc, x1, y1, x2, y2);
  1326. X           if (s[1].p[j]->color == PIECE_BLACK) 
  1327. X              XFillRectangle(d, w, gc, x1, y1, wd, ht);
  1328. X        }
  1329. X        if (s[1].p[j]->type == PIECE_ROUND) {
  1330. X           XDrawArc(d, w, gc, x1, y1, wd, ht, 0, 64*360);
  1331. X           if (s[1].p[j]->color == PIECE_BLACK) 
  1332. X              XFillArc(d, w, gc, x1, y1, wd, ht, 0, 64*360);
  1333. X        }
  1334. X     }
  1335. X  }
  1336. X  else {
  1337. X     if (b->pieces[i][j]) {
  1338. X        if (b->pieces[i][j]->type == PIECE_SQUARE) {
  1339. X           XDrawRectangle(d, w, gc, x1, y1, wd, ht);
  1340. X           if (b->pieces[i][j]->color == PIECE_BLACK) 
  1341. X              XFillRectangle(d, w, gc, x1, y1, wd, ht);
  1342. X        }
  1343. X        if (b->pieces[i][j]->type == PIECE_ROUND) {
  1344. X           XDrawArc(d, w, gc, x1, y1, wd, ht, 0, 64*360);
  1345. X           if (b->pieces[i][j]->color == PIECE_BLACK) 
  1346. X              XFillArc(d, w, gc, x1, y1, wd, ht, 0, 64*360);
  1347. X        }
  1348. X     }
  1349. X  }
  1350. X}
  1351. X
  1352. X
  1353. X/*
  1354. X   Button press callback.  Determines actions based upon location
  1355. X   of pointer when button is pressed, whether a square is already
  1356. X   selected, etc.
  1357. X*/
  1358. Xvoid ButtonPress1 (wg, event, params, num_params)
  1359. XWidget wg;                                       /*The draw widget.*/
  1360. XXButtonEvent *event;                            /*The button event.*/
  1361. XString *params;                                 /*Not used.*/
  1362. XCardinal num_params;                            /*Not used.*/
  1363. X{
  1364. Xint x,y,i,j,m,n;
  1365. XPt t;
  1366. XArg wargs[2];
  1367. X   if (hold) return;
  1368. X   x = event->x;
  1369. X   y = event->y;
  1370. X   if ((y > bxy1) && (y < bxy2)) {
  1371. X      if ((x > s1bxx1) && (x < s1bxx2)) 
  1372. X         i = DRAWLEFTSIDE;
  1373. X      else if ((x > s2bxx1) && (x < s2bxx2)) 
  1374. X         i = DRAWRIGHTSIDE;
  1375. X      else if ((x > bxx1) && (x < bxx2)) 
  1376. X         i = (x-bxx1) / (delta+2);
  1377. X      else return;
  1378. X      j = (y-bxy1) / (delta+2);
  1379. X   }
  1380. X   else return;
  1381. X   if (!selected) {
  1382. X        if (DGetPiece(i,j)) {
  1383. X       SelectSpace(i,j);
  1384. X           selected = 1;
  1385. X           selpt.x = i;
  1386. X           selpt.y = j;
  1387. X        }
  1388. X        else {
  1389. X          XmTextSetString(mess, STR_BAD_SELECT);
  1390. X        }
  1391. X   }
  1392. X   else {
  1393. X        if ((i == selpt.x) && (j == selpt.y)) {
  1394. X           UnselectSpace(selpt.x, selpt.y);
  1395. X           selected = 0;
  1396. X        }
  1397. X        else if (DGetPiece(i,j)) {
  1398. X           UnselectSpace(selpt.x, selpt.y);
  1399. X       SelectSpace(i,j);
  1400. X           selpt.x = i;
  1401. X           selpt.y = j;
  1402. X        }
  1403. X        else {
  1404. X          t.x = i; t.y = j;
  1405. X          if (CheckMove(selpt, t)) {
  1406. X             UnselectSpace(selpt.x, selpt.y);
  1407. X             MvPiece(selpt, t);
  1408. X             Last.x = i; Last.y = j;
  1409. X             selected = 0;
  1410. X             turn ^= 1;
  1411. X             ChangeTurn();
  1412. X          }
  1413. X        }
  1414. X        if (CheckWinner(&i, &j, &x, &y)) {
  1415. X           n = 0;
  1416. X           if (b->pieces[i][j]->color == PIECE_BLACK) {
  1417. X              XmTextSetString(mess,STR_RIGHT_WIN);
  1418. X              XtSetArg(wargs[n],XmNlabelPixmap, goveright); n++;
  1419. X           }
  1420. X           else {
  1421. X              XmTextSetString(mess,STR_LEFT_WIN);
  1422. X              XtSetArg(wargs[n],XmNlabelPixmap, goverleft); n++;
  1423. X           }
  1424. X           hold = 1;
  1425. X           for (m = 0; m < 4; m++) {
  1426. X              SelectSpace(i,j);
  1427. X              i+= x; j+=y;
  1428. X           }
  1429. X           XtSetValues(lt, wargs, n);
  1430. X           XtSetValues(rt, wargs, n);
  1431. X        }
  1432. X           
  1433. X   }
  1434. X}
  1435. X
  1436. X
  1437. X/*
  1438. X   Moves piece from src grid location to dest grid location, rewriting
  1439. X   piece on screen
  1440. X*/
  1441. Xvoid MvPiece(src, dst)
  1442. XPt src,dst;
  1443. X{
  1444. XPt sone, stwo;
  1445. XPt done, dtwo;
  1446. XDisplay * d;
  1447. XWindow w;
  1448. XGC gc;
  1449. Xint l;
  1450. XXGCValues gcvals;
  1451. XXtGCMask gc_mask;
  1452. X  gc_mask = GCForeground | GCBackground;
  1453. X  gcvals.foreground = fore;
  1454. X  gcvals.background = back;
  1455. X  gc = XtGetGC(draw, gc_mask, &gcvals);
  1456. X  d = XtDisplay(draw);
  1457. X  w = XtWindow(draw);
  1458. X  GetSpace(src.x, src.y, &sone, &stwo);
  1459. X  GetSpace(dst.x, dst.y, &done, &dtwo);
  1460. X  XClearArea(d, w, sone.x+1, sone.y+1, delta, delta, 0);
  1461. X  if (dst.x == DRAWLEFTSIDE)
  1462. X     s[0].p[dst.y] = DGetPiece(src.x,src.y);
  1463. X  else if (dst.x == DRAWRIGHTSIDE)
  1464. X     s[1].p[dst.y] = DGetPiece(src.x,src.y);
  1465. X  else 
  1466. X     b->pieces[dst.x][dst.y] = DGetPiece(src.x,src.y);
  1467. X  if (src.x == DRAWLEFTSIDE)
  1468. X     s[0].p[src.y] = NULL;
  1469. X  else if (src.x == DRAWRIGHTSIDE)
  1470. X     s[1].p[src.y] = NULL;
  1471. X  else 
  1472. X     b->pieces[src.x][src.y] = NULL;
  1473. X  if ((dst.x != DRAWLEFTSIDE) && (dst.x != DRAWRIGHTSIDE))
  1474. X     Magnetize(dst.x,dst.y);
  1475. X  DrawPiece(d, w, gc, dst.x, dst.y);
  1476. X  XtReleaseGC(draw, gc);
  1477. X}
  1478. X
  1479. X
  1480. X/*
  1481. X   returns piece at location i,j
  1482. X*/
  1483. XPieceType * DGetPiece(i,j)
  1484. Xint i,j;
  1485. X{
  1486. X  if (i == DRAWLEFTSIDE) 
  1487. X     return (s[0].p[j]);
  1488. X  else if (i == DRAWRIGHTSIDE) 
  1489. X     return (s[1].p[j]);
  1490. X  else 
  1491. X     return (b->pieces[i][j]);
  1492. X}
  1493. X
  1494. X
  1495. X/*
  1496. X    Checks a move against the rules of the games
  1497. X*/
  1498. Xint CheckMove(one, two)
  1499. XPt one, two;
  1500. X{
  1501. Xint i,j,l,m;
  1502. X   if ((one.x == Last.x) && (one.y == Last.y)) {
  1503. X      XmTextSetString(mess,STR_MOVE_LAST);
  1504. X      return(0);
  1505. X   }
  1506. X   if (two.x > W) {
  1507. X      XmTextSetString(mess,STR_SIDE_MOVE);
  1508. X      return(0);
  1509. X   }
  1510. X   if (one.x > W) {
  1511. X      if (turn != (one.x - DRAWLEFTSIDE)) {
  1512. X         XmTextSetString(mess,STR_WRONG_SIDE);
  1513. X         return(0);
  1514. X      }
  1515. X      return(1);
  1516. X   }
  1517. X   i = two.x - one.x;
  1518. X   j = SGN(i);
  1519. X   i = ABS(i);
  1520. X   l = two.y - one.y;
  1521. X   m = SGN(l);
  1522. X   l = ABS(l);
  1523. X   if ((i > 2) || (l > 2)) {
  1524. X      XmTextSetString(mess,STR_FAR_MOVE);
  1525. X      return(0);
  1526. X   }
  1527. X   if ((i == 2) || (l == 2)) {
  1528. X      if (!b->pieces[one.x+((i/2)*j)][one.y+((l/2)*m)]) {
  1529. X         XmTextSetString(mess,STR_MUST_JUMP);
  1530. X         return(0);
  1531. X      }
  1532. X      if ((i == 1) || (l == 1)) {
  1533. X         XmTextSetString(mess,STR_SAME_DIR);
  1534. X         return(0);
  1535. X      }
  1536. X   }
  1537. X   return(1);
  1538. X}
  1539. X
  1540. X
  1541. X/*
  1542. X   Resets the board to start state
  1543. X*/
  1544. Xvoid ResetBoard(w, client_data, call_data)
  1545. XWidget w;
  1546. Xcaddr_t client_data;
  1547. XXmAnyCallbackStruct *call_data;
  1548. X{
  1549. X  KillBoard(s);
  1550. X  InitBoard(s,H,W); 
  1551. X  BoardShuffle();
  1552. X  DrawGame(w,client_data, call_data);
  1553. X  hold = 0;
  1554. X  selected = 0;
  1555. X  Last.x = -1;
  1556. X  Last.y = -1;
  1557. X  turn = 0;
  1558. X  XmTextSetString(mess,"");
  1559. X  ChangeTurn();
  1560. X}
  1561. X
  1562. X
  1563. X/*
  1564. X   Changes the turn pixmaps
  1565. X*/
  1566. Xvoid ChangeTurn() 
  1567. X{
  1568. XArg wargs[10];
  1569. Xint n;
  1570. X  if (turn == 1) {
  1571. X     n = 0;
  1572. X     XtSetArg(wargs[n],XmNlabelPixmap, rturn); n++;
  1573. X     XtSetValues(lt, wargs, n);
  1574. X     XtSetValues(rt, wargs, n);
  1575. X  }
  1576. X  else {
  1577. X     n = 0;
  1578. X     XtSetArg(wargs[n],XmNlabelPixmap, lturn); n++;
  1579. X     XtSetValues(lt, wargs, n);
  1580. X     XtSetValues(rt, wargs, n);
  1581. X  }
  1582. X}
  1583. X
  1584. X
  1585. X/*
  1586. X    Brings up the help window
  1587. X*/
  1588. Xvoid ShowHelp(w, client_data, call_data)
  1589. XWidget w;
  1590. Xcaddr_t client_data;
  1591. XXmAnyCallbackStruct *call_data;
  1592. X{
  1593. X   XtManageChild(help);
  1594. X}
  1595. X
  1596. X
  1597. X/*
  1598. X    Closes the help window
  1599. X*/
  1600. Xvoid CloseHelp(w, client_data, call_data)
  1601. XWidget w;
  1602. Xcaddr_t client_data;
  1603. XXmAnyCallbackStruct *call_data;
  1604. X{
  1605. X   XtUnmanageChild(help);
  1606. X}
  1607. X
  1608. X
  1609. X
  1610. X/*
  1611. X    Brings up the about window
  1612. X*/
  1613. Xvoid ShowAbout(w, client_data, call_data)
  1614. XWidget w;
  1615. Xcaddr_t client_data;
  1616. XXmAnyCallbackStruct *call_data;
  1617. X{
  1618. X   XtManageChild(about);
  1619. X}
  1620. X
  1621. X
  1622. X/*
  1623. X    Closes the about window
  1624. X*/
  1625. Xvoid CloseAbout(w, client_data, call_data)
  1626. XWidget w;
  1627. Xcaddr_t client_data;
  1628. XXmAnyCallbackStruct *call_data;
  1629. X{
  1630. X   XtUnmanageChild(about);
  1631. X}
  1632. END_OF_FILE
  1633. if test 13185 -ne `wc -c <'xboard.c'`; then
  1634.     echo shar: \"'xboard.c'\" unpacked with wrong size!
  1635. fi
  1636. # end of 'xboard.c'
  1637. fi
  1638. if test -f 'xboard.h' -a "${1}" != "-c" ; then 
  1639.   echo shar: Will not clobber existing file \"'xboard.h'\"
  1640. else
  1641. echo shar: Extracting \"'xboard.h'\" \(1062 characters\)
  1642. sed "s/^X//" >'xboard.h' <<'END_OF_FILE'
  1643. X#define DRAWLEFTSIDE    10
  1644. X#define DRAWRIGHTSIDE    11
  1645. X#define STR_BAD_MOVE    "Cannot move there."
  1646. X#define STR_BAD_SELECT  "Space is Empty."
  1647. X#define STR_RIGHT_WIN    "The Right Side WINS!!"
  1648. X#define STR_LEFT_WIN    "The Left Side WINS!!"
  1649. X#define STR_MOVE_LAST    "Cannot move piece last moved by other player."
  1650. X#define STR_SIDE_MOVE   "Cannot move piece back on side bars."
  1651. X#define STR_WRONG_SIDE  "Cannot move piece from other player's side bar."
  1652. X#define STR_FAR_MOVE    "Cannot move piece that far."
  1653. X#define STR_MUST_JUMP   "Cannot move piece 2 spaces without a jump."
  1654. X#define STR_SAME_DIR    "Must move piece 1 or 2 in same direction."
  1655. X
  1656. X#define ABS(x)    (((x)<0)? (-1*(x)):(x))
  1657. X#define SGN(x)    (((x)<0)? -1:(((x) == 0)? 0:1))
  1658. X
  1659. Xstruct _Pt {
  1660. X  int x;
  1661. X  int y;
  1662. X};
  1663. Xtypedef struct _Pt Pt;
  1664. X
  1665. Xvoid DrawGame();
  1666. Xvoid DrawRect();
  1667. Xvoid DrawSpace();
  1668. Xvoid GetXVals();
  1669. Xvoid ResizeGame();
  1670. Xvoid DrawPiece();
  1671. Xvoid ButtonPress1();
  1672. Xvoid MvPiece();
  1673. XPieceType * DGetPiece();
  1674. Xint CheckMove();
  1675. Xvoid ResetBoard();
  1676. Xvoid ChangeTurn();
  1677. Xvoid ShowHelp();
  1678. Xvoid CloseHelp();
  1679. Xvoid ShowAbout();
  1680. Xvoid CloseAbout();
  1681. END_OF_FILE
  1682. if test 1062 -ne `wc -c <'xboard.h'`; then
  1683.     echo shar: \"'xboard.h'\" unpacked with wrong size!
  1684. fi
  1685. # end of 'xboard.h'
  1686. fi
  1687. echo shar: End of archive 1 \(of 2\).
  1688. cp /dev/null ark1isdone
  1689. MISSING=""
  1690. for I in 1 2 ; do
  1691.     if test ! -f ark${I}isdone ; then
  1692.     MISSING="${MISSING} ${I}"
  1693.     fi
  1694. done
  1695. if test "${MISSING}" = "" ; then
  1696.     echo You have unpacked both archives.
  1697.     rm -f ark[1-9]isdone
  1698. else
  1699.     echo You still need to unpack the following archives:
  1700.     echo "        " ${MISSING}
  1701. fi
  1702. ##  End of shell archive.
  1703. exit 0
  1704.