equity

type BlankLeaves ¶

type BlankLeaves struct{}

func (b *BlankLeaves) LeaveValue(leave tilemapping.MachineWord) float64

type CombinedStaticCalculator ¶

type CombinedStaticCalculator struct {
	// contains filtered or unexported fields
}

CombinedStaticCalculator is a redundant struct that combines the function of several calculators. It is only here for speed purposes.

func NewCombinedStaticCalculator(lexiconName string,
	cfg *config.Config, leaveFilename, pegfile string) (
	*CombinedStaticCalculator, error)

func (csc CombinedStaticCalculator) Equity(play *move.Move, board *board.GameBoard,
	bag *tilemapping.Bag, oppRack *tilemapping.Rack) float64

func (csc CombinedStaticCalculator) LeaveValue(leave tilemapping.MachineWord) float64

type EndgameAdjustmentCalculator ¶

type EndgameAdjustmentCalculator struct{}

EndgameAdjustmentCalculator returns an equity adjustment for endgame plays. It should only be used if the bag is empty. Note that it doesn't solve the endgame; this should only be used for simulation estimates!

func (eac EndgameAdjustmentCalculator) Equity(play *move.Move, board *board.GameBoard,
	bag *tilemapping.Bag, oppRack *tilemapping.Rack) float64

type EquityCalculator ¶

type EquityCalculator interface {
	// Equity is a catch-all term for most post-score adjustments that
	// need to be made. It includes first-turn placement heuristic,
	// leave calculations, any pre-endgame timing heuristics, and more.
	Equity(play *move.Move, board *board.GameBoard, bag *tilemapping.Bag,
		oppRack *tilemapping.Rack) float64
}

EquityCalculator is a calculator of equity.

type ExhaustiveLeaveCalculator ¶

type ExhaustiveLeaveCalculator struct {
	// contains filtered or unexported fields
}

ExhaustiveLeaveCalculator should apply an equity calculation for all leaves exhaustively.

func NewExhaustiveLeaveCalculator(lexiconName string,
	cfg *config.Config, leaveFilename string) (
	*ExhaustiveLeaveCalculator, error)

func (els ExhaustiveLeaveCalculator) Equity(play *move.Move, board *board.GameBoard,
	bag *tilemapping.Bag, oppRack *tilemapping.Rack) float64

func (els ExhaustiveLeaveCalculator) LeaveValue(leave tilemapping.MachineWord) float64

type KLV ¶ added in v0.6.0

type KLV struct {
	// contains filtered or unexported fields
}

KLV is a Kurnia Leave Value file. It contains a KWG and a list of float32 leave values. We convert to float64 for our internal structures.

func ReadKLV(file io.Reader) (*KLV, error)

func (k *KLV) LeaveValue(leave tilemapping.MachineWord) float64

type Leaves ¶

type Leaves interface {
	LeaveValue(leave tilemapping.MachineWord) float64
}

type NoLeaveCalculator ¶

type NoLeaveCalculator struct{}

NoLeaveCalculator does not take leave into account at all.

func NewNoLeaveCalculator() *NoLeaveCalculator

func (nls *NoLeaveCalculator) Equity(play *move.Move, board *board.GameBoard,
	bag *tilemapping.Bag, oppRack *tilemapping.Rack) float64

func (nls *NoLeaveCalculator) LeaveValue(leave tilemapping.MachineWord) float64

type OpeningAdjustmentCalculator ¶

type OpeningAdjustmentCalculator struct{}

OpeningAdjustmentCalculator returns an equity adjustment for an opening play. It should only be used if the board is empty.

func (oac OpeningAdjustmentCalculator) Equity(play *move.Move, board *board.GameBoard,
	bag *tilemapping.Bag, oppRack *tilemapping.Rack) float64

type PreEndgameAdjustmentCalculator ¶

type PreEndgameAdjustmentCalculator struct {
	// contains filtered or unexported fields
}

PreEndgameAdjustmentCalculator returns an equity adjustment for preendgame plays. It should only be used if the bag is nearly empty. Note that it doesn't solve pre-endgames; this should only be used for simulation estimates!

func NewPreEndgameAdjustmentCalculator(cfg *config.Config, lexiconName string, pegfile string) (*PreEndgameAdjustmentCalculator, error)

func (pac PreEndgameAdjustmentCalculator) Equity(play *move.Move, board *board.GameBoard,
	bag *tilemapping.Bag, oppRack *tilemapping.Rack) float64