games/adventure/vocab.c

   1 /*      @(#)vocab.c     8.1 (Berkeley) 5/31/93                          */
   2 /*      $NetBSD: vocab.c,v 1.15 2009/08/25 06:56:52 dholland Exp $      */
   3
   4 /*-
   5  * Copyright (c) 1991, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * The game adventure was originally written in Fortran by Will Crowther
   9  * and Don Woods.  It was later translated to C and enhanced by Jim
  10  * Gillogly.  This code is derived from software contributed to Berkeley
  11  * by Jim Gillogly at The Rand Corporation.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  */
  37
  38 /*      Re-coding of advent in C: data structure routines               */
  39
  40 #include <err.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include "hdr.h"
  44 #include "extern.h"
  45
  46 void
  47 destroy(int object)
  48 {
  49         move(object, 0);
  50 }
  51
  52 void
  53 juggle(int object)
  54 {
  55         int     i, j;
  56
  57         i = place[object];
  58         j = fixed[object];
  59         move(object, i);
  60         move(object + 100, j);
  61 }
  62
  63 void
  64 move(int object, int where)
  65 {
  66         int     from;
  67
  68         if (object <= 100)
  69                 from = place[object];
  70         else
  71                 from = fixed[object - 100];
  72         if (from > 0 && from <= 300)
  73                 carry(object, from);
  74         drop(object, where);
  75 }
  76
  77 int
  78 put(int object, int where, int pval)
  79 {
  80         move(object, where);
  81         return (-1 - pval);
  82 }
  83
  84 void
  85 carry(int object, int where)
  86 {
  87         int     temp;
  88
  89         if (object <= 100) {
  90                 if (place[object] == -1)
  91                         return;
  92                 place[object] = -1;
  93                 holding++;
  94         }
  95         if (atloc[where] == object) {
  96                 atloc[where] = links[object];
  97                 return;
  98         }
  99         for (temp = atloc[where]; links[temp] != object; temp = links[temp]);
 100         links[temp] = links[object];
 101 }
 102
 103
 104 void
 105 drop(int object, int where)
 106 {
 107         if (object > 100)
 108                 fixed[object - 100] = where;
 109         else {
 110                 if (place[object] == -1)
 111                         holding--;
 112                 place[object] = where;
 113         }
 114         if (where <= 0)
 115                 return;
 116         links[object] = atloc[where];
 117         atloc[where] = object;
 118 }
 119
 120 /* look up or store a word      */
 121 /* -2 for store, -1 for user word, >=0 for canned lookup */
 122 /* used for storing only        */
 123 int
 124 vocab(const char *word, int type, int value)
 125 {
 126         int     adr;
 127         const char *s;
 128         char   *t;
 129         int     hash, i;
 130         struct hashtab *h;
 131
 132         for (hash = 0, s = word, i = 0; i < 5 && *s; i++) /* some kind of hash*/
 133                 hash += *s++;   /* add all chars in the word    */
 134         hash = (hash * 3719) & 077777;  /* pulled that one out of a hat */
 135         hash %= HTSIZE;         /* put it into range of table   */
 136
 137         for (adr = hash;; adr++) {      /* look for entry in table      */
 138                 if (adr == HTSIZE)
 139                         adr = 0;/* wrap around                  */
 140                 h = &voc[adr];  /* point at the entry           */
 141                 switch (type) {
 142                 case -2:        /* fill in entry                */
 143                         if (h->val)     /* already got an entry?        */
 144                                 goto exitloop2;
 145                         h->val = value;
 146                         h->atab = malloc(length(word));
 147                         if (h->atab == NULL)
 148                                 err(1, NULL);
 149                         for (s = word, t = h->atab; *s;)
 150                                 *t++ = *s++ ^ '=';
 151                         *t = 0 ^ '=';
 152                         /* encrypt slightly to thwart core reader       */
 153                         /* printf("Stored \"%s\" (%d ch) as entry %d\n",   */
 154                         /* word, length(word), adr);               */
 155                         return (0);     /* entry unused                 */
 156                 case -1:        /* looking up user word         */
 157                         if (h->val == 0)
 158                                 return (-1);    /* not found    */
 159                         for (s = word, t = h->atab; *t ^ '=';)
 160                                 if ((*s++ ^ '=') != *t++)
 161                                         goto exitloop2;
 162                         if ((*s ^ '=') != *t && s - word < 5)
 163                                 goto exitloop2;
 164                         /* the word matched o.k.                        */
 165                         return (h->val);
 166                 default:        /* looking up known word        */
 167                         if (h->val == 0)
 168                                 errx(1,"Unable to find %s in vocab", word);
 169                         for (s = word, t = h->atab; *t ^ '=';)
 170                                 if ((*s++ ^ '=') != *t++)
 171                                         goto exitloop2;
 172                         /* the word matched o.k.                        */
 173                         if (h->val / 1000 != type)
 174                                 continue;
 175                         return (h->val % 1000);
 176                 }
 177
 178 exitloop2:                      /* hashed entry does not match  */
 179                 if (adr + 1 == hash || hash == 0)
 180                         errx(1,"Hash table overflow");
 181         }
 182 }
 183
 184 /* print hash table (for debugging)             */
 185 static __unused void
 186 prht(void)
 187 {
 188         int     i, j, l;
 189         char   *c;
 190         struct hashtab *h;
 191         for (i = 0; i < HTSIZE / 10 + 1; i++) {
 192                 printf("%4d", i * 10);
 193                 for (j = 0; j < 10; j++) {
 194                         if (i * 10 + j >= HTSIZE)
 195                                 break;
 196                         h = &voc[i * 10 + j];
 197                         putchar(' ');
 198                         if (h->val == 0) {
 199                                 printf("-----");
 200                                 continue;
 201                         }
 202                         for (l = 0, c = h->atab; l < 5; l++)
 203                                 if ((*c ^ '='))
 204                                         putchar(*c++ ^ '=');
 205                                 else
 206                                         putchar(' ');
 207                 }
 208                 putchar('\n');
 209         }
 210 }