Update goonserver submodule

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,295 @@
+package assets
+
+import (
+	"fmt"
+	"os"
+
+	"gitea.boner.be/bdnugget/goonscape/types"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+// ModelLoader handles loading and fallback for 3D models
+type ModelLoader struct {
+	safeMode bool
+}
+
+// NewModelLoader creates a new model loader instance
+func NewModelLoader() *ModelLoader {
+	return &ModelLoader{
+		safeMode: os.Getenv("GOONSCAPE_SAFE_MODE") == "1",
+	}
+}
+
+// IsSafeMode returns if we should avoid loading external models
+func (ml *ModelLoader) IsSafeMode() bool {
+	return ml.safeMode || os.Getenv("GOONSCAPE_SAFE_MODE") == "1"
+}
+
+// LoadModel attempts to load a model, returning a placeholder if it fails
+func (ml *ModelLoader) LoadModel(fileName string, fallbackShape int, fallbackColor rl.Color) (rl.Model, bool, rl.Color) {
+	// Don't even try to load external models in safe mode
+	if ml.IsSafeMode() {
+		rl.TraceLog(rl.LogInfo, "Safe mode enabled, using primitive shape instead of %s", fileName)
+		return ml.createPrimitiveShape(fallbackShape), false, fallbackColor
+	}
+
+	defer func() {
+		// Recover from any panics during model loading
+		if r := recover(); r != nil {
+			rl.TraceLog(rl.LogError, "Panic in LoadModel: %v", r)
+		}
+	}()
+
+	// Try to load the model
+	model := rl.LoadModel(fileName)
+
+	// Check if the model is valid
+	if model.Meshes == nil || model.Meshes.VertexCount <= 0 {
+		rl.TraceLog(rl.LogWarning, "Failed to load model %s, using placeholder", fileName)
+		return ml.createPrimitiveShape(fallbackShape), false, fallbackColor
+	}
+
+	// For real models, return zero color since we don't need it
+	return model, true, rl.Color{}
+}
+
+// createPrimitiveShape creates a simple shape without loading external models
+func (ml *ModelLoader) createPrimitiveShape(shapeType int) rl.Model {
+	var mesh rl.Mesh
+
+	switch shapeType {
+	case 0: // Cube
+		mesh = rl.GenMeshCube(1.0, 2.0, 1.0)
+	case 1: // Sphere
+		mesh = rl.GenMeshSphere(1.0, 8, 8)
+	case 2: // Cylinder
+		mesh = rl.GenMeshCylinder(0.8, 2.0, 8)
+	case 3: // Cone
+		mesh = rl.GenMeshCone(1.0, 2.0, 8)
+	default: // Default to cube
+		mesh = rl.GenMeshCube(1.0, 2.0, 1.0)
+	}
+
+	model := rl.LoadModelFromMesh(mesh)
+	return model
+}
+
+// Helper function to load animations for a model
+func loadModelAnimations(animPaths map[string]string) (types.AnimationSet, error) {
+	var animSet types.AnimationSet
+
+	// Only try to load animations if environment variable isn't set
+	if os.Getenv("GOONSCAPE_DISABLE_ANIMATIONS") == "1" {
+		return animSet, nil
+	}
+
+	// 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
+}
+
+// ValidateModel checks if a model is valid and properly loaded
+func ValidateModel(model rl.Model) error {
+	if model.Meshes == nil {
+		return fmt.Errorf("model has nil meshes")
+	}
+	if model.Meshes.VertexCount <= 0 {
+		return fmt.Errorf("model has invalid vertex count")
+	}
+	return nil
+}
+
+// CompletelyAvoidExternalModels determines if we should avoid loading external models
+func CompletelyAvoidExternalModels() bool {
+	return os.Getenv("GOONSCAPE_SAFE_MODE") == "1"
+}
+
+// SafeLoadModel attempts to load a model, returning a placeholder if it fails
+func SafeLoadModel(fileName string, fallbackShape int, fallbackColor rl.Color) (rl.Model, bool, rl.Color) {
+	loader := NewModelLoader()
+	return loader.LoadModel(fileName, fallbackShape, fallbackColor)
+}
+
+func LoadModels() ([]types.ModelAsset, error) {
+	// Force safe mode for now until we fix the segfault
+	os.Setenv("GOONSCAPE_SAFE_MODE", "1")
+
+	models := make([]types.ModelAsset, 0, 3)
+	modelLoader := NewModelLoader()
+
+	// Colors for the different models
+	goonerColor := rl.Color{R: 255, G: 200, B: 200, A: 255} // Pinkish
+	coomerColor := rl.Color{R: 200, G: 230, B: 255, A: 255} // Light blue
+	shrekeColor := rl.Color{R: 180, G: 255, B: 180, A: 255} // Light green
+
+	// If in safe mode, create all models directly without loading
+	if modelLoader.IsSafeMode() {
+		// Gooner model (cube)
+		cube := modelLoader.createPrimitiveShape(0)
+		models = append(models, types.ModelAsset{
+			Model:            cube,
+			YOffset:          0.0,
+			PlaceholderColor: goonerColor,
+		})
+
+		// Coomer model (sphere)
+		sphere := modelLoader.createPrimitiveShape(1)
+		models = append(models, types.ModelAsset{
+			Model:            sphere,
+			YOffset:          -4.0,
+			PlaceholderColor: coomerColor,
+		})
+
+		// Shreke model (cylinder)
+		cylinder := modelLoader.createPrimitiveShape(2)
+		models = append(models, types.ModelAsset{
+			Model:            cylinder,
+			YOffset:          0.0,
+			PlaceholderColor: shrekeColor,
+		})
+
+		return models, nil
+	}
+
+	// The rest of the function with normal model loading
+	// Load Goonion model with error handling
+	var goonerModel rl.Model
+	var success bool
+	var modelColor rl.Color
+
+	goonerModel, success, modelColor = modelLoader.LoadModel("resources/models/gooner/walk_no_y_transform.glb", 0, goonerColor)
+
+	// Create animations only if model was loaded successfully
+	var goonerAnims types.AnimationSet
+	if success {
+		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
+	}
+
+	// Always add a model (real or placeholder)
+	models = append(models, types.ModelAsset{
+		Model:            goonerModel,
+		Animation:        append(goonerAnims.Idle, goonerAnims.Walk...),
+		AnimFrames:       int32(len(goonerAnims.Idle) + len(goonerAnims.Walk)),
+		Animations:       goonerAnims,
+		YOffset:          0.0,
+		PlaceholderColor: modelColor,
+	})
+
+	// Coomer model with safe loading - using a sphere shape
+	var coomerModel rl.Model
+	coomerModel, success, modelColor = modelLoader.LoadModel("resources/models/coomer/idle_notransy.glb", 1, coomerColor)
+
+	if success {
+		// Only load animations if the model loaded successfully
+		coomerAnims, _ := loadModelAnimations(map[string]string{
+			"idle": "resources/models/coomer/idle_notransy.glb",
+			"walk": "resources/models/coomer/unsteadywalk_notransy.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))
+		coomerModel.Transform = transform
+
+		models = append(models, types.ModelAsset{
+			Model:            coomerModel,
+			Animation:        append(coomerAnims.Idle, coomerAnims.Walk...),
+			AnimFrames:       int32(len(coomerAnims.Idle) + len(coomerAnims.Walk)),
+			Animations:       coomerAnims,
+			YOffset:          -4.0,
+			PlaceholderColor: rl.Color{}, // Not a placeholder
+		})
+	} else {
+		// Add a placeholder with different shape/color
+		models = append(models, types.ModelAsset{
+			Model:            coomerModel,
+			YOffset:          -4.0,
+			PlaceholderColor: modelColor,
+		})
+	}
+
+	// Shreke model with safe loading - using a cylinder shape
+	var shrekeModel rl.Model
+	shrekeModel, success, modelColor = modelLoader.LoadModel("resources/models/shreke.obj", 2, shrekeColor)
+
+	if success {
+		// Only proceed with texture if model loaded
+		shrekeTexture := rl.LoadTexture("resources/models/shreke.png")
+		if shrekeTexture.ID <= 0 {
+			rl.TraceLog(rl.LogWarning, "Failed to load shreke texture")
+		} else {
+			rl.SetMaterialTexture(shrekeModel.Materials, rl.MapDiffuse, shrekeTexture)
+
+			models = append(models, types.ModelAsset{
+				Model:            shrekeModel,
+				Texture:          shrekeTexture,
+				YOffset:          0.0,
+				PlaceholderColor: rl.Color{}, // Not a placeholder
+			})
+		}
+	} else {
+		// Add another placeholder with different shape/color
+		models = append(models, types.ModelAsset{
+			Model:            shrekeModel,
+			YOffset:          0.0,
+			PlaceholderColor: modelColor,
+		})
+	}
+
+	if len(models) == 0 {
+		return nil, fmt.Errorf("failed to load any models")
+	}
+
+	return models, nil
+}
+
+func LoadMusic(filename string) (rl.Music, error) {
+	defer func() {
+		// Recover from any panics during music loading
+		if r := recover(); r != nil {
+			rl.TraceLog(rl.LogError, "Panic in LoadMusic: %v", r)
+		}
+	}()
+
+	// Skip loading music if environment variable is set
+	if os.Getenv("GOONSCAPE_DISABLE_AUDIO") == "1" {
+		rl.TraceLog(rl.LogInfo, "Audio disabled, skipping music loading")
+		return rl.Music{}, fmt.Errorf("audio disabled")
+	}
+
+	music := rl.LoadMusicStream(filename)
+	if music.Stream.Buffer == nil {
+		return music, fmt.Errorf("failed to load music: %s", filename)
+	}
+	return music, nil
+}

camera.go

@@ -1,54 +0,0 @@
-package main
-
-import (
-	"math"
-
-	rl "github.com/gen2brain/raylib-go/raylib"
-)
-
-func UpdateCamera(camera *rl.Camera3D, player rl.Vector3, deltaTime float32) {
-	// Update camera based on mouse wheel
-	wheelMove := rl.GetMouseWheelMove()
-	if wheelMove != 0 {
-		cameraDistance += -wheelMove * 5
-		if cameraDistance < 10 {
-			cameraDistance = 10
-		}
-		if cameraDistance > 250 {
-			cameraDistance = 250
-		}
-	}
-
-	// Orbit camera around the player using arrow keys
-	if rl.IsKeyDown(rl.KeyRight) {
-		cameraYaw += 100 * deltaTime
-	}
-	if rl.IsKeyDown(rl.KeyLeft) {
-		cameraYaw -= 100 * deltaTime
-	}
-	if rl.IsKeyDown(rl.KeyUp) {
-		cameraPitch -= 50 * deltaTime
-		if cameraPitch < 20 {
-			cameraPitch = 20
-		}
-	}
-	if rl.IsKeyDown(rl.KeyDown) {
-		cameraPitch += 50 * deltaTime
-		if cameraPitch > 85 {
-			cameraPitch = 85
-		}
-	}
-
-	// 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)
-}

constants.go

@@ -2,11 +2,33 @@ package main
 
 import "time"
 
+// Game world constants
 const (
+	// Server-related constants
+	ServerTickRate = 600 * time.Millisecond // RuneScape-style tick rate
+	ClientTickRate = 50 * time.Millisecond  // Client runs at higher rate for smooth rendering
+	MaxTickDesync  = 5                      // Max ticks behind before forcing resync
+	DefaultPort    = "6969"                 // Default server port
+
+	// Map constants
 	MapWidth   = 50
 	MapHeight  = 50
 	TileSize   = 32
 	TileHeight = 2.0
-	TickRate   = 2600 * time.Millisecond // Server tick rate (600ms)
-	serverAddr = "localhost:6969"
+)
+
+// UI constants
+const (
+	ChatMargin    = 10
+	ChatHeight    = 200
+	MessageHeight = 20
+	InputHeight   = 30
+	MaxMessages   = 50
+)
+
+// Environment variable names
+const (
+	EnvSafeMode          = "GOONSCAPE_SAFE_MODE"
+	EnvDisableAnimations = "GOONSCAPE_DISABLE_ANIMATIONS"
+	EnvDisableAudio      = "GOONSCAPE_DISABLE_AUDIO"
 )

game/camera.go

@@ -0,0 +1,92 @@
+package game
+
+import (
+	"math"
+
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+var (
+	cameraDistance = float32(20.0)
+	cameraYaw      = float32(145.0)
+	cameraPitch    = float32(45.0)
+	lastMousePos   rl.Vector2 // Add this to track mouse movement
+)
+
+func UpdateCamera(camera *rl.Camera3D, player rl.Vector3, deltaTime float32) {
+	// 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
+		if cameraDistance < 10 {
+			cameraDistance = 10
+		}
+		if cameraDistance > 250 {
+			cameraDistance = 250
+		}
+	}
+
+	// Handle middle mouse camera rotation
+	if rl.IsMouseButtonDown(rl.MouseMiddleButton) {
+		currentMousePos := rl.GetMousePosition()
+
+		// If we just started holding the button, initialize last position
+		if !rl.IsMouseButtonPressed(rl.MouseMiddleButton) {
+			mouseDelta := rl.Vector2{
+				X: currentMousePos.X - lastMousePos.X,
+				Y: currentMousePos.Y - lastMousePos.Y,
+			}
+
+			// Adjust rotation speed as needed
+			cameraYaw += mouseDelta.X * 0.5 * deltaTime * 60
+			cameraPitch += mouseDelta.Y * 0.5 * deltaTime * 60
+
+			// Clamp pitch to prevent camera flipping
+			if cameraPitch < 20 {
+				cameraPitch = 20
+			}
+			if cameraPitch > 85 {
+				cameraPitch = 85
+			}
+		}
+
+		lastMousePos = currentMousePos
+	}
+
+	// Keep the keyboard controls too
+	if rl.IsKeyDown(rl.KeyRight) {
+		cameraYaw += 100 * deltaTime
+	}
+	if rl.IsKeyDown(rl.KeyLeft) {
+		cameraYaw -= 100 * deltaTime
+	}
+	if rl.IsKeyDown(rl.KeyUp) {
+		cameraPitch -= 50 * deltaTime
+		if cameraPitch < 20 {
+			cameraPitch = 20
+		}
+	}
+	if rl.IsKeyDown(rl.KeyDown) {
+		cameraPitch += 50 * deltaTime
+		if cameraPitch > 85 {
+			cameraPitch = 85
+		}
+	}
+
+	cameraYawRad := float64(cameraYaw) * rl.Deg2rad
+	cameraPitchRad := float64(cameraPitch) * rl.Deg2rad
+
+	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,265 @@
+package game
+
+import (
+	"fmt"
+	"log"
+	"sync"
+	"time"
+
+	"gitea.boner.be/bdnugget/goonscape/types"
+	pb "gitea.boner.be/bdnugget/goonserver/actions"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+// Local UI constants (these could be moved to a centralized constants package later)
+const (
+	runeLimit = 256
+)
+
+type Chat struct {
+	messages     []types.ChatMessage
+	inputBuffer  []rune
+	isTyping     bool
+	cursorPos    int
+	scrollOffset int
+	userData     interface{}
+	mutex        sync.RWMutex
+}
+
+func NewChat() *Chat {
+	return &Chat{
+		messages:    make([]types.ChatMessage, 0, types.MaxChatMessages),
+		inputBuffer: make([]rune, 0, runeLimit),
+	}
+}
+
+func (c *Chat) AddMessage(playerID int32, content string) {
+	msg := types.ChatMessage{
+		PlayerID: playerID,
+		Content:  content,
+		Time:     time.Now(),
+	}
+
+	if len(c.messages) >= types.MaxChatMessages {
+		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) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	if len(messages) == 0 {
+		return
+	}
+
+	log.Printf("Processing %d chat messages", len(messages))
+
+	// Convert protobuf messages to our local type
+	for _, msg := range messages {
+		// Skip invalid messages
+		if msg == nil {
+			log.Printf("Warning: Received nil chat message")
+			continue
+		}
+
+		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) >= types.MaxChatMessages {
+				c.messages = c.messages[1:]
+			}
+			c.messages = append(c.messages, localMsg)
+			log.Printf("Added chat message from %s: %s", msg.Username, msg.Content)
+
+			// Scroll to latest message if it's not already visible
+			visibleMessages := int((types.ChatHeight - types.InputHeight) / types.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 && game != nil {
+				// Make sure each game component exists before using it
+				if game.PlayerManager == nil {
+					log.Printf("Warning: PlayerManager is nil when processing chat message")
+					continue
+				}
+
+				if msg.PlayerId == game.PlayerManager.LocalPlayer.ID {
+					// Check if local player exists
+					if game.PlayerManager.LocalPlayer == nil {
+						log.Printf("Warning: Local player is nil when trying to add floating message")
+						continue
+					}
+
+					game.PlayerManager.LocalPlayer.Lock()
+					game.PlayerManager.LocalPlayer.FloatingMessage = &types.FloatingMessage{
+						Content:    msg.Content,
+						ExpireTime: time.Now().Add(6 * time.Second),
+					}
+					game.PlayerManager.LocalPlayer.Unlock()
+				} else {
+					// The other player might not be in our list yet, handle safely
+					player := game.PlayerManager.GetPlayer(msg.PlayerId)
+					if player == nil {
+						log.Printf("Could not find other player %d to add floating message (player not in game yet)", msg.PlayerId)
+						continue
+					}
+
+					player.Lock()
+					player.FloatingMessage = &types.FloatingMessage{
+						Content:    msg.Content,
+						ExpireTime: time.Now().Add(6 * time.Second),
+					}
+					player.Unlock()
+					log.Printf("Added floating message to other player %d", msg.PlayerId)
+				}
+			}
+		}
+	}
+}
+
+func (c *Chat) Draw(screenWidth, screenHeight int32) {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
+	// Calculate chat window width based on screen width
+	chatWindowWidth := screenWidth - (types.ChatMargin * 2)
+
+	// Draw chat window background
+	chatX := float32(types.ChatMargin)
+	chatY := float32(screenHeight - types.ChatHeight - types.ChatMargin)
+	rl.DrawRectangle(int32(chatX), int32(chatY), chatWindowWidth, types.ChatHeight, rl.ColorAlpha(rl.Black, 0.5))
+
+	// Draw messages from oldest to newest
+	messageY := chatY + 5
+	visibleMessages := int((types.ChatHeight - types.InputHeight) / types.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 += types.MessageHeight
+	}
+
+	// Draw input field
+	inputY := chatY + float32(types.ChatHeight-types.InputHeight)
+	rl.DrawRectangle(int32(chatX), int32(inputY), chatWindowWidth, types.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((types.ChatHeight-types.InputHeight)/types.MessageHeight))
+			c.scrollOffset = clamp(c.scrollOffset-int(wheelMove), 0, maxScroll)
+		}
+
+		if rl.IsKeyPressed(rl.KeyT) {
+			c.isTyping = true
+			return "", false
+		}
+		return "", false
+	}
+
+	key := rl.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 = rl.GetCharPressed()
+	}
+
+	if rl.IsKeyPressed(rl.KeyEnter) || rl.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 rl.IsKeyPressed(rl.KeyEscape) && c.isTyping {
+		c.inputBuffer = c.inputBuffer[:0]
+		c.cursorPos = 0
+		c.isTyping = false
+	}
+
+	if rl.IsKeyPressed(rl.KeyBackspace) && c.cursorPos > 0 {
+		c.inputBuffer = append(c.inputBuffer[:c.cursorPos-1], c.inputBuffer[c.cursorPos:]...)
+		c.cursorPos--
+	}
+
+	if rl.IsKeyPressed(rl.KeyLeft) && c.cursorPos > 0 {
+		c.cursorPos--
+	}
+	if rl.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/components.go

@@ -0,0 +1,107 @@
+package game
+
+import (
+	"sync"
+
+	"gitea.boner.be/bdnugget/goonscape/types"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+// PlayerManager handles all player-related operations
+type PlayerManager struct {
+	LocalPlayer  *types.Player
+	OtherPlayers map[int32]*types.Player
+	mutex        sync.RWMutex
+}
+
+// NewPlayerManager creates a new player manager
+func NewPlayerManager() *PlayerManager {
+	return &PlayerManager{
+		OtherPlayers: make(map[int32]*types.Player),
+	}
+}
+
+// GetPlayer returns the player with the given ID, or the local player if ID matches
+func (pm *PlayerManager) GetPlayer(id int32) *types.Player {
+	pm.mutex.RLock()
+	defer pm.mutex.RUnlock()
+
+	if pm.LocalPlayer != nil && pm.LocalPlayer.ID == id {
+		return pm.LocalPlayer
+	}
+
+	return pm.OtherPlayers[id]
+}
+
+// AddPlayer adds a player to the manager
+func (pm *PlayerManager) AddPlayer(player *types.Player) {
+	pm.mutex.Lock()
+	defer pm.mutex.Unlock()
+
+	pm.OtherPlayers[player.ID] = player
+}
+
+// RemovePlayer removes a player from the manager
+func (pm *PlayerManager) RemovePlayer(id int32) {
+	pm.mutex.Lock()
+	defer pm.mutex.Unlock()
+
+	delete(pm.OtherPlayers, id)
+}
+
+// AssetManager handles all game assets
+type AssetManager struct {
+	Models []types.ModelAsset
+	Music  rl.Music
+}
+
+// NewAssetManager creates a new asset manager
+func NewAssetManager() *AssetManager {
+	return &AssetManager{}
+}
+
+// GetModelForPlayer returns the appropriate model for a player
+func (am *AssetManager) GetModelForPlayer(playerID int32) (types.ModelAsset, bool) {
+	if len(am.Models) == 0 {
+		return types.ModelAsset{}, false
+	}
+
+	// Simple model assignment based on player ID
+	modelIndex := int(playerID) % len(am.Models)
+	return am.Models[modelIndex], true
+}
+
+// UIManager manages all user interface components
+type UIManager struct {
+	Chat        *Chat
+	LoginScreen *LoginScreen
+	IsLoggedIn  bool
+	MenuOpen    bool
+}
+
+// NewUIManager creates a new UI manager
+func NewUIManager() *UIManager {
+	return &UIManager{
+		Chat:        NewChat(),
+		LoginScreen: NewLoginScreen(),
+	}
+}
+
+// HandleChatInput processes chat input and returns messages to send
+func (ui *UIManager) HandleChatInput() (string, bool) {
+	return ui.Chat.Update()
+}
+
+// DrawUI renders all UI components
+func (ui *UIManager) DrawUI(screenWidth, screenHeight int32) {
+	if !ui.IsLoggedIn {
+		ui.LoginScreen.Draw()
+	} else {
+		if ui.MenuOpen {
+			// Draw menu
+		}
+
+		// Draw chat always when logged in
+		ui.Chat.Draw(screenWidth, screenHeight)
+	}
+}

game/game.go

@@ -0,0 +1,556 @@
+package game
+
+import (
+	"log"
+	"sync"
+	"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 {
+	// Component-based architecture
+	PlayerManager *PlayerManager
+	AssetManager  *AssetManager
+	UIManager     *UIManager
+
+	// Core game state
+	Camera       rl.Camera3D
+	quitChan     chan struct{}
+	cleanupOnce  sync.Once
+	frameCounter int // For periodic logging
+
+	// Legacy fields for backward compatibility
+	Player       *types.Player           // Use PlayerManager.LocalPlayer instead
+	OtherPlayers map[int32]*types.Player // Use PlayerManager.OtherPlayers instead
+	Models       []types.ModelAsset      // Use AssetManager.Models instead
+	Music        rl.Music                // Use AssetManager.Music instead
+	Chat         *Chat                   // Use UIManager.Chat instead
+	MenuOpen     bool                    // Use UIManager.MenuOpen instead
+	loginScreen  *LoginScreen            // Use UIManager.LoginScreen instead
+	isLoggedIn   bool                    // Use UIManager.IsLoggedIn instead
+}
+
+func New() *Game {
+	// Create managers
+	playerManager := NewPlayerManager()
+	assetManager := NewAssetManager()
+	uiManager := NewUIManager()
+
+	g := &Game{
+		PlayerManager: playerManager,
+		AssetManager:  assetManager,
+		UIManager:     uiManager,
+		Camera: rl.Camera3D{
+			Position:   rl.NewVector3(0.0, 20.0, 0.0),
+			Target:     rl.NewVector3(0.0, 0.0, 0.0),
+			Up:         rl.NewVector3(0.0, 1.0, 0.0),
+			Fovy:       45.0,
+			Projection: rl.CameraPerspective,
+		},
+		quitChan: make(chan struct{}),
+		// Initialize empty maps to avoid nil references
+		OtherPlayers: make(map[int32]*types.Player),
+	}
+
+	// Initialize legacy fields (for backward compatibility)
+	g.Player = g.PlayerManager.LocalPlayer
+	g.OtherPlayers = g.PlayerManager.OtherPlayers
+	g.Models = g.AssetManager.Models
+	g.Music = g.AssetManager.Music
+	g.Chat = g.UIManager.Chat
+	g.MenuOpen = g.UIManager.MenuOpen
+	g.loginScreen = g.UIManager.LoginScreen
+	g.isLoggedIn = g.UIManager.IsLoggedIn
+
+	// Set up inter-component references
+	g.Chat.userData = g // Pass game instance to chat for callbacks
+
+	// Initialize world
+	InitWorld()
+
+	return g
+}
+
+func (g *Game) LoadAssets() error {
+	return SafeExecute(func() error {
+		// Load models
+		var err error
+		models, err := assets.LoadModels()
+		if err != nil {
+			log.Printf("Warning: Failed to load models: %v", err)
+		}
+		g.AssetManager.Models = models
+
+		// Update legacy field
+		g.Models = models
+
+		// Try to load music
+		music, err := assets.LoadMusic("resources/audio/music.mp3")
+		if err != nil {
+			log.Printf("Warning: Failed to load music: %v", err)
+		} else {
+			g.AssetManager.Music = music
+			// Update legacy field
+			g.Music = music
+		}
+
+		return nil
+	})
+}
+
+func (g *Game) Update(deltaTime float32) {
+	// Legacy code to maintain compatibility
+	if !g.UIManager.IsLoggedIn {
+		// Handle login
+		username, password, isRegistering, doAuth := g.UIManager.LoginScreen.Update()
+		// Update legacy fields
+		g.isLoggedIn = g.UIManager.IsLoggedIn
+
+		if doAuth {
+			conn, playerID, err := network.ConnectToServer(username, password, isRegistering)
+			if err != nil {
+				g.UIManager.LoginScreen.SetError(err.Error())
+				return
+			}
+
+			g.PlayerManager.LocalPlayer = &types.Player{
+				Speed:       50.0,
+				TargetPath:  []types.Tile{},
+				ActionQueue: []*pb.Action{},
+				QuitDone:    make(chan struct{}),
+				ID:          playerID,
+			}
+			g.AssignModelToPlayer(g.PlayerManager.LocalPlayer)
+
+			// Update the legacy Player field
+			g.Player = g.PlayerManager.LocalPlayer
+
+			// Set user data to allow chat message handling
+			g.PlayerManager.LocalPlayer.UserData = g
+
+			go network.HandleServerCommunication(conn, playerID, g.PlayerManager.LocalPlayer, g.PlayerManager.OtherPlayers, g.quitChan)
+			g.UIManager.IsLoggedIn = true
+		}
+		return
+	}
+
+	// Skip update logic if player is not initialized yet
+	if g.PlayerManager.LocalPlayer == nil {
+		log.Printf("Warning: LocalPlayer is nil during update, skipping")
+		return
+	}
+
+	// Handle ESC for menu
+	if rl.IsKeyPressed(rl.KeyEscape) {
+		g.UIManager.MenuOpen = !g.UIManager.MenuOpen
+		return
+	}
+
+	// Don't process other inputs if menu is open
+	if g.UIManager.MenuOpen {
+		return
+	}
+
+	// Handle chat updates
+	if message, sent := g.UIManager.Chat.Update(); sent {
+		g.PlayerManager.LocalPlayer.Lock()
+		g.PlayerManager.LocalPlayer.ActionQueue = append(g.PlayerManager.LocalPlayer.ActionQueue, &pb.Action{
+			Type:        pb.Action_CHAT,
+			ChatMessage: message,
+			PlayerId:    g.PlayerManager.LocalPlayer.ID,
+		})
+		g.PlayerManager.LocalPlayer.Unlock()
+	}
+
+	// Process player input
+	g.HandleInput()
+
+	// Update local player movement
+	if g.PlayerManager.LocalPlayer.TargetPath != nil && len(g.PlayerManager.LocalPlayer.TargetPath) > 0 {
+		g.PlayerManager.LocalPlayer.MoveTowards(g.PlayerManager.LocalPlayer.TargetPath[0], deltaTime, GetMapGrid())
+	}
+
+	// Periodically log information about other players
+	g.frameCounter++
+	if g.frameCounter%300 == 0 {
+		rl.TraceLog(rl.LogInfo, "There are %d other players", len(g.PlayerManager.OtherPlayers))
+		for id, other := range g.PlayerManager.OtherPlayers {
+			if other != nil {
+				rl.TraceLog(rl.LogInfo, "Other player ID: %d, Position: (%f, %f, %f), Has model: %v",
+					id, other.PosActual.X, other.PosActual.Y, other.PosActual.Z, other.Model.Meshes != nil)
+			} else {
+				rl.TraceLog(rl.LogInfo, "Other player ID: %d is nil", id)
+			}
+		}
+	}
+
+	// Process other players
+	for _, other := range g.PlayerManager.OtherPlayers {
+		if other == nil {
+			continue
+		}
+
+		if other.TargetPath != nil && len(other.TargetPath) > 0 {
+			target := other.TargetPath[0]
+			other.MoveTowards(target, deltaTime, GetMapGrid())
+		}
+
+		// Assign model if needed
+		if other.Model.Meshes == nil {
+			g.AssignModelToPlayer(other)
+		}
+	}
+
+	// Update camera position
+	UpdateCamera(&g.Camera, g.PlayerManager.LocalPlayer.PosActual, deltaTime)
+
+	// Update music if available
+	if g.AssetManager.Music.Stream.Buffer != nil {
+		rl.UpdateMusicStream(g.AssetManager.Music)
+	}
+
+	// Update legacy fields
+	g.Player = g.PlayerManager.LocalPlayer
+	g.OtherPlayers = g.PlayerManager.OtherPlayers
+	g.Models = g.AssetManager.Models
+	g.Music = g.AssetManager.Music
+	g.MenuOpen = g.UIManager.MenuOpen
+}
+
+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) {
+	// No need for lock in rendering, we'll use a "take snapshot" approach
+	// This avoids potential deadlocks and makes the rendering more consistent
+
+	// Check for invalid model
+	if model.Meshes == nil || model.Meshes.VertexCount <= 0 {
+		// Don't try to draw invalid models
+		return
+	}
+
+	grid := GetMapGrid()
+	modelIndex := int(player.ID) % len(g.Models)
+	if modelIndex < 0 || modelIndex >= len(g.Models) {
+		// Prevent out of bounds access
+		modelIndex = 0
+	}
+	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
+			if anim.FrameCount > 0 {
+				currentFrame := player.AnimationFrame % anim.FrameCount
+				rl.UpdateModelAnimation(model, anim, currentFrame)
+			}
+		} else if len(modelAsset.Animations.Idle) > 0 {
+			anim := modelAsset.Animations.Idle[0] // Use first idle animation
+			if anim.FrameCount > 0 {
+				currentFrame := player.AnimationFrame % anim.FrameCount
+				rl.UpdateModelAnimation(model, anim, currentFrame)
+			}
+		}
+	}
+
+	// Use placeholder color if it's set, otherwise use white
+	var drawColor rl.Color = rl.White
+	if player.PlaceholderColor.A > 0 {
+		drawColor = player.PlaceholderColor
+	}
+	rl.DrawModel(model, playerPos, 16, drawColor)
+
+	// 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()
+	defer func() {
+		// This defer will catch any panics that might occur during rendering
+		// and ensure EndDrawing gets called to maintain proper graphics state
+		if r := recover(); r != nil {
+			rl.TraceLog(rl.LogError, "Panic during rendering: %v", r)
+		}
+		rl.EndDrawing()
+	}()
+
+	rl.ClearBackground(rl.RayWhite)
+
+	if !g.UIManager.IsLoggedIn {
+		g.UIManager.LoginScreen.Draw()
+		return
+	}
+
+	rl.BeginMode3D(g.Camera)
+	g.DrawMap()
+
+	// Draw player only if valid
+	if g.PlayerManager.LocalPlayer != nil && g.PlayerManager.LocalPlayer.Model.Meshes != nil {
+		g.DrawPlayer(g.PlayerManager.LocalPlayer, g.PlayerManager.LocalPlayer.Model)
+	}
+
+	// Draw other players with defensive checks
+	for _, other := range g.PlayerManager.OtherPlayers {
+		if other == nil {
+			continue
+		}
+
+		// Make sure model is assigned
+		if other.Model.Meshes == nil {
+			g.AssignModelToPlayer(other)
+			// Skip this frame if assignment failed
+			if other.Model.Meshes == nil {
+				continue
+			}
+		}
+		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.PlayerManager.LocalPlayer != nil && g.PlayerManager.LocalPlayer.FloatingMessage != nil {
+		drawFloatingMessage(g.PlayerManager.LocalPlayer.FloatingMessage)
+	}
+
+	for _, other := range g.PlayerManager.OtherPlayers {
+		if other != nil && other.FloatingMessage != nil {
+			drawFloatingMessage(other.FloatingMessage)
+		}
+	}
+
+	// Draw menu if open
+	if g.UIManager.MenuOpen {
+		g.DrawMenu()
+	}
+
+	// Only draw chat if menu is not open
+	if !g.UIManager.MenuOpen && g.UIManager.Chat != nil {
+		g.UIManager.Chat.Draw(int32(rl.GetScreenWidth()), int32(rl.GetScreenHeight()))
+	}
+
+	rl.DrawFPS(10, 10)
+}
+
+func (g *Game) Cleanup() {
+	g.cleanupOnce.Do(func() {
+		// Cleanup models
+		for _, model := range g.AssetManager.Models {
+			rl.UnloadModel(model.Model)
+			if model.Texture.ID > 0 {
+				rl.UnloadTexture(model.Texture)
+			}
+		}
+
+		// Unload music
+		if g.AssetManager.Music.Stream.Buffer != nil {
+			rl.UnloadMusicStream(g.AssetManager.Music)
+		}
+
+		// Only close the channel if it hasn't been closed yet
+		select {
+		case <-g.quitChan:
+			// Channel already closed, do nothing
+		default:
+			close(g.quitChan)
+		}
+	})
+}
+
+func (g *Game) HandleInput() {
+	clickedTile, clicked := g.GetTileAtMouse()
+	if clicked {
+		path := FindPath(GetTile(g.PlayerManager.LocalPlayer.PosTile.X, g.PlayerManager.LocalPlayer.PosTile.Y), clickedTile)
+		if len(path) > 1 {
+			g.PlayerManager.LocalPlayer.Lock()
+			g.PlayerManager.LocalPlayer.TargetPath = path[1:]
+			g.PlayerManager.LocalPlayer.ActionQueue = append(g.PlayerManager.LocalPlayer.ActionQueue, &pb.Action{
+				Type:     pb.Action_MOVE,
+				X:        int32(clickedTile.X),
+				Y:        int32(clickedTile.Y),
+				PlayerId: g.PlayerManager.LocalPlayer.ID,
+			})
+			g.PlayerManager.LocalPlayer.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 := rl.GetMousePosition()
+		mouseHover := rl.CheckCollisionPointRec(mousePoint, buttonRect)
+
+		// Draw button
+		if mouseHover {
+			rl.DrawRectangleRec(buttonRect, rl.ColorAlpha(rl.White, 0.3))
+			if rl.IsMouseButtonPressed(rl.MouseLeftButton) {
+				switch item {
+				case "Resume":
+					g.UIManager.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() {
+	// Use the cleanup method which has channel-closing safety
+	g.Cleanup()
+}
+
+func (g *Game) HandleServerMessages(messages []*pb.ChatMessage) {
+	// Check if Chat is properly initialized
+	if g.UIManager != nil && g.UIManager.Chat != nil {
+		g.UIManager.Chat.HandleServerMessages(messages)
+	} else {
+		log.Printf("Warning: Cannot handle server messages, Chat is not initialized")
+	}
+}
+
+func (g *Game) AssignModelToPlayer(player *types.Player) {
+	if player == nil {
+		return
+	}
+
+	modelAsset, found := g.AssetManager.GetModelForPlayer(player.ID)
+	if !found {
+		return
+	}
+
+	player.Model = modelAsset.Model
+	player.PlaceholderColor = modelAsset.PlaceholderColor
+
+	// Initialize animations if available
+	if len(modelAsset.Animations.Idle) > 0 || len(modelAsset.Animations.Walk) > 0 {
+		player.InitializeAnimations(modelAsset.Animations)
+	}
+}
+
+func (g *Game) QuitChan() <-chan struct{} {
+	return g.quitChan
+}

game/input.go

@@ -0,0 +1,31 @@
+package game
+
+import (
+	"fmt"
+
+	"gitea.boner.be/bdnugget/goonscape/types"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+func (g *Game) GetTileAtMouse() (types.Tile, bool) {
+	if !rl.IsMouseButtonPressed(rl.MouseLeftButton) {
+		return types.Tile{}, false
+	}
+	mouse := rl.GetMousePosition()
+	ray := rl.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/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/pathfinding.go

@@ -0,0 +1,179 @@
+package game
+
+import (
+	"container/heap"
+	"fmt"
+
+	"gitea.boner.be/bdnugget/goonscape/types"
+)
+
+// Node represents a node in the A* pathfinding algorithm
+type Node struct {
+	Tile    types.Tile
+	Parent  *Node
+	G, H, F float32 // G = cost from start, H = heuristic to goal, F = G + H
+}
+
+// PriorityQueue implements a min-heap for nodes ordered by F value
+type PriorityQueue []*Node
+
+// Implement the heap.Interface for PriorityQueue
+func (pq PriorityQueue) Len() int { return len(pq) }
+
+func (pq PriorityQueue) Less(i, j int) bool {
+	return pq[i].F < pq[j].F
+}
+
+func (pq PriorityQueue) Swap(i, j int) {
+	pq[i], pq[j] = pq[j], pq[i]
+}
+
+func (pq *PriorityQueue) Push(x interface{}) {
+	item := x.(*Node)
+	*pq = append(*pq, item)
+}
+
+func (pq *PriorityQueue) Pop() interface{} {
+	old := *pq
+	n := len(old)
+	item := old[n-1]
+	*pq = old[0 : n-1]
+	return item
+}
+
+// Helper to check if tile is in priority queue
+func isInQueue(queue *PriorityQueue, tile types.Tile) (bool, *Node) {
+	for _, node := range *queue {
+		if node.Tile.X == tile.X && node.Tile.Y == tile.Y {
+			return true, node
+		}
+	}
+	return false, nil
+}
+
+// FindPath implements A* pathfinding algorithm with a priority queue
+func FindPath(start, end types.Tile) []types.Tile {
+	// Initialize open and closed sets
+	openSet := &PriorityQueue{}
+	heap.Init(openSet)
+
+	closedSet := make(map[[2]int]bool)
+
+	// Create start node and add to open set
+	startNode := &Node{
+		Tile:   start,
+		Parent: nil,
+		G:      0,
+		H:      heuristic(start, end),
+	}
+	startNode.F = startNode.G + startNode.H
+	heap.Push(openSet, startNode)
+
+	// Main search loop
+	for openSet.Len() > 0 {
+		// Get node with lowest F score
+		current := heap.Pop(openSet).(*Node)
+
+		// If we reached the goal, reconstruct and return the path
+		if current.Tile.X == end.X && current.Tile.Y == end.Y {
+			return reconstructPath(current)
+		}
+
+		// Add current to closed set
+		closedSet[[2]int{current.Tile.X, current.Tile.Y}] = true
+
+		// Check all neighbors
+		for _, neighbor := range GetNeighbors(current.Tile) {
+			// Skip if in closed set or not walkable
+			if !neighbor.Walkable || closedSet[[2]int{neighbor.X, neighbor.Y}] {
+				continue
+			}
+
+			// Calculate tentative G score
+			tentativeG := current.G + distance(current.Tile, neighbor)
+
+			// Check if in open set
+			inOpen, existingNode := isInQueue(openSet, neighbor)
+
+			// If not in open set or better path found
+			if !inOpen || tentativeG < existingNode.G {
+				// Create or update the node
+				var neighborNode *Node
+				if inOpen {
+					neighborNode = existingNode
+				} else {
+					neighborNode = &Node{
+						Tile:   neighbor,
+						Parent: current,
+					}
+				}
+
+				// Update scores
+				neighborNode.G = tentativeG
+				neighborNode.H = heuristic(neighbor, end)
+				neighborNode.F = neighborNode.G + neighborNode.H
+				neighborNode.Parent = current
+
+				// Add to open set if not already there
+				if !inOpen {
+					heap.Push(openSet, neighborNode)
+				}
+			}
+		}
+	}
+
+	// No path found
+	return nil
+}
+
+// reconstructPath builds the path from goal node to start
+func reconstructPath(node *Node) []types.Tile {
+	path := []types.Tile{}
+	current := node
+
+	// Follow parent pointers back to start
+	for current != nil {
+		path = append([]types.Tile{current.Tile}, path...)
+		current = current.Parent
+	}
+
+	fmt.Printf("Path found: %v\n", path)
+	return path
+}
+
+// heuristic estimates cost from current to goal (Manhattan distance)
+func heuristic(a, b types.Tile) float32 {
+	return float32(abs(a.X-b.X) + abs(a.Y-b.Y))
+}
+
+// distance calculates cost between adjacent tiles
+func distance(a, b types.Tile) float32 {
+	return 1.0 // uniform cost for now
+}
+
+// GetNeighbors returns walkable tiles adjacent to the given 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 := []types.Tile{}
+	grid := GetMapGrid()
+	for _, dir := range directions {
+		nx, ny := tile.X+dir[0], tile.Y+dir[1]
+		if nx >= 0 && nx < types.MapWidth && ny >= 0 && ny < types.MapHeight {
+			if grid[nx][ny].Walkable {
+				neighbors = append(neighbors, grid[nx][ny])
+			}
+		}
+	}
+	return neighbors
+}
+
+// abs returns the absolute value of x
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}

game/utils.go

@@ -0,0 +1,72 @@
+package game
+
+import (
+	"fmt"
+	"log"
+	"runtime/debug"
+
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+// SafeExecute runs a function and recovers from panics
+func SafeExecute(action func() error) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			stack := debug.Stack()
+			log.Printf("Recovered from panic: %v\nStack trace:\n%s", r, stack)
+			err = fmt.Errorf("recovered from panic: %v", r)
+		}
+	}()
+	return action()
+}
+
+// SafeExecuteVoid runs a void function and recovers from panics
+func SafeExecuteVoid(action func()) {
+	defer func() {
+		if r := recover(); r != nil {
+			stack := debug.Stack()
+			log.Printf("Recovered from panic: %v\nStack trace:\n%s", r, stack)
+		}
+	}()
+	action()
+}
+
+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,17 @@
-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/ebitengine/purego v0.8.2 // indirect
+	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,12 @@
-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/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=
+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=

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,153 @@
 package main
 
 import (
+	"flag"
 	"log"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
 
+	"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() {
+	// Set up panic recovery at the top level
+	defer func() {
+		if r := recover(); r != nil {
+			log.Printf("Recovered from fatal panic in main: %v", r)
+			// Give the user a chance to see the error
+			time.Sleep(5 * time.Second)
+		}
+	}()
+
+	// Parse command line flags
+	verbose := flag.Bool("v", false, "Also show info logs (spammy)")
+	local := flag.Bool("local", false, "Connect to local server")
+	addr := flag.String("addr", "", "Server address (host or host:port)")
+	flag.Parse()
+
+	if *verbose {
+		rl.SetTraceLogLevel(rl.LogTrace)
+	} else {
+		rl.SetTraceLogLevel(rl.LogWarning)
+	}
+
+	// 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)
+	}
+
+	// Initialize window with error handling
+	rl.SetConfigFlags(rl.FlagMsaa4xHint | rl.FlagWindowResizable) // Enable MSAA and make window resizable
 	rl.InitWindow(1024, 768, "GoonScape")
-	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{},
+	rl.SetExitKey(0)
+
+	// Initialize audio with error handling
+	if !rl.IsAudioDeviceReady() {
+		rl.InitAudioDevice()
+		if !rl.IsAudioDeviceReady() {
+			log.Println("Warning: Failed to initialize audio device, continuing without audio")
+		}
 	}
 
-	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,
+	// Use a maximum of 3 attempts to load assets
+	var gameInstance *game.Game
+	var loadErr error
+	maxAttempts := 3
+
+	for attempt := 1; attempt <= maxAttempts; attempt++ {
+		gameInstance = game.New()
+		loadErr = gameInstance.LoadAssets()
+		if loadErr == nil {
+			break
+		}
+
+		log.Printf("Attempt %d/%d: Failed to load assets: %v", attempt, maxAttempts, loadErr)
+		if attempt < maxAttempts {
+			log.Println("Retrying...")
+			gameInstance.Cleanup() // Cleanup before retrying
+			time.Sleep(500 * time.Millisecond)
+		}
 	}
 
-	conn, playerID, err := ConnectToServer()
-	if err != nil {
-		log.Fatalf("Failed to connect to server: %v", err)
+	if loadErr != nil {
+		log.Printf("Failed to load assets after %d attempts. Starting with default assets.", maxAttempts)
 	}
-	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)
+	defer func() {
+		if gameInstance != nil {
+			gameInstance.Cleanup()
+		}
+		rl.CloseWindow()
+		if rl.IsAudioDeviceReady() {
+			rl.CloseAudioDevice()
+		}
+	}()
 
 	rl.SetTargetFPS(60)
 
+	// Play music if available
+	if gameInstance.Music.Stream.Buffer != nil {
+		rl.PlayMusicStream(gameInstance.Music)
+		rl.SetMusicVolume(gameInstance.Music, 0.5)
+	}
+
+	// Handle OS signals for clean shutdown
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-sigChan
+		if gameInstance != nil {
+			gameInstance.Shutdown()
+		}
+	}()
+
+	// Keep game loop in main thread for Raylib
 	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 music if available
+		if gameInstance.Music.Stream.Buffer != nil {
+			rl.UpdateMusicStream(gameInstance.Music)
 		}
 
-		// Update camera
-		UpdateCamera(&camera, player.PosActual, deltaTime)
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("Recovered from panic in game update: %v", r)
+				}
+			}()
+			gameInstance.Update(deltaTime)
+		}()
 
-		// Rendering
-		rl.BeginDrawing()
-		rl.ClearBackground(rl.RayWhite)
-		rl.BeginMode3D(camera)
-		DrawMap()
-		DrawPlayer(player, player.Model)
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("Recovered from panic in game render: %v", r)
+				}
+			}()
+			gameInstance.Render()
+		}()
 
-		for id, other := range otherPlayers {
-			if len(other.TargetPath) > 0 {
-				other.MoveTowards(other.TargetPath[0], deltaTime)
-			}
-			DrawPlayer(*other, models[int(id)%len(models)].Model)
+		// Check if game requested shutdown
+		select {
+		case <-gameInstance.QuitChan():
+			return
+		default:
 		}
-
-		rl.EndMode3D()
-		rl.DrawFPS(10, 10)
-		rl.EndDrawing()
 	}
 }
-
-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)
-}

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,539 @@
+package network
+
+import (
+	"bufio"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"sync"
+	"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"       // Default server address
+var lastSeenMessageTimestamp int64 = 0 // Track the last message timestamp seen by this client
+
+func SetServerAddr(addr string) {
+	serverAddr = addr
+	log.Printf("Server address set to: %s", serverAddr)
+}
+
+// MessageHandler handles reading and writing protobuf messages
+type MessageHandler struct {
+	conn   net.Conn
+	reader *bufio.Reader
+}
+
+// NewMessageHandler creates a new message handler
+func NewMessageHandler(conn net.Conn) *MessageHandler {
+	return &MessageHandler{
+		conn:   conn,
+		reader: bufio.NewReader(conn),
+	}
+}
+
+// ReadMessage reads a single message from the network
+func (mh *MessageHandler) ReadMessage() (*pb.ServerMessage, error) {
+	// Read message length
+	lengthBuf := make([]byte, 4)
+	if _, err := io.ReadFull(mh.reader, lengthBuf); err != nil {
+		return nil, fmt.Errorf("failed to read message length: %v", err)
+	}
+
+	messageLength := binary.BigEndian.Uint32(lengthBuf)
+
+	// Sanity check message size
+	if messageLength > 1024*1024 { // 1MB max message size
+		return nil, fmt.Errorf("message size too large: %d bytes", messageLength)
+	}
+
+	// Read message body
+	messageBuf := make([]byte, messageLength)
+	if _, err := io.ReadFull(mh.reader, messageBuf); err != nil {
+		return nil, fmt.Errorf("failed to read message body: %v", err)
+	}
+
+	// Unmarshal the message
+	var message pb.ServerMessage
+	if err := proto.Unmarshal(messageBuf, &message); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal message: %v", err)
+	}
+
+	return &message, nil
+}
+
+// WriteMessage writes a protobuf message to the network
+func (mh *MessageHandler) WriteMessage(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 := mh.conn.Write(lengthBuf); err != nil {
+		return err
+	}
+
+	// Write message body
+	_, err = mh.conn.Write(data)
+	return err
+}
+
+// UpdateGameState processes a server message and updates game state
+func UpdateGameState(serverMessage *pb.ServerMessage, player *types.Player, otherPlayers map[int32]*types.Player) {
+	// Safety check for nil inputs
+	if serverMessage == nil {
+		log.Printf("Warning: Received nil server message")
+		return
+	}
+
+	if player == nil {
+		log.Printf("Warning: Local player is nil when updating game state")
+		return
+	}
+
+	if otherPlayers == nil {
+		log.Printf("Warning: otherPlayers map is nil when updating game state")
+		return
+	}
+
+	playerID := player.ID
+
+	player.Lock()
+	player.CurrentTick = serverMessage.CurrentTick
+
+	tickDiff := serverMessage.CurrentTick - player.CurrentTick
+	if tickDiff > types.MaxTickDesync {
+		for _, state := range serverMessage.Players {
+			if state != nil && state.PlayerId == playerID {
+				player.ForceResync(state)
+				break
+			}
+		}
+	}
+	player.Unlock()
+
+	// Process player states
+	validPlayerIds := make(map[int32]bool)
+	for _, state := range serverMessage.Players {
+		// Skip invalid player states
+		if state == nil {
+			log.Printf("Warning: Received nil player state")
+			continue
+		}
+
+		validPlayerIds[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
+		}
+
+		// Update or create other players
+		if otherPlayer, exists := otherPlayers[state.PlayerId]; exists {
+			if otherPlayer != nil {
+				otherPlayer.UpdatePosition(state, types.ServerTickRate)
+			} else {
+				// Replace nil player with a new one
+				log.Printf("Replacing nil player with ID: %d", state.PlayerId)
+				otherPlayers[state.PlayerId] = types.NewPlayer(state)
+			}
+		} else {
+			log.Printf("Creating new player with ID: %d", state.PlayerId)
+			otherPlayers[state.PlayerId] = types.NewPlayer(state)
+		}
+	}
+
+	// Remove players no longer in the server state
+	for id := range otherPlayers {
+		if id != playerID && !validPlayerIds[id] {
+			log.Printf("Removing player with ID: %d", id)
+			delete(otherPlayers, id)
+		}
+	}
+
+	// Handle chat messages with safety checks
+	if handler, ok := player.UserData.(types.ChatMessageHandler); ok && handler != nil && len(serverMessage.ChatMessages) > 0 {
+		log.Printf("Received %d chat messages from server", len(serverMessage.ChatMessages))
+
+		// Make sure we have valid chat messages
+		validMessages := make([]*pb.ChatMessage, 0, len(serverMessage.ChatMessages))
+		for _, msg := range serverMessage.ChatMessages {
+			if msg != nil {
+				validMessages = append(validMessages, msg)
+			}
+		}
+
+		if len(validMessages) > 0 {
+			// Use a separate goroutine to handle messages to prevent blocking
+			// network handling if there's an issue with chat processing
+			go func(msgs []*pb.ChatMessage) {
+				defer func() {
+					if r := recover(); r != nil {
+						log.Printf("Recovered from panic in chat message handler: %v", r)
+					}
+				}()
+				handler.HandleServerMessages(msgs)
+			}(validMessages)
+
+			// Update the last seen message timestamp to the most recent message
+			lastMsg := validMessages[len(validMessages)-1]
+			lastSeenMessageTimestamp = lastMsg.Timestamp
+			log.Printf("Updated last seen message timestamp to %d", lastSeenMessageTimestamp)
+		}
+	}
+}
+
+func ConnectToServer(username, password string, isRegistering bool) (net.Conn, int32, error) {
+	log.Printf("Connecting to server at %s...", serverAddr)
+
+	var err error
+	var conn net.Conn
+
+	// Try connecting with a timeout
+	connChan := make(chan net.Conn, 1)
+	errChan := make(chan error, 1)
+
+	go func() {
+		c, e := net.Dial("tcp", serverAddr)
+		if e != nil {
+			errChan <- e
+			return
+		}
+		connChan <- c
+	}()
+
+	// Wait for connection with timeout
+	select {
+	case conn = <-connChan:
+		// Connection successful, continue
+	case err = <-errChan:
+		return nil, 0, fmt.Errorf("failed to dial server: %v", err)
+	case <-time.After(5 * time.Second):
+		return nil, 0, fmt.Errorf("connection timeout after 5 seconds")
+	}
+
+	log.Println("Connected to server. Authenticating...")
+
+	// Create a message handler
+	msgHandler := NewMessageHandler(conn)
+
+	// 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 := msgHandler.WriteMessage(authBatch); err != nil {
+		conn.Close()
+		return nil, 0, fmt.Errorf("failed to send auth: %v", err)
+	}
+
+	// Set a read deadline for authentication
+	conn.SetReadDeadline(time.Now().Add(10 * time.Second))
+
+	// Read server response
+	response, err := msgHandler.ReadMessage()
+	if err != nil {
+		conn.Close()
+		return nil, 0, fmt.Errorf("failed to read auth response: %v", err)
+	}
+
+	// Clear read deadline after authentication
+	conn.SetReadDeadline(time.Time{})
+
+	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)
+
+	// Reset the lastSeenMessageTimestamp when reconnecting
+	lastSeenMessageTimestamp = 0
+
+	return conn, playerID, nil
+}
+
+func HandleServerCommunication(conn net.Conn, playerID int32, player *types.Player, otherPlayers map[int32]*types.Player, quitChan <-chan struct{}) {
+	msgHandler := NewMessageHandler(conn)
+
+	// Create channels for coordinating goroutines
+	errChan := make(chan error, 1)
+	done := make(chan struct{})
+
+	// Create a WaitGroup to track both sender and receiver goroutines
+	var wg sync.WaitGroup
+	wg.Add(2) // One for sender, one for receiver
+
+	// Set up a deferred cleanup function
+	defer func() {
+		if r := recover(); r != nil {
+			log.Printf("Recovered from panic in HandleServerCommunication: %v", r)
+		}
+
+		// Close the done channel to signal both goroutines to exit
+		close(done)
+
+		// Wait for both goroutines to finish
+		wg.Wait()
+
+		// Close the connection
+		conn.Close()
+
+		// Close the player's QuitDone channel if it exists
+		if player.QuitDone != nil {
+			select {
+			case <-player.QuitDone: // Check if it's already closed
+				// Already closed, do nothing
+			default:
+				close(player.QuitDone)
+			}
+		}
+	}()
+
+	actionTicker := time.NewTicker(types.ClientTickRate)
+	defer actionTicker.Stop()
+
+	// Add a heartbeat ticker to detect connection issues
+	heartbeatTicker := time.NewTicker(5 * time.Second)
+	defer heartbeatTicker.Stop()
+
+	lastMessageTime := time.Now()
+
+	// Start message sending goroutine
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				log.Printf("Recovered from panic in message sender: %v", r)
+				select {
+				case errChan <- fmt.Errorf("message sender panic: %v", r):
+				default:
+					// Channel already closed or full, just log
+					log.Printf("Unable to send error: %v", r)
+				}
+			}
+			wg.Done() // Mark this goroutine as done
+		}()
+
+		for {
+			select {
+			case <-quitChan:
+				// Send disconnect message to server
+				disconnectMsg := &pb.ActionBatch{
+					PlayerId: playerID,
+					Actions: []*pb.Action{{
+						Type:     pb.Action_DISCONNECT,
+						PlayerId: playerID,
+					}},
+				}
+
+				// Try to send disconnect message, ignoring errors
+				_ = msgHandler.WriteMessage(disconnectMsg)
+
+				// No need to signal done channel here, the main goroutine handles this
+				return
+			case <-done:
+				return
+			case <-heartbeatTicker.C:
+				// If no message has been sent for a while, send a heartbeat
+				timeSinceLastMessage := time.Since(lastMessageTime)
+				if timeSinceLastMessage > 5*time.Second {
+					// Send an empty batch as a heartbeat
+					emptyBatch := &pb.ActionBatch{
+						PlayerId:                 playerID,
+						LastSeenMessageTimestamp: lastSeenMessageTimestamp,
+					}
+					if err := msgHandler.WriteMessage(emptyBatch); err != nil {
+						log.Printf("Failed to send heartbeat: %v", err)
+						select {
+						case errChan <- err:
+						case <-done:
+							return
+						}
+					}
+					lastMessageTime = time.Now()
+				}
+			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,
+						LastSeenMessageTimestamp: lastSeenMessageTimestamp,
+					}
+					player.ActionQueue = player.ActionQueue[:0]
+					player.Unlock()
+
+					if err := msgHandler.WriteMessage(batch); err != nil {
+						select {
+						case errChan <- err:
+						case <-done:
+							return
+						}
+					}
+					lastMessageTime = time.Now()
+				} else {
+					player.Unlock()
+				}
+			}
+		}
+	}()
+
+	// Main message receiving loop
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				log.Printf("Recovered from panic in message receiver: %v", r)
+				select {
+				case errChan <- fmt.Errorf("message receiver panic: %v", r):
+				default:
+					// Channel already closed or full, just log
+					log.Printf("Unable to send error: %v", r)
+				}
+			}
+			wg.Done() // Mark this goroutine as done
+		}()
+
+		for {
+			select {
+			case <-quitChan:
+				return
+			case <-done:
+				return
+			default:
+				serverMessage, err := msgHandler.ReadMessage()
+				if err != nil {
+					if err, ok := err.(net.Error); ok && err.Timeout() {
+						log.Printf("Network timeout: %v", err)
+					} else if err != io.EOF {
+						log.Printf("Network read error: %v", err)
+						select {
+						case errChan <- err:
+						case <-done:
+							return
+						}
+					} else {
+						log.Printf("Connection closed by server")
+					}
+					return
+				}
+
+				// Process the server message
+				UpdateGameState(serverMessage, player, otherPlayers)
+			}
+		}
+	}()
+
+	// Wait for error or quit signal
+	select {
+	case <-quitChan:
+		log.Printf("Received quit signal, sending disconnect message")
+		// The cleanup will happen in the deferred function
+		return
+	case err := <-errChan:
+		log.Printf("Network error: %v", err)
+		// The cleanup will happen in the deferred function
+		return
+	}
+}
+
+// Helper function to write length-prefixed messages
+func writeMessage(conn net.Conn, msg proto.Message) error {
+	msgHandler := NewMessageHandler(conn)
+	return msgHandler.WriteMessage(msg)
+}
+
+type Connection struct {
+	conn      net.Conn
+	playerID  int32
+	quitChan  chan struct{}
+	quitDone  chan struct{}
+	closeOnce sync.Once
+}
+
+func NewConnection(username, password string, isRegistering bool) (*Connection, error) {
+	conn, playerID, err := ConnectToServer(username, password, isRegistering)
+	if err != nil {
+		return nil, err
+	}
+	return &Connection{
+		conn:     conn,
+		playerID: playerID,
+		quitChan: make(chan struct{}),
+		quitDone: make(chan struct{}),
+	}, nil
+}
+
+func (c *Connection) Close() {
+	c.closeOnce.Do(func() {
+		select {
+		case <-c.quitChan: // Check if it's already closed
+			// Already closed, do nothing
+		default:
+			close(c.quitChan)
+		}
+
+		// Wait with timeout for network cleanup
+		select {
+		case <-c.quitDone:
+			// Clean shutdown completed
+		case <-time.After(500 * time.Millisecond):
+			log.Println("Network cleanup timed out")
+		}
+
+		// Make sure the connection is closed
+		c.conn.Close()
+	})
+}
+
+func (c *Connection) PlayerID() int32 {
+	return c.playerID
+}
+
+func (c *Connection) Start(player *types.Player, otherPlayers map[int32]*types.Player) {
+	go HandleServerCommunication(c.conn, c.playerID, player, otherPlayers, c.quitChan)
+}
+
+func (c *Connection) QuitChan() <-chan struct{} {
+	return c.quitChan
+}

pathfinding.go

@@ -1,114 +0,0 @@
-package main
-
-import "fmt"
-
-type Node struct {
-	Tile    Tile
-	Parent  *Node
-	G, H, F float32
-}
-
-func FindPath(start, end Tile) []Tile {
-	openList := []*Node{}
-	closedList := make(map[[2]int]bool)
-
-	startNode := &Node{Tile: start, G: 0, H: heuristic(start, end)}
-	startNode.F = startNode.G + startNode.H
-	openList = append(openList, startNode)
-
-	for len(openList) > 0 {
-		// Find node with lowest F
-		current := openList[0]
-		currentIndex := 0
-		for i, node := range openList {
-			if node.F < current.F {
-				current = node
-				currentIndex = i
-			}
-		}
-
-		// 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{}
-			node := current
-			for node != nil {
-				path = append([]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}] {
-				continue
-			}
-
-			tentativeG := current.G + distance(current.Tile, neighbor)
-			inOpen := false
-			var existingNode *Node
-			for _, node := range openList {
-				if node.Tile.X == neighbor.X && node.Tile.Y == neighbor.Y {
-					existingNode = node
-					inOpen = true
-					break
-				}
-			}
-
-			if !inOpen || tentativeG < existingNode.G {
-				newNode := &Node{
-					Tile:   neighbor,
-					Parent: current,
-					G:      tentativeG,
-					H:      heuristic(neighbor, end),
-				}
-				newNode.F = newNode.G + newNode.H
-				if !inOpen {
-					openList = append(openList, newNode)
-				}
-			}
-		}
-	}
-
-	// No path found
-	fmt.Println("No path found")
-	return nil
-}
-
-func heuristic(a, b 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 GetNeighbors(tile Tile) []Tile {
-	directions := [][2]int{
-		{1, 0}, {-1, 0}, {0, 1}, {0, -1},
-		{1, 1}, {-1, -1}, {1, -1}, {-1, 1},
-	}
-	neighbors := []Tile{}
-	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])
-		}
-	}
-	return neighbors
-}
-
-func abs(x int) int {
-	if x < 0 {
-		return -x
-	}
-	return x
-}

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,196 @@
+package types
+
+import (
+	"sync"
+	"time"
+
+	pb "gitea.boner.be/bdnugget/goonserver/actions"
+	rl "github.com/gen2brain/raylib-go/raylib"
+)
+
+// AnimationController manages animation state and updates
+type AnimationController struct {
+	animations       AnimationSet
+	currentAnimation string // "idle" or "walk"
+	frame            int32
+	lastUpdate       time.Time
+	frameCount       int32
+}
+
+// NewAnimationController creates a new animation controller
+func NewAnimationController(animations AnimationSet) *AnimationController {
+	return &AnimationController{
+		animations:       animations,
+		currentAnimation: "idle",
+		frame:            0,
+		lastUpdate:       time.Now(),
+	}
+}
+
+// Update updates the animation state based on movement
+func (ac *AnimationController) Update(deltaTime float32, isMoving bool) {
+	// Set the current animation based on movement
+	newAnimation := "idle"
+	if isMoving {
+		newAnimation = "walk"
+	}
+
+	// Reset frame counter when animation changes
+	if ac.currentAnimation != newAnimation {
+		ac.frame = 0
+		ac.currentAnimation = newAnimation
+	}
+
+	// Update the frame
+	ac.frame += int32(deltaTime * 60)
+
+	// Determine which animation set to use
+	var frames []rl.ModelAnimation
+	if ac.currentAnimation == "walk" && len(ac.animations.Walk) > 0 {
+		frames = ac.animations.Walk
+	} else if len(ac.animations.Idle) > 0 {
+		frames = ac.animations.Idle
+	}
+
+	// If we have frames, ensure we loop properly
+	if len(frames) > 0 && frames[0].FrameCount > 0 {
+		ac.frame = ac.frame % frames[0].FrameCount
+	}
+}
+
+// GetAnimFrame returns the current animation frame
+func (ac *AnimationController) GetAnimFrame() int32 {
+	return ac.frame
+}
+
+// GetCurrentAnimation returns the current animation type
+func (ac *AnimationController) GetCurrentAnimation() string {
+	return ac.currentAnimation
+}
+
+type Player struct {
+	sync.RWMutex          // Keep this for network operations
+	Model                 rl.Model
+	Texture               rl.Texture2D
+	PosActual             rl.Vector3
+	PosTile               Tile
+	TargetPath            []Tile
+	Speed                 float32
+	ActionQueue           []*pb.Action
+	ID                    int32
+	QuitDone              chan struct{}
+	CurrentTick           int64
+	UserData              interface{}
+	FloatingMessage       *FloatingMessage
+	IsMoving              bool
+	AnimationFrame        int32
+	LastAnimUpdate        time.Time
+	LastUpdateTime        time.Time
+	InterpolationProgress float32
+	PlaceholderColor      rl.Color
+	AnimController        *AnimationController
+}
+
+func (p *Player) MoveTowards(target Tile, deltaTime float32, mapGrid [][]Tile) {
+	// No need for lock here as this is called from a single thread (game loop)
+	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 {
+		p.IsMoving = true
+	} else {
+		p.IsMoving = false
+	}
+
+	// Update animation if controller exists
+	if p.AnimController != nil {
+		p.AnimController.Update(deltaTime, p.IsMoving)
+		p.AnimationFrame = p.AnimController.GetAnimFrame()
+	} else {
+		// Legacy animation update for backward compatibility
+		if p.IsMoving {
+			if !p.IsMoving {
+				p.AnimationFrame = 0
+			}
+			p.AnimationFrame += int32(deltaTime * 60)
+		} else {
+			wasMoving := p.IsMoving
+			if wasMoving {
+				p.AnimationFrame = 0
+			}
+			p.AnimationFrame += int32(deltaTime * 60)
+		}
+	}
+
+	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(),
+		LastUpdateTime:        time.Now(),
+		InterpolationProgress: 1.0,
+	}
+}
+
+// InitializeAnimations sets up the animation controller for the player
+func (p *Player) InitializeAnimations(animations AnimationSet) {
+	p.AnimController = NewAnimationController(animations)
+}
+
+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) {
+	// Keep this lock since it's called from the network goroutine
+	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,70 @@
+package types
+
+import (
+	"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 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)
+	PlaceholderColor rl.Color
+}
+
+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
+)
+
+// UI constants
+const (
+	ChatMargin      = 10
+	ChatHeight      = 200
+	MessageHeight   = 20
+	InputHeight     = 30
+	MaxChatMessages = 50
+)