![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / demo / asteroids|
Return to rock.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / demo / asteroids |
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.