mirror of
https://github.com/golang/go
synced 2024-10-05 10:31:22 -06:00
733 lines
15 KiB
Go
733 lines
15 KiB
Go
|
// games/4s - a tetris clone
|
||
|
//
|
||
|
// Derived from Plan 9's /sys/src/games/xs.c
|
||
|
// http://plan9.bell-labs.com/sources/plan9/sys/src/games/xs.c
|
||
|
//
|
||
|
// Copyright (C) 2003, Lucent Technologies Inc. and others. All Rights Reserved.
|
||
|
// Portions Copyright 2009 The Go Authors. All Rights Reserved.
|
||
|
// Distributed under the terms of the Lucent Public License Version 1.02
|
||
|
// See http://plan9.bell-labs.com/plan9/license.html
|
||
|
|
||
|
/*
|
||
|
* engine for 4s, 5s, etc
|
||
|
*/
|
||
|
|
||
|
package main
|
||
|
|
||
|
import (
|
||
|
"exp/draw";
|
||
|
"image";
|
||
|
"log";
|
||
|
"os";
|
||
|
"rand";
|
||
|
"time";
|
||
|
)
|
||
|
|
||
|
/*
|
||
|
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, }
|
||
|
};
|
||
|
*/
|
||
|
|
||
|
const (
|
||
|
CNone = 0;
|
||
|
CBounds = 1;
|
||
|
CPiece = 2;
|
||
|
NX = 10;
|
||
|
NY = 20;
|
||
|
|
||
|
NCOL = 10;
|
||
|
|
||
|
MAXN = 5;
|
||
|
)
|
||
|
|
||
|
var (
|
||
|
N int;
|
||
|
display draw.Context;
|
||
|
screen draw.Image;
|
||
|
screenr draw.Rectangle;
|
||
|
board [NY][NX]byte;
|
||
|
rboard draw.Rectangle;
|
||
|
pscore draw.Point;
|
||
|
scoresz draw.Point;
|
||
|
pcsz = 32;
|
||
|
pos draw.Point;
|
||
|
bbr, bb2r draw.Rectangle;
|
||
|
bb, bbmask, bb2, bb2mask *image.RGBA;
|
||
|
whitemask image.Image;
|
||
|
br, br2 draw.Rectangle;
|
||
|
points int;
|
||
|
dt int;
|
||
|
DY int;
|
||
|
DMOUSE int;
|
||
|
lastmx int;
|
||
|
mouse draw.Mouse;
|
||
|
newscreen bool;
|
||
|
timerc <-chan int64;
|
||
|
suspc chan bool;
|
||
|
mousec chan draw.Mouse;
|
||
|
resizec <-chan bool;
|
||
|
kbdc chan int;
|
||
|
suspended bool;
|
||
|
tsleep int;
|
||
|
piece *Piece;
|
||
|
pieces []Piece;
|
||
|
)
|
||
|
|
||
|
type Piece struct {
|
||
|
rot int;
|
||
|
tx int;
|
||
|
sz draw.Point;
|
||
|
d []draw.Point;
|
||
|
left *Piece;
|
||
|
right *Piece;
|
||
|
}
|
||
|
|
||
|
var txbits = [NCOL][32]byte{
|
||
|
[32]byte{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},
|
||
|
[32]byte{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},
|
||
|
[32]byte{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},
|
||
|
[32]byte{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},
|
||
|
[32]byte{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},
|
||
|
[32]byte{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},
|
||
|
[32]byte{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},
|
||
|
[32]byte{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},
|
||
|
[32]byte{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},
|
||
|
[32]byte{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},
|
||
|
}
|
||
|
|
||
|
var txpix = [NCOL]draw.Color{
|
||
|
draw.Yellow, /* yellow */
|
||
|
draw.Cyan, /* cyan */
|
||
|
draw.Green, /* lime green */
|
||
|
draw.GreyBlue, /* slate */
|
||
|
draw.Red, /* red */
|
||
|
draw.GreyGreen, /* olive green */
|
||
|
draw.Blue, /* blue */
|
||
|
draw.Color(0xFF55AAFF), /* pink */
|
||
|
draw.Color(0xFFAAFFFF), /* lavender */
|
||
|
draw.Color(0xBB005DFF), /* maroon */
|
||
|
}
|
||
|
|
||
|
func movemouse() int {
|
||
|
//mouse.draw.Point = draw.Pt(rboard.Min.X + rboard.Dx()/2, rboard.Min.Y + rboard.Dy()/2);
|
||
|
//moveto(mousectl, mouse.Xy);
|
||
|
return mouse.X;
|
||
|
}
|
||
|
|
||
|
func warp(p draw.Point, x int) int {
|
||
|
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, draw.Pt(x, p.Y));
|
||
|
}
|
||
|
return x;
|
||
|
}
|
||
|
|
||
|
func initPieces() {
|
||
|
for i := range pieces {
|
||
|
p := &pieces[i];
|
||
|
if p.rot == 3 {
|
||
|
p.right = &pieces[i-3];
|
||
|
} else {
|
||
|
p.right = &pieces[i+1];
|
||
|
}
|
||
|
if p.rot == 0 {
|
||
|
p.left = &pieces[i+3];
|
||
|
} else {
|
||
|
p.left = &pieces[i-1];
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func collide(pt draw.Point, p *Piece) bool {
|
||
|
pt.X = (pt.X - rboard.Min.X) / pcsz;
|
||
|
pt.Y = (pt.Y - rboard.Min.Y) / pcsz;
|
||
|
for _, q := range p.d {
|
||
|
pt.X += q.X;
|
||
|
pt.Y += q.Y;
|
||
|
if pt.X<0 || pt.X>=NX || pt.Y<0 || pt.Y>=NY {
|
||
|
return true;
|
||
|
continue;
|
||
|
}
|
||
|
if board[pt.Y][pt.X] != 0 {
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
func collider(pt, pmax draw.Point) bool {
|
||
|
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] != 0 {
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
func setpiece(p *Piece) {
|
||
|
draw.Draw(bb, bbr, draw.White, nil, draw.ZP);
|
||
|
draw.Draw(bbmask, bbr, draw.Transparent, nil, draw.ZP);
|
||
|
br = draw.Rect(0, 0, 0, 0);
|
||
|
br2 = br;
|
||
|
piece = p;
|
||
|
if p == nil {
|
||
|
return;
|
||
|
}
|
||
|
var op draw.Point;
|
||
|
var r draw.Rectangle;
|
||
|
r.Min = bbr.Min;
|
||
|
for i, pt := range p.d {
|
||
|
r.Min.X += pt.X*pcsz;
|
||
|
r.Min.Y += pt.Y*pcsz;
|
||
|
r.Max.X = r.Min.X + pcsz;
|
||
|
r.Max.Y = r.Min.Y + pcsz;
|
||
|
if i == 0 {
|
||
|
draw.Draw(bb, r, draw.Black, nil, draw.ZP);
|
||
|
draw.Draw(bb, r.Inset(1), txpix[piece.tx], nil, draw.ZP);
|
||
|
draw.Draw(bbmask, r, draw.Opaque, nil, draw.ZP);
|
||
|
op = r.Min;
|
||
|
}else{
|
||
|
draw.Draw(bb, r, bb, nil, op);
|
||
|
draw.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 = br.Max.Sub(bbr.Min);
|
||
|
delta := draw.Pt(0,DY);
|
||
|
br2.Max = br.Max.Add(delta);
|
||
|
r = br.Add(bb2r.Min);
|
||
|
r2 := br2.Add(bb2r.Min);
|
||
|
draw.Draw(bb2, r2, draw.White, nil, draw.ZP);
|
||
|
draw.Draw(bb2, r.Add(delta), bb, nil, bbr.Min);
|
||
|
draw.Draw(bb2mask, r2, draw.Transparent, nil, draw.ZP);
|
||
|
draw.Draw(bb2mask, r, draw.Opaque, bbmask, bbr.Min);
|
||
|
draw.Draw(bb2mask, r.Add(delta), draw.Opaque, bbmask, bbr.Min);
|
||
|
}
|
||
|
|
||
|
func drawpiece() {
|
||
|
draw.Draw(screen, br.Add(pos), bb, bbmask, bbr.Min);
|
||
|
if suspended {
|
||
|
draw.Draw(screen, br.Add(pos), draw.White, whitemask, draw.ZP);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func undrawpiece() {
|
||
|
var mask image.Image;
|
||
|
if collider(pos, br.Max) {
|
||
|
mask = bbmask;
|
||
|
}
|
||
|
draw.Draw(screen, br.Add(pos), draw.White, mask, bbr.Min);
|
||
|
}
|
||
|
|
||
|
func rest() {
|
||
|
pt := pos.Sub(rboard.Min).Div(pcsz);
|
||
|
for _, p := range piece.d {
|
||
|
pt.X += p.X;
|
||
|
pt.Y += p.Y;
|
||
|
board[pt.Y][pt.X] = byte(piece.tx+16);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func canfit(p *Piece) bool {
|
||
|
var dx = [...]int{0, -1, 1, -2, 2, -3, 3, 4, -4};
|
||
|
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++ {
|
||
|
var z draw.Point;
|
||
|
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 true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
func score(p int) {
|
||
|
points += p;
|
||
|
// snprint(buf, sizeof(buf), "%.6ld", points);
|
||
|
// draw.Draw(screen, draw.Rpt(pscore, pscore.Add(scoresz)), draw.White, nil, draw.ZP);
|
||
|
// string(screen, pscore, draw.Black, draw.ZP, font, buf);
|
||
|
}
|
||
|
|
||
|
func drawsq(b draw.Image, p draw.Point, ptx int) {
|
||
|
var r draw.Rectangle;
|
||
|
r.Min = p;
|
||
|
r.Max.X = r.Min.X+pcsz;
|
||
|
r.Max.Y = r.Min.Y+pcsz;
|
||
|
draw.Draw(b, r, draw.Black, nil, draw.ZP);
|
||
|
draw.Draw(b, r.Inset(1), txpix[ptx], nil, draw.ZP);
|
||
|
}
|
||
|
|
||
|
func drawboard() {
|
||
|
draw.Border(screen, rboard.Inset(-2), 2, draw.Black, draw.ZP);
|
||
|
draw.Draw(screen, draw.Rect(rboard.Min.X, rboard.Min.Y-2, rboard.Max.X, rboard.Min.Y),
|
||
|
draw.White, nil, draw.ZP);
|
||
|
for i:=0; i<NY; i++ {
|
||
|
for j:=0; j<NX; j++ {
|
||
|
if board[i][j] != 0 {
|
||
|
drawsq(screen, draw.Pt(rboard.Min.X+j*pcsz, rboard.Min.Y+i*pcsz), int(board[i][j]-16));
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
score(0);
|
||
|
if suspended {
|
||
|
draw.Draw(screen, screenr, draw.White, whitemask, draw.ZP);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func choosepiece() {
|
||
|
for {
|
||
|
i := rand.Intn(len(pieces));
|
||
|
setpiece(&pieces[i]);
|
||
|
pos = rboard.Min;
|
||
|
pos.X += rand.Intn(NX)*pcsz;
|
||
|
if !collide(draw.Pt(pos.X, pos.Y+pcsz-DY), piece) {
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
drawpiece();
|
||
|
display.FlushImage();
|
||
|
}
|
||
|
|
||
|
func movepiece() bool {
|
||
|
var mask image.Image;
|
||
|
if collide(draw.Pt(pos.X, pos.Y+pcsz), piece) {
|
||
|
return false;
|
||
|
}
|
||
|
if collider(pos, br2.Max) {
|
||
|
mask = bb2mask;
|
||
|
}
|
||
|
draw.Draw(screen, br2.Add(pos), bb2, mask, bb2r.Min);
|
||
|
pos.Y += DY;
|
||
|
display.FlushImage();
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
func suspend(s bool) {
|
||
|
suspended = s;
|
||
|
/*
|
||
|
if suspended {
|
||
|
setcursor(mousectl, &whitearrow);
|
||
|
} else {
|
||
|
setcursor(mousectl, nil);
|
||
|
}
|
||
|
*/
|
||
|
if !suspended {
|
||
|
drawpiece();
|
||
|
}
|
||
|
drawboard();
|
||
|
display.FlushImage();
|
||
|
}
|
||
|
|
||
|
func pause(t int) {
|
||
|
display.FlushImage();
|
||
|
for {
|
||
|
select {
|
||
|
case s := <-suspc:
|
||
|
if !suspended && s {
|
||
|
suspend(true);
|
||
|
} else if suspended && !s {
|
||
|
suspend(false);
|
||
|
lastmx = warp(mouse.Point, lastmx);
|
||
|
}
|
||
|
case <-timerc:
|
||
|
if suspended {
|
||
|
break;
|
||
|
}
|
||
|
t -= tsleep;
|
||
|
if t < 0 {
|
||
|
return;
|
||
|
}
|
||
|
case <-resizec:
|
||
|
//redraw(true);
|
||
|
case mouse = <-mousec:
|
||
|
case <-kbdc:
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func horiz() bool {
|
||
|
var lev [MAXN]int;
|
||
|
h := 0;
|
||
|
for i:=0; i<NY; i++ {
|
||
|
for j:=0; board[i][j] != 0; j++ {
|
||
|
if j == NX-1 {
|
||
|
lev[h] = i;
|
||
|
h++;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if h == 0 {
|
||
|
return false;
|
||
|
}
|
||
|
r := rboard;
|
||
|
newscreen = false;
|
||
|
for j:=0; j<h; j++ {
|
||
|
r.Min.Y = rboard.Min.Y + lev[j]*pcsz;
|
||
|
r.Max.Y = r.Min.Y + pcsz;
|
||
|
draw.Draw(screen, r, draw.White, whitemask, draw.ZP);
|
||
|
display.FlushImage();
|
||
|
}
|
||
|
PlaySound(whoosh);
|
||
|
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.Draw(screen, r, draw.White, whitemask, draw.ZP);
|
||
|
}
|
||
|
display.FlushImage();
|
||
|
}
|
||
|
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.Draw(screen, r.Add(draw.Pt(0,pcsz)), screen, nil, r.Min);
|
||
|
r.Max.Y = rboard.Min.Y+pcsz;
|
||
|
draw.Draw(screen, r, draw.White, nil, draw.ZP);
|
||
|
for k := lev[j]-1; k >= 0; k-- {
|
||
|
board[k+1] = board[k];
|
||
|
}
|
||
|
board[0] = [NX]byte{};
|
||
|
}
|
||
|
display.FlushImage();
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
func mright() {
|
||
|
if !collide(draw.Pt(pos.X+pcsz, pos.Y), piece)
|
||
|
&& !collide(draw.Pt(pos.X+pcsz, pos.Y+pcsz-DY), piece) {
|
||
|
undrawpiece();
|
||
|
pos.X += pcsz;
|
||
|
drawpiece();
|
||
|
display.FlushImage();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func mleft() {
|
||
|
if !collide(draw.Pt(pos.X-pcsz, pos.Y), piece)
|
||
|
&& !collide(draw.Pt(pos.X-pcsz, pos.Y+pcsz-DY), piece) {
|
||
|
undrawpiece();
|
||
|
pos.X -= pcsz;
|
||
|
drawpiece();
|
||
|
display.FlushImage();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func rright() {
|
||
|
if canfit(piece.right) {
|
||
|
setpiece(piece.right);
|
||
|
drawpiece();
|
||
|
display.FlushImage();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func rleft() {
|
||
|
if canfit(piece.left) {
|
||
|
setpiece(piece.left);
|
||
|
drawpiece();
|
||
|
display.FlushImage();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
var fusst = 0
|
||
|
|
||
|
func drop(f bool) bool {
|
||
|
if f {
|
||
|
score(5*(rboard.Max.Y-pos.Y)/pcsz);
|
||
|
for movepiece() {
|
||
|
}
|
||
|
}
|
||
|
fusst = 0;
|
||
|
rest();
|
||
|
if pos.Y==rboard.Min.Y && !horiz() {
|
||
|
return true;
|
||
|
}
|
||
|
horiz();
|
||
|
setpiece(nil);
|
||
|
pause(1500);
|
||
|
choosepiece();
|
||
|
lastmx = warp(mouse.Point, lastmx);
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
func play() {
|
||
|
var om draw.Mouse;
|
||
|
dt = 64;
|
||
|
lastmx = -1;
|
||
|
lastmx = movemouse();
|
||
|
choosepiece();
|
||
|
lastmx = warp(mouse.Point, lastmx);
|
||
|
for {
|
||
|
select {
|
||
|
case mouse = <-mousec:
|
||
|
if suspended {
|
||
|
om = mouse;
|
||
|
break;
|
||
|
}
|
||
|
if lastmx < 0 {
|
||
|
lastmx = mouse.X;
|
||
|
}
|
||
|
if mouse.X > lastmx+DMOUSE {
|
||
|
mright();
|
||
|
lastmx = mouse.X;
|
||
|
}
|
||
|
if mouse.X < lastmx-DMOUSE {
|
||
|
mleft();
|
||
|
lastmx = mouse.X;
|
||
|
}
|
||
|
if mouse.Buttons&^om.Buttons&1 == 1 {
|
||
|
rleft();
|
||
|
}
|
||
|
if mouse.Buttons&^om.Buttons&2 == 2 {
|
||
|
if drop(true) {
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
if mouse.Buttons&^om.Buttons&4 == 4 {
|
||
|
rright();
|
||
|
}
|
||
|
om = mouse;
|
||
|
|
||
|
case s := <-suspc:
|
||
|
if !suspended && s {
|
||
|
suspend(true);
|
||
|
} else if suspended && !s {
|
||
|
suspend(false);
|
||
|
lastmx = warp(mouse.Point, lastmx);
|
||
|
}
|
||
|
|
||
|
case <-resizec:
|
||
|
//redraw(true);
|
||
|
|
||
|
case r := <-kbdc:
|
||
|
if suspended {
|
||
|
break;
|
||
|
}
|
||
|
switch(r){
|
||
|
case 'f', ';':
|
||
|
mright();
|
||
|
case 'a', 'j':
|
||
|
mleft();
|
||
|
case 'd', 'l':
|
||
|
rright();
|
||
|
case 's', 'k':
|
||
|
rleft();
|
||
|
case ' ':
|
||
|
if drop(true) {
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
case <-timerc:
|
||
|
if suspended {
|
||
|
break;
|
||
|
}
|
||
|
dt -= tsleep;
|
||
|
if dt < 0 {
|
||
|
i := 1;
|
||
|
dt = 16 * (points+rand.Intn(10000)-5000) / 10000;
|
||
|
if dt >= 32 {
|
||
|
i += (dt-32)/16;
|
||
|
dt = 32;
|
||
|
}
|
||
|
dt = 52-dt;
|
||
|
for ; i > 0; i-- {
|
||
|
if movepiece() {
|
||
|
continue;
|
||
|
}
|
||
|
fusst++;
|
||
|
if fusst == 40 {
|
||
|
if drop(false) {
|
||
|
return;
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func suspproc() {
|
||
|
mc := display.MouseChan();
|
||
|
kc := display.KeyboardChan();
|
||
|
|
||
|
s := false;
|
||
|
for {
|
||
|
select {
|
||
|
case mouse = <-mc:
|
||
|
mousec <- mouse;
|
||
|
case r := <-kc:
|
||
|
switch r {
|
||
|
case 'q', 'Q', 0x04, 0x7F:
|
||
|
os.Exit(0);
|
||
|
default:
|
||
|
if s {
|
||
|
s = false;
|
||
|
suspc <- s;
|
||
|
break;
|
||
|
}
|
||
|
switch r {
|
||
|
case 'z', 'Z', 'p', 'P', 0x1B:
|
||
|
s = true;
|
||
|
suspc <- s;
|
||
|
default:
|
||
|
kbdc <- r;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
func redraw(new bool) {
|
||
|
// if new && getwindow(display, Refmesg) < 0 {
|
||
|
// sysfatal("can't reattach to window");
|
||
|
// }
|
||
|
r := draw.Rect(0, 0, screen.Width(), screen.Height());
|
||
|
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 {
|
||
|
log.Exitf("screen too small: %d", pcsz);
|
||
|
}
|
||
|
rboard = screenr;
|
||
|
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;
|
||
|
bbr = draw.Rect(0, 0, N*pcsz, N*pcsz);
|
||
|
bb = image.NewRGBA(bbr.Max.X, bbr.Max.Y);
|
||
|
bbmask = image.NewRGBA(bbr.Max.X, bbr.Max.Y); // actually just a bitmap
|
||
|
bb2r = draw.Rect(0, 0, N*pcsz, N*pcsz+DY);
|
||
|
bb2 = image.NewRGBA(bb2r.Dx(), bb2r.Dy());
|
||
|
bb2mask = image.NewRGBA(bb2r.Dx(), bb2r.Dy()); // actually just a bitmap
|
||
|
draw.Draw(screen, screenr, draw.White, nil, draw.ZP);
|
||
|
drawboard();
|
||
|
setpiece(piece);
|
||
|
if piece != nil {
|
||
|
drawpiece();
|
||
|
}
|
||
|
lastmx = movemouse();
|
||
|
newscreen = true;
|
||
|
display.FlushImage();
|
||
|
}
|
||
|
|
||
|
func quitter(c <-chan bool) {
|
||
|
<-c;
|
||
|
os.Exit(0);
|
||
|
}
|
||
|
|
||
|
func Play(pp []Piece, ctxt draw.Context) {
|
||
|
display = ctxt;
|
||
|
screen = ctxt.Screen();
|
||
|
screenr = draw.Rect(0, 0, screen.Width(), screen.Height());
|
||
|
pieces = pp;
|
||
|
N = len(pieces[0].d);
|
||
|
initPieces();
|
||
|
rand.Seed(int32(time.Nanoseconds()%(1e9-1)));
|
||
|
whitemask = draw.White.SetAlpha(0x7F);
|
||
|
tsleep = 50;
|
||
|
timerc = time.Tick(int64(tsleep/2) * 1e6);
|
||
|
suspc = make(chan bool);
|
||
|
mousec = make(chan draw.Mouse);
|
||
|
resizec = ctxt.ResizeChan();
|
||
|
kbdc = make(chan int);
|
||
|
go quitter(ctxt.QuitChan());
|
||
|
go suspproc();
|
||
|
points = 0;
|
||
|
redraw(false);
|
||
|
play();
|
||
|
}
|