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