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