pinguin-server/board/board.go

package board

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"math/rand"
	"net/http"
	"time"
)

var setMask [4]byte = [4]byte{0xFC, 0xF3, 0xCF, 0x3F}
var getMask [4]byte = [4]byte{0x03, 0x0C, 0x30, 0xC0}

type Board struct {
	Width  int        `json:"cols"`
	Height int        `json:"rows"`
	Finish Coordinate `json:"finish"`
	data   []byte     `json:"-"`
}

type response struct {
	boardTile           io.ReadCloser
	x, y, width, height int
}

const (
	maxIceWidth  = 26
	regionWidth  = 32
	regionHeight = 32
)

// Create a new randomly generated board.
func New(width, height int) *Board {
	return NewPartial(0, 0, width, height, width, height)
}

func NewPartial(startX, startY, width, height, totalWidth, totalHeight int) *Board {
	r := rand.New(rand.NewSource(time.Now().UnixNano() + int64(startY+startY)))
	return newPartial(startX, startY, width, height, totalWidth, totalHeight, r)
}

func NewRemote(width, height int) *Board {
	log.Printf("Start creating board %v x %v", width, height)
	b := newBlank(width, height)

	xRegions := (width + (regionWidth - 1)) / regionWidth
	yRegions := (height + (regionHeight - 1)) / regionHeight

	returnChan := make(chan response, 32)
	go b.genRegions(xRegions, yRegions, returnChan)

	for answers := 0; xRegions*yRegions > answers; answers++ {
		result := <-returnChan
		log.Printf("Received partial: x=%v, y=%v, width=%v, height=%v\n", result.x, result.y, result.width, result.height)
		for ry := 0; ry < result.height; ry++ {
			i, _ := b.xyToIndex(result.x, result.y+ry)
			n, err := result.boardTile.Read(b.data[i : i+byteIndex(result.width)])
			if err != nil {
				log.Printf("ERROR reading after %v bytes: %v", n, err)
			}
		}
		result.boardTile.Close()
	}

	b.placeIglo()
	log.Printf("Finished creating board %v x %v\n", width, height)
	return b
}

func (b *Board) placeIglo() {
	b.Finish.X = b.Width - 2
	b.Finish.Y = rand.Intn(b.Height-2) + 1
	b.Set(b.Finish.X, b.Finish.Y, Iglo)
	b.Set(b.Finish.X, b.Finish.Y-1, Water)
	b.Set(b.Finish.X, b.Finish.Y+1, Water)
	b.Set(b.Finish.X-1, b.Finish.Y, Water)
	b.Set(b.Finish.X+1, b.Finish.Y, Water)
}

func (b *Board) genRegions(xRegions, yRegions int, responseChan chan response) {

	for i := 0; i < xRegions; i++ {
		for j := 0; j < yRegions; j++ {
			var partialWidth, partialHeight int
			x := i * regionWidth
			y := j * regionHeight

			if x+regionWidth > b.Width {
				partialWidth = b.Width - x
			} else {
				partialWidth = regionWidth
			}

			if y+regionHeight > b.Height {
				partialHeight = b.Height - y
			} else {
				partialHeight = regionHeight
			}

			requestUrl := fmt.Sprintf("http://localhost:8081/?totalWidth=%v&totalHeight=%v&width=%v&height=%v&x=%v&y=%v", b.Width, b.Height, partialWidth, partialHeight, x, y)
			log.Printf("Requested generation of tile with url: %v\n", requestUrl)

			resp, err := http.Get(requestUrl)

			if err != nil {
				log.Printf("ERROR requesting region: %v", err)
				continue
			}

			result := response{
				x:         x,
				y:         y,
				width:     partialHeight,
				height:    partialHeight,
				boardTile: resp.Body,
			}

			responseChan <- result
		}
	}
}

func (b *Board) Set(x, y int, t TileType) {
	i, p := b.xyToIndex(x, y)
	b.data[i] = (b.data[i] & setMask[p]) | byte(t)<<(p<<1)
}

func (b *Board) Get(x, y int) TileType {
	i, p := b.xyToIndex(x, y)
	return TileType((b.data[i] & getMask[p]) >> uint(p<<1))
}

// Returns the index and offset inside the byte.
func (b *Board) xyToIndex(x, y int) (int, uint) {
	width := byteIndex(b.Width) * 4
	index := y*width + x
	i := index / 4
	p := index % 4
	return i, uint(p)
}

func byteIndex(x int) int {
	return (x + 3) / 4
}

func (b *Board) WriteData(w io.Writer) {
	n, err := w.Write(b.data)

	if err != nil {
		fmt.Errorf("Error writing board after %v bytes: %v", n, err)
	}
}

func (b *Board) WriteJSON(w io.Writer, startCol, startRow, cols, rows int) {
	sc, sr, cols, rows := sanitizeViewPort(b, startCol, startRow, cols, rows)
	fmt.Fprintf(w, "{\"x\":%v,\"y\":%v,\"rows\":%v,\"cols\":%v,\"tiles\":[", sc, sr, cols, rows)

	for y := startRow; y < sr+rows; y++ {
		for x := startCol; x < sc+cols; x++ {
			if !(x == startCol && y == startRow) {
				w.Write([]byte{','})
			}
			t := &jsonTile{x, y, b.Get(x, y).Name(), ""}
			bs, _ := json.Marshal(t)
			w.Write(bs)
		}
	}

	fmt.Fprintf(w, "]}")
}

func (b *Board) String() string {
	var buffer bytes.Buffer

	for y := 0; y < b.Height; y++ {
		for x := 0; x < b.Width; x++ {
			buffer.WriteString(b.Get(x, y).String())
		}
		buffer.WriteString(fmt.Sprintln())
	}

	return buffer.String()
}

func newBlank(width, height int) *Board {
	return &Board{
		Width:  width,
		Height: height,
		data:   make([]byte, byteIndex(width)*height),
	}
}

func new(width, height int, r *rand.Rand) *Board {
	return newPartial(0, 0, width, height, width, height, r)
}

func newPartial(startX, startY, width, height, totalWidth, totalHeight int, r *rand.Rand) *Board {
	b := newBlank(width, height)
	leftLimit := (totalWidth-maxIceWidth)/2 - startX
	rightLimit := totalWidth/2 + maxIceWidth/2 - startX
	mid := totalWidth/2 - startX

	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ {
			switch {
			case r.Intn(10) > 7:
				b.Set(x, y, Rock)
			case x > leftLimit && x < rightLimit && r.Intn(maxIceWidth) >= abs(mid-x):
				b.Set(x, y, Ice)
			default:
				b.Set(x, y, Water)
			}
		}
	}

	return b
}

func sanitizeViewPort(b *Board, startCol, startRow, cols, rows int) (int, int, int, int) {
	if startCol > b.Width {
		startCol = b.Width
	}
	if startCol < 0 {
		cols += startCol
		startCol = 0
	}
	if startRow > b.Height {
		startRow = b.Height
	}
	if startRow < 0 {
		rows += startRow
		startRow = 0
	}
	if startCol+cols > b.Width {
		cols = b.Width - startCol
	}
	if startRow+rows > b.Height {
		rows = b.Height - startRow
	}
	if cols < 0 {
		cols = 0
	}
	if rows < 0 {
		rows = 0
	}
	return startCol, startRow, cols, rows
}

func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}