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) {
176 printf("Initialising...\n");
177 if(!quick_init()){raw_init(); report(); quick_save();}
181 static int raw_init(void) {
182 printf("Couldn't find adventure.data, using adventure.text...\n");
184 FILE *OPENED=fopen("adventure.text","r" /* NOT binary */);
185 if(!OPENED){printf("Can't read adventure.text!\n"); exit(0);}
187 /* Clear out the various text-pointer arrays. All text is stored in array
188 * lines; each line is preceded by a word pointing to the next pointer (i.e.
189 * the word following the end of the line). The pointer is negative if this is
190 * first line of a message. The text-pointer arrays contain indices of
191 * pointer-words in lines. STEXT(N) is short description of location N.
192 * LTEXT(N) is long description. PTEXT(N) points to message for PROP(N)=0.
193 * Successive prop messages are found by chasing pointers. RTEXT contains
194 * section 6's stuff. CTEXT(N) points to a player-class message. TTEXT is for
195 * section 14. We also clear COND (see description of section 9 for details). */
197 /* 1001 */ for (I=1; I<=300; I++) {
198 if(I <= 100)PTEXT[I]=0;
199 if(I <= RTXSIZ)RTEXT[I]=0;
200 if(I <= CLSMAX)CTEXT[I]=0;
201 if(I <= 100)OBJSND[I]=0;
202 if(I <= 100)OBJTXT[I]=0;
203 if(I > LOCSIZ) goto L1001;
217 /* Start new data section. sect is the section number. */
219 L1002: SECT=GETNUM(OPENED);
221 switch (SECT) { case 0: return(0); case 1: goto L1004; case 2: goto
222 L1004; case 3: goto L1030; case 4: goto L1040; case 5: goto L1004;
223 case 6: goto L1004; case 7: goto L1050; case 8: goto L1060; case
224 9: goto L1070; case 10: goto L1004; case 11: goto L1080; case 12:
225 break; case 13: goto L1090; case 14: goto L1004; }
226 /* (0) (1) (2) (3) (4) (5) (6) (7) (8) (9)
227 * (10) (11) (12) (13) (14) */
230 /* Sections 1, 2, 5, 6, 10, 14. Read messages and set up pointers. */
235 if(LNLENG >= LNPOSN+70)BUG(0);
236 if(LOC == -1) goto L1002;
237 if(LNLENG < LNPOSN)BUG(1);
239 if(KK >= LINSIZ)BUG(2);
240 LINES[KK]=GETTXT(false,false,false,KK);
241 if(LINES[KK] != -1) goto L1006;
243 if(LOC == OLDLOC) goto L1005;
246 if(SECT == 14) goto L1014;
247 if(SECT == 10) goto L1012;
248 if(SECT == 6) goto L1011;
249 if(SECT == 5) goto L1010;
250 if(LOC > LOCSIZ)BUG(10);
251 if(SECT == 1) goto L1008;
256 L1008: LTEXT[LOC]=LINUSE;
259 L1010: if(LOC > 0 && LOC <= 100)PTEXT[LOC]=LINUSE;
262 L1011: if(LOC > RTXSIZ)BUG(6);
266 L1012: CLSSES=CLSSES+1;
267 if(CLSSES > CLSMAX)BUG(11);
268 CTEXT[CLSSES]=LINUSE;
272 L1014: TRNVLS=TRNVLS+1;
273 if(TRNVLS > TRNSIZ)BUG(11);
274 TTEXT[TRNVLS]=LINUSE;
278 /* The stuff for section 3 is encoded here. Each "from-location" gets a
279 * contiguous section of the "TRAVEL" array. each entry in travel is
280 * NEWLOC*1000 + KEYWORD (from section 4, motion verbs), and is negated if
281 * this is the last entry for this location. KEY(N) is the index in travel
282 * of the first option at location N. */
284 L1030: LOC=GETNUM(OPENED);
285 if(LOC == -1) goto L1002;
287 if(KEY[LOC] != 0) goto L1033;
290 L1033: TRVS--; TRAVEL[TRVS]= -TRAVEL[TRVS]; TRVS++;
291 L1035: L=GETNUM(NULL);
292 if(L == 0) goto L1039;
293 TRAVEL[TRVS]=NEWLOC*1000+L;
295 if(TRVS == TRVSIZ)BUG(3);
297 L1039: TRVS--; TRAVEL[TRVS]= -TRAVEL[TRVS]; TRVS++;
300 /* Here we read in the vocabulary. KTAB(N) is the word number, ATAB(N) is
301 * the corresponding word. The -1 at the end of section 4 is left in KTAB
302 * as an end-marker. The words are given a minimal hash to make deciphering
303 * the core-image harder. (We don't use gettxt's hash since that would force
304 * us to hash each input line to make comparisons work, and that in turn
305 * would make it harder to detect particular input words.) */
308 for (TABNDX=1; TABNDX<=TABSIZ; TABNDX++) {
309 KTAB[TABNDX]=GETNUM(OPENED);
310 if(KTAB[TABNDX] == -1) goto L1002;
312 ATAB[TABNDX]=GETTXT(true,true,true,0)+J*J;
316 /* Read in the initial locations for each object. Also the immovability info.
317 * plac contains initial locations of objects. FIXD is -1 for immovable
318 * objects (including the snake), or = second loc for two-placed objects. */
320 L1050: OBJ=GETNUM(OPENED);
321 if(OBJ == -1) goto L1002;
322 PLAC[OBJ]=GETNUM(NULL);
323 FIXD[OBJ]=GETNUM(NULL);
326 /* Read default message numbers for action verbs, store in ACTSPK. */
328 L1060: VERB=GETNUM(OPENED);
329 if(VERB == -1) goto L1002;
330 ACTSPK[VERB]=GETNUM(NULL);
333 /* Read info about available liquids and other conditions, store in COND. */
335 L1070: K=GETNUM(OPENED);
336 if(K == -1) goto L1002;
337 L1071: LOC=GETNUM(NULL);
338 if(LOC == 0) goto L1070;
339 if(CNDBIT(LOC,K)) BUG(8);
340 COND[LOC]=COND[LOC]+SETBIT(K);
343 /* Read data for hints. */
346 L1081: K=GETNUM(OPENED);
347 if(K == -1) goto L1002;
348 if(K <= 0 || K > HNTSIZ)BUG(7);
349 for (I=1; I<=4; I++) {
350 HINTS[K][I] =GETNUM(NULL);
352 HNTMAX=(HNTMAX>K ? HNTMAX : K);
355 /* Read the sound/text info, store in OBJSND, OBJTXT, LOCSND. */
357 L1090: K=GETNUM(OPENED);
358 if(K == -1) goto L1002;
361 if(I == 0) goto L1092;
362 OBJSND[K]=(KK>0 ? KK : 0);
363 OBJTXT[K]=(I>0 ? I : 0);
370 /* Finish constructing internal data format */
372 /* Having read in the database, certain things are now constructed. PROPS are
373 * set to zero. We finish setting up COND by checking for forced-motion travel
374 * entries. The PLAC and FIXD arrays are used to set up ATLOC(N) as the first
375 * object at location N, and LINK(OBJ) as the next object at the same location
376 * as OBJ. (OBJ>100 indicates that FIXED(OBJ-100)=LOC; LINK(OBJ) is still the
377 * correct link to use.) ABB is zeroed; it controls whether the abbreviated
378 * description is printed. Counts modulo 5 unless "LOOK" is used. */
380 static int finish_init(void) {
381 for (I=1; I<=100; I++) {
385 {long x = I+100; LINK[x]=0;}
388 /* 1102 */ for (I=1; I<=LOCSIZ; I++) {
390 if(LTEXT[I] == 0 || KEY[I] == 0) goto L1102;
392 if(MOD(IABS(TRAVEL[K]),1000) == 1)COND[I]=2;
396 /* Set up the ATLOC and LINK arrays as described above. We'll use the DROP
397 * subroutine, which prefaces new objects on the lists. Since we want things
398 * in the other order, we'll run the loop backwards. If the object is in two
399 * locs, we drop it twice. This also sets up "PLACE" and "fixed" as copies of
400 * "PLAC" and "FIXD". Also, since two-placed objects are typically best
401 * described last, we'll drop them first. */
403 /* 1106 */ for (I=1; I<=100; I++) {
405 if(FIXD[K] <= 0) goto L1106;
411 for (I=1; I<=100; I++) {
414 if(PLAC[K] != 0 && FIXD[K] <= 0)DROP(K,PLAC[K]);
417 /* Treasures, as noted earlier, are objects 50 through MAXTRS (CURRENTLY 79).
418 * Their props are initially -1, and are set to 0 the first time they are
419 * described. TALLY keeps track of how many are not yet found, so we know
420 * when to close the cave. */
424 for (I=50; I<=MAXTRS; I++) {
425 if(PTEXT[I] != 0)PROP[I]= -1;
429 /* Clear the hint stuff. HINTLC(I) is how long he's been at LOC with cond bit
430 * I. HINTED(I) is true iff hint I has been used. */
432 for (I=1; I<=HNTMAX; I++) {
437 /* Define some handy mnemonics. these correspond to object numbers. */
440 BATTER=VOCWRD(201202005,1);
441 BEAR=VOCWRD(2050118,1);
442 BIRD=VOCWRD(2091804,1);
443 BLOOD=VOCWRD(212151504,1);
444 BOTTLE=VOCWRD(215202012,1);
445 CAGE=VOCWRD(3010705,1);
446 CAVITY=VOCWRD(301220920,1);
447 CHASM=VOCWRD(308011913,1);
448 CLAM=VOCWRD(3120113,1);
449 DOOR=VOCWRD(4151518,1);
450 DRAGON=VOCWRD(418010715,1);
451 DWARF=VOCWRD(423011806,1);
452 FISSUR=VOCWRD(609191921,1);
453 FOOD=VOCWRD(6151504,1);
454 GRATE=VOCWRD(718012005,1);
455 KEYS=VOCWRD(11052519,1);
456 KNIFE=VOCWRD(1114090605,1);
457 LAMP=VOCWRD(12011316,1);
458 MAGZIN=VOCWRD(1301070126,1);
459 MESSAG=VOCWRD(1305191901,1);
460 MIRROR=VOCWRD(1309181815,1);
461 OGRE=VOCWRD(15071805,1);
462 OIL=VOCWRD(150912,1);
463 OYSTER=VOCWRD(1525192005,1);
464 PILLOW=VOCWRD(1609121215,1);
465 PLANT=VOCWRD(1612011420,1);
467 RESER=VOCWRD(1805190518,1);
468 ROD=VOCWRD(181504,1);
470 SIGN=VOCWRD(19090714,1);
471 SNAKE=VOCWRD(1914011105,1);
472 STEPS=VOCWRD(1920051619,1);
473 TROLL=VOCWRD(2018151212,1);
475 URN=VOCWRD(211814,1);
476 VEND=VOCWRD(1755140409,1);
477 VOLCAN=VOCWRD(1765120301,1);
478 WATER=VOCWRD(1851200518,1);
480 /* Objects from 50 through whatever are treasures. Here are a few. */
482 AMBER=VOCWRD(113020518,1);
483 CHAIN=VOCWRD(308010914,1);
484 CHEST=VOCWRD(308051920,1);
485 COINS=VOCWRD(315091419,1);
486 EGGS=VOCWRD(5070719,1);
487 EMRALD=VOCWRD(513051801,1);
488 JADE=VOCWRD(10010405,1);
489 NUGGET=VOCWRD(7151204,1);
490 PEARL=VOCWRD(1605011812,1);
491 PYRAM=VOCWRD(1625180113,1);
492 RUBY=VOCWRD(18210225,1);
493 RUG=VOCWRD(182107,1);
494 SAPPH=VOCWRD(1901161608,1);
495 TRIDNT=VOCWRD(2018090405,1);
496 VASE=VOCWRD(22011905,1);
498 /* These are motion-verb numbers. */
500 BACK=VOCWRD(2010311,0);
501 CAVE=VOCWRD(3012205,0);
502 DPRSSN=VOCWRD(405161805,0);
503 ENTER=VOCWRD(514200518,0);
504 ENTRNC=VOCWRD(514201801,0);
505 LOOK=VOCWRD(12151511,0);
506 NUL=VOCWRD(14211212,0);
507 STREAM=VOCWRD(1920180501,0);
509 /* And some action verbs. */
511 FIND=VOCWRD(6091404,2);
512 INVENT=VOCWRD(914220514,2);
513 LOCK=VOCWRD(12150311,2);
514 SAY=VOCWRD(190125,2);
515 THROW=VOCWRD(2008181523,2);
517 /* Initialise the dwarves. DLOC is loc of dwarves, hard-wired in. ODLOC is
518 * prior loc of each dwarf, initially garbage. DALTLC is alternate initial loc
519 * for dwarf, in case one of them starts out on top of the adventurer. (No 2
520 * of the 5 initial locs are adjacent.) DSEEN is true if dwarf has seen him.
521 * DFLAG controls the level of activation of all this:
522 * 0 No dwarf stuff yet (wait until reaches Hall Of Mists)
523 * 1 Reached Hall Of Mists, but hasn't met first dwarf
524 * 2 Met first dwarf, others start moving, no knives thrown yet
525 * 3 A knife has been thrown (first set always misses)
526 * 3+ Dwarves are mad (increases their accuracy)
527 * Sixth dwarf is special (the pirate). He always starts at his chest's
528 * eventual location inside the maze. This loc is saved in CHLOC for ref.
529 * the dead end in the other maze has its loc stored in CHLOC2. */
533 for (I=1; I<=6; I++) {
545 /* Other random flags and counters, as follows:
546 * ABBNUM How often we should print non-abbreviated descriptions
547 * BONUS Used to determine amount of bonus if he reaches closing
548 * CLOCK1 Number of turns from finding last treasure till closing
549 * CLOCK2 Number of turns from first warning till blinding flash
550 * CONDS Min value for cond(loc) if loc has any hints
551 * DETAIL How often we've said "not allowed to give more detail"
552 * DKILL Number of dwarves killed (unused in scoring, needed for msg)
553 * FOOBAR Current progress in saying "FEE FIE FOE FOO".
554 * HOLDNG Number of objects being carried
555 * IGO How many times he's said "go XXX" instead of "XXX"
556 * IWEST How many times he's said "west" instead of "w"
557 * KNFLOC 0 if no knife here, loc if knife here, -1 after caveat
558 * LIMIT Lifetime of lamp (not set here)
559 * MAXDIE Number of reincarnation messages available (up to 5)
560 * NUMDIE Number of times killed so far
561 * THRESH Next #turns threshhold (-1 if none)
562 * TRNDEX Index in TRNVAL of next threshhold (section 14 of database)
563 * TRNLUZ # points lost so far due to number of turns used
564 * TURNS Tallies how many commands he's given (ignores yes/no)
565 * Logicals were explained earlier */
570 if(TRNVLS > 0)THRESH=MOD(TRNVAL[1],100000)+1;
578 for (I=0; I<=4; I++) {
579 {long x = 2*I+81; if(RTEXT[x] != 0)MAXDIE=I+1;}
597 /* if we can ever think of how, we should save it at this point */
599 return(0); /* then we won't actually return from initialisation */
602 /* Report on amount of arrays actually used, to permit reductions. */
604 static void report(void) {
605 for (K=1; K<=LOCSIZ; K++) {
607 if(LTEXT[KK] != 0) goto L1997;
612 L1997: for (K=1; K<=100; K++) {
613 if(PTEXT[K] != 0)OBJ=OBJ+1;
616 for (K=1; K<=TABNDX; K++) {
617 if(KTAB[K]/1000 == 2)VERB=KTAB[K]-2000;
620 for (K=1; K<=RTXSIZ; K++) {
622 if(RTEXT[J] != 0) goto L1993;
626 L1993: SETPRM(1,LINUSE,LINSIZ);
627 SETPRM(3,TRVS,TRVSIZ);
628 SETPRM(5,TABNDX,TABSIZ);
631 SETPRM(11,VERB,VRBSIZ);
633 SETPRM(15,CLSSES,CLSMAX);
634 SETPRM(17,HNTMAX,HNTSIZ);
635 SETPRM(19,TRNVLS,TRNSIZ);
640 static long init_reading, init_cksum;
643 static void quick_item(long*);
644 static void quick_array(long*, long);
646 static bool quick_init(void) {
647 extern char *getenv();
648 char *adv = getenv("ADVENTURE");
650 if(adv)f = fopen(adv,READ_MODE);
651 if(f == NULL)f = fopen("adventure.data",READ_MODE);
652 if(f == NULL)return(false);
656 if(fread(&K,sizeof(long),1,f) == 1) init_cksum -= K; else init_cksum = 1;
658 if(init_cksum != 0)printf("Checksum error!\n");
659 return(init_cksum == 0);
662 static void quick_save(void) {
663 printf("Writing adventure.data...\n");
664 f = fopen("adventure.data",WRITE_MODE);
665 if(f == NULL){printf("Can't open file!\n"); return;}
666 init_reading = false;
669 fwrite(&init_cksum,sizeof(long),1,f);
673 static void quick_io(void) {
680 quick_array(PTEXT,100);
681 quick_array(RTEXT,RTXSIZ);
682 quick_array(CTEXT,CLSMAX);
683 quick_array(OBJSND,100);
684 quick_array(OBJTXT,100);
685 quick_array(STEXT,LOCSIZ);
686 quick_array(LTEXT,LOCSIZ);
687 quick_array(COND,LOCSIZ);
688 quick_array(KEY,LOCSIZ);
689 quick_array(LOCSND,LOCSIZ);
690 quick_array(LINES,LINSIZ);
691 quick_array(CVAL,CLSMAX);
692 quick_array(TTEXT,TRNSIZ);
693 quick_array(TRNVAL,TRNSIZ);
694 quick_array(TRAVEL,TRVSIZ);
695 quick_array(KTAB,TABSIZ);
696 quick_array(ATAB,TABSIZ);
697 quick_array(PLAC,100);
698 quick_array(FIXD,100);
699 quick_array(ACTSPK,VRBSIZ);
700 quick_array((long *)HINTS,(HNTMAX+1)*5-1);
703 static void quick_item(W)long *W; {
704 if(init_reading && fread(W,sizeof(long),1,f) != 1)return;
705 init_cksum = MOD(init_cksum*13+(*W),60000000);
706 if(!init_reading)fwrite(W,sizeof(long),1,f);
709 static void quick_array(A,N)long *A, N; { long I;
710 if(init_reading && fread(A,sizeof(long),N+1,f) != N+1)printf("Read error!\n");
711 for(I=1;I<=N;I++)init_cksum = MOD(init_cksum*13+A[I],60000000);
712 if(!init_reading && fwrite(A,sizeof(long),N+1,f)!=N+1)printf("Write error!\n");