igoui

main.go (5935B)

---

 package main
 
 import (
 	"image"
 	"image/color"
 	"strings"
 	// "image/png"
 	"fmt"
 	"log"
 	"os"
 
 	// UI generation
 	"gioui.org/app"
 	"gioui.org/f32"
 	"gioui.org/io/event"
 	"gioui.org/io/key"
 	"gioui.org/io/pointer"
 	"gioui.org/layout"
 	"gioui.org/op"
 	"gioui.org/op/clip"
 	"gioui.org/op/paint"
 	"gioui.org/unit"
 	"gioui.org/widget"
 	"gioui.org/widget/material"
 	// "gioui.org/text"
 	// "gioui.org/widget/material"
 
 	// SGF manipulation
 	"github.com/rooklift/sgf"
 )
 
 type App struct {
 	Node   *sgf.Node
 	Katago *Katago
 	Editor material.EditorStyle
 }
 
 func (g *App) SetNode(node *sgf.Node) {
 	if g.Node != nil {
 		newcomment := g.Editor.Editor.Text()
 		_, present := g.Node.GetValue("C")
 		if newcomment != "" || present {
 			g.Node.SetValue("C", newcomment)
 		}
 	}
 	g.Node = node
 
 	val, ok := node.GetValue("C")
 	if ok {
 		g.Editor.Editor.SetText(val)
 	} else {
 		g.Editor.Editor.SetText("")
 	}
 
 	go g.AnalyzeCurrent()
 }
 
 func (g *App) AnalyzeCurrent() {
 	root := g.Node.GetRoot()
 	board := root.Board()
 	rules, _ := root.GetValue("RU")
 
 	line := g.Node.GetLine()
 
 	moves := make([][]string, 0)
 	for _, inner := range line {
 		move, iswhite := inner.GetValue("W")
 		var color string
 		var isblack bool
 		if iswhite {
 			color = "W"
 		} else if move, isblack = inner.GetValue("B"); isblack {
 			color = "B"
 		}
 
 		if iswhite || isblack {
 			x, y, _ := sgf.ParsePoint(move, board.Size)
 			moves = append(moves, []string{color, fmt.Sprintf("(%d,%d)", x, y)})
 		}
 	}
 
 	initialStones := make([][]string, 0)
 
 	_, present := root.GetValue("HA")
 	if present {
 		log.Fatal("TODO")
 	}
 
 	request := Request{
 		Komi:          root.RootKomi(),
 		Rules:         strings.ToLower(rules),
 		XSize:         board.Size,
 		YSize:         board.Size,
 		Moves:         moves,
 		InitialStones: initialStones,
 	}
 
 	respch, err := g.Katago.request(request)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	log.Print("Waiting for response")
 	resp := <-respch
 	log.Print("Got response ", resp)
 }
 
 // Draws the goban in the area
 // Also handles navigation of the game tree
 func (g *App) LayoutGoban(gtx layout.Context) layout.Dimensions {
 	size := min(gtx.Constraints.Max.X, gtx.Constraints.Max.Y)
 	const padding = 2
 	black := color.NRGBA{A: 0xFF}
 	white := color.NRGBA{A: 0xFF, R: 0xFF, G: 0xFF, B: 0xFF}
 
 	// Handle inputs within the goban area
 	{
 		defer clip.Rect(image.Rect(0, 0, size, size)).Push(gtx.Ops).Pop()
 		offset := float32(size) / float32(g.Node.Board().Size)
 
 		event.Op(gtx.Ops, g)
 
 		for {
 			ev, ok := gtx.Event(pointer.Filter{
 				Target: g,
 				Kinds:  pointer.Press,
 			}, key.Filter{
 				Name: key.NameDownArrow,
 			}, key.Filter{
 				Name: key.NameUpArrow,
 			})
 			if !ok {
 				break
 			}
 
 			var newnode *sgf.Node
 			switch ev.(type) {
 			case pointer.Event:
 				{
 					e := ev.(pointer.Event)
 					switch e.Kind {
 					case pointer.Press:
 						xpos := int(e.Position.X / offset)
 						ypos := int(e.Position.Y / offset)
 						var err error
 						newnode, err = g.Node.Play(sgf.Point(xpos, ypos))
 						if err != nil {
 							newnode = nil
 						}
 						newnode.MakeMainLine()
 					}
 				}
 			case key.Event:
 				{
 					e := ev.(key.Event)
 					if e.State == key.Press {
 						switch e.Name {
 						case key.NameDownArrow:
 							newnode = g.Node.MainChild()
 						case key.NameUpArrow:
 							newnode = g.Node.Parent()
 						}
 					}
 				}
 			}
 			if newnode != nil {
 				g.SetNode(newnode)
 			}
 		}
 	}
 
 	board := g.Node.Board()
 	offset := float32(size) / float32(board.Size)
 
 	// Draw the frame
 	var path clip.Path
 	path.Begin(gtx.Ops)
 	foffset := offset / 2
 	for i := 0; i < board.Size; i++ {
 		ioffset := float32(offset)*float32(i) + foffset
 		// Line from left to right
 		path.MoveTo(f32.Pt(ioffset, foffset))
 		path.LineTo(f32.Pt(ioffset, float32(size)-foffset))
 
 		// Line from top to bottom
 		path.MoveTo(f32.Pt(foffset, ioffset))
 		path.LineTo(f32.Pt(float32(size)-foffset, ioffset))
 	}
 	path.Close()
 	paint.FillShape(gtx.Ops, black, clip.Stroke{
 		Path:  path.End(),
 		Width: 4,
 	}.Op())
 
 	// Now draw the stones
 	// TODO: images ?
 	for x := 0; x < board.Size; x++ {
 		for y := 0; y < board.Size; y++ {
 			if board.State[x][y] != sgf.EMPTY {
 				scolor := board.State[x][y]
 				fx := float32(x)
 				fy := float32(y)
 				rect := image.Rect(int(fx*offset+padding/2), int(fy*offset+padding/2), int((fx+1)*offset-padding/2), int((fy+1)*offset-padding/2))
 				elipse := clip.Ellipse(rect)
 
 				var strokecolor color.NRGBA
 				var fillcolor color.NRGBA
 
 				if scolor == sgf.BLACK {
 					strokecolor = white
 					fillcolor = black
 				} else {
 					strokecolor = black
 					fillcolor = white
 				}
 
 				// Now that we have the rectangle, put the stone
 				paint.FillShape(gtx.Ops, fillcolor, elipse.Op(gtx.Ops))
 				paint.FillShape(gtx.Ops, strokecolor, clip.Stroke{
 					Path:  elipse.Path(gtx.Ops),
 					Width: padding,
 				}.Op())
 			}
 		}
 	}
 
 	return layout.Dimensions{Size: image.Pt(size, size)}
 }
 
 func run(window *app.Window, goban *App) error {
 	var ops op.Ops
 
 	for {
 		switch e := window.Event().(type) {
 		case app.DestroyEvent:
 			return e.Err
 		case app.FrameEvent:
 			// This graphics context is used for managing the rendering state.
 			gtx := app.NewContext(&ops, e)
 
 			layout.Flex{}.Layout(gtx,
 				layout.Rigid(func(gtx layout.Context) layout.Dimensions {
 					return layout.UniformInset(unit.Dp(30)).Layout(gtx, goban.LayoutGoban)
 				}),
 				layout.Flexed(0.5, goban.Editor.Layout),
 			)
 
 			// Pass the drawing operations to the GPU.
 			e.Frame(gtx.Ops)
 		}
 	}
 }
 
 func main() {
 	th := material.NewTheme()
 	goban := new(App)
 
 	// Start KataGo
 	kat, err := newKatago()
 	if err != nil {
 		log.Fatal(err)
 	}
 	goban.Katago = kat
 
 	goban.Editor = material.Editor(th, new(widget.Editor), "")
 	goban.SetNode(sgf.LoadArgOrQuit(1))
 
 	go func() {
 		window := new(app.Window)
 		window.Option(app.MinSize(unit.Dp(1000), unit.Dp(700)))
 		err := run(window, goban)
 		if err != nil {
 			log.Fatal(err)
 		}
 		os.Exit(0)
 	}()
 
 	app.Main()
 }