Stash bunch of broken generated test with shitty broken mocking

Reviewed-on: #4

.gitignore

@@ -0,0 +1,15 @@
+# Build artifacts
+build/
+goonscape
+goonscape.exe
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+
+# OS files
+.DS_Store
+Thumbs.db 
+
+resources/models/old_and_test/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "goonserver"]
+	path = goonserver
+	url = https://gitea.boner.be/bdnugget/goonserver

.woodpecker.yml

@@ -0,0 +1,25 @@
+pipeline:
+  build:
+    image: golang:1.23
+    commands:
+      # Install build dependencies
+      - apt-get update && apt-get install -y gcc-mingw-w64 cmake zip libasound2-dev mesa-common-dev libx11-dev libxrandr-dev libxi-dev xorg-dev libgl1-mesa-dev libglu1-mesa-dev libwayland-dev wayland-protocols libxkbcommon-dev
+      
+      # Build for all platforms
+      - make all
+    
+    when:
+      event: tag
+      tag: v*
+
+  # Optional: Create Gitea release with built artifacts
+  release:
+    image: plugins/gitea-release
+    settings:
+      api_key: 
+        from_secret: gitea_token
+      base_url: https://gitea.boner.be
+      files: build/*.zip
+    when:
+      event: tag
+      tag: v* 

Dockerfile.build

@@ -0,0 +1,30 @@
+FROM golang:1.23
+
+# Install build dependencies
+RUN apt-get update && apt-get install -y \
+    gcc-mingw-w64 \
+    cmake \
+    zip \
+    libasound2-dev \
+    mesa-common-dev \
+    libx11-dev \
+    libxrandr-dev \
+    libxi-dev \
+    xorg-dev \
+    libgl1-mesa-dev \
+    libglu1-mesa-dev \
+    libwayland-dev \
+    wayland-protocols \
+    libxkbcommon-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /build
+
+# Copy build scripts
+COPY . /build/
+
+# Set execute permissions
+RUN chmod +x /build/scripts/build.sh
+
+# Build command
+CMD ["make", "all"] 

LICENSE

@@ -1,11 +1,21 @@
-“Commons Clause” License Condition v1.0
+MIT License
 
-The Software is provided to you by the Licensor under the License, as defined below, subject to the following condition.
+Copyright (c) 2025 bdnugget
 
-Without limiting other conditions in the License, the grant of rights under the License will not include, and the License does not grant to you,  right to Sell the Software.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-For purposes of the foregoing, “Sell” means practicing any or all of the rights granted to you under the License to provide to third parties, for a fee or other consideration (including without limitation fees for hosting or consulting/ support services related to the Software), a product or service whose value derives, entirely or substantially, from the functionality of the Software.  Any license notice or attribution required by the License must also include this Commons Cause License Condition notice.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-Software: GoonScape
-License: Commons Clause v1.0
-Licensor: bdnugget
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -0,0 +1,30 @@
+.PHONY: all clean windows linux darwin
+
+include scripts/platforms.mk
+
+BINARY_NAME=goonscape
+VERSION=1.1.0
+BUILD_DIR=build
+ASSETS_DIR=resources
+
+all: clean $(PLATFORMS)
+
+$(PLATFORMS):
+	@echo "Building for $@..."
+	@mkdir -p $(BUILD_DIR)/$@
+	@scripts/build.sh $(word 1,$(subst /, ,$@)) $(word 2,$(subst /, ,$@)) \
+		$(BUILD_DIR)/$@/$(BINARY_NAME)$(if $(findstring windows,$@),.exe,)
+	@cp -r $(ASSETS_DIR) $(BUILD_DIR)/$@/
+	@cd $(BUILD_DIR) && zip -r $(BINARY_NAME)-$(word 1,$(subst /, ,$@))-$(word 2,$(subst /, ,$@))-v$(VERSION).zip $@
+	@echo "Done building for $@"
+
+clean:
+	rm -rf $(BUILD_DIR)
+
+# Development build for current platform
+dev:
+	go build -o $(BINARY_NAME)
+
+# Run tests
+test:
+	go test ./... 

README.md

@@ -0,0 +1,124 @@
+# GoonScape
+
+A multiplayer isometric game inspired by Oldschool RuneScape, built with Go and Raylib.
+
+![GoonScape Screenshot](resources/screenshot.png)
+
+## Features
+
+- 3D isometric world with height-mapped terrain
+- Multiplayer support with client-server architecture
+- Pathfinding and click-to-move navigation
+- Global chat system with floating messages
+- Multiple character models
+- Background music
+
+## Prerequisites
+
+- Go 1.23 or higher
+- GCC (for CGO/SQLite support)
+- OpenGL development libraries
+- Raylib dependencies (see [raylib-go](https://github.com/gen2brain/raylib-go#requirements))
+
+## Installation
+
+### Pre-built Binaries
+The easiest way to get started is to download the latest release from:
+```
+https://gitea.boner.be/bdnugget/goonscape/releases
+```
+Choose the appropriate zip file for your platform:
+- Windows: `goonscape-windows-amd64-v1.1.0.zip`
+- Linux: `goonscape-linux-amd64-v1.1.0.zip`
+
+Extract the zip and run the executable.
+
+### Quick Start
+For development:
+```bash
+# Run directly (recommended for development)
+go run main.go
+
+# Run with local server
+go run main.go -local
+```
+
+### Server Setup
+The server requires CGO for SQLite support:
+```bash
+# Enable CGO
+go env -w CGO_ENABLED=1
+
+# Clone and build server
+git clone https://gitea.boner.be/bdnugget/goonserver.git
+cd goonserver
+go build
+```
+
+### Client Installation
+Then install or build:
+```bash
+# Install the client
+go install gitea.boner.be/bdnugget/goonscape@latest
+```
+
+Or build from source:
+```bash
+git clone https://gitea.boner.be/bdnugget/goonscape.git
+cd goonscape
+go build
+```
+
+## Controls
+
+- **Mouse Click**: Move to location
+- **T**: Open chat
+- **Enter**: Send chat message
+- **Escape**: Cancel chat/Close game (it does both of these at the same time so gg)
+- **Arrow Keys**: Rotate camera
+- **Mouse Wheel**: Zoom in/out
+
+## Configuration
+
+Server connection can be configured using command-line flags:
+
+```bash
+# Connect to default server (boner.be:6969)
+go run main.go
+
+# Connect to local server
+go run main.go -local
+
+# Connect to specific server
+go run main.go -addr somehost        # Uses somehost:6969
+go run main.go -addr somehost:6970   # Uses somehost:6970
+```
+
+Note: The `-local` flag is a shorthand for `-addr localhost:6969` and cannot be used together with `-addr`.
+
+## Building Release Binaries
+
+The project uses Docker to create consistent builds across platforms. To build release binaries:
+
+1. Build the Docker image (only needed once):
+```bash
+sudo docker build -t goonscape-builder -f Dockerfile.build .
+```
+
+2. Create release builds:
+```bash
+sudo docker run -v $(pwd):/build goonscape-builder
+```
+
+This will create zip files in the `build` directory for:
+- Windows (64-bit): `goonscape-windows-amd64-v1.0.0.zip`
+- Linux (64-bit): `goonscape-linux-amd64-v1.0.0.zip`
+
+Each zip contains the binary and all required assets.
+
+## Development
+
+The project uses Protocol Buffers for network communication. If you modify the `.proto` files, regenerate the Go code with:
+```bash
+protoc --go_out=. goonserver/actions/actions.proto
+```

assets/assets.go

@@ -0,0 +1,103 @@
+package assets
+
+import (
+	"gitea.boner.be/bdnugget/goonscape/types"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+// Helper function to load animations for a model
+func loadModelAnimations(animPaths map[string]string) (types.AnimationSet, error) {
+	var animSet types.AnimationSet
+
+	// Load idle animations if specified
+	if idlePath, ok := animPaths["idle"]; ok {
+		idleAnims := rl.LoadModelAnimations(idlePath)
+		if len(idleAnims) > 0 {
+			animSet.Idle = idleAnims
+			rl.TraceLog(rl.LogInfo, "Loaded idle animation: %s (%d frames, %f seconds)",
+				idlePath, idleAnims[0].FrameCount, float32(idleAnims[0].FrameCount)/60.0)
+		}
+	}
+
+	// Load walk animations if specified
+	if walkPath, ok := animPaths["walk"]; ok {
+		walkAnims := rl.LoadModelAnimations(walkPath)
+		if len(walkAnims) > 0 {
+			animSet.Walk = walkAnims
+			rl.TraceLog(rl.LogInfo, "Loaded walk animation: %s (%d frames, %f seconds)",
+				walkPath, walkAnims[0].FrameCount, float32(walkAnims[0].FrameCount)/60.0)
+		}
+	}
+
+	return animSet, nil
+}
+
+func LoadModels() ([]types.ModelAsset, error) {
+	// Goonion model and animations
+	goonerModel := rl.LoadModel("resources/models/gooner/walk_no_y_transform.glb")
+	goonerAnims, _ := loadModelAnimations(map[string]string{"idle": "resources/models/gooner/idle_no_y_transform.glb", "walk": "resources/models/gooner/walk_no_y_transform.glb"})
+
+	// Apply transformations
+	transform := rl.MatrixIdentity()
+	transform = rl.MatrixMultiply(transform, rl.MatrixRotateY(180*rl.Deg2rad))
+	transform = rl.MatrixMultiply(transform, rl.MatrixRotateX(-90*rl.Deg2rad))
+	transform = rl.MatrixMultiply(transform, rl.MatrixScale(1.0, 1.0, 1.0))
+	goonerModel.Transform = transform
+
+	// Coomer model (ready for animations)
+	coomerModel := rl.LoadModel("resources/models/coomer/idle_notransy.glb")
+	// coomerTexture := rl.LoadTexture("resources/models/coomer.png")
+	// rl.SetMaterialTexture(coomerModel.Materials, rl.MapDiffuse, coomerTexture)
+	// When you have animations, add them like:
+	coomerAnims, _ := loadModelAnimations(map[string]string{"idle": "resources/models/coomer/idle_notransy.glb", "walk": "resources/models/coomer/unsteadywalk_notransy.glb"})
+	coomerModel.Transform = transform
+
+	// Shreke model (ready for animations)
+	shrekeModel := rl.LoadModel("resources/models/shreke.obj")
+	shrekeTexture := rl.LoadTexture("resources/models/shreke.png")
+	rl.SetMaterialTexture(shrekeModel.Materials, rl.MapDiffuse, shrekeTexture)
+	// When you have animations, add them like:
+	// shrekeAnims, _ := loadModelAnimations("resources/models/shreke.glb",
+	//     map[string]string{
+	//         "idle": "resources/models/shreke_idle.glb",
+	//         "walk": "resources/models/shreke_walk.glb",
+	//     })
+
+	return []types.ModelAsset{
+		{
+			Model:      goonerModel,
+			Animation:  append(goonerAnims.Idle, goonerAnims.Walk...),
+			AnimFrames: int32(len(goonerAnims.Idle) + len(goonerAnims.Walk)),
+			Animations: goonerAnims,
+			YOffset:    0.0,
+		},
+		{
+			Model:      coomerModel,
+			Animation:  append(coomerAnims.Idle, coomerAnims.Walk...),
+			AnimFrames: int32(len(coomerAnims.Idle) + len(coomerAnims.Walk)),
+			Animations: coomerAnims,
+			YOffset:    -4.0,
+		},
+		{Model: shrekeModel, Texture: shrekeTexture},
+	}, nil
+}
+
+func LoadMusic(filename string) (rl.Music, error) {
+	return rl.LoadMusicStream(filename), nil
+}
+
+func UnloadModels(models []types.ModelAsset) {
+	for _, model := range models {
+		if model.Animation != nil {
+			for i := int32(0); i < model.AnimFrames; i++ {
+				rl.UnloadModelAnimation(model.Animation[i])
+			}
+		}
+		rl.UnloadModel(model.Model)
+		rl.UnloadTexture(model.Texture)
+	}
+}
+
+func UnloadMusic(music rl.Music) {
+	rl.UnloadMusicStream(music)
+}

constants.go

@@ -7,6 +7,15 @@ const (
 	MapHeight  = 50
 	TileSize   = 32
 	TileHeight = 2.0
-	TickRate   = 2600 * time.Millisecond // Server tick rate (600ms)
+	TickRate   = 600 * time.Millisecond // Server tick rate (600ms)
 	serverAddr = "localhost:6969"
+
+	// RuneScape-style tick rate (600ms)
+	ServerTickRate = 600 * time.Millisecond
+
+	// Client might run at a higher tick rate for smooth rendering
+	ClientTickRate = 50 * time.Millisecond
+
+	// Maximum number of ticks we can get behind before forcing a resync
+	MaxTickDesync = 5
 )

game/camera.go

@@ -1,4 +1,4 @@
-package main
+package game
 
 import (
 	"math"
@@ -6,8 +6,21 @@ import (
 	rl "github.com/gen2brain/raylib-go/raylib"
 )
 
+var (
+	cameraDistance = float32(20.0)
+	cameraYaw      = float32(145.0)
+	cameraPitch    = float32(45.0)
+)
+
 func UpdateCamera(camera *rl.Camera3D, player rl.Vector3, deltaTime float32) {
-	// Update camera based on mouse wheel
+	// Adjust target position to be at character's torso height (about half character height)
+	characterHeight := float32(32.0) // Assuming character is roughly 32 units tall
+	targetPos := rl.Vector3{
+		X: player.X,
+		Y: player.Y + characterHeight*0.5, // Focus on middle of character
+		Z: player.Z,
+	}
+
 	wheelMove := rl.GetMouseWheelMove()
 	if wheelMove != 0 {
 		cameraDistance += -wheelMove * 5
@@ -19,7 +32,6 @@ func UpdateCamera(camera *rl.Camera3D, player rl.Vector3, deltaTime float32) {
 		}
 	}
 
-	// Orbit camera around the player using arrow keys
 	if rl.IsKeyDown(rl.KeyRight) {
 		cameraYaw += 100 * deltaTime
 	}
@@ -39,16 +51,13 @@ func UpdateCamera(camera *rl.Camera3D, player rl.Vector3, deltaTime float32) {
 		}
 	}
 
-	// Calculate the new camera position using spherical coordinates
 	cameraYawRad := float64(cameraYaw) * rl.Deg2rad
 	cameraPitchRad := float64(cameraPitch) * rl.Deg2rad
-	cameraPos := rl.Vector3{
-		X: player.X + cameraDistance*float32(math.Cos(cameraYawRad))*float32(math.Cos(cameraPitchRad)),
-		Y: player.Y + cameraDistance*float32(math.Sin(cameraPitchRad)),
-		Z: player.Z + cameraDistance*float32(math.Sin(cameraYawRad))*float32(math.Cos(cameraPitchRad)),
-	}
 
-	// Update the camera's position and target
-	camera.Position = cameraPos
-	camera.Target = rl.NewVector3(player.X, player.Y, player.Z)
+	camera.Position = rl.Vector3{
+		X: targetPos.X + cameraDistance*float32(math.Cos(cameraYawRad))*float32(math.Cos(cameraPitchRad)),
+		Y: targetPos.Y + cameraDistance*float32(math.Sin(cameraPitchRad)),
+		Z: targetPos.Z + cameraDistance*float32(math.Sin(cameraYawRad))*float32(math.Cos(cameraPitchRad)),
+	}
+	camera.Target = targetPos
 }

game/chat.go

@@ -0,0 +1,229 @@
+package game
+
+import (
+	"fmt"
+	"time"
+
+	"gitea.boner.be/bdnugget/goonscape/types"
+	pb "gitea.boner.be/bdnugget/goonserver/actions"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+const (
+	maxMessages   = 50
+	chatMargin    = 10 // Margin from screen edges
+	chatHeight    = 200
+	messageHeight = 20
+	inputHeight   = 30
+	runeLimit     = 256
+)
+
+type Chat struct {
+	messages     []types.ChatMessage
+	inputBuffer  []rune
+	isTyping     bool
+	cursorPos    int
+	scrollOffset int
+	userData     interface{}
+	input        InputHandler
+}
+
+func NewChat() *Chat {
+	return &Chat{
+		messages:    make([]types.ChatMessage, 0, maxMessages),
+		inputBuffer: make([]rune, 0, runeLimit),
+		input:       &RaylibInput{},
+	}
+}
+
+func (c *Chat) AddMessage(playerID int32, content string) {
+	msg := types.ChatMessage{
+		PlayerID: playerID,
+		Content:  content,
+		Time:     time.Now(),
+	}
+
+	if len(c.messages) >= maxMessages {
+		c.messages = c.messages[1:]
+	}
+	c.messages = append(c.messages, msg)
+	c.scrollOffset = 0 // Reset scroll position for new messages
+}
+
+func (c *Chat) HandleServerMessages(messages []*pb.ChatMessage) {
+	// Convert protobuf messages to our local type
+	for _, msg := range messages {
+		localMsg := types.ChatMessage{
+			PlayerID: msg.PlayerId,
+			Username: msg.Username,
+			Content:  msg.Content,
+			Time:     time.Unix(0, msg.Timestamp),
+		}
+
+		// Only add if it's not already in our history
+		if len(c.messages) == 0 || c.messages[len(c.messages)-1].Time.UnixNano() < msg.Timestamp {
+			if len(c.messages) >= maxMessages {
+				c.messages = c.messages[1:]
+			}
+			c.messages = append(c.messages, localMsg)
+
+			// Scroll to latest message if it's not already visible
+			visibleMessages := int((chatHeight - inputHeight) / messageHeight)
+			if len(c.messages) > visibleMessages {
+				c.scrollOffset = len(c.messages) - visibleMessages
+			}
+
+			// Add floating message to the player
+			if game, ok := c.userData.(*Game); ok {
+				if msg.PlayerId == game.Player.ID {
+					game.Player.Lock()
+					game.Player.FloatingMessage = &types.FloatingMessage{
+						Content:    msg.Content,
+						ExpireTime: time.Now().Add(6 * time.Second),
+					}
+					game.Player.Unlock()
+				} else if otherPlayer, exists := game.OtherPlayers[msg.PlayerId]; exists {
+					otherPlayer.Lock()
+					otherPlayer.FloatingMessage = &types.FloatingMessage{
+						Content:    msg.Content,
+						ExpireTime: time.Now().Add(6 * time.Second),
+					}
+					otherPlayer.Unlock()
+				}
+			}
+		}
+	}
+}
+
+func (c *Chat) Draw(screenWidth, screenHeight int32) {
+	// Calculate chat window width based on screen width
+	chatWindowWidth := screenWidth - (chatMargin * 2)
+
+	// Draw chat window background
+	chatX := float32(chatMargin)
+	chatY := float32(screenHeight - chatHeight - chatMargin)
+	rl.DrawRectangle(int32(chatX), int32(chatY), chatWindowWidth, chatHeight, rl.ColorAlpha(rl.Black, 0.5))
+
+	// Draw messages from oldest to newest
+	messageY := chatY + 5
+	visibleMessages := int((chatHeight - inputHeight) / messageHeight)
+
+	// Auto-scroll to bottom if no manual scrolling has occurred
+	if c.scrollOffset == 0 {
+		if len(c.messages) > visibleMessages {
+			c.scrollOffset = len(c.messages) - visibleMessages
+		}
+	}
+
+	startIdx := max(0, c.scrollOffset)
+	endIdx := min(len(c.messages), startIdx+visibleMessages)
+
+	for i := startIdx; i < endIdx; i++ {
+		msg := c.messages[i]
+		var color rl.Color
+		if msg.PlayerID == 0 { // System message
+			color = rl.Gold
+		} else {
+			color = rl.White
+		}
+		text := fmt.Sprintf("%s: %s", msg.Username, msg.Content)
+		rl.DrawText(text, int32(chatX)+5, int32(messageY), 20, color)
+		messageY += messageHeight
+	}
+
+	// Draw input field
+	inputY := chatY + float32(chatHeight-inputHeight)
+	rl.DrawRectangle(int32(chatX), int32(inputY), chatWindowWidth, inputHeight, rl.ColorAlpha(rl.White, 0.3))
+	if c.isTyping {
+		inputText := string(c.inputBuffer)
+		rl.DrawText(inputText, int32(chatX)+5, int32(inputY)+5, 20, rl.White)
+
+		// Draw cursor
+		cursorX := rl.MeasureText(inputText[:c.cursorPos], 20)
+		rl.DrawRectangle(int32(chatX)+5+cursorX, int32(inputY)+5, 2, 20, rl.White)
+	} else {
+		rl.DrawText("Press T to chat", int32(chatX)+5, int32(inputY)+5, 20, rl.Gray)
+	}
+}
+
+func (c *Chat) Update() (string, bool) {
+	// Handle scrolling with mouse wheel when not typing
+	if !c.isTyping {
+		wheelMove := rl.GetMouseWheelMove()
+		if wheelMove != 0 {
+			maxScroll := max(0, len(c.messages)-int((chatHeight-inputHeight)/messageHeight))
+			c.scrollOffset = clamp(c.scrollOffset-int(wheelMove), 0, maxScroll)
+		}
+
+		if c.input.IsKeyPressed(rl.KeyT) {
+			c.isTyping = true
+			return "", false
+		}
+		return "", false
+	}
+
+	key := c.input.GetCharPressed()
+	for key > 0 {
+		if len(c.inputBuffer) < runeLimit {
+			c.inputBuffer = append(c.inputBuffer[:c.cursorPos], append([]rune{key}, c.inputBuffer[c.cursorPos:]...)...)
+			c.cursorPos++
+		}
+		key = c.input.GetCharPressed()
+	}
+
+	if c.input.IsKeyPressed(rl.KeyEnter) || c.input.IsKeyPressed(rl.KeyKpEnter) {
+		if len(c.inputBuffer) > 0 {
+			message := string(c.inputBuffer)
+			c.inputBuffer = c.inputBuffer[:0]
+			c.cursorPos = 0
+			c.isTyping = false
+			return message, true
+		}
+		c.isTyping = false
+	}
+
+	if c.input.IsKeyPressed(rl.KeyEscape) && c.isTyping {
+		c.inputBuffer = c.inputBuffer[:0]
+		c.cursorPos = 0
+		c.isTyping = false
+	}
+
+	if c.input.IsKeyPressed(rl.KeyBackspace) && c.cursorPos > 0 {
+		c.inputBuffer = append(c.inputBuffer[:c.cursorPos-1], c.inputBuffer[c.cursorPos:]...)
+		c.cursorPos--
+	}
+
+	if c.input.IsKeyPressed(rl.KeyLeft) && c.cursorPos > 0 {
+		c.cursorPos--
+	}
+	if c.input.IsKeyPressed(rl.KeyRight) && c.cursorPos < len(c.inputBuffer) {
+		c.cursorPos++
+	}
+
+	return "", false
+}
+
+// Add helper functions
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func clamp(value, min, max int) int {
+	if value < min {
+		return min
+	}
+	if value > max {
+		return max
+	}
+	return value
+}

game/chat_test.go

@@ -0,0 +1,106 @@
+package game
+
+import (
+	"testing"
+	"time"
+
+	"gitea.boner.be/bdnugget/goonscape/game/testutils"
+	"gitea.boner.be/bdnugget/goonscape/types"
+	pb "gitea.boner.be/bdnugget/goonserver/actions"
+	rl "github.com/gen2brain/raylib-go/raylib"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestChat_AddMessage(t *testing.T) {
+	chat := NewChat()
+
+	// Test adding single message
+	chat.AddMessage(1, "Hello")
+	assert.Equal(t, 1, len(chat.messages))
+	assert.Equal(t, int32(1), chat.messages[0].PlayerID)
+	assert.Equal(t, "Hello", chat.messages[0].Content)
+
+	// Test message limit
+	for i := 0; i < maxMessages+10; i++ {
+		chat.AddMessage(1, "spam")
+	}
+	assert.Equal(t, maxMessages, len(chat.messages))
+	assert.Equal(t, "spam", chat.messages[len(chat.messages)-1].Content)
+}
+
+func TestChat_HandleServerMessages(t *testing.T) {
+	chat := NewChat()
+	mockGame := &Game{
+		Player: &types.Player{ID: 1},
+		OtherPlayers: map[int32]*types.Player{
+			2: {ID: 2},
+		},
+	}
+	chat.userData = mockGame
+
+	messages := []*pb.ChatMessage{
+		{
+			PlayerId:  1,
+			Username:  "player1",
+			Content:   "test1",
+			Timestamp: time.Now().UnixNano(),
+		},
+		{
+			PlayerId:  2,
+			Username:  "player2",
+			Content:   "test2",
+			Timestamp: time.Now().UnixNano(),
+		},
+	}
+
+	chat.HandleServerMessages(messages)
+	assert.Equal(t, 2, len(chat.messages))
+	assert.Equal(t, "test1", chat.messages[0].Content)
+	assert.Equal(t, "test2", chat.messages[1].Content)
+
+	// Test duplicate message prevention
+	chat.HandleServerMessages(messages)
+	assert.Equal(t, 2, len(chat.messages))
+}
+
+func TestChat_Update(t *testing.T) {
+	t.Parallel()
+	done := make(chan bool)
+	go func() {
+		game, cleanup := setupTestEnvironment(t)
+		defer cleanup()
+
+		chat := game.Chat
+
+		// Test starting chat
+		testutils.SimulateKeyPress(rl.KeyT)
+		msg, sent := chat.Update()
+		assert.True(t, chat.isTyping)
+		assert.False(t, sent)
+		assert.Empty(t, msg)
+
+		// Test typing message
+		testutils.SimulateCharInput('h')
+		msg, sent = chat.Update()
+		testutils.SimulateCharInput('i')
+		msg, sent = chat.Update()
+		assert.Equal(t, 2, len(chat.inputBuffer))
+		assert.False(t, sent)
+		assert.Empty(t, msg)
+
+		// Test sending message
+		testutils.SimulateKeyPress(rl.KeyEnter)
+		msg, sent = chat.Update()
+		assert.True(t, sent)
+		assert.Equal(t, "hi", msg)
+		assert.False(t, chat.isTyping)
+		done <- true
+	}()
+
+	select {
+	case <-done:
+		// Test completed successfully
+	case <-time.After(5 * time.Second):
+		t.Fatal("Test timed out")
+	}
+}

game/game.go

@@ -0,0 +1,377 @@
+package game
+
+import (
+	"os"
+	"time"
+
+	"gitea.boner.be/bdnugget/goonscape/assets"
+	"gitea.boner.be/bdnugget/goonscape/network"
+	"gitea.boner.be/bdnugget/goonscape/types"
+	pb "gitea.boner.be/bdnugget/goonserver/actions"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+type Game struct {
+	Player       *types.Player
+	OtherPlayers map[int32]*types.Player
+	Camera       rl.Camera3D
+	Models       []types.ModelAsset
+	Music        rl.Music
+	Chat         *Chat
+	MenuOpen     bool
+	QuitChan     chan struct{} // Channel to signal shutdown
+	loginScreen  *LoginScreen
+	isLoggedIn   bool
+	input        InputHandler
+}
+
+func New() *Game {
+	InitWorld()
+	game := &Game{
+		OtherPlayers: make(map[int32]*types.Player),
+		Camera: rl.Camera3D{
+			Position:   rl.NewVector3(0, 10, 10),
+			Target:     rl.NewVector3(0, 0, 0),
+			Up:         rl.NewVector3(0, 1, 0),
+			Fovy:       45.0,
+			Projection: rl.CameraPerspective,
+		},
+		Chat:        NewChat(),
+		QuitChan:    make(chan struct{}),
+		loginScreen: NewLoginScreen(),
+		input:       &RaylibInput{},
+	}
+	game.Chat.userData = game
+	return game
+}
+
+func (g *Game) LoadAssets() error {
+	var err error
+	g.Models, err = assets.LoadModels()
+	if err != nil {
+		return err
+	}
+
+	g.Music, err = assets.LoadMusic("resources/audio/GoonScape2.mp3")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (g *Game) Update(deltaTime float32) {
+	if !g.isLoggedIn {
+		username, password, isRegistering, submitted := g.loginScreen.Update()
+		if submitted {
+			conn, playerID, err := network.ConnectToServer(username, password, isRegistering)
+			if err != nil {
+				g.loginScreen.SetError(err.Error())
+				return
+			}
+
+			g.Player = &types.Player{
+				Speed:      50.0,
+				TargetPath: []types.Tile{},
+				UserData:   g,
+				QuitDone:   make(chan struct{}),
+				ID:         playerID,
+			}
+			g.AssignModelToPlayer(g.Player)
+
+			go network.HandleServerCommunication(conn, playerID, g.Player, g.OtherPlayers, g.QuitChan)
+			g.isLoggedIn = true
+			return
+		}
+		g.loginScreen.Draw()
+		return
+	}
+
+	// Handle ESC for menu
+	if g.input.IsKeyPressed(rl.KeyEscape) {
+		g.MenuOpen = !g.MenuOpen
+		return
+	}
+
+	// Don't process other inputs if menu is open
+	if g.MenuOpen {
+		return
+	}
+
+	if message, sent := g.Chat.Update(); sent {
+		g.Player.Lock()
+		g.Player.ActionQueue = append(g.Player.ActionQueue, &pb.Action{
+			Type:        pb.Action_CHAT,
+			ChatMessage: message,
+			PlayerId:    g.Player.ID,
+		})
+		g.Player.Unlock()
+	}
+
+	g.HandleInput()
+
+	if len(g.Player.TargetPath) > 0 {
+		g.Player.MoveTowards(g.Player.TargetPath[0], deltaTime, GetMapGrid())
+	}
+
+	for _, other := range g.OtherPlayers {
+		if len(other.TargetPath) > 0 {
+			other.MoveTowards(other.TargetPath[0], deltaTime, GetMapGrid())
+		}
+	}
+
+	UpdateCamera(&g.Camera, g.Player.PosActual, deltaTime)
+}
+
+func (g *Game) DrawMap() {
+	for x := 0; x < types.MapWidth; x++ {
+		for y := 0; y < types.MapHeight; y++ {
+			height := GetTileHeight(x, y)
+
+			// Interpolate height for smoother landscape
+			if x > 0 {
+				height += GetTileHeight(x-1, y)
+			}
+			if y > 0 {
+				height += GetTileHeight(x, y-1)
+			}
+			if x > 0 && y > 0 {
+				height += GetTileHeight(x-1, y-1)
+			}
+			height /= 4.0
+
+			tilePos := rl.Vector3{
+				X: float32(x * types.TileSize),
+				Y: height * types.TileHeight,
+				Z: float32(y * types.TileSize),
+			}
+			color := rl.Color{R: uint8(height * 25), G: 100, B: 100, A: 64}
+			rl.DrawCube(tilePos, types.TileSize, types.TileHeight, types.TileSize, color)
+		}
+	}
+}
+
+func (g *Game) DrawPlayer(player *types.Player, model rl.Model) {
+	player.Lock()
+	defer player.Unlock()
+
+	grid := GetMapGrid()
+	modelIndex := int(player.ID) % len(g.Models)
+	modelAsset := g.Models[modelIndex]
+
+	const defaultHeight = 8.0 // Default height above tile, fine tune per model in types.ModelAsset
+	playerPos := rl.Vector3{
+		X: player.PosActual.X,
+		Y: grid[player.PosTile.X][player.PosTile.Y].Height*types.TileHeight + defaultHeight + modelAsset.YOffset,
+		Z: player.PosActual.Z,
+	}
+
+	// Check if model has animations
+	if modelAsset.Animations.Idle != nil || modelAsset.Animations.Walk != nil {
+		if player.IsMoving && len(modelAsset.Animations.Walk) > 0 {
+			anim := modelAsset.Animations.Walk[0] // Use first walk animation
+			player.AnimationFrame = player.AnimationFrame % anim.FrameCount
+			rl.UpdateModelAnimation(model, anim, player.AnimationFrame)
+		} else if len(modelAsset.Animations.Idle) > 0 {
+			anim := modelAsset.Animations.Idle[0] // Use first idle animation
+			player.AnimationFrame = player.AnimationFrame % anim.FrameCount
+			rl.UpdateModelAnimation(model, anim, player.AnimationFrame)
+		}
+	}
+
+	rl.DrawModel(model, playerPos, 16, rl.White)
+
+	// Draw floating messages and path indicators
+	if player.FloatingMessage != nil {
+		screenPos := rl.GetWorldToScreen(rl.Vector3{
+			X: playerPos.X,
+			Y: playerPos.Y + 24.0,
+			Z: playerPos.Z,
+		}, g.Camera)
+
+		player.FloatingMessage.ScreenPos = screenPos
+	}
+
+	if len(player.TargetPath) > 0 {
+		targetTile := player.TargetPath[len(player.TargetPath)-1]
+		targetPos := rl.Vector3{
+			X: float32(targetTile.X * types.TileSize),
+			Y: grid[targetTile.X][targetTile.Y].Height * types.TileHeight,
+			Z: float32(targetTile.Y * types.TileSize),
+		}
+		rl.DrawCubeWires(targetPos, types.TileSize, types.TileHeight, types.TileSize, rl.Green)
+
+		nextTile := player.TargetPath[0]
+		nextPos := rl.Vector3{
+			X: float32(nextTile.X * types.TileSize),
+			Y: grid[nextTile.X][nextTile.Y].Height * types.TileHeight,
+			Z: float32(nextTile.Y * types.TileSize),
+		}
+		rl.DrawCubeWires(nextPos, types.TileSize, types.TileHeight, types.TileSize, rl.Yellow)
+	}
+}
+
+func (g *Game) Render() {
+	rl.BeginDrawing()
+	rl.ClearBackground(rl.RayWhite)
+
+	if !g.isLoggedIn {
+		g.loginScreen.Draw()
+		rl.EndDrawing()
+		return
+	}
+
+	rl.BeginMode3D(g.Camera)
+	g.DrawMap()
+	g.DrawPlayer(g.Player, g.Player.Model)
+	for _, other := range g.OtherPlayers {
+		if other.Model.Meshes == nil {
+			g.AssignModelToPlayer(other)
+		}
+		g.DrawPlayer(other, other.Model)
+	}
+	rl.EndMode3D()
+
+	// Draw floating messages
+	drawFloatingMessage := func(msg *types.FloatingMessage) {
+		if msg == nil || time.Now().After(msg.ExpireTime) {
+			return
+		}
+		pos := msg.ScreenPos
+		text := msg.Content
+		textWidth := rl.MeasureText(text, 20)
+
+		for offsetX := -2; offsetX <= 2; offsetX++ {
+			for offsetY := -2; offsetY <= 2; offsetY++ {
+				rl.DrawText(text,
+					int32(pos.X)-textWidth/2+int32(offsetX),
+					int32(pos.Y)+int32(offsetY),
+					20,
+					rl.Black)
+			}
+		}
+		rl.DrawText(text, int32(pos.X)-textWidth/2, int32(pos.Y), 20, rl.Yellow)
+	}
+
+	if g.Player.FloatingMessage != nil {
+		drawFloatingMessage(g.Player.FloatingMessage)
+	}
+
+	for _, other := range g.OtherPlayers {
+		drawFloatingMessage(other.FloatingMessage)
+	}
+
+	// Draw menu if open
+	if g.MenuOpen {
+		g.DrawMenu()
+	}
+
+	// Only draw chat if menu is not open
+	if !g.MenuOpen {
+		g.Chat.Draw(int32(rl.GetScreenWidth()), int32(rl.GetScreenHeight()))
+	}
+
+	rl.DrawFPS(10, 10)
+	rl.EndDrawing()
+}
+
+func (g *Game) Cleanup() {
+	assets.UnloadModels(g.Models)
+	assets.UnloadMusic(g.Music)
+}
+
+func (g *Game) HandleInput() {
+	clickedTile, clicked := g.GetTileAtMouse()
+	if clicked {
+		path := FindPath(GetTile(g.Player.PosTile.X, g.Player.PosTile.Y), clickedTile)
+		if len(path) > 1 {
+			g.Player.Lock()
+			g.Player.TargetPath = path[1:]
+			g.Player.ActionQueue = append(g.Player.ActionQueue, &pb.Action{
+				Type:     pb.Action_MOVE,
+				X:        int32(clickedTile.X),
+				Y:        int32(clickedTile.Y),
+				PlayerId: g.Player.ID,
+			})
+			g.Player.Unlock()
+		}
+	}
+}
+
+func (g *Game) DrawMenu() {
+	screenWidth := float32(rl.GetScreenWidth())
+	screenHeight := float32(rl.GetScreenHeight())
+
+	// Semi-transparent background
+	rl.DrawRectangle(0, 0, int32(screenWidth), int32(screenHeight), rl.ColorAlpha(rl.Black, 0.7))
+
+	// Menu title
+	title := "Menu"
+	titleSize := int32(40)
+	titleWidth := rl.MeasureText(title, titleSize)
+	rl.DrawText(title, int32(screenWidth/2)-titleWidth/2, 100, titleSize, rl.White)
+
+	// Menu buttons
+	buttonWidth := float32(200)
+	buttonHeight := float32(40)
+	buttonY := float32(200)
+	buttonSpacing := float32(60)
+
+	menuItems := []string{"Resume", "Settings", "Exit Game"}
+	for _, item := range menuItems {
+		buttonRect := rl.Rectangle{
+			X:      screenWidth/2 - buttonWidth/2,
+			Y:      buttonY,
+			Width:  buttonWidth,
+			Height: buttonHeight,
+		}
+
+		// Check mouse hover
+		mousePoint := g.input.GetMousePosition()
+		mouseHover := rl.CheckCollisionPointRec(mousePoint, buttonRect)
+
+		// Draw button
+		if mouseHover {
+			rl.DrawRectangleRec(buttonRect, rl.ColorAlpha(rl.White, 0.3))
+			if g.input.IsMouseButtonPressed(toInt32(rl.MouseLeftButton)) {
+				switch item {
+				case "Resume":
+					g.MenuOpen = false
+				case "Settings":
+					// TODO: Implement settings
+				case "Exit Game":
+					g.Shutdown()
+				}
+			}
+		}
+
+		// Draw button text
+		textSize := int32(20)
+		textWidth := rl.MeasureText(item, textSize)
+		textX := int32(buttonRect.X+buttonRect.Width/2) - textWidth/2
+		textY := int32(buttonRect.Y + buttonRect.Height/2 - float32(textSize)/2)
+		rl.DrawText(item, textX, textY, textSize, rl.White)
+
+		buttonY += buttonSpacing
+	}
+}
+
+func (g *Game) Shutdown() {
+	close(g.QuitChan)
+	<-g.Player.QuitDone
+	rl.CloseWindow()
+	os.Exit(0)
+}
+
+func (g *Game) HandleServerMessages(messages []*pb.ChatMessage) {
+	g.Chat.HandleServerMessages(messages)
+}
+
+func (g *Game) AssignModelToPlayer(player *types.Player) {
+	modelIndex := int(player.ID) % len(g.Models)
+	modelAsset := g.Models[modelIndex]
+
+	// Just use the original model - don't try to copy it
+	player.Model = modelAsset.Model
+	player.Texture = modelAsset.Texture
+}

game/game_test.go

@@ -0,0 +1,106 @@
+package game
+
+import (
+	"testing"
+
+	"gitea.boner.be/bdnugget/goonscape/game/testutils"
+	"gitea.boner.be/bdnugget/goonscape/types"
+	pb "gitea.boner.be/bdnugget/goonserver/actions"
+	rl "github.com/gen2brain/raylib-go/raylib"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGame_HandleInput(t *testing.T) {
+	game := New()
+	game.Player = &types.Player{
+		ID:    1,
+		Speed: 50.0,
+	}
+
+	// Test valid click
+	simulateMouseRay(rl.Ray{
+		Position:  rl.Vector3{X: 0, Y: 10, Z: 0},
+		Direction: rl.Vector3{X: 0, Y: -1, Z: 0},
+	})
+	simulateMouseButton(toInt32(rl.MouseLeftButton), true)
+	game.HandleInput()
+	assert.NotEmpty(t, game.Player.TargetPath)
+
+	// Test invalid click (outside map)
+	simulateMouseRay(rl.Ray{
+		Position:  rl.Vector3{X: 1000, Y: 10, Z: 1000},
+		Direction: rl.Vector3{X: 0, Y: -1, Z: 0},
+	})
+	simulateMouseButton(toInt32(rl.MouseLeftButton), true)
+	game.HandleInput()
+	assert.Empty(t, game.Player.TargetPath)
+}
+
+func TestGame_UpdateCamera(t *testing.T) {
+	game := New()
+
+	// Test zoom limits
+	testutils.SimulateMouseWheel(1.0) // Zoom in
+	testutils.SimulateMouseWheel(1.0)
+	assert.GreaterOrEqual(t, cameraDistance, float32(10.0))
+
+	testutils.SimulateMouseWheel(-1.0) // Zoom out
+	testutils.SimulateMouseWheel(-1.0)
+	assert.LessOrEqual(t, cameraDistance, float32(250.0))
+
+	// Test camera rotation
+	originalYaw := cameraYaw
+	testutils.SimulateKeyDown(rl.KeyRight, true)
+	game.Update(0.1)
+	assert.Greater(t, cameraYaw, originalYaw)
+
+	// Test pitch limits
+	simulateKeyDown(rl.KeyUp, true)
+	for i := 0; i < 100; i++ {
+		game.Update(0.1)
+	}
+	assert.GreaterOrEqual(t, cameraPitch, float32(20.0))
+	assert.LessOrEqual(t, cameraPitch, float32(85.0))
+}
+
+func TestGame_ChatIntegration(t *testing.T) {
+	game := New()
+	game.Player = &types.Player{ID: 1}
+
+	// Test chat message to action queue
+	testutils.SimulateKeyPress(rl.KeyT)
+	game.Update(0.1)
+	assert.True(t, game.Chat.isTyping)
+
+	testutils.SimulateCharInput('h')
+	testutils.SimulateCharInput('i')
+	testutils.SimulateKeyPress(rl.KeyEnter)
+	game.Update(0.1)
+
+	assert.Equal(t, 1, len(game.Player.ActionQueue))
+	assert.Equal(t, pb.Action_CHAT, game.Player.ActionQueue[0].Type)
+	assert.Equal(t, "hi", game.Player.ActionQueue[0].ChatMessage)
+}
+
+func TestGame_MenuHandling(t *testing.T) {
+	game := New()
+
+	// Test menu toggle
+	assert.False(t, game.MenuOpen)
+	testutils.SimulateKeyPress(rl.KeyEscape)
+	game.Update(0.1)
+	assert.True(t, game.MenuOpen)
+
+	// Test input blocking when menu is open
+	game.Player = &types.Player{ID: 1}
+	testutils.SimulateMouseButton(testutils.ToInt32(rl.MouseLeftButton), true)
+	game.Update(0.1)
+	assert.Empty(t, game.Player.TargetPath)
+
+	// Test menu close
+	testutils.SimulateKeyPress(rl.KeyEscape)
+	game.Update(0.1)
+	assert.False(t, game.MenuOpen)
+}
+
+// Add more test helpers as needed...

game/input.go

@@ -0,0 +1,110 @@
+package game
+
+import (
+	"fmt"
+
+	"gitea.boner.be/bdnugget/goonscape/game/mock"
+	"gitea.boner.be/bdnugget/goonscape/types"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+// InputHandler abstracts raylib input functions for testing
+type InputHandler interface {
+	IsKeyPressed(key int32) bool
+	IsKeyDown(key int32) bool
+	IsMouseButtonPressed(button int32) bool
+	GetMousePosition() rl.Vector2
+	GetMouseRay(mousePos rl.Vector2, camera rl.Camera3D) rl.Ray
+	GetMouseWheelMove() float32
+	GetCharPressed() rune
+}
+
+// RaylibInput implements InputHandler using actual raylib functions
+type RaylibInput struct{}
+
+func (r *RaylibInput) IsKeyPressed(key int32) bool { return rl.IsKeyPressed(key) }
+func (r *RaylibInput) IsKeyDown(key int32) bool    { return rl.IsKeyDown(key) }
+func (r *RaylibInput) IsMouseButtonPressed(button int32) bool {
+	return rl.IsMouseButtonPressed(rl.MouseButton(button))
+}
+func (r *RaylibInput) GetMousePosition() rl.Vector2 { return rl.GetMousePosition() }
+func (r *RaylibInput) GetMouseRay(mousePos rl.Vector2, camera rl.Camera3D) rl.Ray {
+	return rl.GetMouseRay(mousePos, camera)
+}
+func (r *RaylibInput) GetMouseWheelMove() float32 { return rl.GetMouseWheelMove() }
+func (r *RaylibInput) GetCharPressed() rune       { return rl.GetCharPressed() }
+
+// MockInput implements InputHandler using our mock functions
+type MockInput struct{}
+
+func (m *MockInput) IsKeyPressed(key int32) bool {
+	if mock.IsKeyPressed == nil {
+		return false
+	}
+	return mock.IsKeyPressed(key)
+}
+
+func (m *MockInput) IsKeyDown(key int32) bool {
+	if mock.IsKeyDown == nil {
+		return false
+	}
+	return mock.IsKeyDown(key)
+}
+
+func (m *MockInput) IsMouseButtonPressed(button int32) bool {
+	if mock.IsMouseButtonPressed == nil {
+		return false
+	}
+	return mock.IsMouseButtonPressed(button)
+}
+
+func (m *MockInput) GetMousePosition() rl.Vector2 {
+	if mock.GetMousePosition == nil {
+		return rl.Vector2{}
+	}
+	return mock.GetMousePosition()
+}
+
+func (m *MockInput) GetMouseRay(mousePos rl.Vector2, camera rl.Camera3D) rl.Ray {
+	if mock.GetMouseRay == nil {
+		return rl.Ray{}
+	}
+	return mock.GetMouseRay(mousePos, camera)
+}
+
+func (m *MockInput) GetMouseWheelMove() float32 {
+	if mock.GetMouseWheelMove == nil {
+		return 0
+	}
+	return mock.GetMouseWheelMove()
+}
+
+func (m *MockInput) GetCharPressed() rune {
+	if mock.GetCharPressed == nil {
+		return 0
+	}
+	return mock.GetCharPressed()
+}
+
+func (g *Game) GetTileAtMouse() (types.Tile, bool) {
+	if !g.input.IsMouseButtonPressed(toInt32(rl.MouseLeftButton)) {
+		return types.Tile{}, false
+	}
+	mouse := g.input.GetMousePosition()
+	ray := g.input.GetMouseRay(mouse, g.Camera)
+
+	for x := 0; x < types.MapWidth; x++ {
+		for y := 0; y < types.MapHeight; y++ {
+			tile := GetTile(x, y)
+			tilePos := rl.NewVector3(float32(x*types.TileSize), tile.Height*types.TileHeight, float32(y*types.TileSize))
+			boxMin := rl.Vector3Subtract(tilePos, rl.NewVector3(types.TileSize/2, types.TileHeight/2, types.TileSize/2))
+			boxMax := rl.Vector3Add(tilePos, rl.NewVector3(types.TileSize/2, types.TileHeight/2, types.TileSize/2))
+
+			if RayIntersectsBox(ray, boxMin, boxMax) {
+				fmt.Printf("Clicked: %d, %d\n", tile.X, tile.Y)
+				return tile, true
+			}
+		}
+	}
+	return types.Tile{}, false
+}

game/input_test.go

@@ -0,0 +1,187 @@
+package game
+
+import (
+	"testing"
+
+	"gitea.boner.be/bdnugget/goonscape/game/testutils"
+	"gitea.boner.be/bdnugget/goonscape/types"
+	rl "github.com/gen2brain/raylib-go/raylib"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMouseInput_EdgeCases(t *testing.T) {
+	game, cleanup := setupTestEnvironment(t)
+	defer cleanup()
+
+	game.Player = &types.Player{ID: 1}
+
+	tests := []struct {
+		name     string
+		ray      rl.Ray
+		expected bool
+	}{
+		{
+			name: "Click outside map bounds",
+			ray: rl.Ray{
+				Position:  rl.Vector3{X: 1000, Y: 10, Z: 1000},
+				Direction: rl.Vector3{X: 0, Y: -1, Z: 0},
+			},
+			expected: false,
+		},
+		{
+			name: "Click at map edge",
+			ray: rl.Ray{
+				Position:  rl.Vector3{X: float32(types.MapWidth * types.TileSize), Y: 10, Z: 0},
+				Direction: rl.Vector3{X: 0, Y: -1, Z: 0},
+			},
+			expected: false,
+		},
+		{
+			name: "Click on valid tile",
+			ray: rl.Ray{
+				Position:  rl.Vector3{X: 32, Y: 10, Z: 32},
+				Direction: rl.Vector3{X: 0, Y: -1, Z: 0},
+			},
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testutils.ResetMockInput()
+			testutils.SimulateMouseRay(tt.ray)
+			testutils.SimulateMouseButton(testutils.ToInt32(rl.MouseLeftButton), true)
+			tile, clicked := game.GetTileAtMouse()
+			assert.Equal(t, tt.expected, clicked)
+			if tt.expected {
+				assert.NotEmpty(t, tile)
+			}
+		})
+	}
+}
+
+func TestChat_InputValidation(t *testing.T) {
+	game, cleanup := setupTestEnvironment(t)
+	defer cleanup()
+
+	game.Player = &types.Player{ID: 1}
+
+	tests := []struct {
+		name     string
+		input    []rune
+		expected string
+	}{
+		{
+			name:     "Empty message",
+			input:    []rune{},
+			expected: "",
+		},
+		{
+			name:     "Message with only spaces",
+			input:    []rune("   "),
+			expected: "",
+		},
+		{
+			name:     "Very long message",
+			input:    []rune(string(make([]rune, runeLimit))),
+			expected: string(make([]rune, runeLimit)),
+		},
+		{
+			name:     "Unicode characters",
+			input:    []rune("Hello 世界"),
+			expected: "Hello 世界",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testutils.ResetMockInput()
+			testutils.SimulateKeyPress(rl.KeyT)
+			game.Update(0.1)
+
+			for _, r := range tt.input {
+				testutils.SimulateCharInput(r)
+				game.Update(0.1)
+			}
+
+			testutils.SimulateKeyPress(rl.KeyEnter)
+			game.Update(0.1)
+
+			if tt.expected != "" {
+				assert.Equal(t, 1, len(game.Player.ActionQueue))
+				assert.Equal(t, tt.expected, game.Player.ActionQueue[0].ChatMessage)
+			} else {
+				assert.Empty(t, game.Player.ActionQueue)
+			}
+		})
+	}
+}
+
+func TestLogin_InputValidation(t *testing.T) {
+	_, cleanup := setupTestEnvironment(t)
+	defer cleanup()
+
+	tests := []struct {
+		name          string
+		username      string
+		password      string
+		expectSuccess bool
+	}{
+		{
+			name:          "Valid credentials",
+			username:      "validuser",
+			password:      "validpass",
+			expectSuccess: true,
+		},
+		{
+			name:          "Empty username",
+			username:      "",
+			password:      "password",
+			expectSuccess: false,
+		},
+		{
+			name:          "Empty password",
+			username:      "username",
+			password:      "",
+			expectSuccess: false,
+		},
+		{
+			name:          "Username too long",
+			username:      "verylongusername123",
+			password:      "password",
+			expectSuccess: false,
+		},
+		{
+			name:          "Special characters in username",
+			username:      "user@name",
+			password:      "password",
+			expectSuccess: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			login := NewLoginScreen()
+			testutils.ResetMockInput()
+
+			// Simulate typing username
+			login.focusedField = 0
+			for _, r := range tt.username {
+				testutils.SimulateCharInput(r)
+				login.Update()
+			}
+
+			// Simulate typing password
+			login.focusedField = 1
+			for _, r := range tt.password {
+				testutils.SimulateCharInput(r)
+				login.Update()
+			}
+
+			// Simulate clicking login button
+			testutils.SimulateMouseClick(400, 365)
+			_, _, _, submitted := login.Update()
+			assert.Equal(t, tt.expectSuccess, submitted)
+		})
+	}
+}

game/login.go

@@ -0,0 +1,185 @@
+package game
+
+import (
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+type LoginScreen struct {
+	username      string
+	password      string
+	errorMessage  string
+	isRegistering bool
+	focusedField  int // 0 = username, 1 = password
+}
+
+func NewLoginScreen() *LoginScreen {
+	return &LoginScreen{}
+}
+
+func (l *LoginScreen) Draw() {
+	screenWidth := float32(rl.GetScreenWidth())
+	screenHeight := float32(rl.GetScreenHeight())
+
+	// Draw background
+	rl.DrawRectangle(0, 0, int32(screenWidth), int32(screenHeight), rl.RayWhite)
+
+	// Draw title
+	title := "GoonScape"
+	if l.isRegistering {
+		title += " - Register"
+	} else {
+		title += " - Login"
+	}
+	titleSize := int32(40)
+	titleWidth := rl.MeasureText(title, titleSize)
+	rl.DrawText(title, int32(screenWidth/2)-titleWidth/2, 100, titleSize, rl.Black)
+
+	// Draw input fields
+	inputWidth := float32(200)
+	inputHeight := float32(30)
+	inputX := screenWidth/2 - inputWidth/2
+
+	// Username field
+	rl.DrawRectangleRec(rl.Rectangle{
+		X: inputX, Y: 200,
+		Width: inputWidth, Height: inputHeight,
+	}, rl.LightGray)
+	rl.DrawText(l.username, int32(inputX)+5, 205, 20, rl.Black)
+	if l.focusedField == 0 {
+		rl.DrawRectangleLinesEx(rl.Rectangle{
+			X: inputX - 2, Y: 198,
+			Width: inputWidth + 4, Height: inputHeight + 4,
+		}, 2, rl.Blue)
+	}
+
+	// Password field
+	rl.DrawRectangleRec(rl.Rectangle{
+		X: inputX, Y: 250,
+		Width: inputWidth, Height: inputHeight,
+	}, rl.LightGray)
+	masked := ""
+	for range l.password {
+		masked += "*"
+	}
+	rl.DrawText(masked, int32(inputX)+5, 255, 20, rl.Black)
+	if l.focusedField == 1 {
+		rl.DrawRectangleLinesEx(rl.Rectangle{
+			X: inputX - 2, Y: 248,
+			Width: inputWidth + 4, Height: inputHeight + 4,
+		}, 2, rl.Blue)
+	}
+
+	// Draw error message
+	if l.errorMessage != "" {
+		msgWidth := rl.MeasureText(l.errorMessage, 20)
+		rl.DrawText(l.errorMessage, int32(screenWidth/2)-msgWidth/2, 300, 20, rl.Red)
+	}
+
+	// Draw buttons
+	buttonWidth := float32(100)
+	buttonHeight := float32(30)
+	buttonY := float32(350)
+
+	// Login/Register button
+	actionBtn := rl.Rectangle{
+		X:      screenWidth/2 - buttonWidth - 10,
+		Y:      buttonY,
+		Width:  buttonWidth,
+		Height: buttonHeight,
+	}
+	rl.DrawRectangleRec(actionBtn, rl.Blue)
+	actionText := "Login"
+	if l.isRegistering {
+		actionText = "Register"
+	}
+	actionWidth := rl.MeasureText(actionText, 20)
+	rl.DrawText(actionText,
+		int32(actionBtn.X+actionBtn.Width/2)-actionWidth/2,
+		int32(actionBtn.Y+5),
+		20, rl.White)
+
+	// Switch mode button
+	switchBtn := rl.Rectangle{
+		X:      screenWidth/2 + 10,
+		Y:      buttonY,
+		Width:  buttonWidth,
+		Height: buttonHeight,
+	}
+	rl.DrawRectangleRec(switchBtn, rl.DarkGray)
+	switchText := "Register"
+	if l.isRegistering {
+		switchText = "Login"
+	}
+	switchWidth := rl.MeasureText(switchText, 20)
+	rl.DrawText(switchText,
+		int32(switchBtn.X+switchBtn.Width/2)-switchWidth/2,
+		int32(switchBtn.Y+5),
+		20, rl.White)
+}
+
+func (l *LoginScreen) Update() (string, string, bool, bool) {
+	// Handle input field focus
+	if rl.IsMouseButtonPressed(rl.MouseLeftButton) {
+		mousePos := rl.GetMousePosition()
+		screenWidth := float32(rl.GetScreenWidth())
+		inputWidth := float32(200)
+		inputX := screenWidth/2 - inputWidth/2
+
+		// Check username field
+		if mousePos.X >= inputX && mousePos.X <= inputX+inputWidth &&
+			mousePos.Y >= 200 && mousePos.Y <= 230 {
+			l.focusedField = 0
+		}
+		// Check password field
+		if mousePos.X >= inputX && mousePos.X <= inputX+inputWidth &&
+			mousePos.Y >= 250 && mousePos.Y <= 280 {
+			l.focusedField = 1
+		}
+
+		// Check buttons
+		buttonWidth := float32(100)
+		if mousePos.Y >= 350 && mousePos.Y <= 380 {
+			// Action button
+			if mousePos.X >= screenWidth/2-buttonWidth-10 &&
+				mousePos.X <= screenWidth/2-10 {
+				return l.username, l.password, l.isRegistering, true
+			}
+			// Switch mode button
+			if mousePos.X >= screenWidth/2+10 &&
+				mousePos.X <= screenWidth/2+buttonWidth+10 {
+				l.isRegistering = !l.isRegistering
+			}
+		}
+	}
+
+	// Handle text input
+	key := rl.GetCharPressed()
+	for key > 0 {
+		if l.focusedField == 0 && len(l.username) < 12 {
+			l.username += string(key)
+		} else if l.focusedField == 1 && len(l.password) < 20 {
+			l.password += string(key)
+		}
+		key = rl.GetCharPressed()
+	}
+
+	// Handle backspace
+	if rl.IsKeyPressed(rl.KeyBackspace) {
+		if l.focusedField == 0 && len(l.username) > 0 {
+			l.username = l.username[:len(l.username)-1]
+		} else if l.focusedField == 1 && len(l.password) > 0 {
+			l.password = l.password[:len(l.password)-1]
+		}
+	}
+
+	// Handle tab to switch fields
+	if rl.IsKeyPressed(rl.KeyTab) {
+		l.focusedField = (l.focusedField + 1) % 2
+	}
+
+	return "", "", false, false
+}
+
+func (l *LoginScreen) SetError(msg string) {
+	l.errorMessage = msg
+}

game/login_test.go

@@ -0,0 +1,80 @@
+package game
+
+import (
+	"testing"
+
+	"gitea.boner.be/bdnugget/goonscape/game/testutils"
+	rl "github.com/gen2brain/raylib-go/raylib"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLoginScreen_Update(t *testing.T) {
+	login := NewLoginScreen()
+
+	// Test field focus switching
+	simulateMouseClick(400, 215) // Click username field
+	assert.Equal(t, 0, login.focusedField)
+
+	simulateMouseClick(400, 265) // Click password field
+	assert.Equal(t, 1, login.focusedField)
+
+	// Test input length limits
+	login.focusedField = 0
+	for i := 0; i < 20; i++ {
+		simulateCharInput('x')
+	}
+	assert.LessOrEqual(t, len(login.username), 12)
+
+	login.focusedField = 1
+	for i := 0; i < 30; i++ {
+		simulateCharInput('x')
+	}
+	assert.LessOrEqual(t, len(login.password), 20)
+
+	// Test mode switching
+	simulateMouseClick(600, 365) // Click switch mode button
+	assert.True(t, login.isRegistering)
+	simulateMouseClick(600, 365) // Click again
+	assert.False(t, login.isRegistering)
+
+	// Test submission
+	login.username = "test"
+	login.password = "password"
+	testutils.SimulateMousePosition(400, 365)
+	testutils.SimulateMouseButton(testutils.ToInt32(rl.MouseLeftButton), true)
+	username, password, isRegistering, submitted := login.Update()
+	assert.True(t, submitted)
+	assert.Equal(t, "test", username)
+	assert.Equal(t, "password", password)
+	assert.False(t, isRegistering)
+}
+
+func TestLoginScreen_ErrorHandling(t *testing.T) {
+	login := NewLoginScreen()
+
+	// Test empty fields
+	login.username = ""
+	login.password = "test"
+	testutils.SimulateMousePosition(400, 365)
+	testutils.SimulateMouseButton(testutils.ToInt32(rl.MouseLeftButton), true)
+	_, _, _, submitted := login.Update()
+	assert.False(t, submitted)
+	assert.Contains(t, login.errorMessage, "username")
+
+	// Test special characters
+	login.username = "test!@#"
+	login.password = "password"
+	testutils.SimulateMousePosition(400, 365)
+	testutils.SimulateMouseButton(testutils.ToInt32(rl.MouseLeftButton), true)
+	_, _, _, submitted = login.Update()
+	assert.False(t, submitted)
+	assert.Contains(t, login.errorMessage, "invalid characters")
+
+	// Test error message display
+	login.SetError("Test error")
+	assert.Equal(t, "Test error", login.errorMessage)
+}
+
+func simulateMouseClick(x, y float32) {
+	// Implementation would depend on how raylib is mocked
+}

game/mock/raylib.go

@@ -0,0 +1,15 @@
+package mock
+
+import (
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+var (
+	IsKeyPressed         func(key int32) bool
+	IsKeyDown            func(key int32) bool
+	IsMouseButtonPressed func(button int32) bool
+	GetMousePosition     func() rl.Vector2
+	GetMouseRay          func(mousePos rl.Vector2, camera rl.Camera3D) rl.Ray
+	GetMouseWheelMove    func() float32
+	GetCharPressed       func() rune
+)

game/pathfinding.go

@@ -1,14 +1,18 @@
-package main
+package game
 
-import "fmt"
+import (
+	"fmt"
+
+	"gitea.boner.be/bdnugget/goonscape/types"
+)
 
 type Node struct {
-	Tile    Tile
+	Tile    types.Tile
 	Parent  *Node
 	G, H, F float32
 }
 
-func FindPath(start, end Tile) []Tile {
+func FindPath(start, end types.Tile) []types.Tile {
 	openList := []*Node{}
 	closedList := make(map[[2]int]bool)
 
@@ -17,7 +21,6 @@ func FindPath(start, end Tile) []Tile {
 	openList = append(openList, startNode)
 
 	for len(openList) > 0 {
-		// Find node with lowest F
 		current := openList[0]
 		currentIndex := 0
 		for i, node := range openList {
@@ -27,23 +30,20 @@ func FindPath(start, end Tile) []Tile {
 			}
 		}
 
-		// Move current to closed list
 		openList = append(openList[:currentIndex], openList[currentIndex+1:]...)
 		closedList[[2]int{current.Tile.X, current.Tile.Y}] = true
 
-		// Check if reached the end
 		if current.Tile.X == end.X && current.Tile.Y == end.Y {
-			path := []Tile{}
+			path := []types.Tile{}
 			node := current
 			for node != nil {
-				path = append([]Tile{node.Tile}, path...)
+				path = append([]types.Tile{node.Tile}, path...)
 				node = node.Parent
 			}
 			fmt.Printf("Path found: %v\n", path)
 			return path
 		}
 
-		// Generate neighbors
 		neighbors := GetNeighbors(current.Tile)
 		for _, neighbor := range neighbors {
 			if !neighbor.Walkable || closedList[[2]int{neighbor.X, neighbor.Y}] {
@@ -75,32 +75,30 @@ func FindPath(start, end Tile) []Tile {
 			}
 		}
 	}
-
-	// No path found
-	fmt.Println("No path found")
 	return nil
 }
 
-func heuristic(a, b Tile) float32 {
+func heuristic(a, b types.Tile) float32 {
 	return float32(abs(a.X-b.X) + abs(a.Y-b.Y))
 }
 
-func distance(a, b Tile) float32 {
-	_ = a
-	_ = b
-	return 1.0 //uniform cost for now
+func distance(a, b types.Tile) float32 {
+	return 1.0 // uniform cost for now
 }
 
-func GetNeighbors(tile Tile) []Tile {
+func GetNeighbors(tile types.Tile) []types.Tile {
 	directions := [][2]int{
 		{1, 0}, {-1, 0}, {0, 1}, {0, -1},
 		{1, 1}, {-1, -1}, {1, -1}, {-1, 1},
 	}
-	neighbors := []Tile{}
+	neighbors := []types.Tile{}
+	grid := GetMapGrid()
 	for _, dir := range directions {
 		nx, ny := tile.X+dir[0], tile.Y+dir[1]
-		if nx >= 0 && nx < MapWidth && ny >= 0 && ny < MapHeight {
-			neighbors = append(neighbors, mapGrid[nx][ny])
+		if nx >= 0 && nx < types.MapWidth && ny >= 0 && ny < types.MapHeight {
+			if grid[nx][ny].Walkable {
+				neighbors = append(neighbors, grid[nx][ny])
+			}
 		}
 	}
 	return neighbors

game/test_helpers.go

@@ -0,0 +1,141 @@
+package game
+
+import (
+	"sync"
+
+	"gitea.boner.be/bdnugget/goonscape/game/mock"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+var (
+	mockInput struct {
+		sync.Mutex
+		keyPressed    map[int32]bool
+		keyDown       map[int32]bool
+		mousePressed  map[int32]bool
+		mousePosition rl.Vector2
+		mouseRay      rl.Ray
+		mouseWheel    float32
+		charPressed   rune
+	}
+)
+
+func init() {
+	resetMockInput()
+	setupMockFunctions()
+}
+
+func setupMockFunctions() {
+	mock.IsKeyPressed = mockIsKeyPressed
+	mock.IsKeyDown = mockIsKeyDown
+	mock.IsMouseButtonPressed = mockIsMouseButtonPressed
+	mock.GetMousePosition = mockGetMousePosition
+	mock.GetMouseRay = mockGetMouseRay
+	mock.GetMouseWheelMove = mockGetMouseWheelMove
+	mock.GetCharPressed = mockGetCharPressed
+}
+
+func resetMockInput() {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	mockInput.keyPressed = make(map[int32]bool)
+	mockInput.keyDown = make(map[int32]bool)
+	mockInput.mousePressed = make(map[int32]bool)
+	mockInput.mousePosition = rl.Vector2{}
+	mockInput.mouseRay = rl.Ray{}
+	mockInput.mouseWheel = 0
+	mockInput.charPressed = 0
+}
+
+// Mock input simulation functions
+func simulateKeyPress(key int32) {
+	mockInput.Lock()
+	mockInput.keyPressed[key] = true
+	mockInput.Unlock()
+}
+
+func simulateKeyDown(key int32, isDown bool) {
+	mockInput.Lock()
+	mockInput.keyDown[key] = isDown
+	mockInput.Unlock()
+}
+
+func simulateMouseButton(button int32, isPressed bool) {
+	mockInput.Lock()
+	mockInput.mousePressed[button] = isPressed
+	mockInput.Unlock()
+}
+
+func simulateMousePosition(x, y float32) {
+	mockInput.Lock()
+	mockInput.mousePosition = rl.Vector2{X: x, Y: y}
+	mockInput.Unlock()
+}
+
+func simulateMouseRay(ray rl.Ray) {
+	mockInput.Lock()
+	mockInput.mouseRay = ray
+	mockInput.Unlock()
+}
+
+func simulateMouseWheel(move float32) {
+	mockInput.Lock()
+	mockInput.mouseWheel = move
+	mockInput.Unlock()
+}
+
+func simulateCharInput(char rune) {
+	mockInput.Lock()
+	mockInput.charPressed = char
+	mockInput.Unlock()
+}
+
+// Mock raylib functions
+func mockIsKeyPressed(key int32) bool {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.keyPressed[key]
+}
+
+func mockIsKeyDown(key int32) bool {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.keyDown[key]
+}
+
+func mockIsMouseButtonPressed(button int32) bool {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.mousePressed[button]
+}
+
+func mockGetMousePosition() rl.Vector2 {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.mousePosition
+}
+
+func mockGetMouseRay(mousePos rl.Vector2, camera rl.Camera3D) rl.Ray {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.mouseRay
+}
+
+func mockGetMouseWheelMove() float32 {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.mouseWheel
+}
+
+func mockGetCharPressed() rune {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.charPressed
+}
+
+// Add more mock implementations...
+
+// Add this helper function
+func toInt32(button rl.MouseButton) int32 {
+	return int32(button)
+}

game/test_setup.go

@@ -0,0 +1,26 @@
+package game
+
+import (
+	"testing"
+
+	"gitea.boner.be/bdnugget/goonscape/game/mock"
+	"gitea.boner.be/bdnugget/goonscape/game/testutils"
+)
+
+func setupTestEnvironment(t *testing.T) (*Game, func()) {
+	testutils.ResetMockInput()
+	testutils.SetupMockFunctions()
+
+	game := New()
+	game.input = &MockInput{}
+	game.Chat.input = &MockInput{} // Also inject mock input into chat
+
+	// Verify mock setup
+	if mock.IsKeyPressed == nil || mock.GetCharPressed == nil {
+		t.Fatal("Mock functions not properly initialized")
+	}
+
+	return game, func() {
+		testutils.ResetMockInput()
+	}
+}

game/testutils/helpers.go

@@ -0,0 +1,153 @@
+package testutils
+
+import (
+	"sync"
+
+	"gitea.boner.be/bdnugget/goonscape/game/mock"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+var (
+	mockInput struct {
+		sync.Mutex
+		keyPressed    map[int32]bool
+		keyDown       map[int32]bool
+		mousePressed  map[int32]bool
+		mousePosition rl.Vector2
+		mouseRay      rl.Ray
+		mouseWheel    float32
+		charPressed   rune
+	}
+)
+
+func init() {
+	ResetMockInput()
+	SetupMockFunctions()
+}
+
+// SetupMockFunctions initializes mock functions
+func SetupMockFunctions() {
+	mock.IsKeyPressed = MockIsKeyPressed
+	mock.IsKeyDown = MockIsKeyDown
+	mock.IsMouseButtonPressed = MockIsMouseButtonPressed
+	mock.GetMousePosition = MockGetMousePosition
+	mock.GetMouseRay = MockGetMouseRay
+	mock.GetMouseWheelMove = MockGetMouseWheelMove
+	mock.GetCharPressed = MockGetCharPressed
+}
+
+// ResetMockInput resets all mock input states
+func ResetMockInput() {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	mockInput.keyPressed = make(map[int32]bool)
+	mockInput.keyDown = make(map[int32]bool)
+	mockInput.mousePressed = make(map[int32]bool)
+	mockInput.mousePosition = rl.Vector2{}
+	mockInput.mouseRay = rl.Ray{}
+	mockInput.mouseWheel = 0
+	mockInput.charPressed = 0
+}
+
+// SimulateKeyPress simulates a key press
+func SimulateKeyPress(key int32) {
+	mockInput.Lock()
+	mockInput.keyPressed[key] = true
+	mockInput.Unlock()
+}
+
+// SimulateKeyDown simulates holding a key down
+func SimulateKeyDown(key int32, isDown bool) {
+	mockInput.Lock()
+	mockInput.keyDown[key] = isDown
+	mockInput.Unlock()
+}
+
+// SimulateMouseButton simulates a mouse button press
+func SimulateMouseButton(button int32, isPressed bool) {
+	mockInput.Lock()
+	mockInput.mousePressed[button] = isPressed
+	mockInput.Unlock()
+}
+
+// SimulateMousePosition simulates mouse movement
+func SimulateMousePosition(x, y float32) {
+	mockInput.Lock()
+	mockInput.mousePosition = rl.Vector2{X: x, Y: y}
+	mockInput.Unlock()
+}
+
+// SimulateMouseClick simulates a mouse click at the given position
+func SimulateMouseClick(x, y float32) {
+	SimulateMousePosition(x, y)
+	SimulateMouseButton(ToInt32(rl.MouseLeftButton), true)
+}
+
+// SimulateMouseRay simulates a mouse ray
+func SimulateMouseRay(ray rl.Ray) {
+	mockInput.Lock()
+	mockInput.mouseRay = ray
+	mockInput.Unlock()
+}
+
+// SimulateMouseWheel simulates mouse wheel movement
+func SimulateMouseWheel(move float32) {
+	mockInput.Lock()
+	mockInput.mouseWheel = move
+	mockInput.Unlock()
+}
+
+// SimulateCharInput simulates character input
+func SimulateCharInput(char rune) {
+	mockInput.Lock()
+	mockInput.charPressed = char
+	mockInput.Unlock()
+}
+
+// Mock raylib functions
+func MockIsKeyPressed(key int32) bool {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.keyPressed[key]
+}
+
+func MockIsKeyDown(key int32) bool {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.keyDown[key]
+}
+
+func MockIsMouseButtonPressed(button int32) bool {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.mousePressed[button]
+}
+
+func MockGetMousePosition() rl.Vector2 {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.mousePosition
+}
+
+func MockGetMouseRay(mousePos rl.Vector2, camera rl.Camera3D) rl.Ray {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.mouseRay
+}
+
+func MockGetMouseWheelMove() float32 {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.mouseWheel
+}
+
+func MockGetCharPressed() rune {
+	mockInput.Lock()
+	defer mockInput.Unlock()
+	return mockInput.charPressed
+}
+
+// ToInt32 converts MouseButton to int32
+func ToInt32(button rl.MouseButton) int32 {
+	return int32(button)
+}

game/utils.go

@@ -0,0 +1,45 @@
+package game
+
+import (
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+func RayIntersectsBox(ray rl.Ray, boxMin, boxMax rl.Vector3) bool {
+	tmin := (boxMin.X - ray.Position.X) / ray.Direction.X
+	tmax := (boxMax.X - ray.Position.X) / ray.Direction.X
+
+	if tmin > tmax {
+		tmin, tmax = tmax, tmin
+	}
+
+	tymin := (boxMin.Z - ray.Position.Z) / ray.Direction.Z
+	tymax := (boxMax.Z - ray.Position.Z) / ray.Direction.Z
+
+	if tymin > tymax {
+		tymin, tymax = tymax, tymin
+	}
+
+	if (tmin > tymax) || (tymin > tmax) {
+		return false
+	}
+
+	if tymin > tmin {
+		tmin = tymin
+	}
+	if tymax < tmax {
+		tmax = tymax
+	}
+
+	tzmin := (boxMin.Y - ray.Position.Y) / ray.Direction.Y
+	tzmax := (boxMax.Y - ray.Position.Y) / ray.Direction.Y
+
+	if tzmin > tzmax {
+		tzmin, tzmax = tzmax, tzmin
+	}
+
+	if (tmin > tzmax) || (tzmin > tmax) {
+		return false
+	}
+
+	return true
+}

game/world.go

@@ -0,0 +1,39 @@
+package game
+
+import (
+	"gitea.boner.be/bdnugget/goonscape/types"
+)
+
+var (
+	mapGrid [][]types.Tile
+)
+
+func GetMapGrid() [][]types.Tile {
+	return mapGrid
+}
+
+func InitWorld() {
+	mapGrid = make([][]types.Tile, types.MapWidth)
+	for x := 0; x < types.MapWidth; x++ {
+		mapGrid[x] = make([]types.Tile, types.MapHeight)
+		for y := 0; y < types.MapHeight; y++ {
+			mapGrid[x][y] = types.Tile{
+				X:        x,
+				Y:        y,
+				Height:   1.0 + float32(x%5),
+				Walkable: true,
+			}
+		}
+	}
+}
+
+func GetTile(x, y int) types.Tile {
+	if x >= 0 && x < types.MapWidth && y >= 0 && y < types.MapHeight {
+		return mapGrid[x][y]
+	}
+	return types.Tile{}
+}
+
+func GetTileHeight(x, y int) float32 {
+	return mapGrid[x][y].Height
+}

go.mod

@@ -1,15 +1,24 @@
-module goonscape
+module gitea.boner.be/bdnugget/goonscape
 
 go 1.23.0
 
 require (
-	gitea.boner.be/bdnugget/goonserver v0.0.0-20241011195320-f16e8647dc6b
-	github.com/gen2brain/raylib-go/raylib v0.0.0-20240930075631-c66f9e2942fe
-	google.golang.org/protobuf v1.35.1
+	gitea.boner.be/bdnugget/goonserver v1.1.0
+	github.com/gen2brain/raylib-go/raylib v0.0.0-20250109172833-6dbba4f81a9b
+	google.golang.org/protobuf v1.36.3
 )
 
 require (
-	github.com/ebitengine/purego v0.8.0 // indirect
-	golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c // indirect
-	golang.org/x/sys v0.26.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
+
+require (
+	github.com/ebitengine/purego v0.8.2 // indirect
+	github.com/stretchr/testify v1.10.0
+	golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 // indirect
+	golang.org/x/sys v0.29.0 // indirect
+)
+
+replace gitea.boner.be/bdnugget/goonserver => ./goonserver

go.sum

@@ -1,14 +1,21 @@
-gitea.boner.be/bdnugget/goonserver v0.0.0-20241011195320-f16e8647dc6b h1:hdhCZH0YGqCsnSl6ru+8I7rxvCyOj5pCtf92urwyruA=
-gitea.boner.be/bdnugget/goonserver v0.0.0-20241011195320-f16e8647dc6b/go.mod h1:inR1bKrr/vcTba+G1KzmmY6vssMq9oGNOk836VwPa4c=
-github.com/ebitengine/purego v0.8.0 h1:JbqvnEzRvPpxhCJzJJ2y0RbiZ8nyjccVUrSM3q+GvvE=
-github.com/ebitengine/purego v0.8.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
-github.com/gen2brain/raylib-go/raylib v0.0.0-20240930075631-c66f9e2942fe h1:mInjrbJkUglTM7tBmXG+epnPCE744aj15J7vjJwM4gs=
-github.com/gen2brain/raylib-go/raylib v0.0.0-20240930075631-c66f9e2942fe/go.mod h1:BaY76bZk7nw1/kVOSQObPY1v1iwVE1KHAGMfvI6oK1Q=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/ebitengine/purego v0.8.2 h1:jPPGWs2sZ1UgOSgD2bClL0MJIqu58nOmIcBuXr62z1I=
+github.com/ebitengine/purego v0.8.2/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=
+github.com/gen2brain/raylib-go/raylib v0.0.0-20250109172833-6dbba4f81a9b h1:JJfspevP3YOXcSKVABizYOv++yMpTJIdPUtoDzF/RWw=
+github.com/gen2brain/raylib-go/raylib v0.0.0-20250109172833-6dbba4f81a9b/go.mod h1:BaY76bZk7nw1/kVOSQObPY1v1iwVE1KHAGMfvI6oK1Q=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c h1:7dEasQXItcW1xKJ2+gg5VOiBnqWrJc+rq0DPKyvvdbY=
-golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c/go.mod h1:NQtJDoLvd6faHhE7m4T/1IY708gDefGGjR/iUW8yQQ8=
-golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
-golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA=
-google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 h1:yqrTHse8TCMW1M1ZCP+VAR/l0kKxwaAIqN/il7x4voA=
+golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8/go.mod h1:tujkw807nyEEAamNbDrEGzRav+ilXA7PCRAd6xsmwiU=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+google.golang.org/protobuf v1.36.3 h1:82DV7MYdb8anAVi3qge1wSnMDrnKK7ebr+I0hHRN1BU=
+google.golang.org/protobuf v1.36.3/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

input.go

@@ -1,88 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	rl "github.com/gen2brain/raylib-go/raylib"
-)
-
-func GetTileAtMouse(camera *rl.Camera3D) (Tile, bool) {
-	if !rl.IsMouseButtonPressed(rl.MouseLeftButton) {
-		return Tile{}, false
-	}
-	mouse := rl.GetMousePosition()
-	ray := rl.GetMouseRay(mouse, *camera)
-
-	for x := 0; x < MapWidth; x++ {
-		for y := 0; y < MapHeight; y++ {
-			tile := mapGrid[x][y]
-
-			// Define the bounding box for each tile based on its position and height
-			tilePos := rl.NewVector3(float32(x*TileSize), tile.Height*TileHeight, float32(y*TileSize))
-			boxMin := rl.Vector3Subtract(tilePos, rl.NewVector3(TileSize/2, TileHeight/2, TileSize/2))
-			boxMax := rl.Vector3Add(tilePos, rl.NewVector3(TileSize/2, TileHeight/2, TileSize/2))
-
-			// Check if the ray intersects the bounding box
-			if RayIntersectsBox(ray, boxMin, boxMax) {
-				fmt.Println("Clicked:", tile.X, tile.Y)
-				return tile, true
-			}
-		}
-	}
-	return Tile{}, false
-}
-
-func HandleInput(player *Player, camera *rl.Camera) {
-	clickedTile, clicked := GetTileAtMouse(camera)
-	if clicked {
-		path := FindPath(mapGrid[player.PosTile.X][player.PosTile.Y], clickedTile)
-		if path != nil {
-			// Exclude the first tile (current position)
-			if len(path) > 1 {
-				player.TargetPath = path[1:]
-				player.ActionQueue = append(player.ActionQueue, Action{Type: MoveAction, X: clickedTile.X, Y: clickedTile.Y})
-			}
-		}
-	}
-}
-
-// Helper function to test ray-box intersection (slab method)
-func RayIntersectsBox(ray rl.Ray, boxMin, boxMax rl.Vector3) bool {
-	tmin := (boxMin.X - ray.Position.X) / ray.Direction.X
-	tmax := (boxMax.X - ray.Position.X) / ray.Direction.X
-
-	if tmin > tmax {
-		tmin, tmax = tmax, tmin
-	}
-
-	tymin := (boxMin.Z - ray.Position.Z) / ray.Direction.Z
-	tymax := (boxMax.Z - ray.Position.Z) / ray.Direction.Z
-
-	if tymin > tymax {
-		tymin, tymax = tymax, tymin
-	}
-
-	if (tmin > tymax) || (tymin > tmax) {
-		return false
-	}
-
-	if tymin > tmin {
-		tmin = tymin
-	}
-	if tymax < tmax {
-		tmax = tymax
-	}
-
-	tzmin := (boxMin.Y - ray.Position.Y) / ray.Direction.Y
-	tzmax := (boxMax.Y - ray.Position.Y) / ray.Direction.Y
-
-	if tzmin > tzmax {
-		tzmin, tzmax = tzmax, tzmin
-	}
-
-	if (tmin > tzmax) || (tzmin > tmax) {
-		return false
-	}
-
-	return true
-}

main.go

@@ -1,150 +1,60 @@
 package main
 
 import (
+	"flag"
 	"log"
+	"strings"
 
+	"gitea.boner.be/bdnugget/goonscape/game"
+	"gitea.boner.be/bdnugget/goonscape/network"
 	rl "github.com/gen2brain/raylib-go/raylib"
 )
 
-var (
-	cameraDistance = float32(20.0)
-	cameraYaw      = float32(145.0)
-	cameraPitch    = float32(45.0) // Adjusted for a more overhead view
-	mapGrid        = InitMap()
-)
-
 func main() {
+	// Parse command line flags
+	local := flag.Bool("local", false, "Connect to local server")
+	addr := flag.String("addr", "", "Server address (host or host:port)")
+	flag.Parse()
+
+	// Set server address based on flags
+	if *local {
+		if *addr != "" {
+			log.Fatal("Cannot use -local and -addr together")
+		}
+		network.SetServerAddr("localhost:6969")
+	} else if *addr != "" {
+		// If port is not specified, append default port
+		if !strings.Contains(*addr, ":") {
+			*addr += ":6969"
+		}
+		network.SetServerAddr(*addr)
+	}
+
 	rl.InitWindow(1024, 768, "GoonScape")
+	rl.SetExitKey(0)
 	defer rl.CloseWindow()
+
 	rl.InitAudioDevice()
 	defer rl.CloseAudioDevice()
 
-	player := Player{
-		PosActual:  rl.NewVector3(5*TileSize, 0, 5*TileSize),
-		PosTile:    mapGrid[5][5],
-		Speed:      50.0,
-		TargetPath: []Tile{},
-	}
-
-	camera := rl.Camera3D{
-		Position:   rl.NewVector3(0, 10, 10), // Will be updated every frame
-		Target:     player.PosActual,
-		Up:         rl.NewVector3(0, 1, 0), // Y is up in 3D
-		Fovy:       45.0,
-		Projection: rl.CameraPerspective,
-	}
-
-	conn, playerID, err := ConnectToServer()
-	if err != nil {
-		log.Fatalf("Failed to connect to server: %v", err)
-	}
-	log.Printf("Player ID: %d", playerID)
-	player.ID = playerID
-	defer conn.Close()
-
-	otherPlayers := make(map[int32]*Player)
-
-	go HandleServerCommunication(conn, playerID, &player, otherPlayers)
-
-	models, err := LoadModels()
-	if err != nil {
-		log.Fatalf("Failed to load models: %v", err)
-	}
-	defer UnloadModels(models)
-
-	modelIndex := int(playerID) % len(models)
-	player.Model = models[modelIndex].Model
-	player.Texture = models[modelIndex].Texture
-
-	music, err := LoadMusic("resources/audio/GoonScape2.mp3")
-	if err != nil {
-		log.Fatalf("Failed to load music: %v", err)
-	}
-	defer UnloadMusic(music)
-	rl.PlayMusicStream(music)
-	rl.SetMusicVolume(music, 0.5)
-
 	rl.SetTargetFPS(60)
 
+	game := game.New()
+	if err := game.LoadAssets(); err != nil {
+		log.Fatalf("Failed to load assets: %v", err)
+	}
+	defer game.Cleanup()
+
+	rl.PlayMusicStream(game.Music)
+	rl.SetMusicVolume(game.Music, 0.5)
+
 	for !rl.WindowShouldClose() {
-
-		rl.UpdateMusicStream(music)
-
-		// Time management
 		deltaTime := rl.GetFrameTime()
-
-		// Handle input
-		HandleInput(&player, &camera)
-
-		// Update player
-		if len(player.TargetPath) > 0 {
-			player.MoveTowards(player.TargetPath[0], deltaTime)
-		}
-
-		// Update camera
-		UpdateCamera(&camera, player.PosActual, deltaTime)
-
-		// Rendering
-		rl.BeginDrawing()
-		rl.ClearBackground(rl.RayWhite)
-		rl.BeginMode3D(camera)
-		DrawMap()
-		DrawPlayer(player, player.Model)
-
-		for id, other := range otherPlayers {
-			if len(other.TargetPath) > 0 {
-				other.MoveTowards(other.TargetPath[0], deltaTime)
-			}
-			DrawPlayer(*other, models[int(id)%len(models)].Model)
-		}
-
-		rl.EndMode3D()
-		rl.DrawFPS(10, 10)
-		rl.EndDrawing()
+		rl.UpdateMusicStream(game.Music)
+		game.Update(deltaTime)
+		game.Render()
 	}
-}
-
-func LoadModels() ([]struct {
-	Model   rl.Model
-	Texture rl.Texture2D
-}, error) {
-	goonerModel := rl.LoadModel("resources/models/goonion.obj")
-	goonerTexture := rl.LoadTexture("resources/models/goonion.png")
-	rl.SetMaterialTexture(goonerModel.Materials, rl.MapDiffuse, goonerTexture)
-
-	coomerModel := rl.LoadModel("resources/models/coomer.obj")
-	coomerTexture := rl.LoadTexture("resources/models/coomer.png")
-	rl.SetMaterialTexture(coomerModel.Materials, rl.MapDiffuse, coomerTexture)
-
-	shrekeModel := rl.LoadModel("resources/models/shreke.obj")
-	shrekeTexture := rl.LoadTexture("resources/models/shreke.png")
-	rl.SetMaterialTexture(shrekeModel.Materials, rl.MapDiffuse, shrekeTexture)
-
-	return []struct {
-		Model   rl.Model
-		Texture rl.Texture2D
-	}{
-		{Model: goonerModel, Texture: goonerTexture},
-		{Model: coomerModel, Texture: coomerTexture},
-		{Model: shrekeModel, Texture: shrekeTexture},
-	}, nil
-}
-
-func UnloadModels(models []struct {
-	Model   rl.Model
-	Texture rl.Texture2D
-}) {
-	for _, model := range models {
-		rl.UnloadModel(model.Model)
-		rl.UnloadTexture(model.Texture)
-	}
-}
-
-func LoadMusic(filename string) (rl.Music, error) {
-	music := rl.LoadMusicStream(filename)
-	return music, nil
-}
-
-func UnloadMusic(music rl.Music) {
-	rl.UnloadMusicStream(music)
+
+	// Wait for clean shutdown
+	<-game.QuitChan
 }

map.go

@@ -1,48 +0,0 @@
-package main
-
-import rl "github.com/gen2brain/raylib-go/raylib"
-
-// Initialize the map with some height data
-func InitMap() [][]Tile {
-	mapGrid := make([][]Tile, MapWidth)
-	for x := 0; x < MapWidth; x++ {
-		mapGrid[x] = make([]Tile, MapHeight)
-		for y := 0; y < MapHeight; y++ {
-			mapGrid[x][y] = Tile{
-				X:        x,
-				Y:        y,
-				Height:   1.0 + float32(x%5), // Example height
-				Walkable: true,               // Set to false for obstacles
-			}
-		}
-	}
-	return mapGrid
-}
-
-func DrawMap() {
-	for x := 0; x < MapWidth; x++ {
-		for y := 0; y < MapHeight; y++ {
-			tile := mapGrid[x][y]
-			// Interpolate height between adjacent tiles for a smoother landscape
-			height := tile.Height
-			if x > 0 {
-				height += mapGrid[x-1][y].Height
-			}
-			if y > 0 {
-				height += mapGrid[x][y-1].Height
-			}
-			if x > 0 && y > 0 {
-				height += mapGrid[x-1][y-1].Height
-			}
-			height /= 4.0
-			// Draw each tile as a 3D cube based on its height
-			tilePos := rl.Vector3{
-				X: float32(x * TileSize), // X-axis for horizontal position
-				Y: height * TileHeight,   // Y-axis for height (Z in 3D is Y here)
-				Z: float32(y * TileSize), // Z-axis for depth (Y in 3D is Z here)
-			}
-			color := rl.Color{R: uint8(height * 25), G: 100, B: 100, A: 64}
-			rl.DrawCube(tilePos, TileSize, TileHeight, TileSize, color) // Draw a cube representing the tile
-		}
-	}
-}

network.go

@@ -1,121 +0,0 @@
-package main
-
-import (
-	"log"
-	"net"
-	"time"
-
-	pb "gitea.boner.be/bdnugget/goonserver/actions"
-	rl "github.com/gen2brain/raylib-go/raylib"
-	"google.golang.org/protobuf/proto"
-)
-
-func ConnectToServer() (net.Conn, int32, error) {
-	// Attempt to connect to the server
-	conn, err := net.Dial("tcp", serverAddr)
-	if err != nil {
-		log.Printf("Failed to dial server: %v", err)
-		return nil, 0, err
-	}
-
-	log.Println("Connected to server. Waiting for player ID...")
-	// Buffer for incoming server message
-	buf := make([]byte, 1024)
-	n, err := conn.Read(buf)
-	if err != nil {
-		log.Printf("Error reading player ID from server: %v", err)
-		return nil, 0, err
-	}
-
-	log.Printf("Received data: %x", buf[:n])
-
-	// Unmarshal server message to extract the player ID
-	var response pb.ServerMessage
-	if err := proto.Unmarshal(buf[:n], &response); err != nil {
-		log.Printf("Failed to unmarshal server response: %v", err)
-		return nil, 0, err
-	}
-
-	playerID := response.GetPlayerId()
-	log.Printf("Successfully connected with player ID: %d", playerID)
-	return conn, playerID, nil
-}
-
-func HandleServerCommunication(conn net.Conn, playerID int32, player *Player, otherPlayers map[int32]*Player) {
-	// Goroutine to handle sending player's actions to the server
-	go func() {
-		for {
-			if len(player.ActionQueue) > 0 {
-				// Process the first action in the queue
-				actionData := player.ActionQueue[0]
-				action := &pb.Action{
-					PlayerId: playerID,
-					Type:     pb.Action_MOVE,
-					X:        int32(actionData.X),
-					Y:        int32(actionData.Y),
-				}
-
-				// Serialize the action
-				data, err := proto.Marshal(action)
-				if err != nil {
-					log.Printf("Failed to marshal action: %v", err)
-					continue
-				}
-
-				// Send action to server
-				_, err = conn.Write(data)
-				if err != nil {
-					log.Printf("Failed to send action to server: %v", err)
-					return
-				}
-
-				// Remove the action from the queue once it's sent
-				player.ActionQueue = player.ActionQueue[1:]
-			}
-
-			// Add a delay to match the server's tick rate
-			time.Sleep(TickRate)
-		}
-	}()
-
-	// Main loop to handle receiving updates from the server
-	for {
-		buf := make([]byte, 4096)
-		n, err := conn.Read(buf)
-		if err != nil {
-			log.Printf("Failed to read from server: %v", err)
-			return
-		}
-
-		var serverMessage pb.ServerMessage
-		if err := proto.Unmarshal(buf[:n], &serverMessage); err != nil {
-			log.Printf("Failed to unmarshal server message: %v", err)
-			continue
-		}
-
-		// Update other players' states
-		for _, state := range serverMessage.Players {
-			if state.PlayerId != playerID {
-				if otherPlayer, exists := otherPlayers[state.PlayerId]; exists {
-					otherPlayer.PosTile = Tile{X: int(state.X), Y: int(state.Y)}
-					otherPlayer.PosActual = rl.Vector3{
-						X: float32(state.X * TileSize),
-						Y: float32(state.Y * TileHeight),
-						Z: float32(state.Y * TileSize),
-					}
-					otherPlayer.MoveTowards(Tile{X: int(state.X), Y: int(state.Y)}, 0)
-				} else {
-					otherPlayers[state.PlayerId] = &Player{
-						PosTile: Tile{X: int(state.X), Y: int(state.Y)},
-						PosActual: rl.Vector3{
-							X: float32(state.X * TileSize),
-							Y: float32(state.Y * TileHeight),
-							Z: float32(state.Y * TileSize),
-						},
-						ID: state.PlayerId,
-					}
-				}
-			}
-		}
-	}
-}

network/network.go

@@ -0,0 +1,254 @@
+package network
+
+import (
+	"bufio"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"time"
+
+	"gitea.boner.be/bdnugget/goonscape/types"
+	pb "gitea.boner.be/bdnugget/goonserver/actions"
+	rl "github.com/gen2brain/raylib-go/raylib"
+	"google.golang.org/protobuf/proto"
+)
+
+const protoVersion = 1
+
+var serverAddr = "boner.be:6969"
+
+func SetServerAddr(addr string) {
+	serverAddr = addr
+}
+
+func ConnectToServer(username, password string, isRegistering bool) (net.Conn, int32, error) {
+	conn, err := net.Dial("tcp", serverAddr)
+	if err != nil {
+		log.Printf("Failed to dial server: %v", err)
+		return nil, 0, err
+	}
+
+	log.Println("Connected to server. Authenticating...")
+
+	// Send auth message
+	authAction := &pb.Action{
+		Type:     pb.Action_LOGIN,
+		Username: username,
+		Password: password,
+	}
+	if isRegistering {
+		authAction.Type = pb.Action_REGISTER
+	}
+
+	authBatch := &pb.ActionBatch{
+		Actions:         []*pb.Action{authAction},
+		ProtocolVersion: protoVersion,
+	}
+
+	if err := writeMessage(conn, authBatch); err != nil {
+		conn.Close()
+		return nil, 0, fmt.Errorf("failed to send auth: %v", err)
+	}
+
+	// Read server response
+	reader := bufio.NewReader(conn)
+	lengthBuf := make([]byte, 4)
+	if _, err := io.ReadFull(reader, lengthBuf); err != nil {
+		conn.Close()
+		return nil, 0, fmt.Errorf("failed to read auth response: %v", err)
+	}
+	messageLength := binary.BigEndian.Uint32(lengthBuf)
+
+	messageBuf := make([]byte, messageLength)
+	if _, err := io.ReadFull(reader, messageBuf); err != nil {
+		conn.Close()
+		return nil, 0, fmt.Errorf("failed to read auth response body: %v", err)
+	}
+
+	var response pb.ServerMessage
+	if err := proto.Unmarshal(messageBuf, &response); err != nil {
+		conn.Close()
+		return nil, 0, fmt.Errorf("failed to unmarshal auth response: %v", err)
+	}
+
+	if response.ProtocolVersion > protoVersion {
+		conn.Close()
+		return nil, 0, fmt.Errorf("server requires newer protocol version (server: %d, client: %d)",
+			response.ProtocolVersion, protoVersion)
+	}
+
+	if !response.AuthSuccess {
+		conn.Close()
+		return nil, 0, fmt.Errorf(response.ErrorMessage)
+	}
+
+	playerID := response.GetPlayerId()
+	log.Printf("Successfully authenticated with player ID: %d", playerID)
+	return conn, playerID, nil
+}
+
+func HandleServerCommunication(conn net.Conn, playerID int32, player *types.Player, otherPlayers map[int32]*types.Player, quitChan <-chan struct{}) {
+	reader := bufio.NewReader(conn)
+
+	actionTicker := time.NewTicker(types.ClientTickRate)
+	defer actionTicker.Stop()
+	defer conn.Close()
+	defer close(player.QuitDone)
+
+	// Create a channel to signal when goroutines are done
+	done := make(chan struct{})
+
+	// Create a set of current players to track disconnects
+	currentPlayers := make(map[int32]bool)
+
+	go func() {
+		for {
+			select {
+			case <-quitChan:
+				// Send disconnect message to server
+				disconnectMsg := &pb.ActionBatch{
+					PlayerId: playerID,
+					Actions: []*pb.Action{{
+						Type:     pb.Action_DISCONNECT,
+						PlayerId: playerID,
+					}},
+				}
+				writeMessage(conn, disconnectMsg)
+				done <- struct{}{}
+				return
+			case <-actionTicker.C:
+				player.Lock()
+				if len(player.ActionQueue) > 0 {
+					actions := make([]*pb.Action, len(player.ActionQueue))
+					copy(actions, player.ActionQueue)
+
+					batch := &pb.ActionBatch{
+						PlayerId: playerID,
+						Actions:  actions,
+						Tick:     player.CurrentTick,
+					}
+
+					player.ActionQueue = player.ActionQueue[:0]
+					player.Unlock()
+
+					if err := writeMessage(conn, batch); err != nil {
+						log.Printf("Failed to send actions to server: %v", err)
+						return
+					}
+				} else {
+					player.Unlock()
+				}
+			}
+		}
+	}()
+
+	for {
+		select {
+		case <-quitChan:
+			done := make(chan struct{})
+			go func() {
+				<-done
+				close(player.QuitDone)
+			}()
+
+			select {
+			case <-done:
+				time.Sleep(100 * time.Millisecond)
+			case <-time.After(1 * time.Second):
+				log.Println("Shutdown timed out")
+			}
+			return
+		default:
+			// Read message length (4 bytes)
+			lengthBuf := make([]byte, 4)
+			if _, err := io.ReadFull(reader, lengthBuf); err != nil {
+				log.Printf("Failed to read message length: %v", err)
+				return
+			}
+			messageLength := binary.BigEndian.Uint32(lengthBuf)
+
+			// Read the full message
+			messageBuf := make([]byte, messageLength)
+			if _, err := io.ReadFull(reader, messageBuf); err != nil {
+				log.Printf("Failed to read message body: %v", err)
+				return
+			}
+
+			var serverMessage pb.ServerMessage
+			if err := proto.Unmarshal(messageBuf, &serverMessage); err != nil {
+				log.Printf("Failed to unmarshal server message: %v", err)
+				continue
+			}
+
+			player.Lock()
+			player.CurrentTick = serverMessage.CurrentTick
+
+			tickDiff := serverMessage.CurrentTick - player.CurrentTick
+			if tickDiff > types.MaxTickDesync {
+				for _, state := range serverMessage.Players {
+					if state.PlayerId == playerID {
+						player.ForceResync(state)
+						break
+					}
+				}
+			}
+			player.Unlock()
+
+			for _, state := range serverMessage.Players {
+				currentPlayers[state.PlayerId] = true
+				if state.PlayerId == playerID {
+					player.Lock()
+					// Update initial position if not set
+					if player.PosActual.X == 0 && player.PosActual.Z == 0 {
+						player.PosActual = rl.Vector3{
+							X: float32(state.X * types.TileSize),
+							Y: 0,
+							Z: float32(state.Y * types.TileSize),
+						}
+						player.PosTile = types.Tile{X: int(state.X), Y: int(state.Y)}
+					}
+					player.Unlock()
+					continue
+				}
+
+				if otherPlayer, exists := otherPlayers[state.PlayerId]; exists {
+					otherPlayer.UpdatePosition(state, types.ServerTickRate)
+				} else {
+					otherPlayers[state.PlayerId] = types.NewPlayer(state)
+				}
+			}
+
+			// Remove players that are no longer in the server state
+			for id := range otherPlayers {
+				if !currentPlayers[id] {
+					delete(otherPlayers, id)
+				}
+			}
+
+			if handler, ok := player.UserData.(types.ChatMessageHandler); ok && len(serverMessage.ChatMessages) > 0 {
+				handler.HandleServerMessages(serverMessage.ChatMessages)
+			}
+		}
+	}
+}
+
+// Helper function to write length-prefixed messages
+func writeMessage(conn net.Conn, msg proto.Message) error {
+	data, err := proto.Marshal(msg)
+	if err != nil {
+		return err
+	}
+
+	// Write length prefix
+	lengthBuf := make([]byte, 4)
+	binary.BigEndian.PutUint32(lengthBuf, uint32(len(data)))
+	if _, err := conn.Write(lengthBuf); err != nil {
+		return err
+	}
+
+	// Write message body
+	_, err = conn.Write(data)
+	return err
+}

player.go

@@ -1,63 +0,0 @@
-package main
-
-import (
-	rl "github.com/gen2brain/raylib-go/raylib"
-)
-
-func DrawPlayer(player Player, model rl.Model) {
-	// Draw the player based on its actual position (PosActual) and current tile height
-	playerPos := rl.Vector3{
-		X: player.PosActual.X,
-		Y: mapGrid[player.PosTile.X][player.PosTile.Y].Height*TileHeight + 16.0,
-		Z: player.PosActual.Z,
-	}
-
-	rl.DrawModel(model, playerPos, 16, rl.White)
-
-	// Draw highlight around target tile
-	if len(player.TargetPath) > 0 {
-		targetTile := player.TargetPath[len(player.TargetPath)-1] // last tile in the slice
-		targetPos := rl.Vector3{
-			X: float32(targetTile.X * TileSize),
-			Y: mapGrid[targetTile.X][targetTile.Y].Height * TileHeight,
-			Z: float32(targetTile.Y * TileSize),
-		}
-		rl.DrawCubeWires(targetPos, TileSize, TileHeight, TileSize, rl.Green)
-
-		nextTile := player.TargetPath[0] // first tile in the slice
-		nextPos := rl.Vector3{
-			X: float32(nextTile.X * TileSize),
-			Y: mapGrid[nextTile.X][nextTile.Y].Height * TileHeight,
-			Z: float32(nextTile.Y * TileSize),
-		}
-		rl.DrawCubeWires(nextPos, TileSize, TileHeight, TileSize, rl.Yellow)
-	}
-}
-
-func (player *Player) MoveTowards(target Tile, deltaTime float32) {
-	// Calculate the direction vector to the target tile
-	targetPos := rl.Vector3{
-		X: float32(target.X * TileSize),
-		Y: mapGrid[target.X][target.Y].Height * TileHeight,
-		Z: float32(target.Y * TileSize),
-	}
-
-	// Calculate direction and normalize it for smooth movement
-	direction := rl.Vector3Subtract(targetPos, player.PosActual)
-	distance := rl.Vector3Length(direction)
-	if distance > 0 {
-		direction = rl.Vector3Scale(direction, player.Speed*deltaTime/distance)
-	}
-
-	// Move the player towards the target tile
-	if distance > 1.0 {
-		player.PosActual = rl.Vector3Add(player.PosActual, direction)
-	} else {
-		// Snap to the target tile when close enough
-		player.PosActual = targetPos
-		player.PosTile = target // Update player's tile
-		if len(player.TargetPath) > 1 {
-			player.TargetPath = player.TargetPath[1:] // Move to next tile in path if any
-		}
-	}
-}

render.go

@@ -1 +0,0 @@
-package main

scripts/build.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+# Main build process
+build() {
+    local os=$1
+    local arch=$2
+    local output=$3
+
+    # Set GOOS and GOARCH for cross-compilation
+    export GOOS=$os
+    export GOARCH=$arch
+
+    # Disable CGO only for cross-compilation
+    if [ "$os" != "$(go env GOOS)" ] || [ "$arch" != "$(go env GOARCH)" ]; then
+        export CGO_ENABLED=0
+    fi
+
+    if [ "$os" = "windows" ]; then
+        export CC=x86_64-w64-mingw32-gcc
+        export CXX=x86_64-w64-mingw32-g++
+    fi
+
+    go build -buildvcs=false -ldflags="-s -w" -o $output
+}
+
+# Call build with provided arguments
+build "$1" "$2" "$3" 

scripts/platforms.mk

@@ -0,0 +1 @@
+PLATFORMS=windows/amd64 linux/amd64 

types.go

@@ -1,31 +0,0 @@
-package main
-
-import rl "github.com/gen2brain/raylib-go/raylib"
-
-type Tile struct {
-	X, Y     int
-	Height   float32
-	Walkable bool
-}
-
-type ActionType int
-
-const (
-	MoveAction ActionType = iota
-)
-
-type Action struct {
-	Type ActionType
-	X, Y int // Target position for movement
-}
-
-type Player struct {
-	PosActual   rl.Vector3
-	PosTile     Tile
-	TargetPath  []Tile
-	Speed       float32
-	ActionQueue []Action // Queue for player actions
-	Model       rl.Model
-	Texture     rl.Texture2D
-	ID          int32
-}

types/player.go

@@ -0,0 +1,106 @@
+package types
+
+import (
+	"time"
+
+	pb "gitea.boner.be/bdnugget/goonserver/actions"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+func (p *Player) MoveTowards(target Tile, deltaTime float32, mapGrid [][]Tile) {
+	p.Lock()
+	defer p.Unlock()
+
+	targetPos := rl.Vector3{
+		X: float32(target.X * TileSize),
+		Y: mapGrid[target.X][target.Y].Height * TileHeight,
+		Z: float32(target.Y * TileSize),
+	}
+
+	direction := rl.Vector3Subtract(targetPos, p.PosActual)
+	distance := rl.Vector3Length(direction)
+
+	if distance > 1.0 {
+		wasMoving := p.IsMoving
+		p.IsMoving = true
+
+		if !wasMoving {
+			p.AnimationFrame = 0
+		}
+
+		oldFrame := p.AnimationFrame
+		p.AnimationFrame += int32(deltaTime * 60)
+		rl.TraceLog(rl.LogInfo, "Walk frame update: %d -> %d (delta: %f)",
+			oldFrame, p.AnimationFrame, deltaTime)
+	} else {
+		wasMoving := p.IsMoving
+		p.IsMoving = false
+
+		if wasMoving {
+			p.AnimationFrame = 0
+		}
+
+		oldFrame := p.AnimationFrame
+		p.AnimationFrame += int32(deltaTime * 60)
+		rl.TraceLog(rl.LogInfo, "Idle frame update: %d -> %d (delta: %f)",
+			oldFrame, p.AnimationFrame, deltaTime)
+	}
+
+	if distance > 0 {
+		direction = rl.Vector3Scale(direction, p.Speed*deltaTime/distance)
+	}
+
+	if distance > 1.0 {
+		p.PosActual = rl.Vector3Add(p.PosActual, direction)
+	} else {
+		p.PosActual = targetPos
+		p.PosTile = target
+		if len(p.TargetPath) > 1 {
+			p.TargetPath = p.TargetPath[1:]
+		}
+	}
+}
+
+func NewPlayer(state *pb.PlayerState) *Player {
+	return &Player{
+		PosActual: rl.Vector3{
+			X: float32(state.X * TileSize),
+			Y: float32(state.Y * TileHeight),
+			Z: float32(state.Y * TileSize),
+		},
+		PosTile:        Tile{X: int(state.X), Y: int(state.Y)},
+		Speed:          50.0,
+		ID:             state.PlayerId,
+		IsMoving:       false,
+		AnimationFrame: 0,
+		LastAnimUpdate: time.Now(),
+	}
+}
+
+func (p *Player) UpdatePosition(state *pb.PlayerState, tickRate time.Duration) {
+	p.Lock()
+	defer p.Unlock()
+
+	targetTile := Tile{X: int(state.X), Y: int(state.Y)}
+	if p.PosTile != targetTile {
+		p.PosTile = targetTile
+		p.LastUpdateTime = time.Now()
+		p.InterpolationProgress = 0
+		p.TargetPath = []Tile{targetTile}
+	}
+}
+
+func (p *Player) ForceResync(state *pb.PlayerState) {
+	p.Lock()
+	defer p.Unlock()
+
+	p.PosTile = Tile{X: int(state.X), Y: int(state.Y)}
+	p.PosActual = rl.Vector3{
+		X: float32(state.X * TileSize),
+		Y: float32(state.Y * TileHeight),
+		Z: float32(state.Y * TileSize),
+	}
+	p.TargetPath = nil
+	p.ActionQueue = nil
+	p.InterpolationProgress = 1.0
+}

types/types.go

@@ -0,0 +1,82 @@
+package types
+
+import (
+	"sync"
+	"time"
+
+	pb "gitea.boner.be/bdnugget/goonserver/actions"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+type Tile struct {
+	X, Y     int
+	Height   float32
+	Walkable bool
+}
+
+type Player struct {
+	sync.Mutex
+	PosActual             rl.Vector3
+	PosTile               Tile
+	TargetPath            []Tile
+	ActionQueue           []*pb.Action
+	Speed                 float32
+	Model                 rl.Model
+	Texture               rl.Texture2D
+	ID                    int32
+	CurrentTick           int64
+	LastUpdateTime        time.Time
+	LastAnimUpdate        time.Time
+	InterpolationProgress float32
+	UserData              interface{}
+	FloatingMessage       *FloatingMessage
+	QuitDone              chan struct{}
+	AnimationFrame        int32
+	IsMoving              bool
+}
+
+type AnimationSet struct {
+	Idle []rl.ModelAnimation
+	Walk []rl.ModelAnimation
+	// Can add more animation types later like:
+	// Attack []ModelAnimation
+	// Jump   []ModelAnimation
+}
+
+type ModelAsset struct {
+	Model      rl.Model
+	Texture    rl.Texture2D
+	Animation  []rl.ModelAnimation // Keep this for compatibility
+	AnimFrames int32               // Keep this for compatibility
+	Animations AnimationSet        // New field for organized animations
+	YOffset    float32             // Additional height offset (added to default 8.0)
+}
+
+type ChatMessage struct {
+	PlayerID int32
+	Username string
+	Content  string
+	Time     time.Time
+}
+
+type FloatingMessage struct {
+	Content    string
+	ExpireTime time.Time
+	ScreenPos  rl.Vector2 // Store the screen position for 2D rendering
+}
+
+type ChatMessageHandler interface {
+	HandleServerMessages([]*pb.ChatMessage)
+}
+
+const (
+	MapWidth   = 50
+	MapHeight  = 50
+	TileSize   = 32
+	TileHeight = 2.0
+
+	// RuneScape-style tick rate (600ms)
+	ServerTickRate = 600 * time.Millisecond
+	ClientTickRate = 50 * time.Millisecond
+	MaxTickDesync  = 5
+)