ref: af848f17658455d643de41f9cb53b61fe2eb72a6
dir: /sys/src/games/xs.c/
#include "xs.h"
/*
* engine for 4s, 5s, etc
*/
Cursor whitearrow = {
{0, 0},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
0xFF, 0xF0, 0xFF, 0xF0, 0xFF, 0xF8, 0xFF, 0xFC,
0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
0xF3, 0xF8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, },
{0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0xC0, 0x1C,
0xC0, 0x30, 0xC0, 0x30, 0xC0, 0x38, 0xC0, 0x1C,
0xC0, 0x0E, 0xC0, 0x07, 0xCE, 0x0E, 0xDF, 0x1C,
0xD3, 0xB8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, }
};
enum
{
CNone = 0,
CBounds = 1,
CPiece = 2,
NX = 10,
NY = 20,
};
enum{
TIMER,
MOUSE,
RESHAPE,
KBD,
SUSPEND,
NALT
};
char board[NY][NX];
Rectangle rboard;
Point pscore;
Point scoresz;
int pcsz = 32;
Point pos;
Image *bb, *bbmask, *bb2, *bb2mask;
Image *whitemask;
Rectangle br, br2;
long points;
int dt;
int DY;
int DMOUSE;
int lastmx;
Mouse mouse;
int newscreen;
Channel *timerc;
Channel *suspc;
Channel *mousec;
Channel *kbdc;
Mousectl *mousectl;
Keyboardctl *kbdctl;
int suspended;
void redraw(int);
int tsleep;
Piece *piece;
#define NCOL 10
uchar txbits[NCOL][32]={
{0xDD,0xDD,0xFF,0xFF,0x77,0x77,0xFF,0xFF,
0xDD,0xDD,0xFF,0xFF,0x77,0x77,0xFF,0xFF,
0xDD,0xDD,0xFF,0xFF,0x77,0x77,0xFF,0xFF,
0xDD,0xDD,0xFF,0xFF,0x77,0x77,0xFF,0xFF},
{0xDD,0xDD,0x77,0x77,0xDD,0xDD,0x77,0x77,
0xDD,0xDD,0x77,0x77,0xDD,0xDD,0x77,0x77,
0xDD,0xDD,0x77,0x77,0xDD,0xDD,0x77,0x77,
0xDD,0xDD,0x77,0x77,0xDD,0xDD,0x77,0x77},
{0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,
0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,
0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,
0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55},
{0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,
0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,
0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55,
0xAA,0xAA,0x55,0x55,0xAA,0xAA,0x55,0x55},
{0x22,0x22,0x88,0x88,0x22,0x22,0x88,0x88,
0x22,0x22,0x88,0x88,0x22,0x22,0x88,0x88,
0x22,0x22,0x88,0x88,0x22,0x22,0x88,0x88,
0x22,0x22,0x88,0x88,0x22,0x22,0x88,0x88},
{0x22,0x22,0x00,0x00,0x88,0x88,0x00,0x00,
0x22,0x22,0x00,0x00,0x88,0x88,0x00,0x00,
0x22,0x22,0x00,0x00,0x88,0x88,0x00,0x00,
0x22,0x22,0x00,0x00,0x88,0x88,0x00,0x00},
{0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,
0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,
0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,
0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00},
{0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,
0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,
0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,
0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00},
{0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,
0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC},
{0xCC,0xCC,0xCC,0xCC,0x33,0x33,0x33,0x33,
0xCC,0xCC,0xCC,0xCC,0x33,0x33,0x33,0x33,
0xCC,0xCC,0xCC,0xCC,0x33,0x33,0x33,0x33,
0xCC,0xCC,0xCC,0xCC,0x33,0x33,0x33,0x33},
};
int txpix[NCOL] = {
DYellow, /* yellow */
DCyan, /* cyan */
DGreen, /* lime green */
DGreyblue, /* slate */
DRed, /* red */
DGreygreen, /* olive green */
DBlue, /* blue */
0xFF55AAFF, /* pink */
0xFFAAFFFF, /* lavender */
0xBB005DFF, /* maroon */
};
Image *tx[NCOL];
int
movemouse(void)
{
mouse.xy = Pt(rboard.min.x + Dx(rboard)/2, rboard.min.y +Dy(rboard)/2);
moveto(mousectl, mouse.xy);
return mouse.xy.x;
}
int
warp(Point p, int x)
{
if (!suspended && piece != nil) {
x = pos.x + piece->sz.x*pcsz/2;
if (p.y < rboard.min.y)
p.y = rboard.min.y;
if (p.y >= rboard.max.y)
p.y = rboard.max.y - 1;
moveto(mousectl, Pt(x, p.y));
}
return x;
}
Piece *
rotr(Piece *p)
{
if(p->rot == 3)
return p-3;
return p+1;
}
Piece *
rotl(Piece *p)
{
if(p->rot == 0)
return p+3;
return p-1;
}
int
collide(Point pt, Piece *p)
{
int i;
int c = CNone;
pt.x = (pt.x - rboard.min.x) / pcsz;
pt.y = (pt.y - rboard.min.y) / pcsz;
for(i=0; i<N; i++){
pt.x += p->d[i].x;
pt.y += p->d[i].y;
if(pt.x<0 || pt.x>=NX || pt.y<0 || pt.y>=NY)
c |= CBounds;
if(board[pt.y][pt.x])
c |= CPiece;
}
return c;
}
int
collider(Point pt, Point pmax)
{
int i, j, pi, pj, n, m;
pi = (pt.x - rboard.min.x) / pcsz;
pj = (pt.y - rboard.min.y) / pcsz;
n = pmax.x / pcsz;
m = pmax.y / pcsz + 1;
for(i = pi; i < pi+n && i < NX; i++)
for(j = pj; j < pj+m && j < NY; j++)
if(board[j][i])
return 1;
return 0;
}
void
setpiece(Piece *p){
int i;
Rectangle r, r2;
Point op, delta;
draw(bb, bb->r, display->white, nil, ZP);
draw(bbmask, bbmask->r, display->transparent, nil, ZP);
br = Rect(0, 0, 0, 0);
br2 = br;
piece = p;
if(p == 0)
return;
r.min = bb->r.min;
for(i=0; i<N; i++){
r.min.x += p->d[i].x*pcsz;
r.min.y += p->d[i].y*pcsz;
r.max.x = r.min.x + pcsz;
r.max.y = r.min.y + pcsz;
if(i == 0){
draw(bb, r, display->black, nil, ZP);
draw(bb, insetrect(r, 1), tx[piece->tx], nil, ZP);
draw(bbmask, r, display->opaque, nil, ZP);
op = r.min;
}else{
draw(bb, r, bb, nil, op);
draw(bbmask, r, bbmask, nil, op);
}
if(br.max.x < r.max.x)
br.max.x = r.max.x;
if(br.max.y < r.max.y)
br.max.y = r.max.y;
}
br.max = subpt(br.max, bb->r.min);
delta = Pt(0,DY);
br2.max = addpt(br.max, delta);
r = rectaddpt(br, bb2->r.min);
r2 = rectaddpt(br2, bb2->r.min);
draw(bb2, r2, display->white, nil, ZP);
draw(bb2, rectaddpt(r,delta), bb, nil, bb->r.min);
draw(bb2mask, r2, display->transparent, nil, ZP);
draw(bb2mask, r, display->opaque, bbmask, bb->r.min);
draw(bb2mask, rectaddpt(r,delta), display->opaque, bbmask, bb->r.min);
}
void
drawpiece(void){
draw(screen, rectaddpt(br, pos), bb, bbmask, bb->r.min);
if (suspended)
draw(screen, rectaddpt(br, pos), display->white, whitemask, ZP);
}
void
undrawpiece(void)
{
Image *mask = nil;
if(collider(pos, br.max))
mask = bbmask;
draw(screen, rectaddpt(br, pos), display->white, mask, bb->r.min);
}
void
rest(void)
{
int i;
Point pt;
pt = divpt(subpt(pos, rboard.min), pcsz);
for(i=0; i<N; i++){
pt.x += piece->d[i].x;
pt.y += piece->d[i].y;
board[pt.y][pt.x] = piece->tx+16;
}
}
int
canfit(Piece *p)
{
static int dx[]={0, -1, 1, -2, 2, -3, 3, 4, -4};
int i, j;
Point z;
j = N + 1;
if(j >= 4){
j = p->sz.x;
if(j<p->sz.y)
j = p->sz.y;
j = 2*j-1;
}
for(i=0; i<j; i++){
z.x = pos.x + dx[i]*pcsz;
z.y = pos.y;
if(!collide(z, p)){
z.y = pos.y + pcsz-1;
if(!collide(z, p)){
undrawpiece();
pos.x = z.x;
return 1;
}
}
}
return 0;
}
void
score(int p)
{
char buf[128];
points += p;
snprint(buf, sizeof(buf), "%.6ld", points);
draw(screen, Rpt(pscore, addpt(pscore, scoresz)), display->white, nil, ZP);
string(screen, pscore, display->black, ZP, font, buf);
}
void
drawsq(Image *b, Point p, int ptx){
Rectangle r;
r.min = p;
r.max.x = r.min.x+pcsz;
r.max.y = r.min.y+pcsz;
draw(b, r, display->black, nil, ZP);
draw(b, insetrect(r, 1), tx[ptx], nil, ZP);
}
void
drawboard(void)
{
int i, j;
border(screen, insetrect(rboard, -2), 2, display->black, ZP);
draw(screen, Rect(rboard.min.x, rboard.min.y-2, rboard.max.x, rboard.min.y),
display->white, nil, ZP);
for(i=0; i<NY; i++)
for(j=0; j<NX; j++)
if(board[i][j])
drawsq(screen, Pt(rboard.min.x+j*pcsz, rboard.min.y+i*pcsz), board[i][j]-16);
score(0);
if (suspended)
draw(screen, screen->r, display->white, whitemask, ZP);
}
void
choosepiece(void)
{
int i;
do{
i = nrand(NP);
setpiece(&pieces[i]);
pos = rboard.min;
pos.x += nrand(NX)*pcsz;
}while(collide(Pt(pos.x, pos.y+pcsz-DY), piece));
drawpiece();
flushimage(display, 1);
}
int
movepiece(void)
{
Image *mask = nil;
if(collide(Pt(pos.x, pos.y+pcsz), piece))
return 0;
if(collider(pos, br2.max))
mask = bb2mask;
draw(screen, rectaddpt(br2, pos), bb2, mask, bb2->r.min);
pos.y += DY;
flushimage(display, 1);
return 1;
}
void
suspend(int s)
{
suspended = s;
if (suspended)
setcursor(mousectl, &whitearrow);
else
setcursor(mousectl, nil);
if (!suspended)
drawpiece();
drawboard();
flushimage(display, 1);
}
void
pause(int t)
{
int s;
Alt alts[NALT+1];
alts[TIMER].c = timerc;
alts[TIMER].v = nil;
alts[TIMER].op = CHANRCV;
alts[SUSPEND].c = suspc;
alts[SUSPEND].v = &s;
alts[SUSPEND].op = CHANRCV;
alts[RESHAPE].c = mousectl->resizec;
alts[RESHAPE].v = nil;
alts[RESHAPE].op = CHANRCV;
// avoid hanging up those writing ong mousec and kbdc
// so just accept it all and keep mouse up-to-date
alts[MOUSE].c = mousec;
alts[MOUSE].v = &mouse;
alts[MOUSE].op = CHANRCV;
alts[KBD].c = kbdc;
alts[KBD].v = nil;
alts[KBD].op = CHANRCV;
alts[NALT].op = CHANEND;
flushimage(display, 1);
for(;;)
switch(alt(alts)){
case SUSPEND:
if (!suspended && s) {
suspend(1);
} else if (suspended && !s) {
suspend(0);
lastmx = warp(mouse.xy, lastmx);
}
break;
case TIMER:
if(suspended)
break;
if((t -= tsleep) < 0)
return;
break;
case RESHAPE:
redraw(1);
break;
}
}
int
horiz(void)
{
int lev[MAXN];
int i, j, h;
Rectangle r;
h = 0;
for(i=0; i<NY; i++){
for(j=0; board[i][j]; j++)
if(j == NX-1){
lev[h++] = i;
break;
}
}
if(h == 0)
return 0;
r = rboard;
newscreen = 0;
for(j=0; j<h; j++){
r.min.y = rboard.min.y + lev[j]*pcsz;
r.max.y = r.min.y + pcsz;
draw(screen, r, display->white, whitemask, ZP);
flushimage(display, 1);
}
for(i=0; i<3; i++){
pause(250);
if(newscreen){
drawboard();
break;
}
for(j=0; j<h; j++){
r.min.y = rboard.min.y + lev[j]*pcsz;
r.max.y = r.min.y + pcsz;
draw(screen, r, display->white, whitemask, ZP);
}
flushimage(display, 1);
}
r = rboard;
for(j=0; j<h; j++){
i = NY - lev[j] - 1;
score(250+10*i*i);
r.min.y = rboard.min.y;
r.max.y = rboard.min.y+lev[j]*pcsz;
draw(screen, rectaddpt(r, Pt(0,pcsz)), screen, nil, r.min);
r.max.y = rboard.min.y+pcsz;
draw(screen, r, display->white, nil, ZP);
memcpy(&board[1][0], &board[0][0], NX*lev[j]);
memset(&board[0][0], 0, NX);
}
flushimage(display, 1);
return 1;
}
void
mright(void)
{
if(!collide(Pt(pos.x+pcsz, pos.y), piece))
if(!collide(Pt(pos.x+pcsz, pos.y+pcsz-DY), piece)){
undrawpiece();
pos.x += pcsz;
drawpiece();
flushimage(display, 1);
}
}
void
mleft(void)
{
if(!collide(Pt(pos.x-pcsz, pos.y), piece))
if(!collide(Pt(pos.x-pcsz, pos.y+pcsz-DY), piece)){
undrawpiece();
pos.x -= pcsz;
drawpiece();
flushimage(display, 1);
}
}
void
rright(void)
{
if(canfit(rotr(piece))){
setpiece(rotr(piece));
drawpiece();
flushimage(display, 1);
}
}
void
rleft(void)
{
if(canfit(rotl(piece))){
setpiece(rotl(piece));
drawpiece();
flushimage(display, 1);
}
}
int fusst = 0;
int
drop(int f)
{
if(f){
score(5L*(rboard.max.y-pos.y)/pcsz);
do; while(movepiece());
}
fusst = 0;
rest();
if(pos.y==rboard.min.y && !horiz())
return 1;
horiz();
setpiece(0);
pause(1500);
choosepiece();
lastmx = warp(mouse.xy, lastmx);
return 0;
}
int
play(void)
{
int i;
Mouse om;
int s;
Rune r;
Alt alts[NALT+1];
alts[TIMER].c = timerc;
alts[TIMER].v = nil;
alts[TIMER].op = CHANRCV;
alts[MOUSE].c = mousec;
alts[MOUSE].v = &mouse;
alts[MOUSE].op = CHANRCV;
alts[SUSPEND].c = suspc;
alts[SUSPEND].v = &s;
alts[SUSPEND].op = CHANRCV;
alts[RESHAPE].c = mousectl->resizec;
alts[RESHAPE].v = nil;
alts[RESHAPE].op = CHANRCV;
alts[KBD].c = kbdc;
alts[KBD].v = &r;
alts[KBD].op = CHANRCV;
alts[NALT].op = CHANEND;
dt = 64;
lastmx = -1;
lastmx = movemouse();
choosepiece();
lastmx = warp(mouse.xy, lastmx);
for(;;)
switch(alt(alts)){
case MOUSE:
if(suspended) {
om = mouse;
break;
}
if(lastmx < 0)
lastmx = mouse.xy.x;
if(mouse.xy.x > lastmx+DMOUSE){
mright();
lastmx = mouse.xy.x;
}
if(mouse.xy.x < lastmx-DMOUSE){
mleft();
lastmx = mouse.xy.x;
}
if(mouse.buttons&1 && !(om.buttons&1))
rleft();
if(mouse.buttons&2 && !(om.buttons&2))
if(drop(1))
return 1;
if(mouse.buttons&4 && !(om.buttons&4))
rright();
om = mouse;
break;
case SUSPEND:
if (!suspended && s)
suspend(1);
else
if (suspended && !s) {
suspend(0);
lastmx = warp(mouse.xy, lastmx);
}
break;
case RESHAPE:
redraw(1);
break;
case KBD:
if(suspended)
break;
switch(r){
case 'f':
case ';':
mright();
break;
case 'a':
case 'j':
mleft();
break;
case 'd':
case 'l':
rright();
break;
case 's':
case 'k':
rleft();
break;
case ' ':
if(drop(1))
return 1;
break;
}
break;
case TIMER:
if(suspended)
break;
dt -= tsleep;
if(dt < 0){
i = 1;
dt = 16 * (points+nrand(10000)-5000) / 10000;
if(dt >= 32){
i += (dt-32)/16;
dt = 32;
}
dt = 52-dt;
while(i-- > 0)
if(movepiece()==0 && ++fusst==40){
if(drop(0))
return 1;
break;
}
}
break;
}
}
void
setparms(void)
{
char buf[32];
int fd, n;
tsleep = 50;
fd = open("/dev/hz", OREAD);
if(fd < 0)
return;
n = read(fd, buf, sizeof buf - 1);
close(fd);
if(n < 0)
return;
buf[n] = '\0';
tsleep = strtoul(buf, 0, 10);
tsleep = (1000 + tsleep - 1) / tsleep;
}
void
timerproc(void *v)
{
Channel *c;
void **arg;
arg = v;
c = (Channel*)arg;
for(;;){
sleep(tsleep);
send(c, nil);
}
}
void
suspproc(void *)
{
Mouse mouse;
Rune r;
int s;
Alt alts[NALT+1];
alts[TIMER].op = CHANNOP;
alts[MOUSE].c = mousectl->c;
alts[MOUSE].v = &mouse;
alts[MOUSE].op = CHANRCV;
alts[SUSPEND].op = CHANNOP;
alts[RESHAPE].op = CHANNOP;
alts[KBD].c = kbdctl->c;
alts[KBD].v = &r;
alts[KBD].op = CHANRCV;
alts[NALT].op = CHANEND;
s = 0;
for(;;)
switch(alt(alts)){
case MOUSE:
send(mousec, &mouse);
break;
case KBD:
switch(r){
case 'q':
case 'Q':
case 0x04:
case 0x7F:
threadexitsall(nil);
default:
if(s) {
s = 0;
send(suspc, &s);
} else
switch(r){
case 'z':
case 'Z':
case 'p':
case 'P':
case 0x1B:
s = 1;
send(suspc, &s);
break;
default:
send(kbdc, &r);
}
break;
}
}
}
void
redraw(int new)
{
Rectangle r;
long dx, dy;
if(new && getwindow(display, Refmesg) < 0)
sysfatal("can't reattach to window");
r = screen->r;
pos.x = (pos.x - rboard.min.x) / pcsz;
pos.y = (pos.y - rboard.min.y) / pcsz;
dx = r.max.x - r.min.x;
dy = r.max.y - r.min.y - 2*32;
DY = dx / NX;
if(DY > dy / NY)
DY = dy / NY;
DY /= 8;
if(DY > 4)
DY = 4;
pcsz = DY*8;
DMOUSE = pcsz/3;
if(pcsz < 8)
sysfatal("screen too small: %d", pcsz);
rboard = screen->r;
rboard.min.x += (dx-pcsz*NX)/2;
rboard.min.y += (dy-pcsz*NY)/2+32;
rboard.max.x = rboard.min.x+NX*pcsz;
rboard.max.y = rboard.min.y+NY*pcsz;
pscore.x = rboard.min.x+8;
pscore.y = rboard.min.y-32;
scoresz = stringsize(font, "000000");
pos.x = pos.x*pcsz + rboard.min.x;
pos.y = pos.y*pcsz + rboard.min.y;
if(bb){
freeimage(bb);
freeimage(bbmask);
freeimage(bb2);
freeimage(bb2mask);
}
bb = allocimage(display, Rect(0,0,N*pcsz,N*pcsz), screen->chan, 0, 0);
bbmask = allocimage(display, Rect(0,0,N*pcsz,N*pcsz), GREY1, 0, 0);
bb2 = allocimage(display, Rect(0,0,N*pcsz,N*pcsz+DY), screen->chan, 0, 0);
bb2mask = allocimage(display, bb2->r, GREY1, 0, 0);
if(bb==0 || bbmask==0 || bb2==0 || bb2mask==0)
sysfatal("allocimage fail (bb)");
draw(screen, screen->r, display->white, nil, ZP);
drawboard();
setpiece(piece);
if(piece)
drawpiece();
lastmx = movemouse();
newscreen = 1;
flushimage(display, 1);
}
void
usage(void)
{
fprint(2, "usage: %s\n", argv0);
exits("usage");
}
void
threadmain(int argc, char *argv[])
{
Image *tb;
char buf[200];
int i, scores;
long starttime, endtime;
ARGBEGIN{
default:
usage();
}ARGEND
if(argc)
usage();
suspended = 0;
setparms();
snprint(buf, sizeof(buf), "%ds", N);
initdraw(0, 0, buf);
mousectl = initmouse(nil, display->image); /* BUG? */
if(mousectl == nil)
sysfatal("[45]s: mouse init failed: %r");
kbdctl = initkeyboard(nil); /* BUG? */
if(kbdctl == nil)
sysfatal("[45]s: keyboard init failed: %r");
starttime = time(0);
srand(starttime);
snprint(buf, sizeof(buf), "/sys/games/lib/%dscores", N);
scores = open(buf, OWRITE);
if(scores < 0)
print("can't open %s: %r\n", buf);
tb = 0;
if(screen->depth < 3){
tb = allocimage(display, Rect(0,0,16,16), 0, 1, -1);
if(tb == 0)
sysfatal("allocimage fail (tb)");
}
for(i = 0; i<NCOL; i++){
tx[i] = allocimage(display, Rect(0, 0, 16, 16), screen->chan, 1, txpix[i]);
if(tx[i] == 0)
sysfatal("allocimage fail (tx)");
if(screen->depth < 3){
loadimage(tb, tb->r, txbits[i], 32);
draw(tx[i], tx[i]->r, tb, nil, ZP);
}
}
if(tb != 0)
freeimage(tb);
whitemask = allocimage(display, Rect(0,0,1,1), CMAP8, 1, setalpha(DWhite, 0x7F));
if(whitemask==0)
sysfatal("allocimage fail (whitemask)");
threadsetname("4s-5s");
timerc= chancreate(sizeof(int), 0);
proccreate(timerproc, timerc, 8192);
suspc= chancreate(sizeof(int), 0);
mousec= chancreate(sizeof(Mouse), 0);
kbdc= chancreate(sizeof(Rune), 0);
threadcreate(suspproc, nil, 8192);
points = 0;
memset(board, 0, sizeof(board));
redraw(0);
if(play() && scores >= 0){
endtime = time(0);
fprint(scores, "%ld\t%s\t%lud\t%ld\n",
points, getuser(), starttime, endtime-starttime);
}
threadexitsall(nil);
exits(0);
}