Return to hit.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / games / rogue

Annotation of 43BSDTahoe/games/rogue/hit.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * hit.c
        !             3:  *
        !             4:  * This source herein may be modified and/or distributed by anybody who
        !             5:  * so desires, with the following restrictions:
        !             6:  *    1.)  No portion of this notice shall be removed.
        !             7:  *    2.)  Credit shall not be taken for the creation of this source.
        !             8:  *    3.)  This code is not to be traded, sold, or used for personal
        !             9:  *         gain or profit.
        !            10:  *
        !            11:  */
        !            12: 
        !            13: #ifndef lint
        !            14: static char sccsid[] = "@(#)hit.c      5.1 (Berkeley) 11/25/87";
        !            15: #endif /* not lint */
        !            16: 
        !            17: #include "rogue.h"
        !            18: 
        !            19: object *fight_monster = 0;
        !            20: char hit_message[80] = "";
        !            21: 
        !            22: extern short halluc, blind, cur_level;
        !            23: extern short add_strength, ring_exp, r_rings;
        !            24: extern boolean being_held, interrupted, wizard, con_mon;
        !            25: 
        !            26: mon_hit(monster)
        !            27: register object *monster;
        !            28: {
        !            29:        short damage, hit_chance;
        !            30:        char *mn;
        !            31:        float minus;
        !            32: 
        !            33:        if (fight_monster && (monster != fight_monster)) {
        !            34:                fight_monster = 0;
        !            35:        }
        !            36:        monster->trow = NO_ROOM;
        !            37:        if (cur_level >= (AMULET_LEVEL * 2)) {
        !            38:                hit_chance = 100;
        !            39:        } else {
        !            40:                hit_chance = monster->m_hit_chance;
        !            41:                hit_chance -= (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
        !            42:        }
        !            43:        if (wizard) {
        !            44:                hit_chance /= 2;
        !            45:        }
        !            46:        if (!fight_monster) {
        !            47:                interrupted = 1;
        !            48:        }
        !            49:        mn = mon_name(monster);
        !            50: 
        !            51:        if (!rand_percent(hit_chance)) {
        !            52:                if (!fight_monster) {
        !            53:                        sprintf(hit_message + strlen(hit_message), "the %s misses", mn);
        !            54:                        message(hit_message, 1);
        !            55:                        hit_message[0] = 0;
        !            56:                }
        !            57:                return;
        !            58:        }
        !            59:        if (!fight_monster) {
        !            60:                sprintf(hit_message + strlen(hit_message), "the %s hit", mn);
        !            61:                message(hit_message, 1);
        !            62:                hit_message[0] = 0;
        !            63:        }
        !            64:        if (!(monster->m_flags & STATIONARY)) {
        !            65:                damage = get_damage(monster->m_damage, 1);
        !            66:                if (cur_level >= (AMULET_LEVEL * 2)) {
        !            67:                        minus = (float) ((AMULET_LEVEL * 2) - cur_level);
        !            68:                } else {
        !            69:                        minus = (float) get_armor_class(rogue.armor) * 3.00;
        !            70:                        minus = minus/100.00 * (float) damage;
        !            71:                }
        !            72:                damage -= (short) minus;
        !            73:        } else {
        !            74:                damage = monster->stationary_damage++;
        !            75:        }
        !            76:        if (wizard) {
        !            77:                damage /= 3;
        !            78:        }
        !            79:        if (damage > 0) {
        !            80:                rogue_damage(damage, monster, 0);
        !            81:        }
        !            82:        if (monster->m_flags & SPECIAL_HIT) {
        !            83:                special_hit(monster);
        !            84:        }
        !            85: }
        !            86: 
        !            87: rogue_hit(monster, force_hit)
        !            88: register object *monster;
        !            89: boolean force_hit;
        !            90: {
        !            91:        short damage, hit_chance;
        !            92: 
        !            93:        if (monster) {
        !            94:                if (check_imitator(monster)) {
        !            95:                        return;
        !            96:                }
        !            97:                hit_chance = force_hit ? 100 : get_hit_chance(rogue.weapon);
        !            98: 
        !            99:                if (wizard) {
        !           100:                        hit_chance *= 2;
        !           101:                }
        !           102:                if (!rand_percent(hit_chance)) {
        !           103:                        if (!fight_monster) {
        !           104:                                (void) strcpy(hit_message, "you miss  ");
        !           105:                        }
        !           106:                        goto RET;
        !           107:                }
        !           108:                damage = get_weapon_damage(rogue.weapon);
        !           109:                if (wizard) {
        !           110:                        damage *= 3;
        !           111:                }
        !           112:                if (con_mon) {
        !           113:                        s_con_mon(monster);
        !           114:                }
        !           115:                if (mon_damage(monster, damage)) {      /* still alive? */
        !           116:                        if (!fight_monster) {
        !           117:                                (void) strcpy(hit_message, "you hit  ");
        !           118:                        }
        !           119:                }
        !           120: RET:   check_gold_seeker(monster);
        !           121:                wake_up(monster);
        !           122:        }
        !           123: }
        !           124: 
        !           125: rogue_damage(d, monster, other)
        !           126: short d;
        !           127: object *monster;
        !           128: short other;
        !           129: {
        !           130:        if (d >= rogue.hp_current) {
        !           131:                rogue.hp_current = 0;
        !           132:                print_stats(STAT_HP);
        !           133:                killed_by(monster, other);
        !           134:        }
        !           135:        if (d > 0) {
        !           136:                rogue.hp_current -= d;
        !           137:                print_stats(STAT_HP);
        !           138:        }
        !           139: }
        !           140: 
        !           141: get_damage(ds, r)
        !           142: char *ds;
        !           143: boolean r;
        !           144: {
        !           145:        register i = 0, j, n, d, total = 0;
        !           146: 
        !           147:        while (ds[i]) {
        !           148:                n = get_number(ds+i);
        !           149:                while (ds[i++] != 'd') ;
        !           150:                d = get_number(ds+i);
        !           151:                while ((ds[i] != '/') && ds[i]) i++;
        !           152: 
        !           153:                for (j = 0; j < n; j++) {
        !           154:                        if (r) {
        !           155:                                total += get_rand(1, d);
        !           156:                        } else {
        !           157:                                total += d;
        !           158:                        }
        !           159:                }
        !           160:                if (ds[i] == '/') {
        !           161:                        i++;
        !           162:                }
        !           163:        }
        !           164:        return(total);
        !           165: }
        !           166: 
        !           167: get_w_damage(obj)
        !           168: object *obj;
        !           169: {
        !           170:        char new_damage[12];
        !           171:        register to_hit, damage;
        !           172:        register i = 0;
        !           173: 
        !           174:        if ((!obj) || (obj->what_is != WEAPON)) {
        !           175:                return(-1);
        !           176:        }
        !           177:        to_hit = get_number(obj->damage) + obj->hit_enchant;
        !           178:        while (obj->damage[i++] != 'd') ;
        !           179:        damage = get_number(obj->damage + i) + obj->d_enchant;
        !           180: 
        !           181:        sprintf(new_damage, "%dd%d", to_hit, damage);
        !           182: 
        !           183:        return(get_damage(new_damage, 1));
        !           184: }
        !           185: 
        !           186: get_number(s)
        !           187: register char *s;
        !           188: {
        !           189:        register i = 0;
        !           190:        register total = 0;
        !           191: 
        !           192:        while ((s[i] >= '0') && (s[i] <= '9')) {
        !           193:                total = (10 * total) + (s[i] - '0');
        !           194:                i++;
        !           195:        }
        !           196:        return(total);
        !           197: }
        !           198: 
        !           199: long
        !           200: lget_number(s)
        !           201: char *s;
        !           202: {
        !           203:        short i = 0;
        !           204:        long total = 0;
        !           205: 
        !           206:        while ((s[i] >= '0') && (s[i] <= '9')) {
        !           207:                total = (10 * total) + (s[i] - '0');
        !           208:                i++;
        !           209:        }
        !           210:        return(total);
        !           211: }
        !           212: 
        !           213: to_hit(obj)
        !           214: object *obj;
        !           215: {
        !           216:        if (!obj) {
        !           217:                return(1);
        !           218:        }
        !           219:        return(get_number(obj->damage) + obj->hit_enchant);
        !           220: }
        !           221: 
        !           222: damage_for_strength()
        !           223: {
        !           224:        short strength;
        !           225: 
        !           226:        strength = rogue.str_current + add_strength;
        !           227: 
        !           228:        if (strength <= 6) {
        !           229:                return(strength-5);
        !           230:        }
        !           231:        if (strength <= 14) {
        !           232:                return(1);
        !           233:        }
        !           234:        if (strength <= 17) {
        !           235:                return(3);
        !           236:        }
        !           237:        if (strength <= 18) {
        !           238:                return(4);
        !           239:        }
        !           240:        if (strength <= 20) {
        !           241:                return(5);
        !           242:        }
        !           243:        if (strength <= 21) {
        !           244:                return(6);
        !           245:        }
        !           246:        if (strength <= 30) {
        !           247:                return(7);
        !           248:        }
        !           249:        return(8);
        !           250: }
        !           251: 
        !           252: mon_damage(monster, damage)
        !           253: object *monster;
        !           254: short damage;
        !           255: {
        !           256:        char *mn;
        !           257:        short row, col;
        !           258: 
        !           259:        monster->hp_to_kill -= damage;
        !           260: 
        !           261:        if (monster->hp_to_kill <= 0) {
        !           262:                row = monster->row;
        !           263:                col = monster->col;
        !           264:                dungeon[row][col] &= ~MONSTER;
        !           265:                mvaddch(row, col, (int) get_dungeon_char(row, col));
        !           266: 
        !           267:                fight_monster = 0;
        !           268:                cough_up(monster);
        !           269:                mn = mon_name(monster);
        !           270:                sprintf(hit_message+strlen(hit_message), "defeated the %s", mn);
        !           271:                message(hit_message, 1);
        !           272:                hit_message[0] = 0;
        !           273:                add_exp(monster->kill_exp, 1);
        !           274:                take_from_pack(monster, &level_monsters);
        !           275: 
        !           276:                if (monster->m_flags & HOLDS) {
        !           277:                        being_held = 0;
        !           278:                }
        !           279:                free_object(monster);
        !           280:                return(0);
        !           281:        }
        !           282:        return(1);
        !           283: }
        !           284: 
        !           285: fight(to_the_death)
        !           286: boolean to_the_death;
        !           287: {
        !           288:        short ch, c, d;
        !           289:        short row, col;
        !           290:        boolean first_miss = 1;
        !           291:        short possible_damage;
        !           292:        object *monster;
        !           293: 
        !           294:        while (!is_direction(ch = rgetchar(), &d)) {
        !           295:                sound_bell();
        !           296:                if (first_miss) {
        !           297:                        message("direction?", 0);
        !           298:                        first_miss = 0;
        !           299:                }
        !           300:        }
        !           301:        check_message();
        !           302:        if (ch == CANCEL) {
        !           303:                return;
        !           304:        }
        !           305:        row = rogue.row; col = rogue.col;
        !           306:        get_dir_rc(d, &row, &col, 0);
        !           307: 
        !           308:        c = mvinch(row, col);
        !           309:        if (((c < 'A') || (c > 'Z')) ||
        !           310:                (!can_move(rogue.row, rogue.col, row, col))) {
        !           311:                message("I see no monster there", 0);
        !           312:                return;
        !           313:        }
        !           314:        if (!(fight_monster = object_at(&level_monsters, row, col))) {
        !           315:                return;
        !           316:        }
        !           317:        if (!(fight_monster->m_flags & STATIONARY)) {
        !           318:                possible_damage = ((get_damage(fight_monster->m_damage, 0) * 2) / 3);
        !           319:        } else {
        !           320:                possible_damage = fight_monster->stationary_damage - 1;
        !           321:        }
        !           322:        while (fight_monster) {
        !           323:                (void) one_move_rogue(ch, 0);
        !           324:                if (((!to_the_death) && (rogue.hp_current <= possible_damage)) ||
        !           325:                        interrupted || (!(dungeon[row][col] & MONSTER))) {
        !           326:                        fight_monster = 0;
        !           327:                } else {
        !           328:                        monster = object_at(&level_monsters, row, col);
        !           329:                        if (monster != fight_monster) {
        !           330:                                fight_monster = 0;
        !           331:                        }
        !           332:                }
        !           333:        }
        !           334: }
        !           335: 
        !           336: get_dir_rc(dir, row, col, allow_off_screen)
        !           337: short dir;
        !           338: short *row, *col;
        !           339: short allow_off_screen;
        !           340: {
        !           341:        switch(dir) {
        !           342:        case LEFT:
        !           343:                if (allow_off_screen || (*col > 0)) {
        !           344:                        (*col)--;
        !           345:                }
        !           346:                break;
        !           347:        case DOWN:
        !           348:                if (allow_off_screen || (*row < (DROWS-2))) {
        !           349:                        (*row)++;
        !           350:                }
        !           351:                break;
        !           352:        case UPWARD:
        !           353:                if (allow_off_screen || (*row > MIN_ROW)) {
        !           354:                        (*row)--;
        !           355:                }
        !           356:                break;
        !           357:        case RIGHT:
        !           358:                if (allow_off_screen || (*col < (DCOLS-1))) {
        !           359:                        (*col)++;
        !           360:                }
        !           361:                break;
        !           362:        case UPLEFT:
        !           363:                if (allow_off_screen || ((*row > MIN_ROW) && (*col > 0))) {
        !           364:                        (*row)--;
        !           365:                        (*col)--;
        !           366:                }
        !           367:                break;
        !           368:        case UPRIGHT:
        !           369:                if (allow_off_screen || ((*row > MIN_ROW) && (*col < (DCOLS-1)))) {
        !           370:                        (*row)--;
        !           371:                        (*col)++;
        !           372:                }
        !           373:                break;
        !           374:        case DOWNRIGHT:
        !           375:                if (allow_off_screen || ((*row < (DROWS-2)) && (*col < (DCOLS-1)))) {
        !           376:                        (*row)++;
        !           377:                        (*col)++;
        !           378:                }
        !           379:                break;
        !           380:        case DOWNLEFT:
        !           381:                if (allow_off_screen || ((*row < (DROWS-2)) && (*col > 0))) {
        !           382:                        (*row)++;
        !           383:                        (*col)--;
        !           384:                }
        !           385:                break;
        !           386:        }
        !           387: }
        !           388: 
        !           389: get_hit_chance(weapon)
        !           390: object *weapon;
        !           391: {
        !           392:        short hit_chance;
        !           393: 
        !           394:        hit_chance = 40;
        !           395:        hit_chance += 3 * to_hit(weapon);
        !           396:        hit_chance += (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
        !           397:        return(hit_chance);
        !           398: }
        !           399: 
        !           400: get_weapon_damage(weapon)
        !           401: object *weapon;
        !           402: {
        !           403:        short damage;
        !           404: 
        !           405:        damage = get_w_damage(weapon);
        !           406:        damage += damage_for_strength();
        !           407:        damage += ((((rogue.exp + ring_exp) - r_rings) + 1) / 2);
        !           408:        return(damage);
        !           409: }
        !           410: 
        !           411: s_con_mon(monster)
        !           412: object *monster;
        !           413: {
        !           414:        if (con_mon) {
        !           415:                monster->m_flags |= CONFUSED;
        !           416:                monster->moves_confused += get_rand(12, 22);
        !           417:                message("the monster appears confused", 0);
        !           418:                con_mon = 0;
        !           419:        }
        !           420: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.