1: /*      $NetBSD: hack.do_name.c,v 1.6 2003/04/02 18:36:36 jsm Exp $  */
    2: 
    3: /*
    4:  * Copyright (c) 1985, Stichting Centrum voor Wiskunde en Informatica,
    5:  * Amsterdam
    6:  * All rights reserved.
    7:  *
    8:  * Redistribution and use in source and binary forms, with or without
    9:  * modification, are permitted provided that the following conditions are
   10:  * met:
   11:  *
   12:  * - Redistributions of source code must retain the above copyright notice,
   13:  * this list of conditions and the following disclaimer.
   14:  *
   15:  * - 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:  *
   19:  * - Neither the name of the Stichting Centrum voor Wiskunde en
   20:  * Informatica, nor the names of its contributors may be used to endorse or
   21:  * promote products derived from this software without specific prior
   22:  * written permission.
   23:  *
   24:  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   25:  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   26:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
   27:  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
   28:  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   29:  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   30:  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   31:  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   32:  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   33:  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   34:  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   35:  */
   36: 
   37: /*
   38:  * Copyright (c) 1982 Jay Fenlason <hack@gnu.org>
   39:  * All rights reserved.
   40:  *
   41:  * Redistribution and use in source and binary forms, with or without
   42:  * modification, are permitted provided that the following conditions
   43:  * are met:
   44:  * 1. Redistributions of source code must retain the above copyright
   45:  *    notice, this list of conditions and the following disclaimer.
   46:  * 2. Redistributions in binary form must reproduce the above copyright
   47:  *    notice, this list of conditions and the following disclaimer in the
   48:  *    documentation and/or other materials provided with the distribution.
   49:  * 3. The name of the author may not be used to endorse or promote products
   50:  *    derived from this software without specific prior written permission.
   51:  *
   52:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
   53:  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
   54:  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
   55:  * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   56:  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   57:  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
   58:  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   59:  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   60:  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   61:  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   62:  */
   63: 
   64: #include <sys/cdefs.h>
   65: #ifndef lint
   66: __RCSID("$NetBSD: hack.do_name.c,v 1.6 2003/04/02 18:36:36 jsm Exp $");
   67: #endif                          /* not lint */
   68: 
   69: #include <stdlib.h>
   70: #include "hack.h"
   71: #include "extern.h"
   72: 
   73: coord
   74: getpos(force, goal)
   75:         int             force;
   76:         const char           *goal;
   77: {
   78:         int             cx, cy, i, c;
   79:         coord           cc;
   80:         pline("(For instructions type a ?)");
   81:         cx = u.ux;
   82:         cy = u.uy;
   83:         curs(cx, cy + 2);
   84:         while ((c = readchar()) != '.') {
   85:                 for (i = 0; i < 8; i++)
   86:                         if (sdir[i] == c) {
   87:                                 if (1 <= cx + xdir[i] && cx + xdir[i] <= COLNO)
   88:                                         cx += xdir[i];
   89:                                 if (0 <= cy + ydir[i] && cy + ydir[i] <= ROWNO - 1)
   90:                                         cy += ydir[i];
   91:                                 goto nxtc;
   92:                         }
   93:                 if (c == '?') {
   94:                         pline("Use [hjkl] to move the cursor to %s.", goal);
   95:                         pline("Type a . when you are at the right place.");
   96:                 } else {
   97:                         pline("Unknown direction: '%s' (%s).",
   98:                               visctrl(c),
   99:                               force ? "use hjkl or ." : "aborted");
  100:                         if (force)
  101:                                 goto nxtc;
  102:                         cc.x = -1;
  103:                         cc.y = 0;
  104:                         return (cc);
  105:                 }
  106: nxtc:           ;
  107:                 curs(cx, cy + 2);
  108:         }
  109:         cc.x = cx;
  110:         cc.y = cy;
  111:         return (cc);
  112: }
  113: 
  114: int
  115: do_mname()
  116: {
  117:         char            buf[BUFSZ];
  118:         coord           cc;
  119:         int             cx, cy, lth, i;
  120:         struct monst   *mtmp, *mtmp2;
  121:         cc = getpos(0, "the monster you want to name");
  122:         cx = cc.x;
  123:         cy = cc.y;
  124:         if (cx < 0)
  125:                 return (0);
  126:         mtmp = m_at(cx, cy);
  127:         if (!mtmp) {
  128:                 if (cx == u.ux && cy == u.uy)
  129:                         pline("This ugly monster is called %s and cannot be renamed.",
  130:                               plname);
  131:                 else
  132:                         pline("There is no monster there.");
  133:                 return (1);
  134:         }
  135:         if (mtmp->mimic) {
  136:                 pline("I see no monster there.");
  137:                 return (1);
  138:         }
  139:         if (!cansee(cx, cy)) {
  140:                 pline("I cannot see a monster there.");
  141:                 return (1);
  142:         }
  143:         pline("What do you want to call %s? ", lmonnam(mtmp));
  144:         getlin(buf);
  145:         clrlin();
  146:         if (!*buf || *buf == '\033')
  147:                 return (1);
  148:         lth = strlen(buf) + 1;
  149:         if (lth > 63) {
  150:                 buf[62] = 0;
  151:                 lth = 63;
  152:         }
  153:         mtmp2 = newmonst(mtmp->mxlth + lth);
  154:         *mtmp2 = *mtmp;
  155:         for (i = 0; (unsigned)i < mtmp->mxlth; i++)
  156:                 ((char *) mtmp2->mextra)[i] = ((char *) mtmp->mextra)[i];
  157:         mtmp2->mnamelth = lth;
  158:         (void) strcpy(NAME(mtmp2), buf);
  159:         replmon(mtmp, mtmp2);
  160:         return (1);
  161: }
  162: 
  163: /*
  164:  * This routine changes the address of  obj . Be careful not to call it
  165:  * when there might be pointers around in unknown places. For now: only
  166:  * when  obj  is in the inventory.
  167:  */
  168: void
  169: do_oname(obj)
  170:         struct obj     *obj;
  171: {
  172:         struct obj     *otmp, *otmp2;
  173:         int lth;
  174:         char            buf[BUFSZ];
  175:         pline("What do you want to name %s? ", doname(obj));
  176:         getlin(buf);
  177:         clrlin();
  178:         if (!*buf || *buf == '\033')
  179:                 return;
  180:         lth = strlen(buf) + 1;
  181:         if (lth > 63) {
  182:                 buf[62] = 0;
  183:                 lth = 63;
  184:         }
  185:         otmp2 = newobj(lth);
  186:         *otmp2 = *obj;
  187:         otmp2->onamelth = lth;
  188:         (void) strcpy(ONAME(otmp2), buf);
  189: 
  190:         setworn((struct obj *) 0, obj->owornmask);
  191:         setworn(otmp2, otmp2->owornmask);
  192: 
  193:         /*
  194:          * do freeinv(obj); etc. by hand in order to preserve the position of
  195:          * this object in the inventory
  196:          */
  197:         if (obj == invent)
  198:                 invent = otmp2;
  199:         else
  200:                 for (otmp = invent;; otmp = otmp->nobj) {
  201:                         if (!otmp)
  202:                                 panic("Do_oname: cannot find obj.");
  203:                         if (otmp->nobj == obj) {
  204:                                 otmp->nobj = otmp2;
  205:                                 break;
  206:                         }
  207:                 }
  208: #if 0
  209:         obfree(obj, otmp2);    /* now unnecessary: no pointers on bill */
  210: #endif
  211:         free((char *) obj);    /* let us hope nobody else saved a pointer */
  212: }
  213: 
  214: int
  215: ddocall()
  216: {
  217:         struct obj     *obj;
  218: 
  219:         pline("Do you want to name an individual object? [ny] ");
  220:         switch (readchar()) {
  221:         case '\033':
  222:                 break;
  223:         case 'y':
  224:                 obj = getobj("#", "name");
  225:                 if (obj)
  226:                         do_oname(obj);
  227:                 break;
  228:         default:
  229:                 obj = getobj("?!=/", "call");
  230:                 if (obj)
  231:                         docall(obj);
  232:         }
  233:         return (0);
  234: }
  235: 
  236: void
  237: docall(obj)
  238:         struct obj     *obj;
  239: {
  240:         char            buf[BUFSZ];
  241:         struct obj      otemp;
  242:         char          **str1;
  243:         char           *str;
  244: 
  245:         otemp = *obj;
  246:         otemp.quan = 1;
  247:         otemp.onamelth = 0;
  248:         str = xname(&otemp);
  249:         pline("Call %s %s: ", strchr(vowels, *str) ? "an" : "a", str);
  250:         getlin(buf);
  251:         clrlin();
  252:         if (!*buf || *buf == '\033')
  253:                 return;
  254:         str = newstring(strlen(buf) + 1);
  255:         (void) strcpy(str, buf);
  256:         str1 = &(objects[obj->otyp].oc_uname);
  257:         if (*str1)
  258:                 free(*str1);
  259:         *str1 = str;
  260: }
  261: 
  262: const char *const ghostnames[] = {/* these names should have length < PL_NSIZ */
  263:         "adri", "andries", "andreas", "bert", "david", "dirk", "emile",
  264:         "frans", "fred", "greg", "hether", "jay", "john", "jon", "kay",
  265:         "kenny", "maud", "michiel", "mike", "peter", "robert", "ron",
  266:         "tom", "wilmar"
  267: };
  268: 
  269: char           *
  270: xmonnam(mtmp, vb)
  271:         struct monst   *mtmp;
  272:         int             vb;
  273: {
  274:         static char     buf[BUFSZ];    /* %% */
  275:         if (mtmp->mnamelth && !vb) {
  276:                 (void) strcpy(buf, NAME(mtmp));
  277:                 return (buf);
  278:         }
  279:         switch (mtmp->data->mlet) {
  280:         case ' ':
  281:                 {
  282:                         const char           *gn = (char *) mtmp->mextra;
  283:                         if (!*gn) {  /* might also look in scorefile */
  284:                                 gn = ghostnames[rn2(SIZE(ghostnames))];
  285:                                 if (!rn2(2))
  286:                                         (void)
  287:                                                 strcpy((char *) mtmp->mextra, !rn2(5) ? plname : gn);
  288:                         }
  289:                         (void) sprintf(buf, "%s's ghost", gn);
  290:                 }
  291:                 break;
  292:         case '@':
  293:                 if (mtmp->isshk) {
  294:                         (void) strcpy(buf, shkname(mtmp));
  295:                         break;
  296:                 }
  297:                 /* fall into next case */
  298:         default:
  299:                 (void) sprintf(buf, "the %s%s",
  300:                                mtmp->minvis ? "invisible " : "",
  301:                                mtmp->data->mname);
  302:         }
  303:         if (vb && mtmp->mnamelth) {
  304:                 (void) strcat(buf, " called ");
  305:                 (void) strcat(buf, NAME(mtmp));
  306:         }
  307:         return (buf);
  308: }
  309: 
  310: char           *
  311: lmonnam(mtmp)
  312:         struct monst   *mtmp;
  313: {
  314:         return (xmonnam(mtmp, 1));
  315: }
  316: 
  317: char           *
  318: monnam(mtmp)
  319:         struct monst   *mtmp;
  320: {
  321:         return (xmonnam(mtmp, 0));
  322: }
  323: 
  324: char           *
  325: Monnam(mtmp)
  326:         struct monst   *mtmp;
  327: {
  328:         char           *bp = monnam(mtmp);
  329:         if ('a' <= *bp && *bp <= 'z')
  330:                 *bp += ('A' - 'a');
  331:         return (bp);
  332: }
  333: 
  334: char           *
  335: amonnam(mtmp, adj)
  336:         struct monst   *mtmp;
  337:         const char           *adj;
  338: {
  339:         char           *bp = monnam(mtmp);
  340:         static char     buf[BUFSZ];    /* %% */
  341: 
  342:         if (!strncmp(bp, "the ", 4))
  343:                 bp += 4;
  344:         (void) sprintf(buf, "the %s %s", adj, bp);
  345:         return (buf);
  346: }
  347: 
  348: char           *
  349: Amonnam(mtmp, adj)
  350:         struct monst   *mtmp;
  351:         const char           *adj;
  352: {
  353:         char           *bp = amonnam(mtmp, adj);
  354: 
  355:         *bp = 'T';
  356:         return (bp);
  357: }
  358: 
  359: char           *
  360: Xmonnam(mtmp)
  361:         struct monst   *mtmp;
  362: {
  363:         char           *bp = Monnam(mtmp);
  364:         if (!strncmp(bp, "The ", 4)) {
  365:                 bp += 2;
  366:                 *bp = 'A';
  367:         }
  368:         return (bp);
  369: }
  370: 
  371: char           *
  372: visctrl(c)
  373:         char            c;
  374: {
  375:         static char     ccc[3];
  376:         if (c < 040) {
  377:                 ccc[0] = '^';
  378:                 ccc[1] = c + 0100;
  379:                 ccc[2] = 0;
  380:         } else {
  381:                 ccc[0] = c;
  382:                 ccc[1] = 0;
  383:         }
  384:         return (ccc);
  385: }