home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / GAMES / colossal.lzh / database.c < prev    next >
Text File  |  1991-06-06  |  6KB  |  429 lines
  1.  
  2. /*    program DATABASE.C                    *\
  3. \*    WARNING: "advent.c" allocates GLOBAL storage space by    *\
  4. \*        including "advdef.h".                *\
  5. \*        All other modules use "advdec.h".        */
  6.  
  7.  
  8. #include    "stdio.h"    /* drv = 1.1st file 2.def 3.A    */
  9. #include    "advent.h"
  10. #include    "advdec.h"
  11.  
  12. extern    long    atoi();
  13. extern    int        fgetc();
  14. extern    char    *fgets();
  15. extern    long    fseek();
  16. extern    char    *rindex();
  17. extern    char    *strcpy();
  18. extern    int        tolower();
  19.  
  20.  
  21. /*
  22.     Routine to fill travel array for a given location
  23. */
  24. gettrav(loc)
  25. int    loc;
  26. {
  27.     int    i;
  28.     long    t;
  29.     char    atrav[256], *aptr;
  30.  
  31.     strcpy(atrav, cave[loc - 1]);
  32.     while (aptr = rindex(atrav, ','))
  33.         *aptr = '\0';        /* terminate substring    */
  34.     aptr = &atrav[0];
  35.     for (i = 0; i < MAXTRAV; ++i) {
  36.         t = atoi(aptr);        /* convert to long int    */
  37.         travel[i].tcond = (t % 1000);
  38.         t /= 1000;
  39.         travel[i].tverb = (t % 1000);
  40.         t /= 1000;
  41.         travel[i].tdest = (t % 1000);
  42.         while (*aptr++)
  43.             ;        /* to next substring    */
  44.         if (!(*aptr)) {
  45.             travel[++i].tdest = -1;/* end of array    */
  46.             if (dbugflg)
  47.             for (i = 0; i < MAXTRAV; ++i)
  48.                 printf("cave[%d] = %d %d %d\n", 
  49.                         loc, travel[i].tdest, 
  50.                         travel[i].tverb, travel[i].tcond);
  51.             return 0;        /* terminate for loop    */
  52.         }
  53.     }
  54.     bug(33);
  55. }
  56.  
  57. /*
  58.     Function to scan a file up to a specified
  59.     point and either print or return a string.
  60. */
  61. rdupto(fdi, uptoc, print, string)
  62. FILE    *fdi;
  63. char    uptoc, print, *string;
  64. {
  65.     int    c;
  66.  
  67.     while ((c = fgetc(fdi)) != uptoc) {
  68.         if (c == EOF)
  69.             return(0);
  70.  
  71.         /*     the following condition was commented out as it 
  72.             assumes that lines in a text file are separated
  73.             by CR/LF (true for DOS) rather than CR (as in OS/9)
  74.         
  75.                 if (c == '\r')
  76.                     continue;
  77.         */
  78.         if (print)
  79.             fputc(c, stdout);
  80.         else
  81.             *string++ = c;
  82.     }
  83.     if (!print)
  84.         *string = '\0';
  85.     return(1);
  86. }
  87.  
  88. /*
  89.     Function to read a file skipping
  90.     a given character a specified number
  91.     of times, with or without repositioning
  92.     the file.
  93. */
  94. rdskip(fdi, skipc, n, rewind)
  95. FILE    *fdi;
  96. char    skipc, rewind;
  97. int    n;
  98. {
  99.     int    c;
  100.  
  101.     if (rewind)
  102.         if (fseek(fdi, 0, 0) == -1)
  103.             bug(31);
  104.     while (n--)
  105.         while ((c = fgetc(fdi)) != skipc)
  106.             if (c == EOF)
  107.                 bug(32);
  108. }
  109.  
  110. /*
  111.     Routine to request a yes or no answer to a question.
  112. */
  113. yes(msg1, msg2, msg3)
  114. int    msg1, msg2, msg3;
  115. {
  116.     char    answer[80];
  117.  
  118.     if (msg1)
  119.         rspeak(msg1);
  120.     fputc('>', stdout);
  121.     fgets(answer, 80, stdin);
  122.     if (tolower(answer[0]) == 'n') {
  123.         if (msg3)
  124.             rspeak(msg3);
  125.         return(0);
  126.     }
  127.     if (msg2)
  128.         rspeak(msg2);
  129.     return(1);
  130. }
  131.  
  132. /*
  133.     Print a location description from "advent4.txt"
  134. */
  135. rspeak(msg)
  136. int    msg;
  137. {
  138.     if (msg == 54)
  139.         printf("ok.\n");
  140.     else {
  141.         if (dbugflg)
  142.             printf("Seek loc msg #%d @ %ld\n", msg, idx4[msg]);
  143.         fseek(fd4, idx4[msg - 1], 0);
  144.         rdupto(fd4, '#', 1, 0);
  145.     }
  146.     return 0;
  147. }
  148.  
  149. /*
  150.     Print an item message for a given state from "advent3.txt"
  151. */
  152. pspeak(item, state)
  153. int    item, state;
  154. {
  155.     fseek(fd3, idx3[item - 1], 0);
  156.     rdskip(fd3, '/', state+2, 0);
  157.     rdupto(fd3, '/', 1, 0);
  158. }
  159.  
  160. /*
  161.     Print a long location description from "advent1.txt"
  162. */
  163. desclg(loc)
  164. int    loc;
  165. {
  166.     fseek(fd1, idx1[loc - 1], 0);
  167.     rdupto(fd1, '#', 1, 0);
  168. }
  169.  
  170. /*
  171.     Print a short location description from "advent2.txt"
  172. */
  173. descsh(loc)
  174. int    loc;
  175. {
  176.     fseek(fd2, idx2[loc - 1], 0);
  177.     rdupto(fd2, '#', 1, 0);
  178. }
  179.  
  180. /*
  181.     look-up vocabulary word in lex-ordered table.  words may have
  182.     two entries with different codes. if minimum acceptable value
  183.     = 0, then return minimum of different codes.  last word CANNOT
  184.     have two entries(due to binary sort).
  185.     word is the word to look up.
  186.     val  is the minimum acceptable value,
  187.         if != 0 return %1000
  188. */
  189. vocab(word, val)
  190. char    *word;
  191. int    val;
  192. {
  193.     int    v1, v2;
  194.  
  195.     if ((v1 = binary(word, wc, MAXWC)) >= 0) {
  196.         v2 = binary(word, wc, MAXWC-1);
  197.         if (v2 < 0)
  198.             v2 = v1;
  199.         if (!val)
  200.             return(wc[v1].acode < wc[v2].acode\
  201.                    ? wc[v1].acode : wc[v2].acode);
  202.         if (val <= wc[v1].acode)
  203.             return(wc[v1].acode % 1000);
  204.         else if (val <= wc[v2].acode)
  205.             return(wc[v2].acode % 1000);
  206.         else
  207.             return(-1);
  208.     }
  209.     else
  210.         return(-1);
  211. }
  212.  
  213. binary(w, wctable, maxwc)
  214. char    *w;
  215. int    maxwc;
  216. struct    wac    wctable[];
  217. {
  218.     int    lo, mid, hi, check;
  219.  
  220.     lo = 0;
  221.     hi = maxwc - 1;
  222.     while (lo <= hi) {
  223.         mid = (lo + hi) / 2;
  224.         if ((check = strcmp(w, wctable[mid].aword)) < 0)
  225.             hi = mid - 1;
  226.         else if (check > 0)
  227.             lo = mid + 1;
  228.         else
  229.             return(mid);
  230.     }
  231.     return(-1);
  232. }
  233.  
  234.  
  235. /*
  236.     Utility Routines
  237. */
  238.  
  239. /*
  240.     Routine to test for darkness
  241. */
  242. dark()
  243. {
  244.     return(!(cond[loc] & LIGHT) &&
  245.         (!prop[LAMP] ||
  246.         !here(LAMP)));
  247. }
  248.  
  249. /*
  250.     Routine to tell if an item is present.
  251. */
  252. here(item)
  253. int    item;
  254. {
  255.     return(place[item] == loc || toting(item));
  256. }
  257.  
  258. /*
  259.     Routine to tell if an item is being carried.
  260. */
  261. toting(item)
  262. int    item;
  263. {
  264.     return(place[item] == -1);
  265. }
  266.  
  267. /*
  268.     Routine to tell if a location causes
  269.     a forced move.
  270. */
  271. forced(atloc)
  272. int    atloc;
  273. {
  274.     return(cond[atloc] == 2);
  275. }
  276.  
  277. /*
  278.     Routine true x% of the time.
  279. */
  280. pct(x)
  281. int    x;
  282. {
  283.     return(rand() % 100 < x);
  284. }
  285.  
  286. /*
  287.     Routine to tell if player is on
  288.     either side of a two sided object.
  289. */
  290. at(item)
  291. int    item;
  292. {
  293.     return(place[item] == loc || fixed[item] == loc);
  294. }
  295.  
  296. /*
  297.     Routine to destroy an object
  298. */
  299. dstroy(obj)
  300. int    obj;
  301. {
  302.     move(obj, 0);
  303. }
  304.  
  305. /*
  306.     Routine to move an object
  307. */
  308. move(obj, where)
  309. int    obj, where;
  310. {
  311.     int    from;
  312.  
  313.     from = (obj<MAXOBJ) ? place[obj] : fixed[obj];
  314.     if (from>0 && from<=300)
  315.         carry(obj, from);
  316.     drop(obj, where);
  317. }
  318.  
  319. /*
  320.     Juggle an object
  321.     currently a no-op
  322. */
  323. juggle(loc)
  324. int    loc;
  325. {
  326. }
  327.  
  328. /*
  329.     Routine to carry an object
  330. */
  331. carry(obj, where)
  332. int    obj, where;
  333. {
  334.     if (obj<MAXOBJ){
  335.         if (place[obj] == -1)
  336.             return 0;
  337.         place[obj]=-1;
  338.         ++holding;
  339.     }
  340. }
  341.  
  342. /*
  343.     Routine to drop an object
  344. */
  345. drop(obj, where)
  346. int    obj, where;
  347. {
  348.     if (obj<MAXOBJ) {
  349.         if (place[obj] == -1)
  350.             --holding;
  351.         place[obj]=where;
  352.     }
  353.     else
  354.         fixed[obj-MAXOBJ]=where;
  355. }
  356.  
  357. /*
  358.     routine to move an object and return a
  359.     value used to set the negated prop values
  360.     for the repository.
  361. */
  362. put(obj, where, pval)
  363. int    obj, where, pval;
  364. {
  365.     move(obj, where);
  366.     return((-1)-pval);
  367. }
  368. /*
  369.     Routine to check for presence
  370.     of dwarves..
  371. */
  372. dcheck()
  373. {
  374.     int    i;
  375.  
  376.     for (i =1; i < (DWARFMAX-1); ++i)
  377.         if (dloc[i] == loc)
  378.             return(i);
  379.     return(0);
  380. }
  381.  
  382. /*
  383.     Determine liquid in the bottle
  384. */
  385. liq()
  386. {
  387.     int    i, j;
  388.     i=prop[BOTTLE];
  389.     j=-1-i;
  390.     return(liq2(i>j ? i : j));
  391. }
  392.  
  393. /*
  394.     Determine liquid at a location
  395. */
  396. liqloc(loc)
  397. int    loc;
  398. {
  399.     if (cond[loc]&LIQUID)
  400.         return(liq2(cond[loc]&WATOIL));
  401.     else
  402.         return(liq2(1));
  403. }
  404.  
  405. /*
  406.     Convert  0 to WATER
  407.          1 to nothing
  408.          2 to OIL
  409. */
  410. liq2(pbottle)
  411. int    pbottle;
  412. {
  413.     return((1-pbottle)*WATER+(pbottle>>1)*(WATER+OIL));
  414. }
  415.  
  416. /*
  417.     Fatal error routine
  418. */
  419. bug(n)
  420. int    n;
  421. {
  422.     printf("Fatal error number %d\n", n);
  423.     exit(0);
  424. }
  425.  
  426.  
  427.     
  428.  
  429.