home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / games / hack / hack.do_name.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-02  |  6.0 KB  |  290 lines
  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. }
  290.