| // 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(int64(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() |
| } |
