bgammon-bei-bot/bot/bei.go

package bot

import (
	"fmt"
	"net"
	"strconv"
	"time"

	"code.rocket9labs.com/tslocum/bei"
	"code.rocket9labs.com/tslocum/bgammon"
)

type BEIClient struct {
	address    string
	conn       net.Conn
	connected  bool
	terminated bool
	quiet      bool
	started    time.Time
}

func NewBEIClient(address string, quiet bool) *BEIClient {
	c := &BEIClient{
		address: address,
		quiet:   quiet,
		started: time.Now(),
	}
	return c
}

func NewLocalBEIClient(conn net.Conn, quiet bool) *BEIClient {
	c := &BEIClient{
		conn:    conn,
		quiet:   quiet,
		started: time.Now(),
	}
	return c
}

func (c *BEIClient) Connect() error {
	if c.terminated {
		return nil
	}

	if c.conn == nil {
		conn, err := net.Dial("tcp", c.address)
		if err != nil {
			return err
		}
		c.connected = true
		c.conn = conn
	}

	c.conn.Write([]byte("bei\n"))
	buf, err := c.readLine()
	if err != nil {
		return err
	}
	response, err := bei.DecodeEvent(buf)
	if err != nil {
		return err
	}
	if _, ok := response.(*bei.EventOkBEI); !ok {
		return fmt.Errorf("unexpected reply from server")
	}
	return nil
}

func (c *BEIClient) readLine() ([]byte, error) {
	var buf []byte
	b := make([]byte, 1)
	for {
		n, err := c.conn.Read(b)
		if err != nil {
			return nil, err
		} else if n != 1 {
			return nil, fmt.Errorf("zero read")
		}
		if b[0] == '\n' {
			return buf, nil
		}
		buf = append(buf, b[0])
	}
}

func (c *BEIClient) Double(state []int8) (interface{}, error) {
	if c.terminated {
		return nil, nil
	} else if !c.connected {
		err := c.Connect()
		if err != nil {
			return nil, fmt.Errorf("failed to connect to engine at %s: %s", c.address, err)
		}
	}

	var stateBytes []byte
	for i, v := range state {
		if i > 0 {
			stateBytes = append(stateBytes, ',')
		}
		stateBytes = append(stateBytes, []byte(strconv.Itoa(int(v)))...)
	}

	c.conn.Write([]byte(fmt.Sprintf("double %s\n", stateBytes)))
	buf, err := c.readLine()
	if err != nil {
		return nil, err
	}
	return bei.DecodeEvent(buf)
}

func (c *BEIClient) Move(state []int8) (interface{}, error) {
	if c.terminated {
		return nil, nil
	} else if !c.connected {
		err := c.Connect()
		if err != nil {
			return nil, fmt.Errorf("failed to connect to engine at %s: %s", c.address, err)
		}
	}

	var stateBytes []byte
	for i, v := range state {
		if i > 0 {
			stateBytes = append(stateBytes, ',')
		}
		stateBytes = append(stateBytes, []byte(strconv.Itoa(int(v)))...)
	}

	c.conn.Write([]byte(fmt.Sprintf("move %s\n", stateBytes)))
	buf, err := c.readLine()
	if err != nil {
		return nil, err
	}
	return bei.DecodeEvent(buf)
}

func (c *BEIClient) Choose(state []int8) (interface{}, error) {
	if c.terminated {
		return nil, nil
	} else if !c.connected {
		err := c.Connect()
		if err != nil {
			return nil, fmt.Errorf("failed to connect to engine at %s: %s", c.address, err)
		}
	}

	var stateBytes []byte
	for i, v := range state {
		if i > 0 {
			stateBytes = append(stateBytes, ',')
		}
		stateBytes = append(stateBytes, []byte(strconv.Itoa(int(v)))...)
	}

	c.conn.Write([]byte(fmt.Sprintf("choose %s\n", stateBytes)))
	buf, err := c.readLine()
	if err != nil {
		return nil, err
	}
	return bei.DecodeEvent(buf)
}

func beiState(game *bgammon.Game) []int8 {
	// TODO send turn numbers
	var state []int8
	state = append(state, game.Board...)
	state = append(state, game.Roll1, game.Roll2, game.Roll3, 1, 1, game.DoubleValue, game.DoublePlayer, game.Player1.Points, game.Player2.Points, game.Points)
	entered1, entered2 := int8(1), int8(1)
	if game.Variant != bgammon.VariantBackgammon {
		if !game.Player1.Entered {
			entered1 = 0
		}
		if !game.Player2.Entered {
			entered2 = 0
		}
	}
	return append(state, 0, 0, 0, 0, game.Variant, entered1, entered2)
}