![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rings.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / srogue|
Return to rings.c CVS log | Up to [contributed] / early-roguelike / srogue |
1.1 ! rubenllo 1: /*
! 2: * routines dealing specifically with rings
! 3: *
! 4: * @(#)rings.c 9.0 (rdk) 7/17/84
! 5: *
! 6: * Super-Rogue
! 7: * Copyright (C) 1984 Robert D. Kindelberger
! 8: * All rights reserved.
! 9: *
! 10: * Based on "Rogue: Exploring the Dungeons of Doom"
! 11: * Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
! 12: * All rights reserved.
! 13: *
! 14: * See the file LICENSE.TXT for full copyright and licensing information.
! 15: */
! 16:
! 17: #include <stdlib.h>
! 18: #include <string.h>
! 19: #include "rogue.h"
! 20: #include "rogue.ext"
! 21:
! 22: int gethand(bool isrmv);
! 23: int ring_eat(void);
! 24:
! 25: /*
! 26: * ring_on:
! 27: * Put on a ring
! 28: */
! 29: void
! 30: ring_on(void)
! 31: {
! 32: reg struct object *obj;
! 33: reg struct linked_list *item;
! 34: reg int ring, wh;
! 35: char buf[LINLEN];
! 36: bool okring;
! 37:
! 38: if (cur_ring[LEFT] != NULL && cur_ring[RIGHT] != NULL) {
! 39: msg("Already wearing two rings.");
! 40: after = FALSE;
! 41: return;
! 42: }
! 43: /*
! 44: * Make certain that it is somethings that we want to wear
! 45: */
! 46: if ((item = get_item("put on", RING)) == NULL)
! 47: return;
! 48: obj = OBJPTR(item);
! 49: if (obj->o_type != RING) {
! 50: msg("That won't fit on your finger.");
! 51: return;
! 52: }
! 53: /*
! 54: * find out which hand to put it on
! 55: */
! 56: if (is_current(obj))
! 57: return;
! 58: if (cur_ring[LEFT] == NULL && cur_ring[RIGHT] == NULL) {
! 59: if ((ring = gethand(FALSE)) < 0)
! 60: return;
! 61: }
! 62: else if (cur_ring[LEFT] == NULL)
! 63: ring = LEFT;
! 64: else
! 65: ring = RIGHT;
! 66: cur_ring[ring] = obj;
! 67: wh = obj->o_which;
! 68: /*
! 69: * okring = FALSE when:
! 70: * 1) ring is cursed and benefit = plus
! 71: * 2) ring is blessed and benefit = minus
! 72: */
! 73: okring = !((obj->o_ac > 0 && o_on(obj, ISCURSED)) ||
! 74: (obj->o_ac < 0 && o_on(obj, ISBLESS)));
! 75: /*
! 76: * Calculate the effect it has on the poor guy (if possible).
! 77: */
! 78: if (okring) {
! 79: switch (wh) {
! 80: case R_SPEED:
! 81: if (--obj->o_ac < 0) {
! 82: obj->o_ac = 0;
! 83: setoflg(obj,ISCURSED);
! 84: }
! 85: else {
! 86: add_haste(FALSE);
! 87: }
! 88: when R_GIANT: /* to 24 */
! 89: him->s_ef.a_str = MAXSTR;
! 90: when R_ADDSTR:
! 91: chg_abil(STR,obj->o_ac,FROMRING);
! 92: when R_KNOW:
! 93: chg_abil(WIS,obj->o_ac,FROMRING);
! 94: when R_DEX:
! 95: chg_abil(DEX,obj->o_ac,FROMRING);
! 96: when R_CONST:
! 97: chg_abil(CON,obj->o_ac,FROMRING);
! 98: when R_SEEINVIS:
! 99: player.t_flags |= CANSEE;
! 100: light(&hero);
! 101: mvwaddch(cw, hero.y, hero.x, PLAYER);
! 102: when R_AGGR:
! 103: aggravate();
! 104: when R_HEAVY:
! 105: updpack(); /* new pack weight */
! 106: when R_BLIND:
! 107: r_know[R_BLIND] = TRUE;
! 108: player.t_flags |= ISBLIND;
! 109: look(FALSE);
! 110: when R_SLOW:
! 111: player.t_flags |= ISSLOW;
! 112: when R_SAPEM:
! 113: fuse(sapem,TRUE,150);
! 114: when R_LIGHT: {
! 115: struct room *rop;
! 116:
! 117: r_know[R_LIGHT] = TRUE;
! 118: if ((rop = player.t_room) != NULL) {
! 119: rop->r_flags &= ~ISDARK;
! 120: light(&hero);
! 121: mvwaddch(cw, hero.y, hero.x, PLAYER);
! 122: }
! 123: }
! 124: }
! 125: }
! 126: if (r_know[wh] && r_guess[wh]) {
! 127: free(r_guess[wh]);
! 128: r_guess[wh] = NULL;
! 129: }
! 130: else if(!r_know[wh] && r_guess[wh] == NULL) {
! 131: mpos = 0;
! 132: strcpy(buf, r_stones[wh]);
! 133: msg(callit);
! 134: if (get_str(buf, cw) == NORM) {
! 135: r_guess[wh] = new(strlen(buf) + 1);
! 136: strcpy(r_guess[wh], buf);
! 137: }
! 138: }
! 139: mpos = 0;
! 140: msg("Now wearing %s",inv_name(obj,TRUE));
! 141: ringfood = ring_eat();
! 142: nochange = FALSE;
! 143: }
! 144:
! 145:
! 146: /*
! 147: * ring_off:
! 148: * Take off some ring
! 149: */
! 150: void
! 151: ring_off(void)
! 152: {
! 153: reg int ring;
! 154: reg struct object *obj;
! 155:
! 156: if (cur_ring[LEFT] == NULL && cur_ring[RIGHT] == NULL) {
! 157: msg("You're not wearing any rings.");
! 158: return;
! 159: }
! 160: else if (cur_ring[LEFT] == NULL)
! 161: ring = RIGHT;
! 162: else if (cur_ring[RIGHT] == NULL)
! 163: ring = LEFT;
! 164: else
! 165: if ((ring = gethand(TRUE)) < 0)
! 166: return;
! 167: mpos = 0;
! 168: obj = cur_ring[ring];
! 169: if (obj == NULL) {
! 170: msg("Not wearing such a ring.");
! 171: return;
! 172: }
! 173: if (dropcheck(obj)) {
! 174: msg("Was wearing %s", inv_name(obj, TRUE));
! 175: nochange = FALSE;
! 176: ringfood = ring_eat();
! 177: }
! 178: }
! 179:
! 180:
! 181: /*
! 182: * toss_ring:
! 183: * Remove a ring and stop its effects
! 184: */
! 185: void
! 186: toss_ring(struct object *what)
! 187: {
! 188: bool okring;
! 189:
! 190: /*
! 191: * okring = FALSE when:
! 192: * 1) ring is cursed and benefit = plus
! 193: * 2) ring is blessed and benefit = minus
! 194: */
! 195: okring = !((what->o_ac > 0 && o_on(what, ISCURSED)) ||
! 196: (what->o_ac < 0 && o_on(what, ISBLESS)));
! 197:
! 198: cur_ring[what == cur_ring[LEFT] ? LEFT : RIGHT] = NULL;
! 199: if (okring) {
! 200: switch (what->o_which) {
! 201: case R_SPEED:
! 202: extinguish(nohaste);
! 203: nohaste(FALSE);
! 204: when R_BLIND:
! 205: sight(FALSE);
! 206: when R_SLOW:
! 207: player.t_flags &= ~ISSLOW;
! 208: when R_SAPEM:
! 209: extinguish(sapem);
! 210: when R_GIANT:
! 211: him->s_ef = him->s_re;
! 212: ringabil();
! 213: when R_ADDSTR:
! 214: chg_abil(STR,-what->o_ac,FALSE);
! 215: when R_KNOW:
! 216: chg_abil(WIS,-what->o_ac,FALSE);
! 217: when R_DEX:
! 218: chg_abil(DEX,-what->o_ac,FALSE);
! 219: when R_CONST:
! 220: chg_abil(CON,-what->o_ac,FALSE);
! 221: when R_SEEINVIS:
! 222: player.t_flags &= ~CANSEE;
! 223: extinguish(unsee);
! 224: light(&hero);
! 225: mvwaddch(cw, hero.y, hero.x, PLAYER);
! 226: }
! 227: }
! 228: }
! 229:
! 230:
! 231: /*
! 232: * gethand:
! 233: * Get a hand to wear a ring
! 234: */
! 235: int
! 236: gethand(bool isrmv)
! 237: {
! 238: reg int c;
! 239: char *ptr;
! 240: struct object *obj;
! 241:
! 242: while(1) {
! 243: addmsg("Left or Right ring");
! 244: if (isrmv)
! 245: addmsg(starlist);
! 246: addmsg("? ");
! 247: endmsg();
! 248: c = readchar();
! 249: if (isupper(c))
! 250: c = tolower(c);
! 251: if (c == '*' && isrmv) {
! 252: wclear(hw);
! 253: obj = cur_ring[LEFT];
! 254: if (obj != NULL)
! 255: ptr = inv_name(obj, TRUE);
! 256: else
! 257: ptr = "none";
! 258: wprintw(hw, "L) %s\n\r",ptr);
! 259: obj = cur_ring[RIGHT];
! 260: if (obj != NULL)
! 261: ptr = inv_name(obj, TRUE);
! 262: else
! 263: ptr = "none";
! 264: wprintw(hw, "R) %s\n\r", ptr);
! 265: wprintw(hw, "\n\r\nWhich hand? ");
! 266: draw(hw);
! 267: c = readchar();
! 268: if (isupper(c))
! 269: c = tolower(c);
! 270: restscr(cw);
! 271: }
! 272: if (c == 'l')
! 273: return LEFT;
! 274: else if (c == 'r')
! 275: return RIGHT;
! 276: else if (c == ESCAPE)
! 277: return -1;
! 278: mpos = 0;
! 279: msg("L or R");
! 280: }
! 281: }
! 282:
! 283: /*
! 284: * ring_eat:
! 285: * How much food do the hero's rings use up?
! 286: */
! 287: int
! 288: ring_eat(void)
! 289: {
! 290: reg struct object *lb;
! 291: reg int hand, i, howmuch;
! 292: bool addit;
! 293:
! 294: howmuch = 0;
! 295: addit = TRUE;
! 296: for (i = LEFT; i <= RIGHT ; i += 1) {
! 297: lb = cur_ring[i];
! 298: if (lb != NULL) {
! 299: switch (lb->o_which) {
! 300: case R_REGEN:
! 301: case R_GIANT:
! 302: howmuch += 2;
! 303: when R_SPEED:
! 304: case R_SUSTSTR:
! 305: case R_SUSAB:
! 306: howmuch += 1;
! 307: when R_SEARCH:
! 308: howmuch += (rnd(100) < 33);
! 309: when R_DIGEST:
! 310: switch(lb->o_ac) {
! 311: case -3: if (rnd(100) < 25)
! 312: howmuch += 3;
! 313: when -2: if (rnd(100) < 50)
! 314: howmuch += 2;
! 315: when -1: howmuch += 1;
! 316: when 0: howmuch -= (rnd(100) < 50);
! 317: when 3: if (rnd(100) < 25)
! 318: howmuch -= 3;
! 319: when 2: if (rnd(100) < 50)
! 320: howmuch -= 2;
! 321: default: howmuch -= 1;
! 322: }
! 323: otherwise:
! 324: addit = FALSE;
! 325: }
! 326: if (addit) {
! 327: if (o_on(lb, ISBLESS))
! 328: howmuch -= 1;
! 329: else if (o_on(lb, ISCURSED))
! 330: howmuch += 1;
! 331: }
! 332: }
! 333: }
! 334: return howmuch;
! 335: }
! 336:
! 337:
! 338: /*
! 339: * ring_num:
! 340: * Print ring bonuses
! 341: */
! 342: char *
! 343: ring_num(struct object *what)
! 344: {
! 345: static char number[5];
! 346:
! 347: number[0] = '\0';
! 348: if (o_on(what,ISKNOW) || o_on(what,ISPOST)) {
! 349: if (magring(what)) { /* only rings with numbers */
! 350: number[0] = ' ';
! 351: strcpy(&number[1], num(what->o_ac, 0));
! 352: }
! 353: }
! 354: return number;
! 355: }
! 356:
! 357:
! 358: /*
! 359: * magring:
! 360: * Returns TRUE if a ring has a number, i.e. +2
! 361: */
! 362: bool
! 363: magring(struct object *what)
! 364: {
! 365: switch(what->o_which) {
! 366: case R_SPEED:
! 367: case R_ADDSTR:
! 368: case R_PROTECT:
! 369: case R_ADDHIT:
! 370: case R_ADDDAM:
! 371: case R_DIGEST:
! 372: case R_CONST:
! 373: case R_KNOW:
! 374: case R_DEX:
! 375: return TRUE;
! 376: default:
! 377: return FALSE;
! 378: }
! 379: }
! 380:
! 381:
! 382: /*
! 383: * ringabil:
! 384: * Compute effective abilities due to rings
! 385: */
! 386: void
! 387: ringabil(void)
! 388: {
! 389: reg struct object *rptr;
! 390: reg int i;
! 391:
! 392: for(i = LEFT; i <= RIGHT; i++) {
! 393: rptr = cur_ring[i];
! 394: if (rptr != NULL) {
! 395: switch(rptr->o_which) {
! 396: case R_ADDSTR:
! 397: chg_abil(STR,rptr->o_ac,FROMRING);
! 398: when R_DEX:
! 399: chg_abil(DEX,rptr->o_ac,FROMRING);
! 400: when R_KNOW:
! 401: chg_abil(WIS,rptr->o_ac,FROMRING);
! 402: when R_CONST:
! 403: chg_abil(CON,rptr->o_ac,FROMRING);
! 404: }
! 405: }
! 406: }
! 407: }
! 408:
! 409:
! 410: /*
! 411: * init_ring:
! 412: * Initialize a ring
! 413: */
! 414: void
! 415: init_ring(struct object *what, bool fromwiz)
! 416: {
! 417: /* fromwiz: TRUE when from wizards */
! 418: reg int much;
! 419:
! 420: switch (what->o_which) {
! 421: case R_DIGEST: /* -3 to +3 rings */
! 422: case R_ADDSTR:
! 423: case R_PROTECT:
! 424: case R_ADDHIT:
! 425: case R_ADDDAM:
! 426: case R_DEX:
! 427: case R_KNOW:
! 428: case R_CONST:
! 429: if (fromwiz) {
! 430: much = getbless(); /* get wizards response */
! 431: }
! 432: else { /* normal users */
! 433: if (rnd(100) < 25)
! 434: much = -rnd(3) - 1;
! 435: else
! 436: much = rnd(3) + 1;
! 437: }
! 438: what->o_ac = much;
! 439: if (much < 0)
! 440: setoflg(what,ISCURSED);
! 441: when R_SPEED:
! 442: what->o_ac = rnd(4) + 1;
! 443: when R_AGGR:
! 444: case R_DELUS:
! 445: case R_HEAVY:
! 446: case R_BLIND:
! 447: case R_SLOW:
! 448: case R_SAPEM:
! 449: case R_TELEPORT:
! 450: what->o_ac = 0;
! 451: setoflg(what,ISCURSED);
! 452: when R_GIANT:
! 453: what->o_ac = 25; /* lots !! of STR */
! 454: otherwise:
! 455: what->o_ac = 1;
! 456: }
! 457: what->o_type = RING;
! 458: what->o_weight = things[TYP_RING].mi_wght;
! 459: what->o_typname = things[TYP_RING].mi_name;
! 460: what->o_vol = itemvol(what);
! 461: }
! 462:
! 463: /*
! 464: * ringex:
! 465: * Get extra gains from rings
! 466: */
! 467: int
! 468: ringex(int rtype)
! 469: {
! 470: reg int howmuch = 0;
! 471:
! 472: if (isring(LEFT, rtype))
! 473: howmuch += cur_ring[LEFT]->o_ac;
! 474: if (isring(RIGHT, rtype))
! 475: howmuch += cur_ring[RIGHT]->o_ac;
! 476: return howmuch;
! 477: }
! 478:
! 479: /*
! 480: * iswearing:
! 481: * Returns TRUE when the hero is wearing a certain type of ring
! 482: */
! 483: bool
! 484: iswearing(int ring)
! 485: {
! 486: return (isring(LEFT,ring) || isring(RIGHT,ring));
! 487: }
! 488:
! 489: /*
! 490: * isring:
! 491: * Returns TRUE if a ring is on a hand
! 492: */
! 493: bool
! 494: isring(int hand, int ring)
! 495: {
! 496: if (cur_ring[hand] != NULL && cur_ring[hand]->o_which == ring)
! 497: return TRUE;
! 498: return FALSE;
! 499: }