Return to rock.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / demo / asteroids

Annotation of researchv9/jtools/src/demo/asteroids/rock.c, revision 1.1

1.1     ! root        1: #include <jerq.h>
        !             2: #include "rock.h"
        !             3: #define YMAX 1024
        !             4: extern Bitmap *buildimage();
        !             5: extern notdrawn;
        !             6: #define        NROCK   32      /* == number of bits in a long */
        !             7: #define        V       16      /* velocity */
        !             8: #define        DV      5       /* delta v after explosion */
        !             9: #define        W       48      /* radius of rock (sort of) */
        !            10: long allocated=0;
        !            11: Rock rock[NROCK];
        !            12: #define        BINWIDTH        64      /* number of bins across screen */
        !            13: #define        HASHMASK        (YMAX/BINWIDTH-1)
        !            14: #define        HASHSHIFT       4       /* log2(HASHMASK+1) */
        !            15: long   *bitarray;
        !            16: char rock0[]={
        !            17:        'R',    -50,    -50,    50,     50,
        !            18:        'm', 11, -50,
        !            19:        'l', 29, -30,
        !            20:        'l', 24, -7,
        !            21:        'l', 49, 20,
        !            22:        'l', 29, 44,
        !            23:        'l', -24, 44,
        !            24:        'l', -48, 13,
        !            25:        'l', -40, 0,
        !            26:        'l', -50, -21,
        !            27:        'l', -41, -36,
        !            28:        'l', 11, -50,
        !            29:        0
        !            30: };
        !            31: char rock1[]={
        !            32:        'R', -30, -30, 32, 32,
        !            33:        'm', 2, -30,
        !            34:        'l', 30, -10,
        !            35:        'l', 10, 30,
        !            36:        'l', -10, 30,
        !            37:        'l', -21, 9,
        !            38:        'l', -10, -20,
        !            39:        'l', 2, -30,
        !            40:        0
        !            41: };
        !            42: char rock2[]={
        !            43:        'R', -15, -15, 15, 15,
        !            44:        'm', 4, -11,
        !            45:        'l', 6, -4,
        !            46:        'l', 15, 5,
        !            47:        'l', 1, 13,
        !            48:        'l', -15, -4,
        !            49:        'l', -4, -11,
        !            50:        'l', 4, -11,
        !            51:        0
        !            52: };
        !            53: char *rockim[]={
        !            54:        rock0, rock1, rock2
        !            55: };
        !            56: #define        NROCKIMAGES     ((sizeof rockim)/(sizeof (char *)))
        !            57: Bitmap *rockseq[NROCKIMAGES];
        !            58: initrock(n)
        !            59: {
        !            60:        register i;
        !            61:        register size;
        !            62: 
        !            63:        size = ((YMAX/BINWIDTH)*(YMAX/BINWIDTH));
        !            64:        if (!bitarray)
        !            65:                bitarray = (long *)malloc(size * sizeof(long));
        !            66:        for(i=0; i<size; i++)
        !            67:                bitarray[i]=0;
        !            68:        allocated=0;
        !            69:        for(i=0; i<NROCK; i++)
        !            70:                rock[i].hash= -1;
        !            71:        for(i=0; i<NROCKIMAGES; i++)
        !            72:                rockseq[i]=buildimage(rockim[i]);
        !            73:        for(i=0; i<n; i++)      /* start with 6 rocks */
        !            74:                (void)spawn();
        !            75: }
        !            76: spawn()
        !            77: {
        !            78:        Point x, v;
        !            79:        register i;
        !            80:        if(rnd(100)>=50){
        !            81:                x.x=0;
        !            82:                x.y=rnd(YMAX);
        !            83:        }else{
        !            84:                x.x=rnd(Drect.corner.x);
        !            85:                x.y=0;
        !            86:        }
        !            87:        do                              /* 0 velocities are dull */
        !            88:                v.x=V-rnd(2*V);
        !            89:        while(v.x==0);
        !            90:        do
        !            91:                v.y=V-rnd(2*V);
        !            92:        while(v.y==0);
        !            93:        newrock(x, v, 0);
        !            94:        return 1;
        !            95: }
        !            96: rockfree()
        !            97: {
        !            98:        register i;
        !            99:        for(i=0; i<NROCKIMAGES; i++)
        !           100:                bfree(rockseq[i]);
        !           101: }
        !           102: newrock(x, v, im)
        !           103:        Point x, v;
        !           104:        int im;
        !           105: {
        !           106:        register long i;
        !           107:        register Rock *r;
        !           108:        for(i=1; i && (allocated&i); i<<=1)
        !           109:                ;
        !           110:        if(i==0 || im>=NROCKIMAGES)
        !           111:                return;
        !           112:        allocated |= i;
        !           113:        r= &rock[bittoindex(i)];
        !           114:        r->x=x;
        !           115:        r->v=v;
        !           116:        r->r=rockim[im][3];     /* It's true! */
        !           117:        r->i=im;
        !           118:        r->hash=hash(r->x);
        !           119:        draw(r);
        !           120:        addbits(i, r->hash);
        !           121: }
        !           122: draw(r)
        !           123:        register Rock *r;
        !           124: {
        !           125:        register Bitmap *b=rockseq[r->i];
        !           126:        bitblt(b, b->rect, &display, add(transform(r->x), b->rect.origin), F_XOR);
        !           127: }
        !           128: addbits(bits, h)
        !           129:        register long bits;
        !           130:        register h;
        !           131: {
        !           132:        register long *lp= &bitarray[h];
        !           133:        register x=h&HASHMASK;
        !           134:        register y=(h>>HASHSHIFT)&HASHMASK;
        !           135:        int xlo=0, ylo=0, xhi=0, yhi=0;
        !           136:        if(x==0)
        !           137:                xlo=1;
        !           138:        if(y==0)
        !           139:                ylo=1;
        !           140:        if(x==HASHMASK)
        !           141:                xhi=1;
        !           142:        if(y==HASHMASK)
        !           143:                yhi=1;
        !           144:        lp[0]|=bits;
        !           145:        if(!xlo){
        !           146:                lp[-1]|=bits;
        !           147:                if(!ylo)
        !           148:                        lp[-YMAX/BINWIDTH-1]|=bits;
        !           149:                if(!yhi)
        !           150:                        lp[YMAX/BINWIDTH-1]|=bits;
        !           151:        }
        !           152:        if(!ylo)
        !           153:                lp[-YMAX/BINWIDTH]|=bits;
        !           154:        if(!yhi)
        !           155:                lp[YMAX/BINWIDTH]|=bits;
        !           156:        if(!xhi){
        !           157:                lp[1]|=bits;
        !           158:                if(!ylo)
        !           159:                        lp[-YMAX/BINWIDTH+1]|=bits;
        !           160:                if(!yhi)
        !           161:                        lp[YMAX/BINWIDTH+1]|=bits;
        !           162:        }
        !           163: }
        !           164: subbits(bits, h)
        !           165:        register long bits;
        !           166:        register h;
        !           167: {
        !           168:        register long *lp= &bitarray[h];
        !           169:        register x=h&HASHMASK;
        !           170:        register y=(h>>HASHSHIFT)&HASHMASK;
        !           171:        int xlo=0, ylo=0, xhi=0, yhi=0;
        !           172:        if(x==0)
        !           173:                xlo=1;
        !           174:        if(y==0)
        !           175:                ylo=1;
        !           176:        if(x==HASHMASK)
        !           177:                xhi=1;
        !           178:        if(y==HASHMASK)
        !           179:                yhi=1;
        !           180:        bits= ~bits;
        !           181:        lp[0]&=bits;
        !           182:        if(!xlo){
        !           183:                lp[-1]&=bits;
        !           184:                if(!ylo)
        !           185:                        lp[-YMAX/BINWIDTH-1]&=bits;
        !           186:                if(!yhi)
        !           187:                        lp[YMAX/BINWIDTH-1]&=bits;
        !           188:        }
        !           189:        if(!ylo)
        !           190:                lp[-YMAX/BINWIDTH]&=bits;
        !           191:        if(!yhi)
        !           192:                lp[YMAX/BINWIDTH]&=bits;
        !           193:        if(!xhi){
        !           194:                lp[1]&=bits;
        !           195:                if(!ylo)
        !           196:                        lp[-YMAX/BINWIDTH+1]&=bits;
        !           197:                if(!yhi)
        !           198:                        lp[YMAX/BINWIDTH+1]&=bits;
        !           199:        }
        !           200: }
        !           201: bittoindex(i)
        !           202:        register long i;
        !           203: {
        !           204:        register j;
        !           205:        register long b;
        !           206:        for(j=0, b=1; (b&i)==0; b<<=1, j++)
        !           207:                ;
        !           208:        return j;
        !           209: }
        !           210: hash(p)
        !           211:        Point p;
        !           212: {
        !           213:        return (p.x/BINWIDTH)|(((unsigned)p.y/BINWIDTH)<<HASHSHIFT);
        !           214: }
        !           215: Rock *
        !           216: collision(p, hashv, rad)
        !           217:        Point p;
        !           218: {
        !           219:        register long bits, b;
        !           220:        register i;
        !           221:        bits=bitarray[hashv];
        !           222:        for(i=0, b=1; i<NROCK; i++, b<<=1)
        !           223:                if(bits&b){     /* There is a nearby rock */
        !           224:                        register Rock *r= &rock[i];
        !           225:                        Point pp;
        !           226:                        pp=r->x;
        !           227:                        pp.x-=p.x;
        !           228:                        pp.y-=p.y;
        !           229:                        if(pp.x*pp.x + pp.y*pp.y < 
        !           230:                                rad*rad + r->r*r->r)
        !           231:                                return &rock[i];
        !           232:                }
        !           233:        return 0;
        !           234: }
        !           235: moverock()
        !           236: {
        !           237:        static rocknum=0;
        !           238:        register Rock *r= &rock[rocknum];
        !           239:        register hsh=r->hash;
        !           240:        if(hsh==-1){
        !           241:                notdrawn++;
        !           242:                goto Return;
        !           243:        }
        !           244:        draw(r);
        !           245:        r->x=add(r->x, r->v);
        !           246:        onscreen(&r->x);
        !           247:        draw(r);
        !           248:        r->hash=hash(r->x);
        !           249:        if(r->hash != hsh){
        !           250:                subbits(1L<<rocknum, hsh);
        !           251:                addbits(1L<<rocknum, r->hash);
        !           252:        }
        !           253:        batcomp(r);
        !           254:    Return:
        !           255:        if(++rocknum >= NROCK)
        !           256:                rocknum=0;
        !           257: }
        !           258: split(r)
        !           259:        register Rock *r;
        !           260: {
        !           261:        register i=r->i+1;
        !           262:        newrock(r->x, add(r->v, Pt(DV-rnd(2*DV), DV-rnd(2*DV))), i);
        !           263:        newrock(r->x, add(r->v, Pt(DV-rnd(2*DV), DV-rnd(2*DV))), i);
        !           264: }
        !           265: char killvalue[]={
        !           266:        1, 2, 5
        !           267: };
        !           268: killrock(r)
        !           269:        register Rock *r;
        !           270: {
        !           271:        extern score;
        !           272:        register long b=1L<<(r-rock);
        !           273:        allocated&=~b;
        !           274:        subbits(b, r->hash);
        !           275:        r->hash= -1;
        !           276:        score+=killvalue[r->i];
        !           277:        draw(r);
        !           278: }

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