home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / games / volume13 / xsokoban / part01 < prev    next >
Encoding:
Internet Message Format  |  1992-01-12  |  55.7 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: v13i001:  xsokoban - X11 based, get the money game (Version 2), Part01/02
  5. Message-ID: <2121@masterCNA.TEK.COM>
  6. Date: 5 Dec 91 16:33:39 GMT
  7. Sender: news@masterCNA.TEK.COM
  8. Lines: 1990
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: Kevin Solie <kevins@ms.uky.edu>
  12. Posting-number: Volume 13, Issue 1
  13. Archive-name: xsokoban/Part01
  14. Environment: x11, xlib
  15.  
  16.  
  17. #! /bin/sh
  18. # This is a shell archive.  Remove anything before this line, then unpack
  19. # it by saving it into a file and typing "sh file".  To overwrite existing
  20. # files, type "sh file -c".  You can also feed this as standard input via
  21. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  22. # will see the following message at the end:
  23. #        "End of archive 1 (of 2)."
  24. # Contents:  README MANIFEST icon.xbm initx.c initx.h makefile play.c
  25. #   playerstore.xbm readscreen.c save.c score.c screens
  26. #   screens/screen.10 screens/screen.14 screens/screen.20
  27. #   screens/screen.22 screens/screen.24 screens/screen.25
  28. #   screens/screen.35 screens/screen.36 screens/screen.37
  29. #   screens/screen.39 screens/screen.41 screens/screen.50 showscreen.c
  30. #   sok.c sokoban.h
  31. # Wrapped by billr@saab on Wed Dec  4 16:49:46 1991
  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'\" \(808 characters\)
  37. sed "s/^X//" >'README' <<'END_OF_FILE'
  38. X
  39. X    Welcome to Xsokoban. This implementation is very incomplete. I stole
  40. Xthe logic code from a person who stole the idea from a PC game. The original
  41. Xsokoban was based on curses so I simply put an X11 frontend around it. 
  42. XThis game is, however Shareware. A $.50 donation (thats right, 50 cents. I just
  43. Xwant to see if anyone ever sends money) should be sent to me if you use this 
  44. Xsrc. Also, if fancy workin on this please send me updates of your changes.
  45. X
  46. XNOTE:
  47. X        The makefile is designed to be run as root and puts things in
  48. X        a games dir. For a personal scorefile (If you dont have access to
  49. X        root) just change the makefile.
  50. X
  51. X
  52. Xkevins@ms.uky.edu
  53. X
  54. XSend $$$$ to
  55. X
  56. XKevin Solie
  57. X273 Lexington Ave.
  58. XLexington Ky. 40508
  59. X
  60. XAdditional Note: Be sure to edit the path names in sokoban.h to match your
  61. Xsystem/environment.
  62. END_OF_FILE
  63. if test 808 -ne `wc -c <'README'`; then
  64.     echo shar: \"'README'\" unpacked with wrong size!
  65. fi
  66. # end of 'README'
  67. fi
  68. if test -f 'MANIFEST' -a "${1}" != "-c" ; then 
  69.   echo shar: Will not clobber existing file \"'MANIFEST'\"
  70. else
  71. echo shar: Extracting \"'MANIFEST'\" \(2377 characters\)
  72. sed "s/^X//" >'MANIFEST' <<'END_OF_FILE'
  73. X   File Name        Archive #    Description
  74. X-----------------------------------------------------------
  75. X MANIFEST                   1    This shipping list
  76. X README                     1    
  77. X cursor.xbm                 2    
  78. X ground.xbm                 2    
  79. X icon.xbm                   1    
  80. X initx.c                    1    
  81. X initx.h                    1    
  82. X makefile                   1    
  83. X obj.h                      2    
  84. X packet.xbm                 2    
  85. X play.c                     1    
  86. X player.xbm                 2    
  87. X playerstore.xbm            1    
  88. X readscreen.c               1    
  89. X save.c                     1    
  90. X save.xbm                   2    
  91. X score.c                    1    
  92. X screens                    1    
  93. X screens/screen.1           2    
  94. X screens/screen.10          1    
  95. X screens/screen.11          2    
  96. X screens/screen.12          2    
  97. X screens/screen.13          2    
  98. X screens/screen.14          1    
  99. X screens/screen.15          2    
  100. X screens/screen.16          2    
  101. X screens/screen.17          2    
  102. X screens/screen.18          2    
  103. X screens/screen.19          2    
  104. X screens/screen.2           2    
  105. X screens/screen.20          1    
  106. X screens/screen.21          2    
  107. X screens/screen.22          1    
  108. X screens/screen.23          2    
  109. X screens/screen.24          1    
  110. X screens/screen.25          1    
  111. X screens/screen.26          2    
  112. X screens/screen.27          2    
  113. X screens/screen.28          2    
  114. X screens/screen.29          2    
  115. X screens/screen.3           2    
  116. X screens/screen.30          2    
  117. X screens/screen.31          2    
  118. X screens/screen.32          2    
  119. X screens/screen.33          2    
  120. X screens/screen.34          2    
  121. X screens/screen.35          1    
  122. X screens/screen.36          1    
  123. X screens/screen.37          1    
  124. X screens/screen.38          2    
  125. X screens/screen.39          1    
  126. X screens/screen.4           2    
  127. X screens/screen.40          2    
  128. X screens/screen.41          1    
  129. X screens/screen.42          2    
  130. X screens/screen.43          2    
  131. X screens/screen.44          2    
  132. X screens/screen.45          2    
  133. X screens/screen.46          2    
  134. X screens/screen.47          2    
  135. X screens/screen.48          2    
  136. X screens/screen.49          2    
  137. X screens/screen.5           2    
  138. X screens/screen.50          1    
  139. X screens/screen.6           2    
  140. X screens/screen.7           2    
  141. X screens/screen.8           2    
  142. X screens/screen.9           2    
  143. X showscreen.c               1    
  144. X sok.c                      1    
  145. X sokoban.h                  1    
  146. X store.xbm                  2    
  147. X wall.xbm                   2    
  148. END_OF_FILE
  149. if test 2377 -ne `wc -c <'MANIFEST'`; then
  150.     echo shar: \"'MANIFEST'\" unpacked with wrong size!
  151. fi
  152. # end of 'MANIFEST'
  153. fi
  154. if test -f 'icon.xbm' -a "${1}" != "-c" ; then 
  155.   echo shar: Will not clobber existing file \"'icon.xbm'\"
  156. else
  157. echo shar: Extracting \"'icon.xbm'\" \(1676 characters\)
  158. sed "s/^X//" >'icon.xbm' <<'END_OF_FILE'
  159. X#define icon_width 64
  160. X#define icon_height 32
  161. Xstatic char icon_bits[] = {
  162. X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  163. X   0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  164. X   0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
  165. X   0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  166. X   0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
  167. X   0x00, 0x00, 0x00, 0x0e, 0x00, 0x38, 0x3c, 0x00, 0x0e, 0x00, 0x0c, 0x12,
  168. X   0x80, 0x20, 0x66, 0x00, 0x19, 0x00, 0x0b, 0x31, 0x80, 0x20, 0x46, 0x00,
  169. X   0x31, 0x80, 0x09, 0x21, 0x80, 0x21, 0x44, 0x00, 0x21, 0x80, 0x08, 0x21,
  170. X   0x00, 0x23, 0x6c, 0x00, 0x21, 0x80, 0x0c, 0x21, 0x00, 0x3e, 0x38, 0x02,
  171. X   0x33, 0x80, 0x1f, 0x31, 0x00, 0x00, 0x00, 0x03, 0x1e, 0x00, 0x10, 0x10,
  172. X   0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0xc0, 0x00,
  173. X   0x00, 0x07, 0x00, 0x10, 0x00, 0x00, 0x70, 0x00, 0x80, 0x0d, 0x00, 0x10,
  174. X   0x00, 0x00, 0xf8, 0x07, 0xc0, 0x08, 0x00, 0x10, 0x00, 0x00, 0x6c, 0x00,
  175. X   0xe0, 0x08, 0x00, 0x30, 0x00, 0x00, 0x43, 0x00, 0x98, 0x0d, 0x00, 0x00,
  176. X   0x00, 0x40, 0x41, 0x00, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
  177. X   0x0e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0xf0, 0x01, 0x00, 0x00,
  178. X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  179. X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  180. X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  181. X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  182. X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  183. X   0x00, 0x00, 0x00, 0x00};
  184. END_OF_FILE
  185. if test 1676 -ne `wc -c <'icon.xbm'`; then
  186.     echo shar: \"'icon.xbm'\" unpacked with wrong size!
  187. fi
  188. # end of 'icon.xbm'
  189. fi
  190. if test -f 'initx.c' -a "${1}" != "-c" ; then 
  191.   echo shar: Will not clobber existing file \"'initx.c'\"
  192. else
  193. echo shar: Extracting \"'initx.c'\" \(3503 characters\)
  194. sed "s/^X//" >'initx.c' <<'END_OF_FILE'
  195. X#include <stdio.h>
  196. X#include <X11/Xlib.h>
  197. X#include <X11/Xutil.h>
  198. X#include "sokoban.h"
  199. X#include "initx.h"
  200. X#include "obj.h"
  201. X
  202. X#include "icon.xbm"  
  203. X#include "cursor.xbm"
  204. X#include "ground.xbm"
  205. X#include "packet.xbm"
  206. X#include "player.xbm"
  207. X#include "playerstore.xbm"
  208. X#include "save.xbm"
  209. X#include "store.xbm"
  210. X#include "wall.xbm"
  211. X
  212. XDisplay                *dpy;
  213. XWindow                win;
  214. XGC                    gc,gclear;
  215. XPixmap                bitmap,
  216. X                    cursor_bitmap;
  217. XCursor                cursor;
  218. XXColor                fg,bg,dummy;
  219. Xunsigned long             attribmask;
  220. XXGCValues             gcv;
  221. XXSizeHints            xsh;
  222. XXSetWindowAttributes    xswa;
  223. XXWMHints                 xwmh;
  224. XFont                    font;
  225. Xchar                    sline[80];
  226. XXSizeHints                hints;
  227. XPixmap                icon;
  228. X
  229. Xvoid load_pieces();
  230. X
  231. Xvoid killx()
  232. X{
  233. X    XDestroyWindow(dpy,win);
  234. X     XCloseDisplay(dpy);
  235. X}
  236. Xvoid initx()
  237. X{
  238. X
  239. X    if ((dpy = XOpenDisplay(NULL)) == NULL) {
  240. X        fprintf(stderr,"\tCannot open %s\n",DISPLAYNAME);
  241. X        exit(1);
  242. X    }
  243. X
  244. X    xswa.colormap = COLORMAP;
  245. X    xswa.bit_gravity = CenterGravity;
  246. X    xswa.border_pixel = BLACKPIXEL;
  247. X    xswa.background_pixel = WHITEPIXEL;
  248. X    attribmask = ( CWColormap | CWBitGravity | CWBorderPixel | CWBackPixel);
  249. X    win = XCreateWindow(dpy,ROOT,XORIGIN,YORIGIN,PIXMAPX*MAXCOL,
  250. X        PIXMAPY*MAXROW+20,BORDERWIDTH,DEPTH,InputOutput,CopyFromParent,attribmask,&xswa);
  251. X    if ((win==BadMatch)||(win==BadAlloc)||(win==BadColor)||
  252. X        (win==BadCursor)||(win==BadPixmap)||(win==BadValue)||(win==BadWindow))    {
  253. X        fprintf(stderr,"\tHeeeeeeeyyy mon, can't create window\n");
  254. X        exit (-1);
  255. X    }    
  256. X
  257. X    cursor_bitmap = XCreateBitmapFromData(dpy,win,cursor_bits,cursor_width,cursor_height);
  258. X    icon = XCreateBitmapFromData(dpy,ROOT,icon_bits,icon_width,icon_height);    
  259. X
  260. X     XLookupColor(dpy,COLORMAP,"black",&dummy,&fg);
  261. X     XLookupColor(dpy,COLORMAP,"white",&dummy,&bg);
  262. X     xswa.cursor = XCreatePixmapCursor(dpy,cursor_bitmap,cursor_bitmap,&fg,&bg,16,4);
  263. X     XChangeWindowAttributes(dpy,win,CWCursor,&xswa);
  264. X    xwmh.initial_state = NormalState;
  265. X    xwmh.flags = StateHint; 
  266. X    XSetWMHints(dpy,win,&xwmh); 
  267. X
  268. X    hints.width = hints.min_width = hints.max_width = PIXMAPX*MAXCOL;
  269. X    hints.height = hints.min_height = hints.max_height = PIXMAPY*MAXROW+20;
  270. X    hints.flags = PMinSize|PMaxSize|PSize;
  271. X
  272. X    XSetStandardProperties(dpy,win,TITLE,TITLE,icon,NULL,0,&hints);
  273. X    load_pieces();
  274. X
  275. X    font = XLoadFont(dpy,"9x15");
  276. X          
  277. X    gcv.function = GXcopy;
  278. X    gcv.font = font;
  279. X    gcv.foreground = BLACKPIXEL;
  280. X    gcv.background = WHITEPIXEL;
  281. X    gcv.graphics_exposures = FALSE;
  282. X    gc = XCreateGC(dpy,win,(GCFont|GCGraphicsExposures|GCForeground|GCBackground|GCFunction),&gcv);
  283. X
  284. X    gcv.function = GXcopy;
  285. X    gcv.font = font;
  286. X    gcv.foreground = WHITEPIXEL;
  287. X    gcv.background = BLACKPIXEL;
  288. X    gcv.graphics_exposures = FALSE;
  289. X    gclear = XCreateGC(dpy,win,(GCFont|GCGraphicsExposures|GCForeground|GCBackground|GCFunction),&gcv);
  290. X
  291. X
  292. X    XMapRaised(dpy,win);
  293. X    showscreen();
  294. X    sprintf(sline," Level:       Packets:       Saved:      Moves:       Pushes:");
  295. X
  296. X    XSync(dpy,False);
  297. X}
  298. Xvoid load_pieces()
  299. X{
  300. X    player.obj_display = XCreateBitmapFromData(dpy,win,player_bits,player_width,player_height);
  301. X    playerstore.obj_display = XCreateBitmapFromData(dpy,win,playerstore_bits,playerstore_width,playerstore_height);
  302. X    wall.obj_display = XCreateBitmapFromData(dpy,win,wall_bits,wall_width,wall_height);
  303. X    store.obj_display = XCreateBitmapFromData(dpy,win,store_bits,store_width,store_height);
  304. X    packet.obj_display = XCreateBitmapFromData(dpy,win,packet_bits,packet_width,packet_height);
  305. X    save.obj_display = XCreateBitmapFromData(dpy,win,save_bits,save_width,save_height);
  306. X    ground.obj_display = XCreateBitmapFromData(dpy,win,ground_bits,ground_width,ground_height);
  307. X}
  308. END_OF_FILE
  309. if test 3503 -ne `wc -c <'initx.c'`; then
  310.     echo shar: \"'initx.c'\" unpacked with wrong size!
  311. fi
  312. # end of 'initx.c'
  313. fi
  314. if test -f 'initx.h' -a "${1}" != "-c" ; then 
  315.   echo shar: Will not clobber existing file \"'initx.h'\"
  316. else
  317. echo shar: Extracting \"'initx.h'\" \(609 characters\)
  318. sed "s/^X//" >'initx.h' <<'END_OF_FILE'
  319. X#define NUMQ    5 
  320. X#define TRUE (1==1)
  321. X#define FALSE (1==0)
  322. X#define BORDER    1
  323. X#define BORDERWIDTH 3
  324. X#define TITLE "Sokoban"
  325. X#define FONT "-adobe-times-bold-r-normal--18-180-75-75-p-99-iso8859-1"
  326. X#define WIDTH 200
  327. X#define HEIGHT 200
  328. X#define XORIGIN 1
  329. X#define YORIGIN 1
  330. X#define SCR  DefaultScreen(dpy)
  331. X#define DEPTH  DefaultDepth(dpy,SCR)
  332. X#define ROOT DefaultRootWindow(dpy)
  333. X#define COLORMAP DefaultColormap(dpy,SCR)
  334. X#define BLACKPIXEL     BlackPixel(dpy,SCR)
  335. X#define WHITEPIXEL  WhitePixel(dpy,SCR)
  336. X#define DWIDTH DisplayWidth(dpy,SCR)
  337. X#define DHEIGHT DisplayHeight(dpy,SCR)
  338. X#define DISPLAYNAME XDisplayName(NULL)
  339. END_OF_FILE
  340. if test 609 -ne `wc -c <'initx.h'`; then
  341.     echo shar: \"'initx.h'\" unpacked with wrong size!
  342. fi
  343. # end of 'initx.h'
  344. fi
  345. if test -f 'makefile' -a "${1}" != "-c" ; then 
  346.   echo shar: Will not clobber existing file \"'makefile'\"
  347. else
  348. echo shar: Extracting \"'makefile'\" \(1177 characters\)
  349. sed "s/^X//" >'makefile' <<'END_OF_FILE'
  350. XPARALLEL = # &
  351. XCCOPT= -O
  352. XOBJECTS= sok.o readscreen.o showscreen.o play.o save.o score.o initx.o
  353. XCC = cc
  354. XINCLUDE = -I/usr/X11R5/include
  355. X
  356. Xsokoban: $(PARALLEL) $(OBJECTS)
  357. X    $(CC) $(CCOPT) -o sokoban $(OBJECTS) -lX11 
  358. X
  359. Xinstall:    sokoban
  360. X    cp sokoban /usr/games/sokoban
  361. X    chmod 4711 /usr/games/sokoban
  362. X    -mkdir /usr/games/lib/sokoban
  363. X    -mkdir /usr/games/lib/sokoban/screens
  364. X    -mkdir /usr/games/lib/sokoban/save
  365. X    cp screen.* /usr/games/lib/sokoban/screens
  366. X    @echo "\007"
  367. X    @echo "Login as games, and \"sokoban -c\" to generate new score file"
  368. Xlocal:    sokoban
  369. X    cp sokoban /u/s7/staff/kevins/bin/xsokoban
  370. X    chmod 4755 /u/s7/staff/kevins/bin/xsokoban
  371. X    chown games /u/s7/staff/kevins/bin/xsokoban
  372. X    chgrp games /u/s7/staff/kevins/bin/xsokoban
  373. Xclean:
  374. X    rm -f *.o sokoban
  375. X
  376. Xsok.o: sok.c sokoban.h
  377. X    $(CC) $(CCOPT) -c sok.c
  378. X
  379. Xreadscreen.o: readscreen.c sokoban.h
  380. X    $(CC) $(CCOPT) -c readscreen.c
  381. X
  382. Xshowscreen.o: showscreen.c 
  383. X    $(CC) $(CCOPT) -c showscreen.c
  384. X
  385. Xplay.o: play.c sokoban.h
  386. X    $(CC) $(CCOPT) $(INCLUDE) -c play.c
  387. X
  388. Xsave.o: save.c sokoban.h
  389. X    $(CC) $(CCOPT) -c save.c
  390. X
  391. Xscore.o: score.c sokoban.h
  392. X    $(CC) $(CCOPT) -c score.c
  393. X
  394. Xinitx.o: initx.c sokoban.h obj.h initx.h
  395. X    $(CC) $(CCOPT) $(INCLUDE) -c initx.c
  396. END_OF_FILE
  397. if test 1177 -ne `wc -c <'makefile'`; then
  398.     echo shar: \"'makefile'\" unpacked with wrong size!
  399. fi
  400. # end of 'makefile'
  401. fi
  402. if test -f 'play.c' -a "${1}" != "-c" ; then 
  403.   echo shar: Will not clobber existing file \"'play.c'\"
  404. else
  405. echo shar: Extracting \"'play.c'\" \(6649 characters\)
  406. sed "s/^X//" >'play.c' <<'END_OF_FILE'
  407. X#include <stdio.h>
  408. X#include <ctype.h>
  409. X#include <X11/keysym.h>
  410. X#include "sokoban.h"
  411. X#include "obj.h"
  412. X
  413. X/* defining the types of move */
  414. X#define MOVE         1
  415. X#define PUSH         2
  416. X#define SAVE         3
  417. X#define UNSAVE     4
  418. X#define STOREMOVE     5
  419. X#define STOREPUSH     6
  420. X
  421. X#define EVMASK KeyPressMask | ExposureMask | ButtonPressMask | FocusChangeMask
  422. X
  423. X#if 0
  424. Xvoid doit(void);
  425. X#else
  426. Xvoid doit();
  427. X#endif
  428. Xextern dispstatus();
  429. X
  430. Xextern char    map[MAXROW+1][MAXCOL+1];
  431. Xextern short    rows, cols, level, moves, pushes, savepack, packets;
  432. Xextern short    scorelevel, scoremoves, scorepushes;
  433. Xextern POS    ppos;
  434. Xextern Display    *dpy;
  435. Xextern Window    win;
  436. Xextern GC        gc;
  437. Xextern char    sline[80];
  438. X
  439. Xstatic XEvent    xev;
  440. Xstatic POS    tpos1,            /* testpos1: 1 pos. over/under/left/right */
  441. X            tpos2,            /* testpos2: 2 pos.  "                    */
  442. X            lastppos,            /* the last player position (for undo)    */
  443. X            lasttpos1,lasttpos2;/* last test positions (for undo)         */
  444. Xstatic char     lppc, ltp1c, ltp2c;    /* the char for the above pos. (for undo) */
  445. Xstatic short    action, lastaction;
  446. XKeySym        keyhit;
  447. Xshort        undolock = 1;        /* locked for undo */
  448. X
  449. X/** For the temporary save **/
  450. Xstatic char  tmp_map[MAXROW+1][MAXCOL+1];
  451. Xstatic short tmp_pushes, tmp_moves, tmp_savepack;
  452. Xstatic POS   tmp_ppos;
  453. X
  454. Xshort play() {
  455. X
  456. X    short     c,
  457. X            ret = 0;
  458. X    int        keycount;
  459. X    char     buf[50];
  460. X
  461. X    XSelectInput(dpy,win,EVMASK);
  462. X    tmpsave();
  463. X    showscreen();
  464. X    while(ret == 0) {
  465. X        XNextEvent(dpy,&xev);
  466. X        XDrawString(dpy,win,gc,10,MAXROW*PIXMAPY,sline,strlen(sline));
  467. X        if (xev.type == Expose &&  xev.xexpose.count == 0)
  468. X            showscreen();
  469. X        else
  470. X            if(xev.type == KeyPress)    {
  471. X                keycount = XLookupString(&xev,buf,50,&keyhit,(XComposeStatus *) NULL);
  472. X                if(xev.xkey.state & ControlMask)
  473. X                    switch(keyhit)  {
  474. X                    case XK_u:
  475. X                        tmpreset();
  476. X                        undolock = 1;
  477. X                        showscreen();
  478. X                        break;
  479. X                    case XK_r: 
  480. X                        clearscreen();
  481. X                        break;
  482. X                    case XK_Left:
  483. X                    case XK_Up:
  484. X                    case XK_Right:
  485. X                    case XK_Down:
  486. X                        doit();
  487. X                        break;
  488. X                    default:     
  489. X                        break;
  490. X                    }
  491. X                else
  492. X                    switch(keyhit) {
  493. X                    case XK_q:    
  494. X                        ret = E_ENDGAME; 
  495. X                        break;
  496. X                    case XK_s:   
  497. X                        if( (ret = savegame()) == 0)
  498. X                            ret = E_SAVED;
  499. X                        break;
  500. X                    case XK_c:  
  501. X                        tmpsave();
  502. X                        break;
  503. X                    case XK_U:  
  504. X                        moves = pushes = 0;
  505. X                        if( (ret = readscreen()) == 0) {
  506. X                            showscreen();
  507. X                            undolock = 1;
  508. X                        }
  509. X                        break;
  510. X                    case XK_u: 
  511. X                        if( ! undolock) {
  512. X                            undomove();
  513. X                            undolock = 1;
  514. X                        }
  515. X                        break;
  516. X                    case XK_Left:
  517. X                    case XK_Up:
  518. X                    case XK_Right:
  519. X                    case XK_Down:
  520. X                        doit();
  521. X                        break;
  522. X                    default:     
  523. X                        break;
  524. X                    }
  525. X                if( (ret == 0) && (packets == savepack)) {
  526. X                    scorelevel = level;
  527. X                    scoremoves = moves;
  528. X                    scorepushes = pushes;
  529. X                    clearscreen();
  530. X                    break;
  531. X                }
  532. X            }
  533. X    }
  534. X    return(ret);
  535. X}
  536. X
  537. Xvoid doit()
  538. X{
  539. X    do {
  540. X        if((action = testmove(keyhit)) != 0) {
  541. X            lastaction = action;
  542. X            lastppos.x = ppos.x; 
  543. X            lastppos.y = ppos.y;
  544. X            lppc = map[ppos.x][ppos.y];
  545. X            lasttpos1.x = tpos1.x; 
  546. X            lasttpos1.y = tpos1.y; 
  547. X            ltp1c = map[tpos1.x][tpos1.y];
  548. X            lasttpos2.x = tpos2.x; 
  549. X            lasttpos2.y = tpos2.y; 
  550. X            ltp2c = map[tpos2.x][tpos2.y];
  551. X            domove(lastaction); 
  552. X            undolock = 0;
  553. X        }
  554. X    }     while((action != 0) && (packets != savepack) && 
  555. X            ((xev.xkey.state & ShiftMask) || (xev.xkey.state & ControlMask)));
  556. X}
  557. X
  558. Xtestmove(action)
  559. Xregister KeySym action;
  560. X{
  561. X    register short ret,
  562. X                stop_at_object = 0;
  563. X    register char  tc;
  564. X
  565. X    if(xev.xkey.state & ShiftMask)
  566. X        stop_at_object = 1;
  567. X
  568. X    if( (action == XK_Up) || (action == XK_Down)) {
  569. X        tpos1.x = (action == XK_Up) ? ppos.x-1 : ppos.x+1;
  570. X        tpos2.x = (action == XK_Up) ? ppos.x-2 : ppos.x+2;
  571. X        tpos1.y = tpos2.y = ppos.y;
  572. X    }
  573. X    else {
  574. X        tpos1.y = (action == XK_Left) ? ppos.y-1 : ppos.y+1;
  575. X        tpos2.y = (action == XK_Left) ? ppos.y-2 : ppos.y+2;
  576. X        tpos1.x = tpos2.x = ppos.x;
  577. X    }
  578. X    tc = map[tpos1.x][tpos1.y];
  579. X    if((tc == packet.obj_intern) || (tc == save.obj_intern)) {
  580. X        if(!stop_at_object) {
  581. X            if(map[tpos2.x][tpos2.y] == ground.obj_intern)
  582. X                ret = (tc == save.obj_intern) ? UNSAVE : PUSH;
  583. X            else if(map[tpos2.x][tpos2.y] == store.obj_intern)
  584. X                ret = (tc == save.obj_intern) ? STOREPUSH : SAVE;
  585. X            else ret = 0;
  586. X        }
  587. X        else ret = 0;
  588. X    }
  589. X    else if(tc == ground.obj_intern)
  590. X        ret = MOVE;
  591. X    else if(tc == store.obj_intern)
  592. X        ret = STOREMOVE;
  593. X    else ret = 0;
  594. X    return(ret);
  595. X}
  596. X
  597. Xdomove( moveaction) 
  598. Xregister short moveaction;
  599. X{
  600. X    map[ppos.x][ppos.y] = (map[ppos.x][ppos.y] == player.obj_intern) 
  601. X        ? ground.obj_intern 
  602. X            : store.obj_intern;
  603. X    switch( moveaction) {
  604. X    case MOVE:      
  605. X        map[tpos1.x][tpos1.y] = player.obj_intern;     
  606. X        break;
  607. X    case STOREMOVE: 
  608. X        map[tpos1.x][tpos1.y] = playerstore.obj_intern;     
  609. X        break;
  610. X    case PUSH:      
  611. X        map[tpos2.x][tpos2.y] = map[tpos1.x][tpos1.y];
  612. X        map[tpos1.x][tpos1.y] = player.obj_intern;    
  613. X        pushes++;                        
  614. X        break;
  615. X    case UNSAVE:    
  616. X        map[tpos2.x][tpos2.y] = packet.obj_intern;
  617. X        map[tpos1.x][tpos1.y] = playerstore.obj_intern;        
  618. X        pushes++; 
  619. X        savepack--;                 
  620. X        break;
  621. X    case SAVE:      
  622. X        map[tpos2.x][tpos2.y] = save.obj_intern;
  623. X        map[tpos1.x][tpos1.y] = player.obj_intern;            
  624. X        savepack++; 
  625. X        pushes++;                
  626. X        break;
  627. X    case STOREPUSH: 
  628. X        map[tpos2.x][tpos2.y] = save.obj_intern;
  629. X        map[tpos1.x][tpos1.y] = playerstore.obj_intern;        
  630. X        pushes++;                        
  631. X        break;
  632. X    }
  633. X    moves++;
  634. X    dispstatus();
  635. X    mapchar(map[ppos.x][ppos.y], ppos.x, ppos.y);
  636. X    mapchar(map[tpos1.x][tpos1.y], tpos1.x, tpos1.y);
  637. X    mapchar(map[tpos2.x][tpos2.y], tpos2.x, tpos2.y);
  638. X    ppos.x = tpos1.x; 
  639. X    ppos.y = tpos1.y;
  640. X}
  641. X
  642. Xundomove() {
  643. X
  644. X    map[lastppos.x][lastppos.y] = lppc;
  645. X    map[lasttpos1.x][lasttpos1.y] = ltp1c;
  646. X    map[lasttpos2.x][lasttpos2.y] = ltp2c;
  647. X    ppos.x = lastppos.x; 
  648. X    ppos.y = lastppos.y;
  649. X    switch( lastaction) {
  650. X    case MOVE:      
  651. X        moves--;                
  652. X        break;
  653. X    case STOREMOVE: 
  654. X        moves--;                
  655. X        break;
  656. X    case PUSH:      
  657. X        moves--; 
  658. X        pushes--;        
  659. X        break;
  660. X    case UNSAVE:    
  661. X        moves--; 
  662. X        pushes--; 
  663. X        savepack++;    
  664. X        break;
  665. X    case SAVE:      
  666. X        moves--; 
  667. X        pushes--; 
  668. X        savepack--;    
  669. X        break;
  670. X    case STOREPUSH: 
  671. X        moves--; 
  672. X        pushes--;        
  673. X        break;
  674. X    }
  675. X    dispstatus();
  676. X    mapchar( map[ppos.x][ppos.y], ppos.x, ppos.y);
  677. X    mapchar( map[lasttpos1.x][lasttpos1.y], lasttpos1.x, lasttpos1.y);
  678. X    mapchar( map[lasttpos2.x][lasttpos2.y], lasttpos2.x, lasttpos2.y);
  679. X}
  680. X
  681. Xtmpsave() {
  682. X
  683. X    register short i, j;
  684. X
  685. X    for( i = 0; i < rows; i++) for( j = 0; j < cols; j++)
  686. X        tmp_map[i][j] = map[i][j];
  687. X    tmp_pushes = pushes;
  688. X    tmp_moves = moves;
  689. X    tmp_savepack = savepack;
  690. X    tmp_ppos.x = ppos.x; 
  691. X    tmp_ppos.y = ppos.y;
  692. X}
  693. X
  694. Xtmpreset() {
  695. X
  696. X    register short i, j;
  697. X
  698. X    for( i = 0; i < rows; i++) for( j = 0; j < cols; j++)
  699. X        map[i][j] = tmp_map[i][j];
  700. X    pushes = tmp_pushes;
  701. X    moves = tmp_moves;
  702. X    savepack = tmp_savepack;
  703. X    ppos.x = tmp_ppos.x; 
  704. X    ppos.y = tmp_ppos.y;
  705. X}
  706. END_OF_FILE
  707. if test 6649 -ne `wc -c <'play.c'`; then
  708.     echo shar: \"'play.c'\" unpacked with wrong size!
  709. fi
  710. # end of 'play.c'
  711. fi
  712. if test -f 'playerstore.xbm' -a "${1}" != "-c" ; then 
  713.   echo shar: Will not clobber existing file \"'playerstore.xbm'\"
  714. else
  715. echo shar: Extracting \"'playerstore.xbm'\" \(296 characters\)
  716. sed "s/^X//" >'playerstore.xbm' <<'END_OF_FILE'
  717. X#define playerstore_width 16
  718. X#define playerstore_height 16
  719. Xstatic char playerstore_bits[] = {
  720. X   0x55, 0x5f, 0xba, 0xae, 0x7d, 0x55, 0xfe, 0xae, 0xfd, 0x57, 0xfb, 0xab,
  721. X   0xf7, 0x55, 0xff, 0xab, 0xd5, 0x57, 0xaa, 0xaf, 0xd5, 0xdd, 0xea, 0xfa,
  722. X   0x55, 0xd5, 0xea, 0xaa, 0x55, 0x55, 0xfa, 0xab};
  723. END_OF_FILE
  724. if test 296 -ne `wc -c <'playerstore.xbm'`; then
  725.     echo shar: \"'playerstore.xbm'\" unpacked with wrong size!
  726. fi
  727. # end of 'playerstore.xbm'
  728. fi
  729. if test -f 'readscreen.c' -a "${1}" != "-c" ; then 
  730.   echo shar: Will not clobber existing file \"'readscreen.c'\"
  731. else
  732. echo shar: Extracting \"'readscreen.c'\" \(1509 characters\)
  733. sed "s/^X//" >'readscreen.c' <<'END_OF_FILE'
  734. X#include <stdio.h>
  735. X#include "sokoban.h"
  736. X#include "obj.h"
  737. X
  738. Xextern char *malloc();
  739. Xextern FILE *fopen();
  740. X
  741. Xextern short level, packets, savepack, rows, cols;
  742. Xextern char  map[MAXROW+1][MAXCOL+1];
  743. Xextern POS   ppos;
  744. X
  745. Xshort readscreen() {
  746. X
  747. X   FILE *screen;
  748. X   char *fnam;
  749. X   short j, c, ret = 0;
  750. X
  751. X   fnam = malloc( strlen( SCREENPATH) + 11);
  752. X   sprintf( fnam, "%s/screen.%d", SCREENPATH, level);
  753. X   if( (screen = fopen( fnam, "r")) == NULL) 
  754. X      ret = E_FOPENSCREEN;
  755. X   else {
  756. X      packets = savepack = rows = j = cols  = 0;
  757. X      ppos.x = -1; ppos.y = -1;
  758. X      while( (ret == 0) && ((c = getc( screen)) != EOF)) {
  759. X         if( c == '\n') {
  760. X        map[rows++][j] = '\0';
  761. X        if( rows > MAXROW) 
  762. X           ret = E_TOMUCHROWS;
  763. X        else {
  764. X           if( j > cols) cols = j;
  765. X           j = 0;
  766. X        }
  767. X     }
  768. X     else if( (c == player.obj_intern) || (c == playerstore.obj_intern)) {
  769. X        if( ppos.x != -1) 
  770. X           ret = E_PLAYPOS1;
  771. X        else { 
  772. X           ppos.x = rows; ppos.y = j;
  773. X           map[rows][j++] = c;
  774. X           if( j > MAXCOL) ret = E_TOMUCHCOLS;
  775. X        }
  776. X     }
  777. X     else if( (c == save.obj_intern) || (c == packet.obj_intern) ||
  778. X          (c == wall.obj_intern) || (c == store.obj_intern) ||
  779. X          (c == ground.obj_intern)) {
  780. X        if( c == save.obj_intern)   { savepack++; packets++; }
  781. X        if( c == packet.obj_intern) packets++;
  782. X        map[rows][j++] = c;
  783. X        if( j > MAXCOL) ret = E_TOMUCHCOLS;
  784. X     }
  785. X     else ret = E_ILLCHAR;
  786. X      }
  787. X      fclose( screen);
  788. X      if( (ret == 0) && (ppos.x == -1)) ret = E_PLAYPOS2;
  789. X   }
  790. X   return( ret);
  791. X}
  792. END_OF_FILE
  793. if test 1509 -ne `wc -c <'readscreen.c'`; then
  794.     echo shar: \"'readscreen.c'\" unpacked with wrong size!
  795. fi
  796. # end of 'readscreen.c'
  797. fi
  798. if test -f 'save.c' -a "${1}" != "-c" ; then 
  799.   echo shar: Will not clobber existing file \"'save.c'\"
  800. else
  801. echo shar: Extracting \"'save.c'\" \(3668 characters\)
  802. sed "s/^X//" >'save.c' <<'END_OF_FILE'
  803. X#include <stdio.h>
  804. X#include <sys/types.h>
  805. X#include <sys/stat.h>
  806. X#include <signal.h>
  807. X#include "sokoban.h"
  808. X
  809. Xextern char  *malloc();
  810. Xextern FILE  *fopen();
  811. X
  812. Xextern char  *username;
  813. Xextern char  map[MAXROW+1][MAXCOL+1];
  814. Xextern short level, moves, pushes, packets, savepack, rows, cols;
  815. Xextern short scoring;
  816. Xextern POS   ppos;
  817. X
  818. Xstatic long        savedbn;
  819. Xstatic char        *sfname;
  820. Xstatic FILE        *savefile;
  821. Xstatic struct stat sfstat;
  822. X
  823. Xshort savegame() {
  824. X
  825. X   short ret = 0;
  826. X
  827. X   signal( SIGINT, SIG_IGN);
  828. X   sfname = malloc( strlen( SAVEPATH) + strlen( username) + 5);
  829. X   sprintf( sfname, "%s/%s.sav", SAVEPATH, username);
  830. X   if( (savefile = fopen( sfname, "w")) == NULL)
  831. X      ret = E_FOPENSAVE;
  832. X   else {
  833. X      savedbn = fileno( savefile);
  834. X      if( write( savedbn, &(map[0][0]), MAXROW*MAXCOL) != MAXROW*MAXCOL)
  835. X     ret = E_WRITESAVE;
  836. X      else if( write( savedbn, &ppos, sizeof( POS)) != sizeof( POS))     
  837. X     ret = E_WRITESAVE;
  838. X      else if( write( savedbn, &scoring, 2) != 2)  ret = E_WRITESAVE;
  839. X      else if( write( savedbn, &level, 2) != 2)    ret = E_WRITESAVE;
  840. X      else if( write( savedbn, &moves, 2) != 2)    ret = E_WRITESAVE;
  841. X      else if( write( savedbn, &pushes, 2) != 2)   ret = E_WRITESAVE;
  842. X      else if( write( savedbn, &packets, 2) != 2)  ret = E_WRITESAVE;
  843. X      else if( write( savedbn, &savepack, 2) != 2) ret = E_WRITESAVE;
  844. X      else if( write( savedbn, &rows, 2) != 2)     ret = E_WRITESAVE;
  845. X      else if( write( savedbn, &cols, 2) != 2)     ret = E_WRITESAVE;
  846. X      else {
  847. X     fclose( savefile);
  848. X     if( stat( sfname, &sfstat) != 0) ret = E_STATSAVE;
  849. X     else if( (savefile = fopen( sfname, "a")) == NULL)
  850. X            ret = E_FOPENSAVE;
  851. X         else {
  852. X        if( write( savedbn, &sfstat, sizeof( sfstat)) != sizeof( sfstat))
  853. X           ret = E_WRITESAVE;
  854. X        fclose( savefile);
  855. X     }
  856. X      }
  857. X   }
  858. X   if( (ret == E_WRITESAVE) || (ret == E_STATSAVE)) unlink( sfname);
  859. X   signal( SIGINT, SIG_DFL);
  860. X
  861. X   return( ret);
  862. X}
  863. X
  864. Xshort restoregame() {
  865. X
  866. X   short ret = 0;
  867. X   struct stat oldsfstat;
  868. X
  869. X   signal( SIGINT, SIG_IGN);
  870. X   sfname = malloc( strlen( SAVEPATH) + strlen( username) + 5);
  871. X   sprintf( sfname, "%s/%s.sav", SAVEPATH, username);
  872. X   if( stat( sfname, &oldsfstat) < -1) 
  873. X      ret = E_NOSAVEFILE;
  874. X   else {
  875. X      if( (savefile = fopen( sfname, "r")) == NULL)
  876. X     ret = E_FOPENSAVE;
  877. X      else {
  878. X         savedbn = fileno( savefile);
  879. X         if( read( savedbn, &(map[0][0]), MAXROW*MAXCOL) != MAXROW*MAXCOL)
  880. X        ret = E_READSAVE;
  881. X         else if( read( savedbn, &ppos, sizeof( POS)) != sizeof( POS))     
  882. X        ret = E_READSAVE;
  883. X         else if( read( savedbn, &scoring, 2) != 2)  ret = E_READSAVE;
  884. X         else if( read( savedbn, &level, 2) != 2)    ret = E_READSAVE;
  885. X         else if( read( savedbn, &moves, 2) != 2)    ret = E_READSAVE;
  886. X         else if( read( savedbn, &pushes, 2) != 2)   ret = E_READSAVE;
  887. X         else if( read( savedbn, &packets, 2) != 2)  ret = E_READSAVE;
  888. X         else if( read( savedbn, &savepack, 2) != 2) ret = E_READSAVE;
  889. X         else if( read( savedbn, &rows, 2) != 2)     ret = E_READSAVE;
  890. X         else if( read( savedbn, &cols, 2) != 2)     ret = E_READSAVE;
  891. X     else if( read( savedbn, &sfstat, sizeof( sfstat)) != sizeof( sfstat))
  892. X        ret = E_READSAVE;
  893. X     else if( (sfstat.st_dev != oldsfstat.st_dev) ||
  894. X                  (sfstat.st_ino != oldsfstat.st_ino) ||
  895. X                  (sfstat.st_nlink != oldsfstat.st_nlink) ||
  896. X                  (sfstat.st_uid != oldsfstat.st_uid) ||
  897. X                  (sfstat.st_gid != oldsfstat.st_gid) ||
  898. X                  (sfstat.st_mtime != oldsfstat.st_mtime))
  899. X            ret = E_ALTERSAVE;
  900. X      }
  901. X      unlink( sfname);
  902. X   }
  903. X   signal( SIGINT, SIG_DFL);
  904. X   return( ret);
  905. X}
  906. END_OF_FILE
  907. if test 3668 -ne `wc -c <'save.c'`; then
  908.     echo shar: \"'save.c'\" unpacked with wrong size!
  909. fi
  910. # end of 'save.c'
  911. fi
  912. if test -f 'score.c' -a "${1}" != "-c" ; then 
  913.   echo shar: Will not clobber existing file \"'score.c'\"
  914. else
  915. echo shar: Extracting \"'score.c'\" \(5071 characters\)
  916. sed "s/^X//" >'score.c' <<'END_OF_FILE'
  917. X#include <stdio.h>
  918. X#include <signal.h>
  919. X#include "sokoban.h"
  920. X
  921. Xextern FILE *fopen();
  922. X
  923. Xextern char  *username;
  924. Xextern short scorelevel, scoremoves, scorepushes;
  925. X
  926. Xstatic short scoreentries;
  927. Xstatic struct {
  928. X   char user[MAXUSERNAME];
  929. X   short lv, mv, ps;
  930. X} scoretable[MAXSCOREENTRIES];
  931. X
  932. Xstatic FILE *scorefile;
  933. Xstatic long sfdbn;
  934. X
  935. Xshort outputscore() {
  936. X
  937. X   short ret;
  938. X
  939. X   while( creat( LOCKFILE, 0666) < 0);    /* lock the score file */
  940. X   if( (ret = readscore()) == 0)
  941. X      showscore();
  942. X   unlink( LOCKFILE);
  943. X   return( (ret == 0) ? E_ENDGAME : ret);
  944. X}
  945. X
  946. Xshort makenewscore() {
  947. X
  948. X   short ret = 0;
  949. X
  950. X   while( creat( LOCKFILE, 0666) < 0) ;
  951. X   scoreentries = 0;
  952. X   if( (scorefile = fopen( SCOREFILE, "w")) == NULL)
  953. X      ret = E_FOPENSCORE;
  954. X   else {
  955. X      sfdbn = fileno( scorefile);
  956. X      if( write( sfdbn, &scoreentries, 2) != 2) ret = E_WRITESCORE;
  957. X      fclose( scorefile);
  958. X   }
  959. X   unlink( LOCKFILE);
  960. X   return( (ret == 0) ? E_ENDGAME : ret);
  961. X}
  962. X
  963. Xshort getuserlevel( lv)
  964. Xshort *lv;
  965. X{
  966. X   short ret = 0, pos;
  967. X
  968. X   while( creat( LOCKFILE, 0666) < 0);
  969. X   if( (scorefile = fopen( SCOREFILE, "r")) == NULL)
  970. X      ret = E_FOPENSCORE;
  971. X   else {
  972. X      if( (ret = readscore()) == 0)
  973. X     *lv = ( (pos = finduser()) > -1) ? scoretable[pos].lv+1 : 1;
  974. X   }
  975. X   unlink( LOCKFILE);
  976. X   return( ret);
  977. X}
  978. X
  979. Xshort score() {
  980. X   
  981. X   short ret;
  982. X
  983. X   while( creat( LOCKFILE, 0666) < 0);    /* lock the score file */
  984. X   if( (ret = readscore()) == 0)
  985. X      if( (ret = makescore()) == 0)
  986. X     if( (ret = writescore()) == 0)
  987. X        showscore();
  988. X   unlink( LOCKFILE);
  989. X   return( (ret == 0) ? E_ENDGAME : ret);
  990. X}
  991. X
  992. Xreadscore() {
  993. X
  994. X   short ret = 0;
  995. X   long tmp;
  996. X
  997. X   if( (scorefile = fopen( SCOREFILE, "r")) == NULL)
  998. X      ret = E_FOPENSCORE;
  999. X   else {
  1000. X      sfdbn = fileno( scorefile);
  1001. X      if( read( sfdbn, &scoreentries, 2) != 2) ret = E_READSCORE;
  1002. X      else {
  1003. X     tmp = scoreentries * sizeof( scoretable[0]);
  1004. X     if( read( sfdbn, &(scoretable[0]), tmp) != tmp) ret = E_READSCORE;
  1005. X      }
  1006. X      fclose( scorefile);
  1007. X   }
  1008. X   return( ret);
  1009. X}
  1010. X
  1011. Xmakescore() {
  1012. X
  1013. X   short ret = 0, pos, i, build = 1, insert;
  1014. X
  1015. X   if( (pos = finduser()) > -1) {    /* user already in score file */
  1016. X      insert =    (scorelevel > scoretable[pos].lv)
  1017. X           || ( (scorelevel == scoretable[pos].lv) &&
  1018. X                    (scoremoves < scoretable[pos].mv)
  1019. X          )
  1020. X           || ( (scorelevel == scoretable[pos].lv) &&
  1021. X            (scoremoves == scoretable[pos].mv) &&
  1022. X            (scorepushes < scoretable[pos].ps)
  1023. X          );
  1024. X      if( insert) {             /* delete existing entry */
  1025. X     for( i = pos; i < scoreentries-1; i++)
  1026. X        cp_entry( i, i+1);
  1027. X     scoreentries--;
  1028. X      }
  1029. X      else build = 0;
  1030. X   }
  1031. X   else if( scoreentries == MAXSCOREENTRIES)
  1032. X      ret = E_TOMUCHSE;
  1033. X   if( (ret == 0) && build) {
  1034. X      pos = findpos();            /* find the new score position */
  1035. X      if( pos > -1) {            /* score table not empty */
  1036. X     for( i = scoreentries; i > pos; i--)
  1037. X        cp_entry( i, i-1);
  1038. X      }
  1039. X      else pos = scoreentries;
  1040. X
  1041. X      strcpy( scoretable[pos].user, username);
  1042. X      scoretable[pos].lv = scorelevel;
  1043. X      scoretable[pos].mv = scoremoves;
  1044. X      scoretable[pos].ps = scorepushes;
  1045. X      scoreentries++;
  1046. X   }
  1047. X   return( ret);
  1048. X}
  1049. X
  1050. Xfinduser() {
  1051. X
  1052. X   short i, found = 0;
  1053. X
  1054. X   for( i = 0; (i < scoreentries) && (! found); i++)
  1055. X      found = (strcmp( scoretable[i].user, username) == 0);
  1056. X   return( (found) ? i-1 : -1);
  1057. X}
  1058. X
  1059. Xfindpos() {
  1060. X 
  1061. X   short i, found = 0;
  1062. X
  1063. X   for( i = 0; (i < scoreentries) && (! found); i++)
  1064. X      found =    (scorelevel > scoretable[i].lv)
  1065. X          || ( (scorelevel == scoretable[i].lv) &&
  1066. X                   (scoremoves < scoretable[i].mv)
  1067. X         )
  1068. X          || ( (scorelevel == scoretable[i].lv) &&
  1069. X           (scoremoves == scoretable[i].mv) &&
  1070. X           (scorepushes < scoretable[i].ps)
  1071. X         );
  1072. X   return( (found) ? i-1 : -1);
  1073. X}
  1074. X
  1075. Xwritescore() {
  1076. X
  1077. X   short ret = 0;
  1078. X   long tmp;
  1079. X
  1080. X   if( (scorefile = fopen( SCOREFILE, "w")) == NULL)
  1081. X      ret = E_FOPENSCORE;
  1082. X   else {
  1083. X      sfdbn = fileno( scorefile);
  1084. X      if( write( sfdbn, &scoreentries, 2) != 2) ret = E_WRITESCORE;
  1085. X      else {
  1086. X     tmp = scoreentries * sizeof( scoretable[0]);
  1087. X     if( write( sfdbn, &(scoretable[0]), tmp) != tmp) ret = E_WRITESCORE;
  1088. X      }
  1089. X      fclose( scorefile);
  1090. X   }
  1091. X   return( ret);
  1092. X}
  1093. X
  1094. Xshowscore() {
  1095. X
  1096. X   register short lastlv = 0, lastmv = 0, lastps = 0, i;
  1097. X
  1098. X   fprintf( stdout, "Rank        User     Level     Moves    Pushes\n");
  1099. X   fprintf( stdout, "==============================================\n");
  1100. X   for( i = 0; i < scoreentries; i++) {
  1101. X      if( (scoretable[i].lv == lastlv)&& 
  1102. X      (scoretable[i].mv == lastmv) && 
  1103. X      (scoretable[i].ps == lastps))
  1104. X     fprintf( stdout, "      ");
  1105. X      else {
  1106. X         lastlv = scoretable[i].lv;
  1107. X         lastmv = scoretable[i].mv;
  1108. X         lastps = scoretable[i].ps;
  1109. X         fprintf( stdout, "%4d  ", i+1);
  1110. X      }
  1111. X      fprintf( stdout, "%10s  %8d  %8d  %8d\n", scoretable[i].user, 
  1112. X        scoretable[i].lv, scoretable[i].mv, scoretable[i].ps);
  1113. X   }
  1114. X}
  1115. X
  1116. Xcp_entry( i1, i2)
  1117. Xregister short i1, i2;
  1118. X{
  1119. X   strcpy( scoretable[i1].user, scoretable[i2].user);
  1120. X   scoretable[i1].lv = scoretable[i2].lv;
  1121. X   scoretable[i1].mv = scoretable[i2].mv;
  1122. X   scoretable[i1].ps = scoretable[i2].ps;
  1123. X}
  1124. END_OF_FILE
  1125. if test 5071 -ne `wc -c <'score.c'`; then
  1126.     echo shar: \"'score.c'\" unpacked with wrong size!
  1127. fi
  1128. # end of 'score.c'
  1129. fi
  1130. if test ! -d 'screens' ; then
  1131.     echo shar: Creating directory \"'screens'\"
  1132.     mkdir 'screens'
  1133. fi
  1134. if test -f 'screens/screen.10' -a "${1}" != "-c" ; then 
  1135.   echo shar: Will not clobber existing file \"'screens/screen.10'\"
  1136. else
  1137. echo shar: Extracting \"'screens/screen.10'\" \(320 characters\)
  1138. sed "s/^X//" >'screens/screen.10' <<'END_OF_FILE'
  1139. X ###  #############
  1140. X##@####       #   #
  1141. X# $$   $$  $ $ ...#
  1142. X#  $$$#    $  #...#
  1143. X# $   # $$ $$ #...#
  1144. X###   #  $    #...#
  1145. X#     # $ $ $ #...#
  1146. X#    ###### ###...#
  1147. X## #  #  $ $  #...#
  1148. X#  ## # $$ $ $##..#
  1149. X# ..# #  $      #.#
  1150. X# ..# # $$$ $$$ #.#
  1151. X##### #       # #.#
  1152. X    # ######### #.#
  1153. X    #           #.#
  1154. X    ###############
  1155. END_OF_FILE
  1156. if test 320 -ne `wc -c <'screens/screen.10'`; then
  1157.     echo shar: \"'screens/screen.10'\" unpacked with wrong size!
  1158. fi
  1159. # end of 'screens/screen.10'
  1160. fi
  1161. if test -f 'screens/screen.14' -a "${1}" != "-c" ; then 
  1162.   echo shar: Will not clobber existing file \"'screens/screen.14'\"
  1163. else
  1164. echo shar: Extracting \"'screens/screen.14'\" \(284 characters\)
  1165. sed "s/^X//" >'screens/screen.14' <<'END_OF_FILE'
  1166. X       #######
  1167. X #######     #
  1168. X #     # $@$ #
  1169. X #$$ #   #########
  1170. X # ###......##   #
  1171. X #   $......## # #
  1172. X # ###......     #
  1173. X##   #### ### #$##
  1174. X#  #$   #  $  # #
  1175. X#  $ $$$  # $## #
  1176. X#   $ $ ###$$ # #
  1177. X#####     $   # #
  1178. X    ### ###   # #
  1179. X      #     #   #
  1180. X      ########  #
  1181. X             ####
  1182. END_OF_FILE
  1183. if test 284 -ne `wc -c <'screens/screen.14'`; then
  1184.     echo shar: \"'screens/screen.14'\" unpacked with wrong size!
  1185. fi
  1186. # end of 'screens/screen.14'
  1187. fi
  1188. if test -f 'screens/screen.20' -a "${1}" != "-c" ; then 
  1189.   echo shar: Will not clobber existing file \"'screens/screen.20'\"
  1190. else
  1191. echo shar: Extracting \"'screens/screen.20'\" \(303 characters\)
  1192. sed "s/^X//" >'screens/screen.20' <<'END_OF_FILE'
  1193. X    ##########
  1194. X#####        ####
  1195. X#     #   $  #@ #
  1196. X# #######$####  ###
  1197. X# #    ## #  #$ ..#
  1198. X# # $     #  #  #.#
  1199. X# # $  #     #$ ..#
  1200. X# #  ### ##     #.#
  1201. X# ###  #  #  #$ ..#
  1202. X# #    #  ####  #.#
  1203. X# #$   $  $  #$ ..#
  1204. X#    $ # $ $ #  #.#
  1205. X#### $###    #$ ..#
  1206. X   #    $$ ###....#
  1207. X   #      ## ######
  1208. X   ########
  1209. END_OF_FILE
  1210. if test 303 -ne `wc -c <'screens/screen.20'`; then
  1211.     echo shar: \"'screens/screen.20'\" unpacked with wrong size!
  1212. fi
  1213. # end of 'screens/screen.20'
  1214. fi
  1215. if test -f 'screens/screen.22' -a "${1}" != "-c" ; then 
  1216.   echo shar: Will not clobber existing file \"'screens/screen.22'\"
  1217. else
  1218. echo shar: Extracting \"'screens/screen.22'\" \(311 characters\)
  1219. sed "s/^X//" >'screens/screen.22' <<'END_OF_FILE'
  1220. X######     ####
  1221. X#    #######  #####
  1222. X#   $#  #  $  #   #
  1223. X#  $  $  $ # $ $  #
  1224. X##$ $   # @# $    #
  1225. X#  $ ########### ##
  1226. X# #   #.......# $#
  1227. X# ##  # ......#  #
  1228. X# #   $........$ #
  1229. X# # $ #.... ..#  #
  1230. X#  $ $####$#### $#
  1231. X# $   ### $   $  ##
  1232. X# $     $ $  $    #
  1233. X## ###### $ ##### #
  1234. X#         #       #
  1235. X###################
  1236. END_OF_FILE
  1237. if test 311 -ne `wc -c <'screens/screen.22'`; then
  1238.     echo shar: \"'screens/screen.22'\" unpacked with wrong size!
  1239. fi
  1240. # end of 'screens/screen.22'
  1241. fi
  1242. if test -f 'screens/screen.24' -a "${1}" != "-c" ; then 
  1243.   echo shar: Will not clobber existing file \"'screens/screen.24'\"
  1244. else
  1245. echo shar: Extracting \"'screens/screen.24'\" \(306 characters\)
  1246. sed "s/^X//" >'screens/screen.24' <<'END_OF_FILE'
  1247. X###############
  1248. X#..........  .####
  1249. X#..........$$.#  #
  1250. X###########$ #   ##
  1251. X#      $  $     $ #
  1252. X## ####   #  $ #  #
  1253. X#      #   ##  # ##
  1254. X#  $#  # ##  ### ##
  1255. X# $ #$###    ### ##
  1256. X###  $ #  #  ### ##
  1257. X###    $ ## #  # ##
  1258. X # $  #  $  $ $   #
  1259. X #  $  $#$$$  #   #
  1260. X #  #  $      #####
  1261. X # @##  #  #  #
  1262. X ##############
  1263. END_OF_FILE
  1264. if test 306 -ne `wc -c <'screens/screen.24'`; then
  1265.     echo shar: \"'screens/screen.24'\" unpacked with wrong size!
  1266. fi
  1267. # end of 'screens/screen.24'
  1268. fi
  1269. if test -f 'screens/screen.25' -a "${1}" != "-c" ; then 
  1270.   echo shar: Will not clobber existing file \"'screens/screen.25'\"
  1271. else
  1272. echo shar: Extracting \"'screens/screen.25'\" \(295 characters\)
  1273. sed "s/^X//" >'screens/screen.25' <<'END_OF_FILE'
  1274. X####
  1275. X#  ##############
  1276. X#  #   ..#......#
  1277. X#  # # ##### ...#
  1278. X##$#    ........#
  1279. X#   ##$######  ####
  1280. X# $ #     ######@ #
  1281. X##$ # $   ######  #
  1282. X#  $ #$$$##       #
  1283. X#      #    #$#$###
  1284. X# #### #$$$$$    #
  1285. X# #    $     #   #
  1286. X# #   ##        ###
  1287. X# ######$###### $ #
  1288. X#        #    #   #
  1289. X##########    #####
  1290. END_OF_FILE
  1291. if test 295 -ne `wc -c <'screens/screen.25'`; then
  1292.     echo shar: \"'screens/screen.25'\" unpacked with wrong size!
  1293. fi
  1294. # end of 'screens/screen.25'
  1295. fi
  1296. if test -f 'screens/screen.35' -a "${1}" != "-c" ; then 
  1297.   echo shar: Will not clobber existing file \"'screens/screen.35'\"
  1298. else
  1299. echo shar: Extracting \"'screens/screen.35'\" \(298 characters\)
  1300. sed "s/^X//" >'screens/screen.35' <<'END_OF_FILE'
  1301. X############ ######
  1302. X#   #    # ###....#
  1303. X#   $$#   @  .....#
  1304. X#   # ###   # ....#
  1305. X## ## ###  #  ....#
  1306. X # $ $     # # ####
  1307. X #  $ $##  #      #
  1308. X#### #  #### # ## #
  1309. X#  # #$   ## #    #
  1310. X# $  $  # ## #   ##
  1311. X# # $ $    # #   #
  1312. X#  $ ## ## # #####
  1313. X# $$     $$  #
  1314. X## ## ### $  #
  1315. X #    # #    #
  1316. X ###### ######
  1317. END_OF_FILE
  1318. if test 298 -ne `wc -c <'screens/screen.35'`; then
  1319.     echo shar: \"'screens/screen.35'\" unpacked with wrong size!
  1320. fi
  1321. # end of 'screens/screen.35'
  1322. fi
  1323. if test -f 'screens/screen.36' -a "${1}" != "-c" ; then 
  1324.   echo shar: Will not clobber existing file \"'screens/screen.36'\"
  1325. else
  1326. echo shar: Extracting \"'screens/screen.36'\" \(289 characters\)
  1327. sed "s/^X//" >'screens/screen.36' <<'END_OF_FILE'
  1328. X            #####
  1329. X#####  ######   #
  1330. X#   ####  $ $ $ #
  1331. X# $   ## ## ##  ##
  1332. X#   $ $     $  $ #
  1333. X### $  ## ##     ##
  1334. X  # ##### #####$$ #
  1335. X ##$##### @##     #
  1336. X # $  ###$### $  ##
  1337. X # $  #   ###  ###
  1338. X # $$ $ #   $$ #
  1339. X #     #   ##  #
  1340. X #######.. .###
  1341. X    #.........#
  1342. X    #.........#
  1343. X    ###########
  1344. END_OF_FILE
  1345. if test 289 -ne `wc -c <'screens/screen.36'`; then
  1346.     echo shar: \"'screens/screen.36'\" unpacked with wrong size!
  1347. fi
  1348. # end of 'screens/screen.36'
  1349. fi
  1350. if test -f 'screens/screen.37' -a "${1}" != "-c" ; then 
  1351.   echo shar: Will not clobber existing file \"'screens/screen.37'\"
  1352. else
  1353. echo shar: Extracting \"'screens/screen.37'\" \(272 characters\)
  1354. sed "s/^X//" >'screens/screen.37' <<'END_OF_FILE'
  1355. X###########
  1356. X#......   #########
  1357. X#......   #  ##   #
  1358. X#..### $    $     #
  1359. X#... $ $ #   ##   #
  1360. X#...#$#####    #  #
  1361. X###    #   #$  #$ #
  1362. X  #  $$ $ $  $##  #
  1363. X  #  $   #$#$ ##$ #
  1364. X  ### ## #    ##  #
  1365. X   #  $ $ ## ######
  1366. X   #    $  $  #
  1367. X   ##   # #   #
  1368. X    #####@#####
  1369. X        ###
  1370. END_OF_FILE
  1371. if test 272 -ne `wc -c <'screens/screen.37'`; then
  1372.     echo shar: \"'screens/screen.37'\" unpacked with wrong size!
  1373. fi
  1374. # end of 'screens/screen.37'
  1375. fi
  1376. if test -f 'screens/screen.39' -a "${1}" != "-c" ; then 
  1377.   echo shar: Will not clobber existing file \"'screens/screen.39'\"
  1378. else
  1379. echo shar: Extracting \"'screens/screen.39'\" \(291 characters\)
  1380. sed "s/^X//" >'screens/screen.39' <<'END_OF_FILE'
  1381. X             ######
  1382. X #############....#
  1383. X##   ##     ##....#
  1384. X#  $$##  $ @##....#
  1385. X#      $$ $#  ....#
  1386. X#  $ ## $$ # # ...#
  1387. X#  $ ## $  #  ....#
  1388. X## ##### ### ##.###
  1389. X##   $  $ ##   .  #
  1390. X# $###  # ##### ###
  1391. X#   $   #       #
  1392. X#  $ #$ $ $###  #
  1393. X# $$$# $   # ####
  1394. X#    #  $$ #
  1395. X######   ###
  1396. X     #####
  1397. END_OF_FILE
  1398. if test 291 -ne `wc -c <'screens/screen.39'`; then
  1399.     echo shar: \"'screens/screen.39'\" unpacked with wrong size!
  1400. fi
  1401. # end of 'screens/screen.39'
  1402. fi
  1403. if test -f 'screens/screen.41' -a "${1}" != "-c" ; then 
  1404.   echo shar: Will not clobber existing file \"'screens/screen.41'\"
  1405. else
  1406. echo shar: Extracting \"'screens/screen.41'\" \(286 characters\)
  1407. sed "s/^X//" >'screens/screen.41' <<'END_OF_FILE'
  1408. X           #####
  1409. X          ##   ##
  1410. X         ##     #
  1411. X        ##  $$  #
  1412. X       ## $$  $ #
  1413. X       # $    $ #
  1414. X####   #   $$ #####
  1415. X#  ######## ##    #
  1416. X#.            $$$@#
  1417. X#.# ####### ##   ##
  1418. X#.# #######. #$ $##
  1419. X#........... #    #
  1420. X##############  $ #
  1421. X             ##  ##
  1422. X              ####
  1423. END_OF_FILE
  1424. if test 286 -ne `wc -c <'screens/screen.41'`; then
  1425.     echo shar: \"'screens/screen.41'\" unpacked with wrong size!
  1426. fi
  1427. # end of 'screens/screen.41'
  1428. fi
  1429. if test -f 'screens/screen.50' -a "${1}" != "-c" ; then 
  1430.   echo shar: Will not clobber existing file \"'screens/screen.50'\"
  1431. else
  1432. echo shar: Extracting \"'screens/screen.50'\" \(307 characters\)
  1433. sed "s/^X//" >'screens/screen.50' <<'END_OF_FILE'
  1434. X      ############
  1435. X     ##..    #   #
  1436. X    ##..* $    $ #
  1437. X   ##..*.# # # $##
  1438. X   #..*.# # # $  #
  1439. X####...#  #    # #
  1440. X#  ## #          #
  1441. X# @$ $ ###  #   ##
  1442. X# $   $   # #   #
  1443. X###$$   # # # # #
  1444. X  #   $   # # #####
  1445. X  # $# #####      #
  1446. X  #$   #   #    # #
  1447. X  #  ###   ##     #
  1448. X  #  #      #    ##
  1449. X  ####      ######
  1450. END_OF_FILE
  1451. if test 307 -ne `wc -c <'screens/screen.50'`; then
  1452.     echo shar: \"'screens/screen.50'\" unpacked with wrong size!
  1453. fi
  1454. # end of 'screens/screen.50'
  1455. fi
  1456. if test -f 'showscreen.c' -a "${1}" != "-c" ; then 
  1457.   echo shar: Will not clobber existing file \"'showscreen.c'\"
  1458. else
  1459. echo shar: Extracting \"'showscreen.c'\" \(5219 characters\)
  1460. sed "s/^X//" >'showscreen.c' <<'END_OF_FILE'
  1461. X#include <stdio.h>
  1462. X#include "sokoban.h"
  1463. X#include "obj.h"
  1464. X
  1465. Xextern Display        *dpy;
  1466. Xextern Window        win;
  1467. Xextern GC            gc,gclear;
  1468. X
  1469. Xextern short rows, cols, level, moves, pushes, packets, savepack;
  1470. Xextern char  map[MAXROW+1][MAXCOL+1];
  1471. Xchar line[80];
  1472. X
  1473. Xshowscreen() {
  1474. X
  1475. X   register short i, j;
  1476. X
  1477. X   for( i = 0; i < rows; i++)    {
  1478. X      for( j = 0; map[i][j] != '\0'; j++)
  1479. X            mapchar(map[i][j], i, j);
  1480. X    }
  1481. X   dispstatus();
  1482. X}
  1483. X
  1484. Xmapchar( c, i, j) 
  1485. Xregister char c; 
  1486. Xregister short i, j;
  1487. X{
  1488. X    OBJECT *obj, *get_obj_adr();
  1489. X
  1490. X    obj = get_obj_adr(c);
  1491. X    XCopyPlane(dpy,obj->obj_display,win,gc,0,0,PIXMAPX,PIXMAPY,j*PIXMAPX+PIXMAPX*(MAXCOL/2-cols/2),i*PIXMAPY+PIXMAPY*(MAXROW/2-rows/2),1);    
  1492. X}
  1493. X
  1494. Xclearscreen() {
  1495. X
  1496. X   register short i, j;
  1497. X
  1498. X   for( i = 0; i < rows; i++)    {
  1499. X      for( j = 0; map[i][j] != '\0'; j++)
  1500. X            clearchar(map[i][j], i, j);
  1501. X    }
  1502. X   dispstatus();
  1503. X}
  1504. X
  1505. Xclearchar( c, i, j) 
  1506. Xregister char c; 
  1507. Xregister short i, j;
  1508. X{
  1509. X    XCopyPlane(dpy,ground.obj_display,win,gc,0,0,PIXMAPX,PIXMAPY,j*PIXMAPX+PIXMAPX*(MAXCOL/2-cols/2),i*PIXMAPY+PIXMAPY*(MAXROW/2-rows/2),1);    
  1510. X}
  1511. X
  1512. XOBJECT *get_obj_adr(c)
  1513. Xregister char c;
  1514. X{
  1515. X   register OBJECT *ret;
  1516. X    if (c ==  player.obj_intern)        return &player;
  1517. X    if (c ==  playerstore.obj_intern)    return &playerstore;
  1518. X    if (c ==  store.obj_intern)        return &store;
  1519. X    if (c ==  save.obj_intern)        return &save;
  1520. X    if (c ==  packet.obj_intern)        return &packet;
  1521. X    if (c ==  wall.obj_intern)        return &wall;
  1522. X    if (c ==  ground.obj_intern)        return &ground;
  1523. X    return &ground;
  1524. X}
  1525. X
  1526. X
  1527. Xdispstatus()
  1528. X{
  1529. X
  1530. X    XDrawString(dpy,win,gclear,10,MAXROW*PIXMAPY,line,strlen(line));
  1531. X    sprintf(line,"         %3d            %3d         %3d        %5d         %5d ",level,packets,savepack,moves,pushes);    
  1532. X    XDrawString(dpy,win,gc,10,MAXROW*PIXMAPY,line,strlen(line));
  1533. X}
  1534. X
  1535. Xhelpmessage() {
  1536. X   fprintf( stdout,"Press ? for help.\n");
  1537. X}
  1538. X/*
  1539. Xstatic char *helppages[] = { 
  1540. X   "The problem is to push packets to",
  1541. X   "saving positions by moving around",
  1542. X   "and  pushing only one packet at a",
  1543. X   "        time if possible.        ",
  1544. X   "                                 ",
  1545. X   "                                 ",
  1546. X   "                                 ",
  1547. X   "                                 ",
  1548. X   "                                 ",
  1549. X   NULL,                
  1550. X   "Moving: You can move by using    ",
  1551. X   "           the vi-keys hjkl.     ",
  1552. X   "                                 ",
  1553. X   "              left right up down ",
  1554. X   "  Move/Push     h    l    k   j  ",
  1555. X   "  Run/Push      H    L    K   J  ",
  1556. X   "  Run only     ^H   ^L   ^K  ^J  ",
  1557. X   "                                 ",
  1558. X   "                                 ",
  1559. X   NULL,            
  1560. X   "Other commands:                  ",
  1561. X   "   c:  temporary save            ",
  1562. X   "   q:  quit                      ",
  1563. X   "  ^R:  refresh the screen        ",
  1564. X   "   s:  save the game             ",
  1565. X   "   u:  undo last move/push       ",
  1566. X   "   U:  undo all                  ",
  1567. X   "  ^U:  reset to temp save        ",
  1568. X   "   ?:  this help scree           ",
  1569. X   NULL,        
  1570. X   "Characters on screen are:        ",
  1571. X   "                                 ",
  1572. X   "  %@  player                     ",
  1573. X   "  %+  player on saving position  ",
  1574. X   "  %.  saving position for packet ",
  1575. X   "  %$  packet                     ",
  1576. X   "  %*  saved packet               ",
  1577. X   "  %#  wall                       ",
  1578. X   "                                 ",
  1579. X   NULL,    
  1580. X   "If you set a temporary  save, you",
  1581. X   "need not  undo  all when you  get",
  1582. X   "stucked. Just reset to this save.",
  1583. X   "                                 ",
  1584. X   "A temporary save is automatically",
  1585. X   "made at the start.",
  1586. X   "                                 ",
  1587. X   "                                 ",
  1588. X   "                                 ",
  1589. X   NULL,
  1590. X   NULL
  1591. X};
  1592. X
  1593. Xstatic char *title[] = {
  1594. X   "          S O K O B A N          ",
  1595. X   "---------------------------------"
  1596. X};
  1597. X
  1598. Xstatic char *helphelp[] = {
  1599. X   "   (Press return to exit help,   ",
  1600. X   "    any other key to continue)   "
  1601. X};
  1602. X
  1603. X#define HELPROWS    16
  1604. X#define HELPCOLS    37
  1605. X
  1606. Xshowhelp() {
  1607. X
  1608. X   register short line, i;
  1609. X   short goon = 1;
  1610. X   WINDOW *win, *makehelpwin();
  1611. X
  1612. X   win = makehelpwin();
  1613. X   for( i = 0, line = 2; goon; i++, line++) {
  1614. X      if( helppages[i] != NULL) {
  1615. X     wmove( win, line+1, 2);
  1616. X     printhelpline( win, helppages[i]);
  1617. X      }
  1618. X      else {
  1619. X     wmove( win, HELPROWS-1, 0);
  1620. X     wrefresh( win);
  1621. X     if( (goon = (wgetch( win) != '\n'))) {
  1622. X        line = 1;
  1623. X        if( helppages[i+1] == NULL) i = -1;
  1624. X     }
  1625. X      }
  1626. X   }
  1627. X   werase( win);
  1628. X   wrefresh( win);
  1629. X   delwin( win);
  1630. X}
  1631. X
  1632. XWINDOW *makehelpwin() {
  1633. X
  1634. X   WINDOW *win, *newwin();
  1635. X
  1636. X   win = newwin( HELPROWS, HELPCOLS, 2, 0);
  1637. X   box( win, '|', '-');
  1638. X   wmove( win, 1, 2);
  1639. X   wprintw( win, "%s", title[0]);
  1640. X   wmove( win, 2, 2);
  1641. X   wprintw( win, "%s", title[1]);
  1642. X   wmove( win, HELPROWS-3, 2);
  1643. X   wprintw( win, "%s", helphelp[0]);
  1644. X   wmove( win, HELPROWS-2, 2);
  1645. X   wprintw( win, "%s", helphelp[1]);
  1646. X
  1647. X   return( win);
  1648. X}
  1649. X
  1650. Xprinthelpline( win, line)
  1651. XWINDOW *win;
  1652. Xchar *line;
  1653. X{
  1654. X   OBJECT *obj, *get_obj_adr();
  1655. X
  1656. X   for( ; *line != '\0'; line++) {
  1657. X      if( *line == '%') {
  1658. X     ++line;
  1659. X     obj = get_obj_adr( *line);
  1660. X         if( obj -> invers) wstandout( win);
  1661. X         waddch( win, obj -> obj_display); waddch( win, obj -> obj_display);
  1662. X         if( obj -> invers) wstandend( win);
  1663. X      }
  1664. X      else waddch( win, *line);
  1665. X   }
  1666. X}
  1667. X*/
  1668. END_OF_FILE
  1669. if test 5219 -ne `wc -c <'showscreen.c'`; then
  1670.     echo shar: \"'showscreen.c'\" unpacked with wrong size!
  1671. fi
  1672. # end of 'showscreen.c'
  1673. fi
  1674. if test -f 'sok.c' -a "${1}" != "-c" ; then 
  1675.   echo shar: Will not clobber existing file \"'sok.c'\"
  1676. else
  1677. echo shar: Extracting \"'sok.c'\" \(4950 characters\)
  1678. sed "s/^X//" >'sok.c' <<'END_OF_FILE'
  1679. X#include <stdio.h>
  1680. X#include "sokoban.h"
  1681. X
  1682. XOBJECT 
  1683. X   player =      { '@',NULL, 0 },
  1684. X   playerstore = { '+',NULL, 1 },
  1685. X   store =      { '.',NULL, 0 },
  1686. X   packet =      { '$',NULL, 0 },
  1687. X   save =      { '*',NULL, 1 },
  1688. X   ground =      { ' ',NULL, 0 },
  1689. X   wall =      { '#',NULL, 1 };
  1690. X
  1691. Xextern char  *rindex(), *getlogin(), *getpass();
  1692. Xextern short readscreen(), play(), outputscore(), getuserlevel(),
  1693. X         makenewscore(), restoregame(), score();
  1694. X
  1695. Xshort scoring = 1;
  1696. Xshort level, packets, savepack, moves, pushes, rows, cols;
  1697. Xshort scorelevel, scoremoves, scorepushes;
  1698. Xchar  map[MAXROW+1][MAXCOL+1];
  1699. XPOS   ppos;
  1700. Xchar  *username, *prgname;
  1701. X
  1702. Xstatic short optshowscore = 0, 
  1703. X         optmakescore = 0, 
  1704. X             optrestore = 0, 
  1705. X         optlevel = 0; 
  1706. Xstatic short superuser = 0;
  1707. X
  1708. Xstatic short userlevel;
  1709. X
  1710. Xmain( argc, argv) 
  1711. Xshort argc; 
  1712. Xchar *argv[];
  1713. X{
  1714. X   short ret, ret2;
  1715. X
  1716. X   scorelevel = 0;
  1717. X   moves = pushes = packets = savepack = 0;
  1718. X   if( (prgname = rindex( argv[0], '/')) == NULL)
  1719. X      prgname = argv[0];
  1720. X   else prgname++;
  1721. X   if( (username = getlogin()) == NULL)
  1722. X      ret = E_NOUSER;
  1723. X   else {
  1724. X      superuser = (strcmp( username, SUPERUSER) == 0);
  1725. X      if( (ret = checkcmdline( argc, argv)) == 0) {
  1726. X         if( optshowscore)
  1727. X        ret = outputscore();
  1728. X         else if( optmakescore) {
  1729. X        if( superuser) {
  1730. X           if( (ret = getpassword()) == 0)
  1731. X              ret = makenewscore();
  1732. X        }
  1733. X        else ret = E_NOSUPER;
  1734. X     }
  1735. X     else if( optrestore) {
  1736. X        ret = restoregame();
  1737. X     }
  1738. X         else if( (ret = getuserlevel( &userlevel)) == 0) {
  1739. X            if( optlevel > 0) {
  1740. X           if( superuser) {
  1741. X              level = optlevel;
  1742. X          scoring = 0;
  1743. X           }
  1744. X           else if( userlevel < optlevel)
  1745. X              ret = E_LEVELTOOHIGH;
  1746. X           else level = optlevel;
  1747. X        }
  1748. X        else level = userlevel;
  1749. X         }
  1750. X      }
  1751. X   }
  1752. X   if( ret == 0) {
  1753. X    initx();
  1754. X      ret = gameloop();
  1755. X    killx();
  1756. X    }
  1757. X   errmess( ret);
  1758. X   if( scorelevel && scoring) {
  1759. X      ret2 = score();
  1760. X      errmess( ret2);
  1761. X   }
  1762. X   exit( ret);
  1763. X}
  1764. X
  1765. Xcheckcmdline( argc, argv) 
  1766. Xshort argc; 
  1767. Xchar *argv[];
  1768. X{
  1769. X   short ret = 0;
  1770. X
  1771. X   if( argc > 1)
  1772. X      if( (argc == 2) && (argv[1][0] == '-')) {
  1773. X     if( (argv[1][1] == 's') && (argv[1][2] == '\0'))
  1774. X        optshowscore = 1;
  1775. X     else if( (argv[1][1] == 'c') && (argv[1][2] == '\0'))
  1776. X        optmakescore = 1;
  1777. X     else if( (argv[1][1] == 'r') && (argv[1][2] == '\0'))
  1778. X        optrestore = 1;
  1779. X     else if( (optlevel = atoi( &(argv[1][1]))) == 0)
  1780. X        ret = E_USAGE;
  1781. X      }
  1782. X      else ret = E_USAGE;
  1783. X   return( ret);
  1784. X}
  1785. X
  1786. Xgameloop() {
  1787. X
  1788. X   short ret ;
  1789. X
  1790. X    ret = readscreen();
  1791. X   while( ret == 0) {
  1792. X      if( (ret = play()) == 0) {
  1793. X         level++;
  1794. X         moves = pushes = packets = savepack = 0;
  1795. X         ret = readscreen();
  1796. X      }
  1797. X   }
  1798. X   return( ret);
  1799. X}
  1800. X
  1801. Xgetpassword() {
  1802. X
  1803. X   return( (strcmp(getpass("Password: "), PASSWORD) == 0) ? 0 : E_ILLPASSWORD);
  1804. X}
  1805. X
  1806. Xchar *message[] = {
  1807. X   "illegal error number",
  1808. X   "cannot open screen file",
  1809. X   "more than one player position in screen file",
  1810. X   "illegal char in screen file",
  1811. X   "no player position in screenfile",
  1812. X   "too much rows in screen file",
  1813. X   "too much columns in screenfile",
  1814. X   "quit the game",
  1815. X   NULL,            /* errmessage deleted */
  1816. X   "cannot get your username",
  1817. X   "cannot open savefile",
  1818. X   "error writing to savefile",
  1819. X   "cannot stat savefile",
  1820. X   "error reading savefile",
  1821. X   "cannot restore, your savefile has been altered",
  1822. X   "game saved",
  1823. X   "too much users in score table",
  1824. X   "cannot open score file",
  1825. X   "error reading scorefile",
  1826. X   "error writing scorefile",
  1827. X   "illegal command line syntax",
  1828. X   "illegal password",
  1829. X   "level number too big in command line",
  1830. X   "only superuser is allowed to make a new score table",
  1831. X   "cannot find file to restore"
  1832. X};
  1833. X
  1834. Xerrmess( ret) 
  1835. Xregister short ret;
  1836. X{
  1837. X   if( ret != E_ENDGAME) {
  1838. X      fprintf( stderr, "%s: ", prgname);
  1839. X      switch( ret) {
  1840. X         case E_FOPENSCREEN: case E_PLAYPOS1:   case E_ILLCHAR: 
  1841. X     case E_PLAYPOS2:    case E_TOMUCHROWS: case E_TOMUCHCOLS: 
  1842. X     case E_ENDGAME:     case E_NOUSER:      
  1843. X     case E_FOPENSAVE:   case E_WRITESAVE:  case E_STATSAVE:    
  1844. X     case E_READSAVE:    case E_ALTERSAVE:  case E_SAVED:       
  1845. X     case E_TOMUCHSE:    case E_FOPENSCORE: case E_READSCORE: 
  1846. X     case E_WRITESCORE:  case E_USAGE:    case E_ILLPASSWORD:
  1847. X     case E_LEVELTOOHIGH: case E_NOSUPER:    case E_NOSAVEFILE:
  1848. X                 fprintf( stderr, "%s\n", message[ret]);
  1849. X                             break;
  1850. X         default:            fprintf( stderr, "%s\n", message[0]);
  1851. X                             break;
  1852. X      }
  1853. X      if( ret == E_USAGE) usage();
  1854. X   }
  1855. X}
  1856. X
  1857. Xstatic char *usagestr[] = {
  1858. X   "           -c:    create new score table (superuser only)\n",
  1859. X   "           -r:    restore saved game\n",
  1860. X   "           -s:    show score table\n",
  1861. X   "           -<nn>: play this level (<nn> must be greater 0)\n",
  1862. X   NULL
  1863. X};
  1864. X
  1865. Xusage() {
  1866. X
  1867. X   register short i;
  1868. X
  1869. X   fprintf( stderr, "Usage: %s [-{s|c|r|<nn>}]\n\n", prgname);
  1870. X   for( i = 0; usagestr[i] != NULL; i++)
  1871. X      fprintf( stderr, "%s", usagestr[i]);
  1872. X}
  1873. END_OF_FILE
  1874. if test 4950 -ne `wc -c <'sok.c'`; then
  1875.     echo shar: \"'sok.c'\" unpacked with wrong size!
  1876. fi
  1877. # end of 'sok.c'
  1878. fi
  1879. if test -f 'sokoban.h' -a "${1}" != "-c" ; then 
  1880.   echo shar: Will not clobber existing file \"'sokoban.h'\"
  1881. else
  1882. echo shar: Extracting \"'sokoban.h'\" \(2634 characters\)
  1883. sed "s/^X//" >'sokoban.h' <<'END_OF_FILE'
  1884. X/***********************************************************************
  1885. X   You may wish to alter the following directory paths
  1886. X***********************************************************************/
  1887. X#include <X11/Xlib.h>
  1888. X#include <X11/Xutil.h>
  1889. X/**/
  1890. X/* SCREENPATH: the name of the directioy where the screen file are held */
  1891. X/**/
  1892. X#define SCREENPATH     "/u/s7/staff/kevins/src/X/sokoban/screens"
  1893. X
  1894. X/**/
  1895. X/* SAVEPATH: the name of the path where save files are held */
  1896. X/*           Attention: Be sure that there are no other files with */
  1897. X/*                      the name <username>.sav                    */
  1898. X/**/
  1899. X#define SAVEPATH    "/u/s7/staff/kevins/src/X/sokoban/"
  1900. X
  1901. X/**/
  1902. X/* LOCKPATH: temporary file which is created to ensure that no users */
  1903. X/*           work with the scorefile at the same time                */
  1904. X/**/
  1905. X#define LOCKFILE    "/tmp/sok.lock"
  1906. X
  1907. X/**/
  1908. X/* SCOREFILE: the full pathname of the score file */
  1909. X/**/
  1910. X#define SCOREFILE    "/u/s3/games/lib/sokoban/sok.score"
  1911. X
  1912. X/**/
  1913. X/* MAXUSERNAME: defines the maximum length of a system's user name */
  1914. X/**/
  1915. X#define MAXUSERNAME    10
  1916. X
  1917. X/**/
  1918. X/* MAXSCOREENTRIES: defines the maximum numner of entries in the scoretable */
  1919. X/**/
  1920. X#define MAXSCOREENTRIES    50
  1921. X
  1922. X/**/
  1923. X/* SUPERUSER: defines the name of the game superuser */
  1924. X/**/
  1925. X#define SUPERUSER "kevins"
  1926. X
  1927. X/**/
  1928. X/* PASSWORD: defines the password necessary for creating a new score file */
  1929. X/**/
  1930. X#define PASSWORD "nabokos"
  1931. X
  1932. X/**/
  1933. X/* OBJECT: this typedef is used for internal and external representation */
  1934. X/*         of objects                                                    */
  1935. X/**/
  1936. Xtypedef struct {
  1937. X   char obj_intern;    /* internal representation of the object */
  1938. X   Pixmap obj_display;    /* display char for the object         */
  1939. X   short invers;    /* if set to 1 the object will be shown invers */
  1940. X} OBJECT;
  1941. X
  1942. X
  1943. X/*************************************************************************
  1944. X********************** DO NOT CHANGE BELOW THIS LINE *********************
  1945. X*************************************************************************/
  1946. X#define MAXROW        20
  1947. X#define MAXCOL        40
  1948. X#define PIXMAPX    16
  1949. X#define PIXMAPY    16
  1950. X
  1951. Xtypedef struct {
  1952. X   short x, y;
  1953. X} POS;
  1954. X
  1955. X#define E_FOPENSCREEN    1
  1956. X#define E_PLAYPOS1    2
  1957. X#define E_ILLCHAR    3
  1958. X#define E_PLAYPOS2    4
  1959. X#define E_TOMUCHROWS    5
  1960. X#define E_TOMUCHCOLS    6
  1961. X#define E_ENDGAME    7
  1962. X#define E_NOUSER    9
  1963. X#define E_FOPENSAVE    10
  1964. X#define E_WRITESAVE    11
  1965. X#define E_STATSAVE    12
  1966. X#define E_READSAVE    13
  1967. X#define E_ALTERSAVE    14
  1968. X#define E_SAVED        15
  1969. X#define E_TOMUCHSE    16
  1970. X#define E_FOPENSCORE    17
  1971. X#define E_READSCORE    18
  1972. X#define E_WRITESCORE    19
  1973. X#define E_USAGE        20
  1974. X#define E_ILLPASSWORD    21
  1975. X#define E_LEVELTOOHIGH    22
  1976. X#define E_NOSUPER    23
  1977. X#define E_NOSAVEFILE    24
  1978. END_OF_FILE
  1979. if test 2634 -ne `wc -c <'sokoban.h'`; then
  1980.     echo shar: \"'sokoban.h'\" unpacked with wrong size!
  1981. fi
  1982. # end of 'sokoban.h'
  1983. fi
  1984. echo shar: End of archive 1 \(of 2\).
  1985. cp /dev/null ark1isdone
  1986. MISSING=""
  1987. for I in 1 2 ; do
  1988.     if test ! -f ark${I}isdone ; then
  1989.     MISSING="${MISSING} ${I}"
  1990.     fi
  1991. done
  1992. if test "${MISSING}" = "" ; then
  1993.     echo You have unpacked both archives.
  1994.     rm -f ark[1-9]isdone
  1995. else
  1996.     echo You still need to unpack the following archives:
  1997.     echo "        " ${MISSING}
  1998. fi
  1999. ##  End of shell archive.
  2000. exit 0
  2001.