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 req struct {
	x, y, width, height int
}

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

const maxIceWidth = 26

// 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()))
	return newPartial(startX, startY, width, height, totalWidth, totalHeight, r)
}

func NewRemote(width, height int) *Board {
	b := &Board{
		Width:  width,
		Height: height,
		data:   make([]byte, (width*height)/4+1),
	}

	log.Printf("Start creating board %v x %v", width, height)

	regionWidth := 16
	regionHeight := 16

	regionWidthNum := width / regionWidth
	regionHeightNum := height / regionHeight

	returnChan := make(chan response)

	for i := 0; i < regionWidthNum; i++ {
		for j := 0; j < regionHeightNum; j++ {
			x := i * regionWidth
			y := j * regionHeight

			region := req{
				x:      x,
				y:      y,
				width:  regionWidth,
				height: regionHeight,
			}
			go b.genRegion(region, returnChan)
		}
	}

	answers := 0

	for answers < regionWidthNum*regionHeightNum {
		result := <-returnChan

		fmt.Printf("Received partial: x=%v, y=%v", result.x, result.y)
		for ry := 0; ry < regionHeight; ry++ {
			index := result.x + (result.y+ry)*b.Width
			fmt.Printf("index=%v\n", index)
			i := index / 4 // tiles per byte
			result.boardTile.Read(b.data[i:i+regionWidth/4])
			for _, v := range b.data[i:i+regionWidth/4] {
				fmt.Printf("%b ", v)
			}
			fmt.Println()

		}
		answers++
	}

	igloY := rand.Intn(height-2) + 1

	b.Set(width-2, igloY, Iglo)
	b.Finish.X = width - 2
	b.Finish.Y = igloY
	b.Set(width-2, igloY-1, Water)
	b.Set(width-2, igloY+1, Water)
	log.Printf("Finished creating board %v x %v\n", width, height)

	return b
}

func (b *Board) genRegion(region req, responseChan chan response) {
	requestUrl := fmt.Sprintf("http://localhost:8081/?totalWidth=%v&totalHeight=%v&width=%v&height=%v&x=%v&y=%v", b.Width, b.Height, region.width, region.height, region.x, region.y)
	log.Printf("Requested generation of tile with url: %v\n", requestUrl)
	resp, _ := http.Get(requestUrl)

	result := response{
		x:         region.x,
		y:         region.y,
		boardTile: resp.Body,
	}

	responseChan <- result
}

func (b *Board) Set(x, y int, t TileType) {
	index := uint(y*b.Width + x)
	i := index / 4
	p := index % 4
	b.data[i] = (b.data[i] & setMask[p]) | byte(t)<<(p<<1)
}

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

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 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 := &Board{
		Width:  width,
		Height: height,
		data:   make([]byte, (width*height)/4+1),
	}

	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
}