16 * 12500 words of message text (LINES, LINSIZ).
17 * 885 travel options (TRAVEL, TRVSIZ).
18 * 330 vocabulary words (KTAB, ATAB, TABSIZ).
19 * 185 locations (LTEXT, STEXT, KEY, COND, ABB, ATLOC, LOCSND, LOCSIZ).
20 * 100 objects (PLAC, PLACE, FIXD, FIXED, LINK (TWICE), PTEXT, PROP,
22 * 35 "action" verbs (ACTSPK, VRBSIZ).
23 * 277 random messages (RTEXT, RTXSIZ).
24 * 12 different player classifications (CTEXT, CVAL, CLSMAX).
25 * 20 hints (HINTLC, HINTED, HINTS, HNTSIZ).
26 * 5 "# of turns" threshholds (TTEXT, TRNVAL, TRNSIZ).
27 * There are also limits which cannot be exceeded due to the structure of
28 * the database. (E.G., The vocabulary uses n/1000 to determine word type,
29 * so there can't be more than 1000 words.) These upper limits are:
30 * 1000 non-synonymous vocabulary words
35 /* Description of the database format
38 * The data file contains several sections. Each begins with a line containing
39 * a number identifying the section, and ends with a line containing "-1".
41 * Section 1: Long form descriptions. Each line contains a location number,
42 * a tab, and a line of text. The set of (necessarily adjacent) lines
43 * whose numbers are X form the long description of location X.
44 * Section 2: Short form descriptions. Same format as long form. Not all
45 * places have short descriptions.
46 * Section 3: Travel table. Each line contains a location number (X), a second
47 * location number (Y), and a list of motion numbers (see section 4).
48 * each motion represents a verb which will go to Y if currently at X.
49 * Y, in turn, is interpreted as follows. Let M=Y/1000, N=Y mod 1000.
50 * If N<=300 it is the location to go to.
51 * If 300<N<=500 N-300 is used in a computed goto to
52 * a section of special code.
53 * If N>500 message N-500 from section 6 is printed,
54 * and he stays wherever he is.
55 * Meanwhile, M specifies the conditions on the motion.
56 * If M=0 it's unconditional.
57 * If 0<M<100 it is done with M% probability.
58 * If M=100 unconditional, but forbidden to dwarves.
59 * If 100<M<=200 he must be carrying object M-100.
60 * If 200<M<=300 must be carrying or in same room as M-200.
61 * If 300<M<=400 PROP(M % 100) must *not* be 0.
62 * If 400<M<=500 PROP(M % 100) must *not* be 1.
63 * If 500<M<=600 PROP(M % 100) must *not* be 2, etc.
64 * If the condition (if any) is not met, then the next *different*
65 * "destination" value is used (unless it fails to meet *its* conditions,
66 * in which case the next is found, etc.). Typically, the next dest will
67 * be for one of the same verbs, so that its only use is as the alternate
68 * destination for those verbs. For instance:
69 * 15 110022 29 31 34 35 23 43
71 * This says that, from loc 15, any of the verbs 29, 31, etc., will take
72 * him to 22 if he's carrying object 10, and otherwise will go to 14.
75 * This says that, from 11, 49 takes him to 8 unless PROP(3)=0, in which
76 * case he goes to 9. Verb 50 takes him to 9 regardless of PROP(3).
77 * Section 4: Vocabulary. Each line contains a number (n), a tab, and a
78 * five-letter word. Call M=N/1000. If M=0, then the word is a motion
79 * verb for use in travelling (see section 3). Else, if M=1, the word is
80 * an object. Else, if M=2, the word is an action verb (such as "carry"
81 * or "attack"). Else, if M=3, the word is a special case verb (such as
82 * "dig") and N % 1000 is an index into section 6. Objects from 50 to
83 * (currently, anyway) 79 are considered treasures (for pirate, closeout).
84 * Section 5: Object descriptions. Each line contains a number (N), a tab,
85 * and a message. If N is from 1 to 100, the message is the "inventory"
86 * message for object n. Otherwise, N should be 000, 100, 200, etc., and
87 * the message should be the description of the preceding object when its
88 * prop value is N/100. The N/100 is used only to distinguish multiple
89 * messages from multi-line messages; the prop info actually requires all
90 * messages for an object to be present and consecutive. Properties which
91 * produce no message should be given the message ">$<".
92 * Section 6: Arbitrary messages. Same format as sections 1, 2, and 5, except
93 * the numbers bear no relation to anything (except for special verbs
95 * Section 7: Object locations. Each line contains an object number and its
96 * initial location (zero (or omitted) if none). If the object is
97 * immovable, the location is followed by a "-1". If it has two locations
98 * (e.g. the grate) the first location is followed with the second, and
99 * the object is assumed to be immovable.
100 * Section 8: Action defaults. Each line contains an "action-verb" number and
101 * the index (in section 6) of the default message for the verb.
102 * Section 9: Location attributes. Each line contains a number (n) and up to
103 * 20 location numbers. Bit N (where 0 is the units bit) is set in
104 * COND(LOC) for each loc given. The cond bits currently assigned are:
106 * 1 If bit 2 is on: on for oil, off for water
107 * 2 Liquid asset, see bit 1
108 * 3 Pirate doesn't go here unless following player
109 * 4 Cannot use "back" to move away
110 * Bits past 10 indicate areas of interest to "hint" routines:
111 * 11 Trying to get into cave
112 * 12 Trying to catch bird
113 * 13 Trying to deal with snake
115 * 15 Pondering dark room
119 * 19 Trying to deal with ogre
120 * 20 Found all treasures except jade
121 * COND(LOC) is set to 2, overriding all other bits, if loc has forced
123 * Section 10: Class messages. Each line contains a number (n), a tab, and a
124 * message describing a classification of player. The scoring section
125 * selects the appropriate message, where each message is considered to
126 * apply to players whose scores are higher than the previous N but not
127 * higher than this N. Note that these scores probably change with every
128 * modification (and particularly expansion) of the program.
129 * SECTION 11: Hints. Each line contains a hint number (add 10 to get cond
130 * bit; see section 9), the number of turns he must be at the right loc(s)
131 * before triggering the hint, the points deducted for taking the hint,
132 * the message number (section 6) of the question, and the message number
133 * of the hint. These values are stashed in the "hints" array. HNTMAX is
134 * set to the max hint number (<= HNTSIZ).
135 * Section 12: Unused in this version.
136 * Section 13: Sounds and text. Each line contains either 2 or 3 numbers. If
137 * 2 (call them N and S), N is a location and message ABS(S) from section
138 * 6 is the sound heard there. If S<0, the sound there drowns out all
139 * other noises. If 3 numbers (call them N, S, and T), N is an object
140 * number and S+PROP(N) is the property message (from section 5) if he
141 * listens to the object, and T+PROP(N) is the text if he reads it. If
142 * S or T is -1, the object has no sound or text, respectively. Neither
143 * S nor T is allowed to be 0.
144 * Section 14: Turn threshholds. Each line contains a number (N), a tab, and
145 * a message berating the player for taking so many turns. The messages
146 * must be in the proper (ascending) order. The message gets printed if
147 * the player exceeds N % 100000 turns, at which time N/100000 points
148 * get deducted from his score.
149 * Section 0: End of database. */
151 /* The various messages (sections 1, 2, 5, 6, etc.) may include certain
152 * special character sequences to denote that the program must provide
153 * parameters to insert into a message when the message is printed. These
155 * %S = The letter 'S' or nothing (if a given value is exactly 1)
156 * %W = A word (up to 10 characters)
157 * %L = A word mapped to lower-case letters
158 * %U = A word mapped to upper-case letters
159 * %C = A word mapped to lower-case, first letter capitalised
160 * %T = Several words of text, ending with a word of -1
161 * %1 = A 1-digit number
162 * %2 = A 2-digit number
164 * %9 = A 9-digit number
165 * %B = Variable number of blanks
166 * %! = The entire message should be suppressed */
168 static bool quick_init(void);
169 static int raw_init(void);
170 static void report(void);
171 static void quick_save(void);
172 static int finish_init(void);
173 static void quick_io(void);
175 void initialise(void) {
177 printf("Initialising...\n");
178 if(!quick_init()){raw_init(); report(); quick_save();}
182 static int raw_init(void) {
183 printf("Couldn't find adventure.data, using adventure.text...\n");
185 FILE *OPENED=fopen("adventure.text","r" /* NOT binary */);
186 if(!OPENED){printf("Can't read adventure.text!\n"); exit(0);}
188 /* Clear out the various text-pointer arrays. All text is stored in array
189 * lines; each line is preceded by a word pointing to the next pointer (i.e.
190 * the word following the end of the line). The pointer is negative if this is
191 * first line of a message. The text-pointer arrays contain indices of
192 * pointer-words in lines. STEXT(N) is short description of location N.
193 * LTEXT(N) is long description. PTEXT(N) points to message for PROP(N)=0.
194 * Successive prop messages are found by chasing pointers. RTEXT contains
195 * section 6's stuff. CTEXT(N) points to a player-class message. TTEXT is for
196 * section 14. We also clear COND (see description of section 9 for details). */
198 /* 1001 */ for (I=1; I<=300; I++) {
199 if(I <= 100)PTEXT[I]=0;
200 if(I <= RTXSIZ)RTEXT[I]=0;
201 if(I <= CLSMAX)CTEXT[I]=0;
202 if(I <= 100)OBJSND[I]=0;
203 if(I <= 100)OBJTXT[I]=0;
204 if(I > LOCSIZ) goto L1001;
218 /* Start new data section. Sect is the section number. */
220 L1002: SECT=GETNUM(OPENED);
222 switch (SECT) { case 0: return(0); case 1: goto L1004; case 2: goto
223 L1004; case 3: goto L1030; case 4: goto L1040; case 5: goto L1004;
224 case 6: goto L1004; case 7: goto L1050; case 8: goto L1060; case
225 9: goto L1070; case 10: goto L1004; case 11: goto L1080; case 12:
226 break; case 13: goto L1090; case 14: goto L1004; }
227 /* (0) (1) (2) (3) (4) (5) (6) (7) (8) (9)
228 * (10) (11) (12) (13) (14) */
231 /* Sections 1, 2, 5, 6, 10, 14. Read messages and set up pointers. */
236 if(LNLENG >= LNPOSN+70)BUG(0);
237 if(LOC == -1) goto L1002;
238 if(LNLENG < LNPOSN)BUG(1);
240 if(KK >= LINSIZ)BUG(2);
241 LINES[KK]=GETTXT(false,false,false,KK);
242 if(LINES[KK] != -1) goto L1006;
244 if(LOC == OLDLOC) goto L1005;
247 if(SECT == 14) goto L1014;
248 if(SECT == 10) goto L1012;
249 if(SECT == 6) goto L1011;
250 if(SECT == 5) goto L1010;
251 if(LOC > LOCSIZ)BUG(10);
252 if(SECT == 1) goto L1008;
257 L1008: LTEXT[LOC]=LINUSE;
260 L1010: if(LOC > 0 && LOC <= 100)PTEXT[LOC]=LINUSE;
263 L1011: if(LOC > RTXSIZ)BUG(6);
267 L1012: CLSSES=CLSSES+1;
268 if(CLSSES > CLSMAX)BUG(11);
269 CTEXT[CLSSES]=LINUSE;
273 L1014: TRNVLS=TRNVLS+1;
274 if(TRNVLS > TRNSIZ)BUG(11);
275 TTEXT[TRNVLS]=LINUSE;
279 /* The stuff for section 3 is encoded here. Each "from-location" gets a
280 * contiguous section of the "TRAVEL" array. Each entry in travel is
281 * NEWLOC*1000 + KEYWORD (from section 4, motion verbs), and is negated if
282 * this is the last entry for this location. KEY(N) is the index in travel
283 * of the first option at location N. */
285 L1030: LOC=GETNUM(OPENED);
286 if(LOC == -1) goto L1002;
288 if(KEY[LOC] != 0) goto L1033;
291 L1033: TRVS--; TRAVEL[TRVS]= -TRAVEL[TRVS]; TRVS++;
292 L1035: L=GETNUM(NULL);
293 if(L == 0) goto L1039;
294 TRAVEL[TRVS]=NEWLOC*1000+L;
296 if(TRVS == TRVSIZ)BUG(3);
298 L1039: TRVS--; TRAVEL[TRVS]= -TRAVEL[TRVS]; TRVS++;
301 /* Here we read in the vocabulary. KTAB(N) is the word number, ATAB(N) is
302 * the corresponding word. The -1 at the end of section 4 is left in KTAB
303 * as an end-marker. The words are given a minimal hash to make deciphering
304 * the core-image harder. (We don't use gettxt's hash since that would force
305 * us to hash each input line to make comparisons work, and that in turn
306 * would make it harder to detect particular input words.) */
309 for (TABNDX=1; TABNDX<=TABSIZ; TABNDX++) {
310 KTAB[TABNDX]=GETNUM(OPENED);
311 if(KTAB[TABNDX] == -1) goto L1002;
313 ATAB[TABNDX]=GETTXT(true,true,true,0)+J*J;
317 /* Read in the initial locations for each object. Also the immovability info.
318 * plac contains initial locations of objects. FIXD is -1 for immovable
319 * objects (including the snake), or = second loc for two-placed objects. */
321 L1050: OBJ=GETNUM(OPENED);
322 if(OBJ == -1) goto L1002;
323 PLAC[OBJ]=GETNUM(NULL);
324 FIXD[OBJ]=GETNUM(NULL);
327 /* Read default message numbers for action verbs, store in ACTSPK. */
329 L1060: VERB=GETNUM(OPENED);
330 if(VERB == -1) goto L1002;
331 ACTSPK[VERB]=GETNUM(NULL);
334 /* Read info about available liquids and other conditions, store in COND. */
336 L1070: K=GETNUM(OPENED);
337 if(K == -1) goto L1002;
338 L1071: LOC=GETNUM(NULL);
339 if(LOC == 0) goto L1070;
340 if(CNDBIT(LOC,K)) BUG(8);
341 COND[LOC]=COND[LOC]+SETBIT(K);
344 /* Read data for hints. */
347 L1081: K=GETNUM(OPENED);
348 if(K == -1) goto L1002;
349 if(K <= 0 || K > HNTSIZ)BUG(7);
350 for (I=1; I<=4; I++) {
351 HINTS[K][I] =GETNUM(NULL);
353 HNTMAX=(HNTMAX>K ? HNTMAX : K);
356 /* Read the sound/text info, store in OBJSND, OBJTXT, LOCSND. */
358 L1090: K=GETNUM(OPENED);
359 if(K == -1) goto L1002;
362 if(I == 0) goto L1092;
363 OBJSND[K]=(KK>0 ? KK : 0);
364 OBJTXT[K]=(I>0 ? I : 0);
371 /* Finish constructing internal data format */
373 /* Having read in the database, certain things are now constructed. PROPS are
374 * set to zero. We finish setting up COND by checking for forced-motion travel
375 * entries. The PLAC and FIXD arrays are used to set up ATLOC(N) as the first
376 * object at location N, and LINK(OBJ) as the next object at the same location
377 * as OBJ. (OBJ>100 indicates that FIXED(OBJ-100)=LOC; LINK(OBJ) is still the
378 * correct link to use.) ABB is zeroed; it controls whether the abbreviated
379 * description is printed. Counts modulo 5 unless "LOOK" is used. */
381 static int finish_init(void) {
382 for (I=1; I<=100; I++) {
386 {long x = I+100; LINK[x]=0;}
389 /* 1102 */ for (I=1; I<=LOCSIZ; I++) {
391 if(LTEXT[I] == 0 || KEY[I] == 0) goto L1102;
393 if(MOD(IABS(TRAVEL[K]),1000) == 1)COND[I]=2;
397 /* Set up the ATLOC and LINK arrays as described above. We'll use the DROP
398 * subroutine, which prefaces new objects on the lists. Since we want things
399 * in the other order, we'll run the loop backwards. If the object is in two
400 * locs, we drop it twice. This also sets up "PLACE" and "fixed" as copies of
401 * "PLAC" and "FIXD". Also, since two-placed objects are typically best
402 * described last, we'll drop them first. */
404 /* 1106 */ for (I=1; I<=100; I++) {
406 if(FIXD[K] <= 0) goto L1106;
412 for (I=1; I<=100; I++) {
415 if(PLAC[K] != 0 && FIXD[K] <= 0)DROP(K,PLAC[K]);
418 /* Treasures, as noted earlier, are objects 50 through MAXTRS (CURRENTLY 79).
419 * Their props are initially -1, and are set to 0 the first time they are
420 * described. TALLY keeps track of how many are not yet found, so we know
421 * when to close the cave. */
425 for (I=50; I<=MAXTRS; I++) {
426 if(PTEXT[I] != 0)PROP[I]= -1;
430 /* Clear the hint stuff. HINTLC(I) is how long he's been at LOC with cond bit
431 * I. HINTED(I) is true iff hint I has been used. */
433 for (I=1; I<=HNTMAX; I++) {
438 /* Define some handy mnemonics. These correspond to object numbers. */
441 BATTER=VOCWRD(201202005,1);
442 BEAR=VOCWRD(2050118,1);
443 BIRD=VOCWRD(2091804,1);
444 BLOOD=VOCWRD(212151504,1);
445 BOTTLE=VOCWRD(215202012,1);
446 CAGE=VOCWRD(3010705,1);
447 CAVITY=VOCWRD(301220920,1);
448 CHASM=VOCWRD(308011913,1);
449 CLAM=VOCWRD(3120113,1);
450 DOOR=VOCWRD(4151518,1);
451 DRAGON=VOCWRD(418010715,1);
452 DWARF=VOCWRD(423011806,1);
453 FISSUR=VOCWRD(609191921,1);
454 FOOD=VOCWRD(6151504,1);
455 GRATE=VOCWRD(718012005,1);
456 KEYS=VOCWRD(11052519,1);
457 KNIFE=VOCWRD(1114090605,1);
458 LAMP=VOCWRD(12011316,1);
459 MAGZIN=VOCWRD(1301070126,1);
460 MESSAG=VOCWRD(1305191901,1);
461 MIRROR=VOCWRD(1309181815,1);
462 OGRE=VOCWRD(15071805,1);
463 OIL=VOCWRD(150912,1);
464 OYSTER=VOCWRD(1525192005,1);
465 PILLOW=VOCWRD(1609121215,1);
466 PLANT=VOCWRD(1612011420,1);
468 RESER=VOCWRD(1805190518,1);
469 ROD=VOCWRD(181504,1);
471 SIGN=VOCWRD(19090714,1);
472 SNAKE=VOCWRD(1914011105,1);
473 STEPS=VOCWRD(1920051619,1);
474 TROLL=VOCWRD(2018151212,1);
476 URN=VOCWRD(211814,1);
477 VEND=VOCWRD(1755140409,1);
478 VOLCAN=VOCWRD(1765120301,1);
479 WATER=VOCWRD(1851200518,1);
481 /* Objects from 50 through whatever are treasures. Here are a few. */
483 AMBER=VOCWRD(113020518,1);
484 CHAIN=VOCWRD(308010914,1);
485 CHEST=VOCWRD(308051920,1);
486 COINS=VOCWRD(315091419,1);
487 EGGS=VOCWRD(5070719,1);
488 EMRALD=VOCWRD(513051801,1);
489 JADE=VOCWRD(10010405,1);
490 NUGGET=VOCWRD(7151204,1);
491 PEARL=VOCWRD(1605011812,1);
492 PYRAM=VOCWRD(1625180113,1);
493 RUBY=VOCWRD(18210225,1);
494 RUG=VOCWRD(182107,1);
495 SAPPH=VOCWRD(1901161608,1);
496 TRIDNT=VOCWRD(2018090405,1);
497 VASE=VOCWRD(22011905,1);
499 /* These are motion-verb numbers. */
501 BACK=VOCWRD(2010311,0);
502 CAVE=VOCWRD(3012205,0);
503 DPRSSN=VOCWRD(405161805,0);
504 ENTER=VOCWRD(514200518,0);
505 ENTRNC=VOCWRD(514201801,0);
506 LOOK=VOCWRD(12151511,0);
507 NUL=VOCWRD(14211212,0);
508 STREAM=VOCWRD(1920180501,0);
510 /* And some action verbs. */
512 FIND=VOCWRD(6091404,2);
513 INVENT=VOCWRD(914220514,2);
514 LOCK=VOCWRD(12150311,2);
515 SAY=VOCWRD(190125,2);
516 THROW=VOCWRD(2008181523,2);
518 /* Initialise the dwarves. DLOC is loc of dwarves, hard-wired in. ODLOC is
519 * prior loc of each dwarf, initially garbage. DALTLC is alternate initial loc
520 * for dwarf, in case one of them starts out on top of the adventurer. (No 2
521 * of the 5 initial locs are adjacent.) DSEEN is true if dwarf has seen him.
522 * DFLAG controls the level of activation of all this:
523 * 0 No dwarf stuff yet (wait until reaches Hall Of Mists)
524 * 1 Reached Hall Of Mists, but hasn't met first dwarf
525 * 2 Met first dwarf, others start moving, no knives thrown yet
526 * 3 A knife has been thrown (first set always misses)
527 * 3+ Dwarves are mad (increases their accuracy)
528 * Sixth dwarf is special (the pirate). He always starts at his chest's
529 * eventual location inside the maze. This loc is saved in CHLOC for ref.
530 * the dead end in the other maze has its loc stored in CHLOC2. */
534 for (I=1; I<=6; I++) {
546 /* Other random flags and counters, as follows:
547 * ABBNUM How often we should print non-abbreviated descriptions
548 * BONUS Used to determine amount of bonus if he reaches closing
549 * CLOCK1 Number of turns from finding last treasure till closing
550 * CLOCK2 Number of turns from first warning till blinding flash
551 * CONDS Min value for cond(loc) if loc has any hints
552 * DETAIL How often we've said "not allowed to give more detail"
553 * DKILL Number of dwarves killed (unused in scoring, needed for msg)
554 * FOOBAR Current progress in saying "FEE FIE FOE FOO".
555 * HOLDNG Number of objects being carried
556 * IGO How many times he's said "go XXX" instead of "XXX"
557 * IWEST How many times he's said "west" instead of "w"
558 * KNFLOC 0 if no knife here, loc if knife here, -1 after caveat
559 * LIMIT Lifetime of lamp (not set here)
560 * MAXDIE Number of reincarnation messages available (up to 5)
561 * NUMDIE Number of times killed so far
562 * THRESH Next #turns threshhold (-1 if none)
563 * TRNDEX Index in TRNVAL of next threshhold (section 14 of database)
564 * TRNLUZ # points lost so far due to number of turns used
565 * TURNS Tallies how many commands he's given (ignores yes/no)
566 * Logicals were explained earlier */
571 if(TRNVLS > 0)THRESH=MOD(TRNVAL[1],100000)+1;
579 for (I=0; I<=4; I++) {
580 {long x = 2*I+81; if(RTEXT[x] != 0)MAXDIE=I+1;}
598 /* if we can ever think of how, we should save it at this point */
600 return(0); /* then we won't actually return from initialisation */
603 /* Report on amount of arrays actually used, to permit reductions. */
605 static void report(void) {
606 for (K=1; K<=LOCSIZ; K++) {
608 if(LTEXT[KK] != 0) goto L1997;
613 L1997: for (K=1; K<=100; K++) {
614 if(PTEXT[K] != 0)OBJ=OBJ+1;
617 for (K=1; K<=TABNDX; K++) {
618 if(KTAB[K]/1000 == 2)VERB=KTAB[K]-2000;
621 for (K=1; K<=RTXSIZ; K++) {
623 if(RTEXT[J] != 0) goto L1993;
627 L1993: SETPRM(1,LINUSE,LINSIZ);
628 SETPRM(3,TRVS,TRVSIZ);
629 SETPRM(5,TABNDX,TABSIZ);
632 SETPRM(11,VERB,VRBSIZ);
634 SETPRM(15,CLSSES,CLSMAX);
635 SETPRM(17,HNTMAX,HNTSIZ);
636 SETPRM(19,TRNVLS,TRNSIZ);
641 static long init_reading, init_cksum;
644 static void quick_item(long*);
645 static void quick_array(long*, long);
647 static bool quick_init(void) {
648 extern char *getenv();
649 char *adv = getenv("ADVENTURE");
651 if(adv)f = fopen(adv,READ_MODE);
652 if(f == NULL)f = fopen("adventure.data",READ_MODE);
653 if(f == NULL)return(false);
657 if(fread(&K,sizeof(long),1,f) == 1) init_cksum -= K; else init_cksum = 1;
659 if(init_cksum != 0)printf("Checksum error!\n");
660 return(init_cksum == 0);
663 static void quick_save(void) {
664 printf("Writing adventure.data...\n");
665 f = fopen("adventure.data",WRITE_MODE);
666 if(f == NULL){printf("Can't open file!\n"); return;}
667 init_reading = false;
670 fwrite(&init_cksum,sizeof(long),1,f);
674 static void quick_io(void) {
681 quick_array(PTEXT,100);
682 quick_array(RTEXT,RTXSIZ);
683 quick_array(CTEXT,CLSMAX);
684 quick_array(OBJSND,100);
685 quick_array(OBJTXT,100);
686 quick_array(STEXT,LOCSIZ);
687 quick_array(LTEXT,LOCSIZ);
688 quick_array(COND,LOCSIZ);
689 quick_array(KEY,LOCSIZ);
690 quick_array(LOCSND,LOCSIZ);
691 quick_array(LINES,LINSIZ);
692 quick_array(CVAL,CLSMAX);
693 quick_array(TTEXT,TRNSIZ);
694 quick_array(TRNVAL,TRNSIZ);
695 quick_array(TRAVEL,TRVSIZ);
696 quick_array(KTAB,TABSIZ);
697 quick_array(ATAB,TABSIZ);
698 quick_array(PLAC,100);
699 quick_array(FIXD,100);
700 quick_array(ACTSPK,VRBSIZ);
701 quick_array((long *)HINTS,(HNTMAX+1)*5-1);
704 static void quick_item(W)long *W; {
705 if(init_reading && fread(W,sizeof(long),1,f) != 1)return;
706 init_cksum = MOD(init_cksum*13+(*W),60000000);
707 if(!init_reading)fwrite(W,sizeof(long),1,f);
710 static void quick_array(A,N)long *A, N; { long I;
711 if(init_reading && fread(A,sizeof(long),N+1,f) != N+1)printf("Read error!\n");
712 for(I=1;I<=N;I++)init_cksum = MOD(init_cksum*13+A[I],60000000);
713 if(!init_reading && fwrite(A,sizeof(long),N+1,f)!=N+1)printf("Write error!\n");