Return to bang.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / games / warp

Annotation of 43BSDReno/games/warp/bang.c, revision 1.1

1.1     ! root        1: /* $Header: bang.c,v 7.0.1.3 86/12/12 16:57:00 lwall Exp $ */
        !             2: 
        !             3: /* $Log:       bang.c,v $
        !             4:  * Revision 7.0.1.3  86/12/12  16:57:00  lwall
        !             5:  * Made circular explosions.
        !             6:  * 
        !             7:  * Revision 7.0.1.2  86/10/20  14:36:02  lwall
        !             8:  * Picked some lint.
        !             9:  * 
        !            10:  * Revision 7.0.1.1  86/10/16  10:49:45  lwall
        !            11:  * Added Damage.  Fixed random bugs.
        !            12:  * 
        !            13:  * Revision 7.0  86/10/08  15:11:57  lwall
        !            14:  * Split into separate files.  Added amoebas and pirates.
        !            15:  * 
        !            16:  */
        !            17: 
        !            18: #include "EXTERN.h"
        !            19: #include "warp.h"
        !            20: #include "object.h"
        !            21: #include "move.h"
        !            22: #include "sig.h"
        !            23: #include "term.h"
        !            24: #include "them.h"
        !            25: #include "INTERN.h"
        !            26: #include "bang.h"
        !            27: 
        !            28: void
        !            29: bang_init()
        !            30: {
        !            31:     ;
        !            32: }
        !            33: 
        !            34: void
        !            35: make_plink(y,x)
        !            36: Reg1 int x;
        !            37: Reg2 int y;
        !            38: {
        !            39:     Reg3 OBJECT *obj;
        !            40: 
        !            41:     move(y+1,x*2,0);
        !            42:     beg_qwrite();
        !            43:     *filler = '@';
        !            44:     qwrite();
        !            45:     obj = occupant[y][x];
        !            46:     if (obj) {
        !            47:        if (numamoebas && obj->image == ' ')
        !            48:            qaddc(amb[y][x]);
        !            49:        else
        !            50:            qaddc(obj->image);
        !            51:     }
        !            52:     else if (numamoebas)
        !            53:        qaddc(amb[y][x]);
        !            54:     else
        !            55:        qaddspace();
        !            56:     end_qwrite();
        !            57: }
        !            58: 
        !            59: void
        !            60: make_blast(y,x,mass,size)
        !            61: Reg1 int x;
        !            62: Reg2 int y;
        !            63: int size;
        !            64: long mass;
        !            65: {
        !            66:     bangy[nxtbang] = y;
        !            67:     bangx[nxtbang] = x;
        !            68:     bangm[nxtbang] = mass;
        !            69:     bangs[nxtbang++] = size;
        !            70:     assert(nxtbang <= XSIZE * YSIZE);
        !            71:     if (numamoebas && amb[y][x] == '~') {
        !            72:        if (mass > 10000)
        !            73:            modify_amoeba(y,x,1,'~', 10);
        !            74:        else if (mass > 100)
        !            75:            modify_amoeba(y,x,1,'~', 5);
        !            76:        bangs[nxtbang-1] = 0;           /* don't propagate */
        !            77:        return;
        !            78:     }
        !            79:     else if (mass >= 0) {
        !            80:        Reg3 OBJECT *obj;
        !            81: 
        !            82:        move(y+1,x*2,0);
        !            83:        beg_qwrite();
        !            84:        *filler = '@';
        !            85:        qwrite();
        !            86:        *filler = '#';
        !            87:        qwrite();
        !            88:        *filler = '@';
        !            89:        qwrite();
        !            90:        *filler = '#';
        !            91:        qwrite();
        !            92:        *filler = '@';
        !            93:        qwrite();
        !            94:        obj = occupant[y][x];
        !            95:        if (obj) {
        !            96:            if (numamoebas && obj->image == ' ')
        !            97:                qaddc(amb[y][x]);
        !            98:            else
        !            99:                qaddc(obj->image);
        !           100:        }
        !           101:        else if (numamoebas)
        !           102:            qaddc(amb[y][x]);
        !           103:        else
        !           104:            qaddspace();
        !           105:        end_qwrite();
        !           106:     }
        !           107: }
        !           108: 
        !           109: void
        !           110: do_bangs()
        !           111: {
        !           112:     Reg1 int x;
        !           113:     Reg2 int y;
        !           114:     Reg3 int i;
        !           115:     Reg4 int j;
        !           116:     Reg7 int k;
        !           117:     Reg5 int lastxy;
        !           118:     Reg6 OBJECT *obj;
        !           119: 
        !           120:     /* read blast list and update blast array */
        !           121:     assert(nxtbang >= 0 && nxtbang <= XSIZE * YSIZE);
        !           122:     for (i=0; i<nxtbang; i++) {
        !           123:        if (bangm[i] != 32767)
        !           124:            bangm[i] *= 4;
        !           125:        lastxy = bangs[i] << 1;
        !           126:        if (lastxy >= MAXBDIST)
        !           127:            lastxy = MAXBDIST - 1;
        !           128:        for (y=bangy[i]-bangs[i],x=bangx[i]-bangs[i],j=lastxy;
        !           129:          j>=0;
        !           130:          y++,x++,--j) {
        !           131:            yblasted[yy[j] = (y+YSIZE00) % YSIZE] |= 1;
        !           132:            xblasted[xx[j] = (x+XSIZE00) % XSIZE] |= 1;
        !           133:        }
        !           134:        blasted = TRUE;
        !           135:        for (y=lastxy;y>=0;--y) {
        !           136:            for (x=lastxy;x>=0;--x) {
        !           137:                if (lastxy > 2) {
        !           138:                    j = abs(y-bangs[i]);
        !           139:                    k = abs(x-bangs[i]);
        !           140:                    if (j < k)          /* distance is long + 1/2 short */
        !           141:                        j += k + k;
        !           142:                    else
        !           143:                        j += j + k;
        !           144:                    if (--j > lastxy)
        !           145:                        continue;
        !           146:                }
        !           147:                if (bangm[i] != 32767 ||
        !           148:                  !(obj=occupant[yy[y]][xx[x]]) || obj->type != Web)
        !           149:                    blast[yy[y]][xx[x]] += bangm[i];
        !           150:            }
        !           151:        }
        !           152:     }
        !           153: }

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