projects / unix-history / blame
| Commit | Line | Data |
|---|---|---|
| 7c496796 WJ |
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 | } |