Commit | Line | Data |
---|---|---|
15637ed4 RG |
1 | /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */ |
2 | /* hack.do_name.c - version 1.0.3 */ | |
3 | ||
4 | #include "hack.h" | |
5 | #include <stdio.h> | |
6 | extern char plname[]; | |
7 | ||
8 | coord | |
9 | getpos(force,goal) int force; char *goal; { | |
10 | register cx,cy,i,c; | |
11 | extern char sdir[]; /* defined in hack.c */ | |
12 | extern schar xdir[], ydir[]; /* idem */ | |
13 | extern char *visctrl(); /* see below */ | |
14 | coord cc; | |
15 | pline("(For instructions type a ?)"); | |
16 | cx = u.ux; | |
17 | cy = u.uy; | |
18 | curs(cx,cy+2); | |
19 | while((c = readchar()) != '.'){ | |
20 | for(i=0; i<8; i++) if(sdir[i] == c){ | |
21 | if(1 <= cx + xdir[i] && cx + xdir[i] <= COLNO) | |
22 | cx += xdir[i]; | |
23 | if(0 <= cy + ydir[i] && cy + ydir[i] <= ROWNO-1) | |
24 | cy += ydir[i]; | |
25 | goto nxtc; | |
26 | } | |
27 | if(c == '?'){ | |
28 | pline("Use [hjkl] to move the cursor to %s.", goal); | |
29 | pline("Type a . when you are at the right place."); | |
30 | } else { | |
31 | pline("Unknown direction: '%s' (%s).", | |
32 | visctrl(c), | |
33 | force ? "use hjkl or ." : "aborted"); | |
34 | if(force) goto nxtc; | |
35 | cc.x = -1; | |
36 | cc.y = 0; | |
37 | return(cc); | |
38 | } | |
39 | nxtc: ; | |
40 | curs(cx,cy+2); | |
41 | } | |
42 | cc.x = cx; | |
43 | cc.y = cy; | |
44 | return(cc); | |
45 | } | |
46 | ||
47 | do_mname(){ | |
48 | char buf[BUFSZ]; | |
49 | coord cc; | |
50 | register int cx,cy,lth,i; | |
51 | register struct monst *mtmp, *mtmp2; | |
52 | extern char *lmonnam(); | |
53 | cc = getpos(0, "the monster you want to name"); | |
54 | cx = cc.x; | |
55 | cy = cc.y; | |
56 | if(cx < 0) return(0); | |
57 | mtmp = m_at(cx,cy); | |
58 | if(!mtmp){ | |
59 | if(cx == u.ux && cy == u.uy) | |
60 | pline("This ugly monster is called %s and cannot be renamed.", | |
61 | plname); | |
62 | else | |
63 | pline("There is no monster there."); | |
64 | return(1); | |
65 | } | |
66 | if(mtmp->mimic){ | |
67 | pline("I see no monster there."); | |
68 | return(1); | |
69 | } | |
70 | if(!cansee(cx,cy)) { | |
71 | pline("I cannot see a monster there."); | |
72 | return(1); | |
73 | } | |
74 | pline("What do you want to call %s? ", lmonnam(mtmp)); | |
75 | getlin(buf); | |
76 | clrlin(); | |
77 | if(!*buf || *buf == '\033') | |
78 | return(1); | |
79 | lth = strlen(buf)+1; | |
80 | if(lth > 63){ | |
81 | buf[62] = 0; | |
82 | lth = 63; | |
83 | } | |
84 | mtmp2 = newmonst(mtmp->mxlth + lth); | |
85 | *mtmp2 = *mtmp; | |
86 | for(i=0; i<mtmp->mxlth; i++) | |
87 | ((char *) mtmp2->mextra)[i] = ((char *) mtmp->mextra)[i]; | |
88 | mtmp2->mnamelth = lth; | |
89 | (void) strcpy(NAME(mtmp2), buf); | |
90 | replmon(mtmp,mtmp2); | |
91 | return(1); | |
92 | } | |
93 | ||
94 | /* | |
95 | * This routine changes the address of obj . Be careful not to call it | |
96 | * when there might be pointers around in unknown places. For now: only | |
97 | * when obj is in the inventory. | |
98 | */ | |
99 | do_oname(obj) register struct obj *obj; { | |
100 | register struct obj *otmp, *otmp2; | |
101 | register lth; | |
102 | char buf[BUFSZ]; | |
103 | pline("What do you want to name %s? ", doname(obj)); | |
104 | getlin(buf); | |
105 | clrlin(); | |
106 | if(!*buf || *buf == '\033') | |
107 | return; | |
108 | lth = strlen(buf)+1; | |
109 | if(lth > 63){ | |
110 | buf[62] = 0; | |
111 | lth = 63; | |
112 | } | |
113 | otmp2 = newobj(lth); | |
114 | *otmp2 = *obj; | |
115 | otmp2->onamelth = lth; | |
116 | (void) strcpy(ONAME(otmp2), buf); | |
117 | ||
118 | setworn((struct obj *) 0, obj->owornmask); | |
119 | setworn(otmp2, otmp2->owornmask); | |
120 | ||
121 | /* do freeinv(obj); etc. by hand in order to preserve | |
122 | the position of this object in the inventory */ | |
123 | if(obj == invent) invent = otmp2; | |
124 | else for(otmp = invent; ; otmp = otmp->nobj){ | |
125 | if(!otmp) | |
126 | panic("Do_oname: cannot find obj."); | |
127 | if(otmp->nobj == obj){ | |
128 | otmp->nobj = otmp2; | |
129 | break; | |
130 | } | |
131 | } | |
132 | /* obfree(obj, otmp2); /* now unnecessary: no pointers on bill */ | |
133 | free((char *) obj); /* let us hope nobody else saved a pointer */ | |
134 | } | |
135 | ||
136 | ddocall() | |
137 | { | |
138 | register struct obj *obj; | |
139 | ||
140 | pline("Do you want to name an individual object? [ny] "); | |
141 | switch(readchar()) { | |
142 | case '\033': | |
143 | break; | |
144 | case 'y': | |
145 | obj = getobj("#", "name"); | |
146 | if(obj) do_oname(obj); | |
147 | break; | |
148 | default: | |
149 | obj = getobj("?!=/", "call"); | |
150 | if(obj) docall(obj); | |
151 | } | |
152 | return(0); | |
153 | } | |
154 | ||
155 | docall(obj) | |
156 | register struct obj *obj; | |
157 | { | |
158 | char buf[BUFSZ]; | |
159 | struct obj otemp; | |
160 | register char **str1; | |
161 | extern char *xname(); | |
162 | register char *str; | |
163 | ||
164 | otemp = *obj; | |
165 | otemp.quan = 1; | |
166 | otemp.onamelth = 0; | |
167 | str = xname(&otemp); | |
168 | pline("Call %s %s: ", index(vowels,*str) ? "an" : "a", str); | |
169 | getlin(buf); | |
170 | clrlin(); | |
171 | if(!*buf || *buf == '\033') | |
172 | return; | |
173 | str = newstring(strlen(buf)+1); | |
174 | (void) strcpy(str,buf); | |
175 | str1 = &(objects[obj->otyp].oc_uname); | |
176 | if(*str1) free(*str1); | |
177 | *str1 = str; | |
178 | } | |
179 | ||
180 | char *ghostnames[] = { /* these names should have length < PL_NSIZ */ | |
181 | "adri", "andries", "andreas", "bert", "david", "dirk", "emile", | |
182 | "frans", "fred", "greg", "hether", "jay", "john", "jon", "kay", | |
183 | "kenny", "maud", "michiel", "mike", "peter", "robert", "ron", | |
184 | "tom", "wilmar" | |
185 | }; | |
186 | ||
187 | char * | |
188 | xmonnam(mtmp, vb) register struct monst *mtmp; int vb; { | |
189 | static char buf[BUFSZ]; /* %% */ | |
190 | extern char *shkname(); | |
191 | if(mtmp->mnamelth && !vb) { | |
192 | (void) strcpy(buf, NAME(mtmp)); | |
193 | return(buf); | |
194 | } | |
195 | switch(mtmp->data->mlet) { | |
196 | case ' ': | |
197 | { register char *gn = (char *) mtmp->mextra; | |
198 | if(!*gn) { /* might also look in scorefile */ | |
199 | gn = ghostnames[rn2(SIZE(ghostnames))]; | |
200 | if(!rn2(2)) (void) | |
201 | strcpy((char *) mtmp->mextra, !rn2(5) ? plname : gn); | |
202 | } | |
203 | (void) sprintf(buf, "%s's ghost", gn); | |
204 | } | |
205 | break; | |
206 | case '@': | |
207 | if(mtmp->isshk) { | |
208 | (void) strcpy(buf, shkname(mtmp)); | |
209 | break; | |
210 | } | |
211 | /* fall into next case */ | |
212 | default: | |
213 | (void) sprintf(buf, "the %s%s", | |
214 | mtmp->minvis ? "invisible " : "", | |
215 | mtmp->data->mname); | |
216 | } | |
217 | if(vb && mtmp->mnamelth) { | |
218 | (void) strcat(buf, " called "); | |
219 | (void) strcat(buf, NAME(mtmp)); | |
220 | } | |
221 | return(buf); | |
222 | } | |
223 | ||
224 | char * | |
225 | lmonnam(mtmp) register struct monst *mtmp; { | |
226 | return(xmonnam(mtmp, 1)); | |
227 | } | |
228 | ||
229 | char * | |
230 | monnam(mtmp) register struct monst *mtmp; { | |
231 | return(xmonnam(mtmp, 0)); | |
232 | } | |
233 | ||
234 | char * | |
235 | Monnam(mtmp) register struct monst *mtmp; { | |
236 | register char *bp = monnam(mtmp); | |
237 | if('a' <= *bp && *bp <= 'z') *bp += ('A' - 'a'); | |
238 | return(bp); | |
239 | } | |
240 | ||
241 | char * | |
242 | amonnam(mtmp,adj) | |
243 | register struct monst *mtmp; | |
244 | register char *adj; | |
245 | { | |
246 | register char *bp = monnam(mtmp); | |
247 | static char buf[BUFSZ]; /* %% */ | |
248 | ||
249 | if(!strncmp(bp, "the ", 4)) bp += 4; | |
250 | (void) sprintf(buf, "the %s %s", adj, bp); | |
251 | return(buf); | |
252 | } | |
253 | ||
254 | char * | |
255 | Amonnam(mtmp, adj) | |
256 | register struct monst *mtmp; | |
257 | register char *adj; | |
258 | { | |
259 | register char *bp = amonnam(mtmp,adj); | |
260 | ||
261 | *bp = 'T'; | |
262 | return(bp); | |
263 | } | |
264 | ||
265 | char * | |
266 | Xmonnam(mtmp) register struct monst *mtmp; { | |
267 | register char *bp = Monnam(mtmp); | |
268 | if(!strncmp(bp, "The ", 4)) { | |
269 | bp += 2; | |
270 | *bp = 'A'; | |
271 | } | |
272 | return(bp); | |
273 | } | |
274 | ||
275 | char * | |
276 | visctrl(c) | |
277 | char c; | |
278 | { | |
279 | static char ccc[3]; | |
280 | if(c < 040) { | |
281 | ccc[0] = '^'; | |
282 | ccc[1] = c + 0100; | |
283 | ccc[2] = 0; | |
284 | } else { | |
285 | ccc[0] = c; | |
286 | ccc[1] = 0; | |
287 | } | |
288 | return(ccc); | |
289 | } |