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