Client initial commit.

client/.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Package",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "program": "main.go"
+        }
+    ]
+}

client/client/client.go

@@ -0,0 +1,68 @@
+package client
+
+import (
+	"bufio"
+	"fmt"
+	"net"
+)
+
+type Client struct {
+	conn      net.Conn
+	connected bool
+}
+
+func NewClient() *Client {
+	c := &Client{
+		connected: false,
+	}
+
+	//conn, err := net.Dial("tcp", "localhost:501")
+	conn, err := net.Dial("tcp", "192.168.5.100:501")
+	if err != nil {
+		fmt.Println("Error connecting to server:", err)
+	} else {
+		c.connected = true
+	}
+
+	c.conn = conn
+	return c
+}
+
+func (c *Client) SendData(msg string) {
+	// Send input to the server
+	//fmt.Fprintf(c.conn, msg)
+	_, err := c.conn.Write([]byte(msg))
+	if err != nil {
+		fmt.Println("Error writing to connection:", err)
+		return
+	}
+}
+
+func (c *Client) ReadData(callback func(string)) {
+
+	for {
+		message, err := bufio.NewReader(c.conn).ReadString('\n')
+		if err != nil {
+			fmt.Println("Error reading from server:", err)
+			return
+		}
+
+		if callback != nil {
+			callback(message)
+		}
+	}
+
+}
+
+func (c *Client) GetLocalAddr() string {
+	return c.conn.LocalAddr().String()
+}
+
+func (c *Client) IsConnected() bool {
+	return c.connected
+}
+
+func (c *Client) Disconnect() {
+	c.conn.Close()
+	c.connected = false
+}

client/client/identity.go

@@ -0,0 +1,7 @@
+package client
+
+import "net"
+
+type Identity struct {
+	conn net.Conn
+}

client/elements/block.go

@@ -0,0 +1,38 @@
+package elements
+
+import (
+	"client/gamedata"
+	"image/color"
+
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+type Block struct {
+	Sprite   *ebiten.Image
+	cycle    int
+	position gamedata.Coordinates
+}
+
+func NewBlock() *Block {
+	return &Block{
+		Sprite: ebiten.NewImage(20, 20),
+		cycle:  0,
+	}
+}
+
+func (b *Block) Update() {
+	b.cycle++
+}
+
+func (b *Block) Draw() {
+	b.Sprite.Clear()
+	b.Sprite.Fill(color.RGBA{R: 0xff, G: 0x00, B: 0x00, A: 0x00})
+}
+
+func (b *Block) SetPosition(pos gamedata.Coordinates) {
+	b.position = pos
+}
+
+func (b *Block) GetPosition() gamedata.Coordinates {
+	return b.position
+}

client/fonts/fonts.go

@@ -0,0 +1,81 @@
+package fonts
+
+import (
+	"bytes"
+	"log"
+
+	_ "embed"
+
+	"github.com/hajimehoshi/ebiten/v2/text/v2"
+	"golang.org/x/image/font"
+	"golang.org/x/image/font/opentype"
+	"golang.org/x/image/font/sfnt"
+)
+
+const (
+	FontDPI          = 72
+	FontSizeStandard = 16
+	FontSizeLarge    = 24
+)
+
+type FontStruct struct {
+	Standard font.Face
+	Large    font.Face
+	New      *text.GoTextFaceSource
+	Bitfont  *text.GoTextFaceSource
+}
+
+var (
+
+	//go:embed vcrmono.ttf
+	vcrmono_ttf []byte
+	//go:embed bitbybit.ttf
+	bitbybit_ttf []byte
+
+	LaunchyFont FontStruct
+)
+
+func LoadFontFatal(src []byte) *sfnt.Font {
+	tt, err := opentype.Parse(src)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return tt
+}
+
+func GetFaceFatal(fnt *sfnt.Font, dpi, size float64) font.Face {
+	var face font.Face
+	var err error
+
+	if dpi > 0 && size > 0 && fnt != nil {
+		face, err = opentype.NewFace(fnt, &opentype.FaceOptions{
+			Size:    size,
+			DPI:     dpi,
+			Hinting: font.HintingVertical,
+		})
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return face
+}
+
+func init() {
+	LaunchyFont = FontStruct{}
+
+	fnt := LoadFontFatal(vcrmono_ttf)
+	LaunchyFont.Standard = GetFaceFatal(fnt, FontDPI, FontSizeStandard)
+	LaunchyFont.Large = GetFaceFatal(fnt, FontDPI, FontSizeLarge)
+
+	s, err := text.NewGoTextFaceSource(bytes.NewReader(vcrmono_ttf))
+	if err != nil {
+		log.Fatal(err)
+	}
+	LaunchyFont.New = s
+
+	s, err = text.NewGoTextFaceSource(bytes.NewReader(bitbybit_ttf))
+	if err != nil {
+		log.Fatal(err)
+	}
+	LaunchyFont.Bitfont = s
+}

client/game/game.go

@@ -0,0 +1,175 @@
+package game
+
+import (
+	"client/client"
+	"client/elements"
+	"client/fonts"
+	"client/gamedata"
+	"fmt"
+	"maps"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/text/v2"
+	"golang.org/x/exp/rand"
+)
+
+var (
+	screenWidth  = 640
+	screenHeight = 480
+
+	namelist = []string{"slappy", "mick", "rodney", "george", "ringo", "robin", "temitry "}
+)
+
+func init() {
+	rand.Seed(uint64(time.Now().UnixNano()))
+}
+
+type ClientData struct {
+	Address  string
+	Name     string
+	Position gamedata.Coordinates
+}
+
+type Game struct {
+	name   string
+	blocky *elements.Block
+
+	//players map[client.Identity]
+
+	clients map[string]ClientData
+
+	gameclient *client.Client
+	cycle      int
+
+	position gamedata.Coordinates
+
+	mu sync.Mutex
+}
+
+func NewGame() *Game {
+	g := &Game{
+		gameclient: client.NewClient(),
+		blocky:     elements.NewBlock(),
+		cycle:      0,
+		name:       namelist[rand.Intn(len(namelist))],
+	}
+	g.clients = make(map[string]ClientData)
+	go g.gameclient.ReadData(g.HandleServerData)
+	return g
+}
+
+func (g *Game) Update() error {
+
+	x, y := ebiten.CursorPosition()
+	g.position.X = float64(x)
+	g.position.Y = float64(y)
+
+	g.blocky.SetPosition(g.position)
+
+	//broadcast our position
+	if g.cycle%2 == 0 {
+		if g.gameclient.IsConnected() {
+			g.gameclient.SendData(fmt.Sprintf("%s,%.0f,%.0f\n", g.name, g.position.X, g.position.Y))
+		}
+	}
+
+	//cleanup client list every 2 seconds
+	if g.cycle%120 == 0 {
+		go g.CleanupClients()
+	}
+
+	g.cycle++
+	return nil
+}
+
+func (g *Game) Draw(screen *ebiten.Image) {
+	screen.Clear()
+
+	g.blocky.Draw()
+	op := &ebiten.DrawImageOptions{}
+	op.GeoM.Translate(-float64(g.blocky.Sprite.Bounds().Dx())/2, -float64(g.blocky.Sprite.Bounds().Dy())/2)
+	op.GeoM.Translate(g.blocky.GetPosition().X, g.blocky.GetPosition().Y)
+	screen.DrawImage(g.blocky.Sprite, op)
+	f2 := &text.GoTextFace{
+		Source: fonts.LaunchyFont.New,
+		Size:   12,
+	}
+	top := &text.DrawOptions{}
+	top.GeoM.Translate(g.blocky.GetPosition().X-50, g.blocky.GetPosition().Y+15)
+	text.Draw(screen, "you ("+g.name+")", f2, top)
+
+	g.mu.Lock()
+	clientcopy := maps.Clone(g.clients)
+	g.mu.Unlock()
+	for _, client := range clientcopy {
+		op := &ebiten.DrawImageOptions{}
+		op.GeoM.Translate(-float64(g.blocky.Sprite.Bounds().Dx())/2, -float64(g.blocky.Sprite.Bounds().Dy())/2)
+		op.GeoM.Translate(client.Position.X, client.Position.Y)
+		screen.DrawImage(g.blocky.Sprite, op)
+
+		f2 := &text.GoTextFace{
+			Source: fonts.LaunchyFont.New,
+			Size:   12,
+		}
+		top := &text.DrawOptions{}
+		top.GeoM.Translate(client.Position.X, client.Position.Y)
+		text.Draw(screen, client.Name, f2, top)
+	}
+
+}
+
+func (g *Game) Layout(outsideWidth, outsideHeight int) (screenwidth, screenheight int) {
+	return screenWidth, screenHeight
+}
+
+func (g *Game) HandleServerData(data string) {
+	//log.Println(data)
+
+	raw := data[1 : len(data)-1]
+	clientinfo := strings.Split(raw, ";")
+	for _, info := range clientinfo {
+		subdata := strings.Split(info, ",")
+
+		if len(subdata) == 4 {
+
+			if g.gameclient.GetLocalAddr() != subdata[0] {
+
+				x, err := strconv.Atoi(subdata[2])
+				if err != nil {
+					x = 0
+				}
+
+				y, err := strconv.Atoi(subdata[3])
+				if err != nil {
+					y = 0
+				}
+
+				update := ClientData{
+					Address: subdata[0],
+					Name:    subdata[1],
+					Position: gamedata.Coordinates{
+						X: float64(x),
+						Y: float64(y),
+					},
+				}
+
+				g.mu.Lock()
+				g.clients[update.Address] = update
+				g.mu.Unlock()
+			}
+		}
+	}
+
+}
+
+func (g *Game) CleanupClients() {
+	g.mu.Lock()
+	for k := range g.clients {
+		delete(g.clients, k)
+	}
+	g.mu.Unlock()
+}

client/gamedata/gamedata.go

@@ -0,0 +1,6 @@
+package gamedata
+
+type Coordinates struct {
+	X float64 `json:"X"`
+	Y float64 `json:"Y"`
+}

client/go.mod

@@ -0,0 +1,22 @@
+module client
+
+go 1.22.0
+
+toolchain go1.22.10
+
+require (
+	github.com/hajimehoshi/ebiten/v2 v2.8.5
+	golang.org/x/exp v0.0.0-20241204233417-43b7b7cde48d
+	golang.org/x/image v0.20.0
+)
+
+require (
+	github.com/ebitengine/gomobile v0.0.0-20240911145611-4856209ac325 // indirect
+	github.com/ebitengine/hideconsole v1.0.0 // indirect
+	github.com/ebitengine/purego v0.8.0 // indirect
+	github.com/go-text/typesetting v0.2.0 // indirect
+	github.com/jezek/xgb v1.1.1 // indirect
+	golang.org/x/sync v0.10.0 // indirect
+	golang.org/x/sys v0.25.0 // indirect
+	golang.org/x/text v0.18.0 // indirect
+)

client/main.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"client/game"
+	"log"
+
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+func main() {
+
+	game := game.NewGame()
+	ebiten.SetWindowSize(640*1.5, 480*1.5)
+	ebiten.SetWindowTitle("game")
+
+	err := ebiten.RunGame(game)
+	if err != nil {
+		log.Fatal(err)
+	}
+}