Return to hack.mkobj.c CVS log

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

Annotation of 43BSDTahoe/games/hack/hack.mkobj.c, revision 1.1.1.1

1.1       root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
                      2: /* hack.mkobj.c - version 1.0.3 */
                      3: 
                      4: #include "hack.h"
                      5: 
                      6: char mkobjstr[] = "))[[!!!!????%%%%/=**))[[!!!!????%%%%/=**(%";
                      7: struct obj *mkobj(), *mksobj();
                      8: 
                      9: struct obj *
                     10: mkobj_at(let,x,y)
                     11: register let,x,y;
                     12: {
                     13:        register struct obj *otmp = mkobj(let);
                     14:        otmp->ox = x;
                     15:        otmp->oy = y;
                     16:        otmp->nobj = fobj;
                     17:        fobj = otmp;
                     18:        return(otmp);
                     19: }
                     20: 
                     21: mksobj_at(otyp,x,y)
                     22: register otyp,x,y;
                     23: {
                     24:        register struct obj *otmp = mksobj(otyp);
                     25:        otmp->ox = x;
                     26:        otmp->oy = y;
                     27:        otmp->nobj = fobj;
                     28:        fobj = otmp;
                     29: }
                     30: 
                     31: struct obj *
                     32: mkobj(let) {
                     33:        if(!let)
                     34:                let = mkobjstr[rn2(sizeof(mkobjstr) - 1)];
                     35:        return(
                     36:            mksobj(
                     37:                letter(let) ?
                     38:                    CORPSE + ((let > 'Z') ? (let-'a'+'Z'-'@'+1) : (let-'@'))
                     39:                :   probtype(let)
                     40:            )
                     41:        );
                     42: }
                     43:        
                     44: 
                     45: struct obj zeroobj;
                     46: 
                     47: struct obj *
                     48: mksobj(otyp)
                     49: register otyp;
                     50: {
                     51:        register struct obj *otmp;
                     52:        char let = objects[otyp].oc_olet;
                     53: 
                     54:        otmp = newobj(0);
                     55:        *otmp = zeroobj;
                     56:        otmp->age = moves;
                     57:        otmp->o_id = flags.ident++;
                     58:        otmp->quan = 1;
                     59:        otmp->olet = let;
                     60:        otmp->otyp = otyp;
                     61:        otmp->dknown = index("/=!?*", let) ? 0 : 1;
                     62:        switch(let) {
                     63:        case WEAPON_SYM:
                     64:                otmp->quan = (otmp->otyp <= ROCK) ? rn1(6,6) : 1;
                     65:                if(!rn2(11)) otmp->spe = rnd(3);
                     66:                else if(!rn2(10)) {
                     67:                        otmp->cursed = 1;
                     68:                        otmp->spe = -rnd(3);
                     69:                }
                     70:                break;
                     71:        case FOOD_SYM:
                     72:                if(otmp->otyp >= CORPSE) break;
                     73: #ifdef NOT_YET_IMPLEMENTED
                     74:                /* if tins are to be identified, need to adapt doname() etc */
                     75:                if(otmp->otyp == TIN)
                     76:                        otmp->spe = rnd(...);
                     77: #endif NOT_YET_IMPLEMENTED
                     78:                /* fall into next case */
                     79:        case GEM_SYM:
                     80:                otmp->quan = rn2(6) ? 1 : 2;
                     81:        case TOOL_SYM:
                     82:        case CHAIN_SYM:
                     83:        case BALL_SYM:
                     84:        case ROCK_SYM:
                     85:        case POTION_SYM:
                     86:        case SCROLL_SYM:
                     87:        case AMULET_SYM:
                     88:                break;
                     89:        case ARMOR_SYM:
                     90:                if(!rn2(8)) otmp->cursed = 1;
                     91:                if(!rn2(10)) otmp->spe = rnd(3);
                     92:                else if(!rn2(9)) {
                     93:                        otmp->spe = -rnd(3);
                     94:                        otmp->cursed = 1;
                     95:                }
                     96:                break;
                     97:        case WAND_SYM:
                     98:                if(otmp->otyp == WAN_WISHING) otmp->spe = 3; else
                     99:                otmp->spe = rn1(5,
                    100:                        (objects[otmp->otyp].bits & NODIR) ? 11 : 4);
                    101:                break;
                    102:        case RING_SYM:
                    103:                if(objects[otmp->otyp].bits & SPEC) {
                    104:                        if(!rn2(3)) {
                    105:                                otmp->cursed = 1;
                    106:                                otmp->spe = -rnd(2);
                    107:                        } else otmp->spe = rnd(2);
                    108:                } else if(otmp->otyp == RIN_TELEPORTATION ||
                    109:                          otmp->otyp == RIN_AGGRAVATE_MONSTER ||
                    110:                          otmp->otyp == RIN_HUNGER || !rn2(9))
                    111:                        otmp->cursed = 1;
                    112:                break;
                    113:        default:
                    114:                panic("impossible mkobj");
                    115:        }
                    116:        otmp->owt = weight(otmp);
                    117:        return(otmp);
                    118: }
                    119: 
                    120: letter(c) {
                    121:        return(('@' <= c && c <= 'Z') || ('a' <= c && c <= 'z'));
                    122: }
                    123: 
                    124: weight(obj)
                    125: register struct obj *obj;
                    126: {
                    127: register int wt = objects[obj->otyp].oc_weight;
                    128:        return(wt ? wt*obj->quan : (obj->quan + 1)/2);
                    129: }
                    130: 
                    131: mkgold(num,x,y)
                    132: register long num;
                    133: {
                    134:        register struct gold *gold;
                    135:        register long amount = (num ? num : 1 + (rnd(dlevel+2) * rnd(30)));
                    136: 
                    137:        if(gold = g_at(x,y))
                    138:                gold->amount += amount;
                    139:        else {
                    140:                gold = newgold();
                    141:                gold->ngold = fgold;
                    142:                gold->gx = x;
                    143:                gold->gy = y;
                    144:                gold->amount = amount;
                    145:                fgold = gold;
                    146:                /* do sth with display? */
                    147:        }
                    148: }

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