WebSVN – planix.SVN – Blame – /os/branches/planix-v0/sys/src/games/xs.c

Rev	Author	Line No.	Line
2	-	1	`#include "xs.h"`
		2
		3	`/*`
		4	`* engine for 4s, 5s, etc`
		5	`*/`
		6
		7	`Cursor whitearrow = {`
		8	`{0, 0},`
		9	`{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,`
		10	`0xFF, 0xF0, 0xFF, 0xF0, 0xFF, 0xF8, 0xFF, 0xFC,`
		11	`0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,`
		12	`0xF3, 0xF8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, },`
		13	`{0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0xC0, 0x1C,`
		14	`0xC0, 0x30, 0xC0, 0x30, 0xC0, 0x38, 0xC0, 0x1C,`
		15	`0xC0, 0x0E, 0xC0, 0x07, 0xCE, 0x0E, 0xDF, 0x1C,`
		16	`0xD3, 0xB8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, }`
		17	`};`
		18
		19	`enum`
		20	`{`
		21	`CNone = 0,`
		22	`CBounds = 1,`
		23	`CPiece = 2,`
		24	`NX = 10,`
		25	`NY = 20,`
		26	`};`
		27
		28	`enum{`
		29	`TIMER,`
		30	`MOUSE,`
		31	`RESHAPE,`
		32	`KBD,`
		33	`SUSPEND,`
		34	`NALT`
		35	`};`
		36
		37	`char board[NY][NX];`
		38	`Rectangle rboard;`
		39	`Point pscore;`
		40	`Point scoresz;`
		41	`int pcsz = 32;`
		42	`Point pos;`
		43	`Image bb, bbmask, bb2, bb2mask;`
		44	`Image *whitemask;`
		45	`Rectangle br, br2;`
		46	`long points;`
		47	`int dt;`
		48	`int DY;`
		49	`int DMOUSE;`
		50	`int lastmx;`
		51	`Mouse mouse;`
		52	`int newscreen;`
		53	`Channel *timerc;`
		54	`Channel *suspc;`
		55	`Channel *mousec;`
		56	`Channel *kbdc;`
		57	`Mousectl *mousectl;`
		58	`Keyboardctl *kbdctl;`
		59	`int suspended;`
		60
		61	`void redraw(int);`
		62
		63	`int tsleep;`
		64
		65	`Piece *piece;`
		66
		67	`#define NCOL 10`
		68
		69	`uchar txbits[NCOL][32]={`
		70	`{0xDD,0xDD,0xFF,0xFF,0x77,0x77,0xFF,0xFF,`
		71	`0xDD,0xDD,0xFF,0xFF,0x77,0x77,0xFF,0xFF,`
		72	`0xDD,0xDD,0xFF,0xFF,0x77,0x77,0xFF,0xFF,`
		73	`0xDD,0xDD,0xFF,0xFF,0x77,0x77,0xFF,0xFF},`
		74	`{0xDD,0xDD,0x77,0x77,0xDD,0xDD,0x77,0x77,`
		75	`0xDD,0xDD,0x77,0x77,0xDD,0xDD,0x77,0x77,`
		76	`0xDD,0xDD,0x77,0x77,0xDD,0xDD,0x77,0x77,`
		77	`0xDD,0xDD,0x77,0x77,0xDD,0xDD,0x77,0x77},`
		78	`{0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,`
		79	`0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,`
		80	`0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,`
		81	`0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55},`
		82	`{0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,`
		83	`0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,`
		84	`0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,`
		85	`0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55},`
		86	`{0x22,0x22,0x88,0x88,0x22,0x22,0x88,0x88,`
		87	`0x22,0x22,0x88,0x88,0x22,0x22,0x88,0x88,`
		88	`0x22,0x22,0x88,0x88,0x22,0x22,0x88,0x88,`
		89	`0x22,0x22,0x88,0x88,0x22,0x22,0x88,0x88},`
		90	`{0x22,0x22,0x00,0x00,0x88,0x88,0x00,0x00,`
		91	`0x22,0x22,0x00,0x00,0x88,0x88,0x00,0x00,`
		92	`0x22,0x22,0x00,0x00,0x88,0x88,0x00,0x00,`
		93	`0x22,0x22,0x00,0x00,0x88,0x88,0x00,0x00},`
		94	`{0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,`
		95	`0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,`
		96	`0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,`
		97	`0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00},`
		98	`{0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,`
		99	`0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,`
		100	`0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,`
		101	`0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00},`
		102	`{0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,`
		103	`0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,`
		104	`0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,`
		105	`0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC},`
		106	`{0xCC,0xCC,0xCC,0xCC,0x33,0x33,0x33,0x33,`
		107	`0xCC,0xCC,0xCC,0xCC,0x33,0x33,0x33,0x33,`
		108	`0xCC,0xCC,0xCC,0xCC,0x33,0x33,0x33,0x33,`
		109	`0xCC,0xCC,0xCC,0xCC,0x33,0x33,0x33,0x33},`
		110	`};`
		111
		112	`int txpix[NCOL] = {`
		113	`DYellow, /* yellow */`
		114	`DCyan, /* cyan */`
		115	`DGreen, /* lime green */`
		116	`DGreyblue, /* slate */`
		117	`DRed, /* red */`
		118	`DGreygreen, /* olive green */`
		119	`DBlue, /* blue */`
		120	`0xFF55AAFF, /* pink */`
		121	`0xFFAAFFFF, /* lavender */`
		122	`0xBB005DFF, /* maroon */`
		123	`};`
		124
		125	`Image *tx[NCOL];`
		126
		127	`int`
		128	`movemouse(void)`
		129	`{`
		130	`mouse.xy = Pt(rboard.min.x + Dx(rboard)/2, rboard.min.y +Dy(rboard)/2);`
		131	`moveto(mousectl, mouse.xy);`
		132	`return mouse.xy.x;`
		133	`}`
		134
		135	`int`
		136	`warp(Point p, int x)`
		137	`{`
		138	`if (!suspended && piece != nil) {`
		139	`x = pos.x + piece->sz.x*pcsz/2;`
		140	`if (p.y < rboard.min.y)`
		141	`p.y = rboard.min.y;`
		142	`if (p.y >= rboard.max.y)`
		143	`p.y = rboard.max.y - 1;`
		144	`moveto(mousectl, Pt(x, p.y));`
		145	`}`
		146	`return x;`
		147	`}`
		148
		149	`Piece *`
		150	`rotr(Piece *p)`
		151	`{`
		152	`if(p->rot == 3)`
		153	`return p-3;`
		154	`return p+1;`
		155	`}`
		156
		157	`Piece *`
		158	`rotl(Piece *p)`
		159	`{`
		160	`if(p->rot == 0)`
		161	`return p+3;`
		162	`return p-1;`
		163	`}`
		164
		165	`int`
		166	`collide(Point pt, Piece *p)`
		167	`{`
		168	`int i;`
		169	`int c = CNone;`
		170
		171	`pt.x = (pt.x - rboard.min.x) / pcsz;`
		172	`pt.y = (pt.y - rboard.min.y) / pcsz;`
		173	`for(i=0; i<N; i++){`
		174	`pt.x += p->d[i].x;`
		175	`pt.y += p->d[i].y;`
		176	`if(pt.x<0 \|\| pt.x>=NX \|\| pt.y<0 \|\| pt.y>=NY)`
		177	`c \|= CBounds;`
		178	`if(board[pt.y][pt.x])`
		179	`c \|= CPiece;`
		180	`}`
		181	`return c;`
		182	`}`
		183
		184	`int`
		185	`collider(Point pt, Point pmax)`
		186	`{`
		187	`int i, j, pi, pj, n, m;`
		188
		189	`pi = (pt.x - rboard.min.x) / pcsz;`
		190	`pj = (pt.y - rboard.min.y) / pcsz;`
		191	`n = pmax.x / pcsz;`
		192	`m = pmax.y / pcsz + 1;`
		193	`for(i = pi; i < pi+n && i < NX; i++)`
		194	`for(j = pj; j < pj+m && j < NY; j++)`
		195	`if(board[j][i])`
		196	`return 1;`
		197	`return 0;`
		198	`}`
		199
		200	`void`
		201	`setpiece(Piece *p){`
		202	`int i;`
		203	`Rectangle r, r2;`
		204	`Point op, delta;`
		205
		206	`draw(bb, bb->r, display->white, nil, ZP);`
		207	`draw(bbmask, bbmask->r, display->transparent, nil, ZP);`
		208	`br = Rect(0, 0, 0, 0);`
		209	`br2 = br;`
		210	`piece = p;`
		211	`if(p == 0)`
		212	`return;`
		213	`r.min = bb->r.min;`
		214	`for(i=0; i<N; i++){`
		215	`r.min.x += p->d[i].x*pcsz;`
		216	`r.min.y += p->d[i].y*pcsz;`
		217	`r.max.x = r.min.x + pcsz;`
		218	`r.max.y = r.min.y + pcsz;`
		219	`if(i == 0){`
		220	`draw(bb, r, display->black, nil, ZP);`
		221	`draw(bb, insetrect(r, 1), tx[piece->tx], nil, ZP);`
		222	`draw(bbmask, r, display->opaque, nil, ZP);`
		223	`op = r.min;`
		224	`}else{`
		225	`draw(bb, r, bb, nil, op);`
		226	`draw(bbmask, r, bbmask, nil, op);`
		227	`}`
		228	`if(br.max.x < r.max.x)`
		229	`br.max.x = r.max.x;`
		230	`if(br.max.y < r.max.y)`
		231	`br.max.y = r.max.y;`
		232	`}`
		233	`br.max = subpt(br.max, bb->r.min);`
		234	`delta = Pt(0,DY);`
		235	`br2.max = addpt(br.max, delta);`
		236	`r = rectaddpt(br, bb2->r.min);`
		237	`r2 = rectaddpt(br2, bb2->r.min);`
		238	`draw(bb2, r2, display->white, nil, ZP);`
		239	`draw(bb2, rectaddpt(r,delta), bb, nil, bb->r.min);`
		240	`draw(bb2mask, r2, display->transparent, nil, ZP);`
		241	`draw(bb2mask, r, display->opaque, bbmask, bb->r.min);`
		242	`draw(bb2mask, rectaddpt(r,delta), display->opaque, bbmask, bb->r.min);`
		243	`}`
		244
		245	`void`
		246	`drawpiece(void){`
		247	`draw(screen, rectaddpt(br, pos), bb, bbmask, bb->r.min);`
		248	`if (suspended)`
		249	`draw(screen, rectaddpt(br, pos), display->white, whitemask, ZP);`
		250	`}`
		251
		252	`void`
		253	`undrawpiece(void)`
		254	`{`
		255	`Image *mask = nil;`
		256	`if(collider(pos, br.max))`
		257	`mask = bbmask;`
		258	`draw(screen, rectaddpt(br, pos), display->white, mask, bb->r.min);`
		259	`}`
		260
		261	`void`
		262	`rest(void)`
		263	`{`
		264	`int i;`
		265	`Point pt;`
		266
		267	`pt = divpt(subpt(pos, rboard.min), pcsz);`
		268	`for(i=0; i<N; i++){`
		269	`pt.x += piece->d[i].x;`
		270	`pt.y += piece->d[i].y;`
		271	`board[pt.y][pt.x] = piece->tx+16;`
		272	`}`
		273	`}`
		274
		275	`int`
		276	`canfit(Piece *p)`
		277	`{`
		278	`static int dx[]={0, -1, 1, -2, 2, -3, 3, 4, -4};`
		279	`int i, j;`
		280	`Point z;`
		281
		282	`j = N + 1;`
		283	`if(j >= 4){`
		284	`j = p->sz.x;`
		285	`if(j<p->sz.y)`
		286	`j = p->sz.y;`
		287	`j = 2*j-1;`
		288	`}`
		289	`for(i=0; i<j; i++){`
		290	`z.x = pos.x + dx[i]*pcsz;`
		291	`z.y = pos.y;`
		292	`if(!collide(z, p)){`
		293	`z.y = pos.y + pcsz-1;`
		294	`if(!collide(z, p)){`
		295	`undrawpiece();`
		296	`pos.x = z.x;`
		297	`return 1;`
		298	`}`
		299	`}`
		300	`}`
		301	`return 0;`
		302	`}`
		303
		304	`void`
		305	`score(int p)`
		306	`{`
		307	`char buf[128];`
		308
		309	`points += p;`
		310	`snprint(buf, sizeof(buf), "%.6ld", points);`
		311	`draw(screen, Rpt(pscore, addpt(pscore, scoresz)), display->white, nil, ZP);`
		312	`string(screen, pscore, display->black, ZP, font, buf);`
		313	`}`
		314
		315	`void`
		316	`drawsq(Image *b, Point p, int ptx){`
		317	`Rectangle r;`
		318
		319	`r.min = p;`
		320	`r.max.x = r.min.x+pcsz;`
		321	`r.max.y = r.min.y+pcsz;`
		322	`draw(b, r, display->black, nil, ZP);`
		323	`draw(b, insetrect(r, 1), tx[ptx], nil, ZP);`
		324	`}`
		325
		326	`void`
		327	`drawboard(void)`
		328	`{`
		329	`int i, j;`
		330
		331	`border(screen, insetrect(rboard, -2), 2, display->black, ZP);`
		332	`draw(screen, Rect(rboard.min.x, rboard.min.y-2, rboard.max.x, rboard.min.y),`
		333	`display->white, nil, ZP);`
		334	`for(i=0; i<NY; i++)`
		335	`for(j=0; j<NX; j++)`
		336	`if(board[i][j])`
		337	`drawsq(screen, Pt(rboard.min.x+jpcsz, rboard.min.y+ipcsz), board[i][j]-16);`
		338	`score(0);`
		339	`if (suspended)`
		340	`draw(screen, screen->r, display->white, whitemask, ZP);`
		341	`}`
		342
		343	`void`
		344	`choosepiece(void)`
		345	`{`
		346	`int i;`
		347
		348	`do{`
		349	`i = nrand(NP);`
		350	`setpiece(&pieces[i]);`
		351	`pos = rboard.min;`
		352	`pos.x += nrand(NX)*pcsz;`
		353	`}while(collide(Pt(pos.x, pos.y+pcsz-DY), piece));`
		354	`drawpiece();`
		355	`flushimage(display, 1);`
		356	`}`
		357
		358	`int`
		359	`movepiece(void)`
		360	`{`
		361	`Image *mask = nil;`
		362
		363	`if(collide(Pt(pos.x, pos.y+pcsz), piece))`
		364	`return 0;`
		365	`if(collider(pos, br2.max))`
		366	`mask = bb2mask;`
		367	`draw(screen, rectaddpt(br2, pos), bb2, mask, bb2->r.min);`
		368	`pos.y += DY;`
		369	`flushimage(display, 1);`
		370	`return 1;`
		371	`}`
		372
		373	`void`
		374	`suspend(int s)`
		375	`{`
		376	`suspended = s;`
		377	`if (suspended)`
		378	`setcursor(mousectl, &whitearrow);`
		379	`else`
		380	`setcursor(mousectl, nil);`
		381	`if (!suspended)`
		382	`drawpiece();`
		383	`drawboard();`
		384	`flushimage(display, 1);`
		385	`}`
		386
		387	`void`
		388	`pause(int t)`
		389	`{`
		390	`int s;`
		391	`Alt alts[NALT+1];`
		392
		393	`alts[TIMER].c = timerc;`
		394	`alts[TIMER].v = nil;`
		395	`alts[TIMER].op = CHANRCV;`
		396	`alts[SUSPEND].c = suspc;`
		397	`alts[SUSPEND].v = &s;`
		398	`alts[SUSPEND].op = CHANRCV;`
		399	`alts[RESHAPE].c = mousectl->resizec;`
		400	`alts[RESHAPE].v = nil;`
		401	`alts[RESHAPE].op = CHANRCV;`
		402	`// avoid hanging up those writing ong mousec and kbdc`
		403	`// so just accept it all and keep mouse up-to-date`
		404	`alts[MOUSE].c = mousec;`
		405	`alts[MOUSE].v = &mouse;`
		406	`alts[MOUSE].op = CHANRCV;`
		407	`alts[KBD].c = kbdc;`
		408	`alts[KBD].v = nil;`
		409	`alts[KBD].op = CHANRCV;`
		410	`alts[NALT].op = CHANEND;`
		411
		412	`flushimage(display, 1);`
		413	`for(;;)`
		414	`switch(alt(alts)){`
		415	`case SUSPEND:`
		416	`if (!suspended && s) {`
		417	`suspend(1);`
		418	`} else if (suspended && !s) {`
		419	`suspend(0);`
		420	`lastmx = warp(mouse.xy, lastmx);`
		421	`}`
		422	`break;`
		423	`case TIMER:`
		424	`if(suspended)`
		425	`break;`
		426	`if((t -= tsleep) < 0)`
		427	`return;`
		428	`break;`
		429	`case RESHAPE:`
		430	`redraw(1);`
		431	`break;`
		432	`}`
		433	`}`
		434
		435	`int`
		436	`horiz(void)`
		437	`{`
		438	`int lev[MAXN];`
		439	`int i, j, h;`
		440	`Rectangle r;`
		441
		442	`h = 0;`
		443	`for(i=0; i<NY; i++){`
		444	`for(j=0; board[i][j]; j++)`
		445	`if(j == NX-1){`
		446	`lev[h++] = i;`
		447	`break;`
		448	`}`
		449	`}`
		450	`if(h == 0)`
		451	`return 0;`
		452	`r = rboard;`
		453	`newscreen = 0;`
		454	`for(j=0; j<h; j++){`
		455	`r.min.y = rboard.min.y + lev[j]*pcsz;`
		456	`r.max.y = r.min.y + pcsz;`
		457	`draw(screen, r, display->white, whitemask, ZP);`
		458	`flushimage(display, 1);`
		459	`}`
		460	`for(i=0; i<3; i++){`
		461	`pause(250);`
		462	`if(newscreen){`
		463	`drawboard();`
		464	`break;`
		465	`}`
		466	`for(j=0; j<h; j++){`
		467	`r.min.y = rboard.min.y + lev[j]*pcsz;`
		468	`r.max.y = r.min.y + pcsz;`
		469	`draw(screen, r, display->white, whitemask, ZP);`
		470	`}`
		471	`flushimage(display, 1);`
		472	`}`
		473	`r = rboard;`
		474	`for(j=0; j<h; j++){`
		475	`i = NY - lev[j] - 1;`
		476	`score(250+10ii);`
		477	`r.min.y = rboard.min.y;`
		478	`r.max.y = rboard.min.y+lev[j]*pcsz;`
		479	`draw(screen, rectaddpt(r, Pt(0,pcsz)), screen, nil, r.min);`
		480	`r.max.y = rboard.min.y+pcsz;`
		481	`draw(screen, r, display->white, nil, ZP);`
		482	`memcpy(&board[1][0], &board[0][0], NX*lev[j]);`
		483	`memset(&board[0][0], 0, NX);`
		484	`}`
		485	`flushimage(display, 1);`
		486	`return 1;`
		487	`}`
		488
		489	`void`
		490	`mright(void)`
		491	`{`
		492	`if(!collide(Pt(pos.x+pcsz, pos.y), piece))`
		493	`if(!collide(Pt(pos.x+pcsz, pos.y+pcsz-DY), piece)){`
		494	`undrawpiece();`
		495	`pos.x += pcsz;`
		496	`drawpiece();`
		497	`flushimage(display, 1);`
		498	`}`
		499	`}`
		500
		501	`void`
		502	`mleft(void)`
		503	`{`
		504	`if(!collide(Pt(pos.x-pcsz, pos.y), piece))`
		505	`if(!collide(Pt(pos.x-pcsz, pos.y+pcsz-DY), piece)){`
		506	`undrawpiece();`
		507	`pos.x -= pcsz;`
		508	`drawpiece();`
		509	`flushimage(display, 1);`
		510	`}`
		511	`}`
		512
		513	`void`
		514	`rright(void)`
		515	`{`
		516	`if(canfit(rotr(piece))){`
		517	`setpiece(rotr(piece));`
		518	`drawpiece();`
		519	`flushimage(display, 1);`
		520	`}`
		521	`}`
		522
		523	`void`
		524	`rleft(void)`
		525	`{`
		526	`if(canfit(rotl(piece))){`
		527	`setpiece(rotl(piece));`
		528	`drawpiece();`
		529	`flushimage(display, 1);`
		530	`}`
		531	`}`
		532
		533	`int fusst = 0;`
		534	`int`
		535	`drop(int f)`
		536	`{`
		537	`if(f){`
		538	`score(5L*(rboard.max.y-pos.y)/pcsz);`
		539	`do; while(movepiece());`
		540	`}`
		541	`fusst = 0;`
		542	`rest();`
		543	`if(pos.y==rboard.min.y && !horiz())`
		544	`return 1;`
		545	`horiz();`
		546	`setpiece(0);`
		547	`pause(1500);`
		548	`choosepiece();`
		549	`lastmx = warp(mouse.xy, lastmx);`
		550	`return 0;`
		551	`}`
		552
		553	`int`
		554	`play(void)`
		555	`{`
		556	`int i;`
		557	`Mouse om;`
		558	`int s;`
		559	`Rune r;`
		560	`Alt alts[NALT+1];`
		561
		562	`alts[TIMER].c = timerc;`
		563	`alts[TIMER].v = nil;`
		564	`alts[TIMER].op = CHANRCV;`
		565	`alts[MOUSE].c = mousec;`
		566	`alts[MOUSE].v = &mouse;`
		567	`alts[MOUSE].op = CHANRCV;`
		568	`alts[SUSPEND].c = suspc;`
		569	`alts[SUSPEND].v = &s;`
		570	`alts[SUSPEND].op = CHANRCV;`
		571	`alts[RESHAPE].c = mousectl->resizec;`
		572	`alts[RESHAPE].v = nil;`
		573	`alts[RESHAPE].op = CHANRCV;`
		574	`alts[KBD].c = kbdc;`
		575	`alts[KBD].v = &r;`
		576	`alts[KBD].op = CHANRCV;`
		577	`alts[NALT].op = CHANEND;`
		578
		579	`dt = 64;`
		580	`lastmx = -1;`
		581	`lastmx = movemouse();`
		582	`choosepiece();`
		583	`lastmx = warp(mouse.xy, lastmx);`
		584	`for(;;)`
		585	`switch(alt(alts)){`
		586	`case MOUSE:`
		587	`if(suspended) {`
		588	`om = mouse;`
		589	`break;`
		590	`}`
		591	`if(lastmx < 0)`
		592	`lastmx = mouse.xy.x;`
		593	`if(mouse.xy.x > lastmx+DMOUSE){`
		594	`mright();`
		595	`lastmx = mouse.xy.x;`
		596	`}`
		597	`if(mouse.xy.x < lastmx-DMOUSE){`
		598	`mleft();`
		599	`lastmx = mouse.xy.x;`
		600	`}`
		601	`if(mouse.buttons&1 && !(om.buttons&1))`
		602	`rleft();`
		603	`if(mouse.buttons&2 && !(om.buttons&2))`
		604	`if(drop(1))`
		605	`return 1;`
		606	`if(mouse.buttons&4 && !(om.buttons&4))`
		607	`rright();`
		608	`om = mouse;`
		609	`break;`
		610	`case SUSPEND:`
		611	`if (!suspended && s)`
		612	`suspend(1);`
		613	`else`
		614	`if (suspended && !s) {`
		615	`suspend(0);`
		616	`lastmx = warp(mouse.xy, lastmx);`
		617	`}`
		618	`break;`
		619	`case RESHAPE:`
		620	`redraw(1);`
		621	`break;`
		622	`case KBD:`
		623	`if(suspended)`
		624	`break;`
		625	`switch(r){`
		626	`case 'f':`
		627	`case ';':`
		628	`mright();`
		629	`break;`
		630	`case 'a':`
		631	`case 'j':`
		632	`mleft();`
		633	`break;`
		634	`case 'd':`
		635	`case 'l':`
		636	`rright();`
		637	`break;`
		638	`case 's':`
		639	`case 'k':`
		640	`rleft();`
		641	`break;`
		642	`case ' ':`
		643	`if(drop(1))`
		644	`return 1;`
		645	`break;`
		646	`}`
		647	`break;`
		648	`case TIMER:`
		649	`if(suspended)`
		650	`break;`
		651	`dt -= tsleep;`
		652	`if(dt < 0){`
		653	`i = 1;`
		654	`dt = 16 * (points+nrand(10000)-5000) / 10000;`
		655	`if(dt >= 32){`
		656	`i += (dt-32)/16;`
		657	`dt = 32;`
		658	`}`
		659	`dt = 52-dt;`
		660	`while(i-- > 0)`
		661	`if(movepiece()==0 && ++fusst==40){`
		662	`if(drop(0))`
		663	`return 1;`
		664	`break;`
		665	`}`
		666	`}`
		667	`break;`
		668	`}`
		669	`}`
		670
		671	`void`
		672	`setparms(void)`
		673	`{`
		674	`char buf[32];`
		675	`int fd, n;`
		676
		677	`tsleep = 50;`
		678	`fd = open("/dev/hz", OREAD);`
		679	`if(fd < 0)`
		680	`return;`
		681	`n = read(fd, buf, sizeof buf - 1);`
		682	`close(fd);`
		683	`if(n < 0)`
		684	`return;`
		685	`buf[n] = '\0';`
		686	`tsleep = strtoul(buf, 0, 10);`
		687	`tsleep = (1000 + tsleep - 1) / tsleep;`
		688	`}`
		689
		690	`void`
		691	`timerproc(void *v)`
		692	`{`
		693	`Channel *c;`
		694	`void **arg;`
		695
		696	`arg = v;`
		697	`c = (Channel*)arg;`
		698
		699	`for(;;){`
		700	`sleep(tsleep);`
		701	`send(c, nil);`
		702	`}`
		703	`}`
		704
		705	`void`
		706	`suspproc(void *)`
		707	`{`
		708	`Mouse mouse;`
		709	`Rune r;`
		710	`int s;`
		711	`Alt alts[NALT+1];`
		712
		713	`alts[TIMER].op = CHANNOP;`
		714	`alts[MOUSE].c = mousectl->c;`
		715	`alts[MOUSE].v = &mouse;`
		716	`alts[MOUSE].op = CHANRCV;`
		717	`alts[SUSPEND].op = CHANNOP;`
		718	`alts[RESHAPE].op = CHANNOP;`
		719	`alts[KBD].c = kbdctl->c;`
		720	`alts[KBD].v = &r;`
		721	`alts[KBD].op = CHANRCV;`
		722	`alts[NALT].op = CHANEND;`
		723
		724	`s = 0;`
		725	`for(;;)`
		726	`switch(alt(alts)){`
		727	`case MOUSE:`
		728	`send(mousec, &mouse);`
		729	`break;`
		730	`case KBD:`
		731	`switch(r){`
		732	`case 'q':`
		733	`case 'Q':`
		734	`case 0x04:`
		735	`case 0x7F:`
		736	`threadexitsall(nil);`
		737	`default:`
		738	`if(s) {`
		739	`s = 0;`
		740	`send(suspc, &s);`
		741	`} else`
		742	`switch(r){`
		743	`case 'z':`
		744	`case 'Z':`
		745	`case 'p':`
		746	`case 'P':`
		747	`case 0x1B:`
		748	`s = 1;`
		749	`send(suspc, &s);`
		750	`break;`
		751	`default:`
		752	`send(kbdc, &r);`
		753	`}`
		754	`break;`
		755	`}`
		756	`}`
		757	`}`
		758
		759	`void`
		760	`redraw(int new)`
		761	`{`
		762	`Rectangle r;`
		763	`long dx, dy;`
		764
		765	`if(new && getwindow(display, Refmesg) < 0)`
		766	`sysfatal("can't reattach to window");`
		767	`r = screen->r;`
		768	`pos.x = (pos.x - rboard.min.x) / pcsz;`
		769	`pos.y = (pos.y - rboard.min.y) / pcsz;`
		770	`dx = r.max.x - r.min.x;`
		771	`dy = r.max.y - r.min.y - 2*32;`
		772	`DY = dx / NX;`
		773	`if(DY > dy / NY)`
		774	`DY = dy / NY;`
		775	`DY /= 8;`
		776	`if(DY > 4)`
		777	`DY = 4;`
		778	`pcsz = DY*8;`
		779	`DMOUSE = pcsz/3;`
		780	`if(pcsz < 8)`
		781	`sysfatal("screen too small: %d", pcsz);`
		782	`rboard = screen->r;`
		783	`rboard.min.x += (dx-pcsz*NX)/2;`
		784	`rboard.min.y += (dy-pcsz*NY)/2+32;`
		785	`rboard.max.x = rboard.min.x+NX*pcsz;`
		786	`rboard.max.y = rboard.min.y+NY*pcsz;`
		787	`pscore.x = rboard.min.x+8;`
		788	`pscore.y = rboard.min.y-32;`
		789	`scoresz = stringsize(font, "000000");`
		790	`pos.x = pos.x*pcsz + rboard.min.x;`
		791	`pos.y = pos.y*pcsz + rboard.min.y;`
		792	`if(bb){`
		793	`freeimage(bb);`
		794	`freeimage(bbmask);`
		795	`freeimage(bb2);`
		796	`freeimage(bb2mask);`
		797	`}`
		798	`bb = allocimage(display, Rect(0,0,Npcsz,Npcsz), screen->chan, 0, 0);`
		799	`bbmask = allocimage(display, Rect(0,0,Npcsz,Npcsz), GREY1, 0, 0);`
		800	`bb2 = allocimage(display, Rect(0,0,Npcsz,Npcsz+DY), screen->chan, 0, 0);`
		801	`bb2mask = allocimage(display, bb2->r, GREY1, 0, 0);`
		802	`if(bb==0 \|\| bbmask==0 \|\| bb2==0 \|\| bb2mask==0)`
		803	`sysfatal("allocimage fail (bb)");`
		804	`draw(screen, screen->r, display->white, nil, ZP);`
		805	`drawboard();`
		806	`setpiece(piece);`
		807	`if(piece)`
		808	`drawpiece();`
		809	`lastmx = movemouse();`
		810	`newscreen = 1;`
		811	`flushimage(display, 1);`
		812	`}`
		813
		814	`void`
		815	`usage(void)`
		816	`{`
		817	`fprint(2, "usage: %s\n", argv0);`
		818	`exits("usage");`
		819	`}`
		820
		821	`void`
		822	`threadmain(int argc, char *argv[])`
		823	`{`
		824	`Image *tb;`
		825	`char buf[200];`
		826	`int i, scores;`
		827	`long starttime, endtime;`
		828
		829	`ARGBEGIN{`
		830	`default:`
		831	`usage();`
		832	`}ARGEND`
		833	`if(argc)`
		834	`usage();`
		835
		836	`suspended = 0;`
		837	`setparms();`
		838	`snprint(buf, sizeof(buf), "%ds", N);`
		839	`initdraw(0, 0, buf);`
		840	`mousectl = initmouse(nil, display->image); /* BUG? */`
		841	`if(mousectl == nil)`
		842	`sysfatal("[45]s: mouse init failed: %r");`
		843	`kbdctl = initkeyboard(nil); /* BUG? */`
		844	`if(kbdctl == nil)`
		845	`sysfatal("[45]s: keyboard init failed: %r");`
		846	`starttime = time(0);`
		847	`srand(starttime);`
		848	`snprint(buf, sizeof(buf), "/sys/games/lib/%dscores", N);`
		849	`scores = open(buf, OWRITE);`
		850	`if(scores < 0)`
		851	`sysfatal("can't open %s: %r", buf);`
		852	`tb = 0;`
		853	`if(screen->depth < 3){`
		854	`tb = allocimage(display, Rect(0,0,16,16), 0, 1, -1);`
		855	`if(tb == 0)`
		856	`sysfatal("allocimage fail (tb)");`
		857	`}`
		858	`for(i = 0; i<NCOL; i++){`
		859	`tx[i] = allocimage(display, Rect(0, 0, 16, 16), screen->chan, 1, txpix[i]);`
		860	`if(tx[i] == 0)`
		861	`sysfatal("allocimage fail (tx)");`
		862	`if(screen->depth < 3){`
		863	`loadimage(tb, tb->r, txbits[i], 32);`
		864	`draw(tx[i], tx[i]->r, tb, nil, ZP);`
		865	`}`
		866	`}`
		867	`if(tb != 0)`
		868	`freeimage(tb);`
		869
		870	`whitemask = allocimage(display, Rect(0,0,1,1), CMAP8, 1, setalpha(DWhite, 0x7F));`
		871	`if(whitemask==0)`
		872	`sysfatal("allocimage fail (whitemask)");`
		873
		874	`threadsetname("4s-5s");`
		875	`timerc= chancreate(sizeof(int), 0);`
		876	`proccreate(timerproc, timerc, 1024);`
		877	`suspc= chancreate(sizeof(int), 0);`
		878	`mousec= chancreate(sizeof(Mouse), 0);`
		879	`kbdc= chancreate(sizeof(Rune), 0);`
		880	`threadcreate(suspproc, nil, 1024);`
		881	`points = 0;`
		882	`memset(board, 0, sizeof(board));`
		883	`redraw(0);`
		884	`if(play()){`
		885	`endtime = time(0);`
		886	`fprint(scores, "%ld\t%s\t%lud\t%ld\n",`
		887	`points, getuser(), starttime, endtime-starttime);`
		888	`}`
		889	`threadexitsall(nil);`
		890	`exits(0);`
		891	`}`

Subversion Repositories planix.SVN

(root)/os/branches/planix-v0/sys/src/games/xs.c – Rev 2