![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hack.do_name.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / hack|
Return to hack.do_name.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / hack |
1.1 root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.