Add basic snapshot data types + symbols (#202)

Basic work on snapshotting logic

This PR provides a basic snapshotting library that makes a symbolic representation of a go-board. Very basic initial start on the idea.

Partial work on: #13

Author: artasparks

core/movetree/node.go

@@ -43,6 +43,8 @@ type Node struct {
 	// example, handicap stones will be in in placements.
 	Placements []*move.Move
 
+	// TODO(#193): Move GameInfo property to MoveTree struct.
+
 	// GameInfo contains properties only found on the root. Should be nil on
 	// non-root nodes.
 	GameInfo *GameInfo

core/snapshot/intersection.go

@@ -0,0 +1,42 @@
+package snapshot
+
+import (
+	"github.com/otrego/clamshell/core/point"
+	"github.com/otrego/clamshell/core/snapshot/symbol"
+)
+
+// Intersection contains information for a single intersection
+type Intersection struct {
+	// The Point for this intersection.
+	Point *point.Point
+
+	// The Base symbol is the first layer of the intesection, indicating the
+	// underlying board symbol.
+	Base symbol.Symbol
+
+	// The Symbol symbol is the second layer of the intesection, indicating the
+	// black or white stones.
+	Stone symbol.Symbol
+
+	// The Mark symbol is the third layer of the intesection, indicating the
+	// marks on top of the board or stones.
+	Mark symbol.Symbol
+
+	// Label for the intersection. Label should only be set when Mark == TextLabel
+	// or a similar label-mark.
+	Label string
+}
+
+// TopLayerUnicodeString outputs a single character for the intersection, based
+// on the "Top" symbol. This method is primarily for debugging.
+func (n *Intersection) TopLayerUnicodeString() string {
+	switch {
+	case n.Mark != symbol.Empty:
+		return n.Mark.UnicodeString()
+	case n.Stone != symbol.Empty:
+		return n.Stone.UnicodeString()
+	case n.Base != symbol.Empty:
+		return n.Base.UnicodeString()
+	}
+	return " "
+}

core/snapshot/intersection_test.go

@@ -0,0 +1,46 @@
+package snapshot
+
+import (
+	"testing"
+
+	"github.com/otrego/clamshell/core/snapshot/symbol"
+)
+
+func TestIntersection_TopLayerUnicodeChar(t *testing.T) {
+	testCases := []struct {
+		in  *Intersection
+		exp string
+	}{
+		{
+			in: &Intersection{
+				Base: symbol.TopLeft,
+			},
+			exp: "┏",
+		},
+		{
+			in: &Intersection{
+				Base:  symbol.TopLeft,
+				Stone: symbol.BlackStone,
+			},
+			exp: "●",
+		},
+		{
+			in: &Intersection{
+				Base:  symbol.TopLeft,
+				Stone: symbol.BlackStone,
+				Mark:  symbol.Xmark,
+			},
+			exp: "☓",
+		},
+		{
+			in:  &Intersection{},
+			exp: " ",
+		},
+	}
+
+	for _, tc := range testCases {
+		if out := tc.in.TopLayerUnicodeString(); out != tc.exp {
+			t.Errorf("(%v).TopLayerUnicodeString()=%s, but expected %s", tc.in, out, tc.exp)
+		}
+	}
+}

core/snapshot/snapshot.go

@@ -0,0 +1,40 @@
+// Package snapshot makes a flattened, abstracted snapshot of a game
+// position.
+//
+// This is based on the flattener logic from glift-core:
+// https://github.com/Kashomon/glift-core/tree/master/src/flattener
+package snapshot
+
+import (
+	"github.com/otrego/clamshell/core/bbox"
+	"github.com/otrego/clamshell/core/movetree"
+)
+
+// Options contains options for creating flattened snapshots.
+type Options struct {
+}
+
+// Create a new Snapshot from a given movetree and path.
+func Create(mt *movetree.MoveTree, position movetree.Path, opts *Options) *Snapshot {
+	return &Snapshot{}
+}
+
+// A Snapshot represents a specific board position, which can be used during
+// image generation.
+type Snapshot struct {
+	// Comment for this position.
+	Comment string
+
+	// Borad contains the symbolic representation of the display of the board.
+	Board *Board
+}
+
+// Board is a snapshot-board representation. It can be cropped.
+type Board struct {
+	// Intersections contain the intersections for the board.
+	Intersections [][]*Intersection
+
+	// The CropBox for the board, specifying the original size and the cropped
+	// bounding box.
+	CropBox *bbox.CropBox
+}

core/snapshot/symbol/symbol.go

@@ -0,0 +1,90 @@
+// Package symbol contains an inventory of intersection symbol.
+package symbol
+
+// Symbol represents an intersection on the board.
+type Symbol int
+
+const (
+	// Empty is the default symbol.
+	Empty Symbol = 0
+
+	// TopLeft corner of the board.
+	TopLeft Symbol = 10
+	// TopRight corner of the board.
+	TopRight Symbol = 11
+	// BottomLeft corner of the board.
+	BottomLeft Symbol = 12
+	// BottomRight corner of the board.
+	BottomRight Symbol = 13
+	// TopEdge of the board.
+	TopEdge Symbol = 14
+	// BottomEdge of the board.
+	BottomEdge Symbol = 15
+	// LeftEdge of the board.
+	LeftEdge Symbol = 16
+	// RightEdge of the board.
+	RightEdge Symbol = 17
+	// Center of the board.
+	Center Symbol = 18
+	// StarPoint of the board.
+	StarPoint Symbol = 19
+
+	// BlackStone is a black stone.
+	BlackStone Symbol = 20
+	// WhiteStone is a white stone.
+	WhiteStone Symbol = 21
+
+	// Triangle is a triangle-mark.
+	Triangle Symbol = 30
+	// Square is a square-mark.
+	Square Symbol = 31
+	// Circle is a circle-mark.
+	Circle Symbol = 32
+	// Xmark is an x-mark.
+	Xmark Symbol = 33
+
+	// TextLabel represents some arbitrary text-label mark.
+	TextLabel Symbol = 34
+)
+
+// UnicodeString converts a symbol representation to a single char. This method is
+// primarily for debugging.
+func (s Symbol) UnicodeString() string {
+	switch s {
+	case TopLeft:
+		return "┏"
+	case TopRight:
+		return "┓"
+	case BottomLeft:
+		return "┗"
+	case BottomRight:
+		return "┛"
+	case TopEdge:
+		return "┳"
+	case BottomEdge:
+		return "┻"
+	case LeftEdge:
+		return "┣"
+	case RightEdge:
+		return "┫"
+	case Center:
+		return "╋"
+	case StarPoint:
+		return "✻"
+	case BlackStone:
+		return "●"
+	case WhiteStone:
+		return "○"
+	case Triangle:
+		return "▴"
+	case Square:
+		return "□"
+	case Circle:
+		return "⊙"
+	case Xmark:
+		return "☓"
+	case TextLabel:
+		return "☒"
+	}
+	return "?"
+}

core/snapshot/symbol/symbol_test.go

@@ -0,0 +1,13 @@
+package symbol
+
+import "testing"
+
+func TestUnicodeString(t *testing.T) {
+	if got := TopLeft.UnicodeString(); got != "┏" {
+		t.Errorf("expected TopLeft.UnicodeString() == \"┏\", but was %q", got)
+	}
+
+	if got := Symbol(100).UnicodeString(); got != "?" {
+		t.Errorf("expected unknown.UnicodeString() == \"?\", but was %q", got)
+	}
+}