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