Hochwasser/rpc/repl.go

193 lines
4.2 KiB
Go

package rpc
import (
"bufio"
"encoding/hex"
"fmt"
"image"
"image/color"
"os"
"strconv"
"strings"
"github.com/SpeckiJ/Hochwasser/render"
)
// Fluter implements flut operations that can be triggered via a REPL
type Fluter interface {
getTask() FlutTask
applyTask(FlutTask)
stopTask()
toggleMetrics()
}
const commandMode = "cmd"
const textMode = "txt"
// RunREPL starts reading os.Stdin for commands to apply to the given Fluter
func RunREPL(f Fluter) {
mode := commandMode
textSize := 10
var textCol image.Image = image.White
var bgCol image.Image = image.Transparent
fmt.Print("[rán] REPL is active. ")
printHelp()
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
inputStr := scanner.Text()
switch strings.ToLower(mode) {
case textMode:
if strings.ToLower(inputStr) == commandMode {
fmt.Println("[rán] command mode")
mode = commandMode
continue
}
t := f.getTask()
t.Img = render.RenderText(inputStr, textSize, textCol, bgCol)
f.applyTask(t)
case commandMode:
input := strings.Split(inputStr, " ")
cmd := strings.ToLower(input[0])
args := input[1:]
t := f.getTask()
printTask := true
switch cmd {
case "stop":
t.Paused = true
f.stopTask()
printTask = false
case "start":
t.Paused = false
case "offset":
if len(args) == 1 && args[0] == "rand" {
t.RandOffset = true
t.Offset = image.Point{}
} else if len(args) == 2 {
t.RandOffset = false
x, err := strconv.Atoi(args[0])
y, err2 := strconv.Atoi(args[1])
if err == nil && err2 == nil {
t.Offset = image.Pt(x, y)
}
}
case "conns":
if len(args) == 1 {
if conns, err := strconv.Atoi(args[0]); err == nil {
t.MaxConns = conns
}
}
case "addr":
if len(args) == 1 {
t.Address = args[0]
}
case "shuffle":
t.Shuffle = !t.Shuffle
case "rgbsplit":
t.RGBSplit = !t.RGBSplit
case "txt":
if len(args) > 0 {
if size, err := strconv.Atoi(args[0]); err == nil {
textSize = size
}
}
if len(args) > 1 {
textCol = parseColorOrPalette(args[1])
}
if len(args) > 2 {
bgCol = parseColorOrPalette(args[2])
}
if len(args) < 4 {
fmt.Printf("[rán] text mode, return via '%v'\n", strings.ToUpper(commandMode))
mode = textMode
printTask = false
} else {
input := strings.Join(args[3:], " ")
t.Img = render.RenderText(input, textSize, textCol, bgCol)
}
case "img":
if len(args) > 0 {
path := strings.Join(args, " ")
if img, err := render.ReadImage(path); err != nil {
fmt.Println(err)
} else {
t.Img = img
}
}
case "metrics":
f.toggleMetrics()
printTask = false
default:
printTask = false
fmt.Print("[rán] unknown command. ")
printHelp()
}
if printTask {
fmt.Println(t)
}
f.applyTask(t)
}
}
}
func printHelp() {
fmt.Println(`available commands:
start start fluting
stop pause fluting
conns <n> set number of connections per client
addr <host>:<port> set target server
offset <x> <y> set top-left offset
offset rand random offset for each draw
metrics toggle bandwidth reporting (may cost some performance)
img <filepath> set image
txt <scale> <color <bgcolor> <txt> send text
txt [<scale> [<color> [<bgcolor>]] enter interactive text mode
rgbsplit toggle RGB split effect
shuffle toggle between column-wise & randomized draw order`)
}
// try to parse as hex-encoded RGB color,
// alternatively treat it as palette name. If both fail,
// give image.Transparent
func parseColorOrPalette(input string) image.Image {
if input == "w" {
return image.NewUniform(color.White)
} else if input == "b" {
return image.NewUniform(color.Black)
} else if input == "t" {
return image.Transparent
} else if col, err := hex.DecodeString(input); err == nil && len(col) >= 3 {
var alpha byte = 0xff
if len(col) == 4 {
alpha = col[3]
}
return image.NewUniform(color.NRGBA{col[0], col[1], col[2], alpha})
}
if pal := render.PrideFlags[input]; len(pal) != 0 {
return &render.StripePattern{Palette: pal, Size: 13}
}
if p, ok := render.DynPatterns[input]; ok {
return p
}
return image.Transparent
}