46 changed files with 668 additions and 2976 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,15 +0,0 @@
-# Build artifacts
-build/
-goonscape
-goonscape.exe
-
-# IDE files
-.vscode/
-.idea/
-*.swp
-
-# OS files
-.DS_Store
-Thumbs.db 
-
-resources/models/old_and_test/
--- a/.gitmodules
+++ b/.gitmodules
@ -1,3 +0,0 @@
-[submodule "goonserver"]
-	path = goonserver
-	url = https://gitea.boner.be/bdnugget/goonserver
--- a/.woodpecker.yml
+++ b/.woodpecker.yml
@ -1,25 +0,0 @@
-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* 
--- a/Dockerfile.build
+++ b/Dockerfile.build
@ -1,30 +0,0 @@
-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"] 
--- a/24
+++ b/24
@ -1,21 +1,11 @@
-MIT License
+“Commons Clause” License Condition v1.0

-Copyright (c) 2025 bdnugget
+The Software is provided to you by the Licensor under the License, as defined below, subject to the following condition.

-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:
+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.

-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+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 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.
+Software: GoonScape
+License: Commons Clause v1.0
+Licensor: bdnugget
--- a/30
+++ b/30
@ -1,30 +0,0 @@
-.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 ./... 
--- a/README.md
+++ b/README.md
@ -1,124 +0,0 @@
-# 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
-```
--- a/assets/assets.go
+++ b/assets/assets.go
@ -1,295 +0,0 @@
-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
-}
--- a/camera.go
+++ b/camera.go
@ -0,0 +1,54 @@
+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)
+}
--- a/constants.go
+++ b/constants.go
@ -2,33 +2,11 @@ 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
-)
-
-// 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"
+	TickRate   = 2600 * time.Millisecond // Server tick rate (600ms)
+	serverAddr = "localhost:6969"
 )
--- a/game/camera.go
+++ b/game/camera.go
@ -1,92 +0,0 @@
-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
-}
--- a/game/chat.go
+++ b/game/chat.go
@ -1,265 +0,0 @@
-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
-}
--- a/game/components.go
+++ b/game/components.go
@ -1,107 +0,0 @@
-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)
-	}
-}
--- a/game/game.go
+++ b/game/game.go
@ -1,467 +0,0 @@
-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
-}
-
-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{}),
-	}
-
-	// Set up inter-component references
-	g.UIManager.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
-
-		// Try to load music
-		music, err := assets.LoadMusic("resources/audio/GoonScape1.mp3")
-		if err != nil {
-			log.Printf("Warning: Failed to load music: %v", err)
-		} else {
-			g.AssetManager.Music = music
-		}
-
-		return nil
-	})
-}
-
-func (g *Game) Update(deltaTime float32) {
-	// Handle login screen if not logged in
-	if !g.UIManager.IsLoggedIn {
-		// Handle login
-		username, password, isRegistering, doAuth := g.UIManager.LoginScreen.Update()
-
-		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)
-
-			// 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 {
-				// Calculate tile coordinates from absolute position
-				tileX := int(other.PosActual.X / float32(types.TileSize))
-				tileY := int(other.PosActual.Z / float32(types.TileSize))
-
-				rl.TraceLog(rl.LogInfo, "Other player ID: %d, Position: (%f, %f, %f), Tile: (%d, %d), Has model: %v",
-					id, other.PosActual.X, other.PosActual.Y, other.PosActual.Z,
-					tileX, tileY, 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)
-	}
-}
-
-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) {
-	if player == nil {
-		return
-	}
-
-	// Get necessary data
-	modelIndex := int(player.ID) % len(g.AssetManager.Models)
-	if modelIndex < 0 || modelIndex >= len(g.AssetManager.Models) {
-		modelIndex = 0
-	}
-	modelAsset := g.AssetManager.Models[modelIndex]
-
-	// Calculate position
-	const defaultHeight = 8.0
-	playerPos := rl.Vector3{
-		X: player.PosActual.X,
-		Y: player.PosActual.Y + defaultHeight + modelAsset.YOffset,
-		Z: player.PosActual.Z,
-	}
-
-	// Simple drawing with scale parameter
-	var drawColor rl.Color = rl.White
-	if player.PlaceholderColor.A > 0 {
-		drawColor = player.PlaceholderColor
-	}
-
-	// Draw the model at normal scale (16.0)
-	rl.DrawModel(model, playerPos, 16.0, drawColor)
-
-	// Update floating message position
-	if player.FloatingMessage != nil {
-		worldPos := rl.Vector3{
-			X: playerPos.X,
-			Y: playerPos.Y + 24.0, // Position above head
-			Z: playerPos.Z,
-		}
-		player.FloatingMessage.ScreenPos = rl.GetWorldToScreen(worldPos, g.Camera)
-	}
-}
-
-func (g *Game) DrawFloatingMessages() {
-	var drawFloatingMessage = func(msg *types.FloatingMessage) {
-		if msg == nil || time.Now().After(msg.ExpireTime) {
-			return
-		}
-
-		// Draw the message with RuneScape-style coloring (black outline with yellow text)
-		text := msg.Content
-		textWidth := rl.MeasureText(text, 20)
-
-		// Draw black outline by offsetting the text slightly in all directions
-		for offsetX := -2; offsetX <= 2; offsetX++ {
-			for offsetY := -2; offsetY <= 2; offsetY++ {
-				rl.DrawText(text,
-					int32(msg.ScreenPos.X)-textWidth/2+int32(offsetX),
-					int32(msg.ScreenPos.Y)+int32(offsetY),
-					20,
-					rl.Black)
-			}
-		}
-
-		// Draw the yellow text on top
-		rl.DrawText(text, int32(msg.ScreenPos.X)-textWidth/2, int32(msg.ScreenPos.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)
-		}
-	}
-}
-
-func (g *Game) Render() {
-	rl.BeginDrawing()
-	defer rl.EndDrawing()
-
-	rl.ClearBackground(rl.RayWhite)
-
-	if !g.UIManager.IsLoggedIn {
-		g.UIManager.LoginScreen.Draw()
-		return
-	}
-
-	// Draw 3D elements
-	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
-		}
-
-		if other.Model.Meshes != nil {
-			g.DrawPlayer(other, other.Model)
-		}
-	}
-	rl.EndMode3D()
-
-	// Draw floating messages with RuneScape style
-	g.DrawFloatingMessages()
-
-	// 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()))
-	}
-
-	// Draw FPS counter
-	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())
-
-	// Draw semi-transparent background
-	rl.DrawRectangle(0, 0, int32(screenWidth), int32(screenHeight), rl.ColorAlpha(rl.Black, 0.7))
-
-	// Draw menu items
-	menuItems := []string{"Resume", "Settings", "Quit"}
-	menuY := screenHeight/2 - float32(len(menuItems)*40)/2
-
-	for i, item := range menuItems {
-		itemY := menuY + float32(i*40)
-		mousePoint := rl.GetMousePosition()
-		itemRect := rl.Rectangle{X: screenWidth/2 - 100, Y: itemY, Width: 200, Height: 36}
-
-		// Check for hover
-		isHover := rl.CheckCollisionPointRec(mousePoint, itemRect)
-
-		// Draw button background
-		if isHover {
-			rl.DrawRectangleRec(itemRect, rl.ColorAlpha(rl.White, 0.3))
-		} else {
-			rl.DrawRectangleRec(itemRect, rl.ColorAlpha(rl.White, 0.1))
-		}
-
-		// Draw button text
-		textWidth := rl.MeasureText(item, 20)
-		rl.DrawText(item, int32(itemRect.X+(itemRect.Width-float32(textWidth))/2), int32(itemRect.Y+8), 20, rl.White)
-
-		// Handle click
-		if isHover && rl.IsMouseButtonReleased(rl.MouseLeftButton) {
-			switch item {
-			case "Resume":
-				g.UIManager.MenuOpen = false
-			case "Settings":
-				// TODO: Implement settings
-			case "Quit":
-				g.Shutdown()
-				rl.CloseWindow()
-			}
-		}
-	}
-}
-
-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) QuitChan() <-chan struct{} {
-	return g.quitChan
-}
-
-func (g *Game) Shutdown() {
-	// Use the cleanup method which has channel-closing safety
-	g.Cleanup()
-}
-
-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)
-	}
-}
--- a/game/input.go
+++ b/game/input.go
@ -1,31 +0,0 @@
-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
-}
--- a/game/login.go
+++ b/game/login.go
@ -1,185 +0,0 @@
-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
-}
--- a/game/pathfinding.go
+++ b/game/pathfinding.go
@ -1,179 +0,0 @@
-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
-}
--- a/game/utils.go
+++ b/game/utils.go
@ -1,72 +0,0 @@
-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
-}
--- a/game/world.go
+++ b/game/world.go
@ -1,39 +0,0 @@
-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
-}
--- a/go.mod
+++ b/go.mod
@ -1,17 +1,15 @@
-module gitea.boner.be/bdnugget/goonscape
+module goonscape

 go 1.23.0

 require (
-	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
+	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
 )

 require (
-	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
+	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
 )
-
-replace gitea.boner.be/bdnugget/goonserver => ./goonserver
--- a/go.sum
+++ b/go.sum
@ -1,12 +1,14 @@
-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=
+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/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-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=
+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=
--- a/1
+++ b/1
@ -1 +0,0 @@
-Subproject commit 00aa3022292b8f4eec6c01522b6a91cf6769155b
--- a/input.go
+++ b/input.go
@ -0,0 +1,88 @@
+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
+}
--- a/main.go
+++ b/main.go
@ -1,153 +1,150 @@
 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()

-	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")
-		}
+	player := Player{
+		PosActual:  rl.NewVector3(5*TileSize, 0, 5*TileSize),
+		PosTile:    mapGrid[5][5],
+		Speed:      50.0,
+		TargetPath: []Tile{},
 	}

-	// 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)
-		}
+	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,
 	}

-	if loadErr != nil {
-		log.Printf("Failed to load assets after %d attempts. Starting with default assets.", maxAttempts)
+	conn, playerID, err := ConnectToServer()
+	if err != nil {
+		log.Fatalf("Failed to connect to server: %v", err)
 	}
+	log.Printf("Player ID: %d", playerID)
+	player.ID = playerID
+	defer conn.Close()

-	defer func() {
-		if gameInstance != nil {
-			gameInstance.Cleanup()
-		}
-		rl.CloseWindow()
-		if rl.IsAudioDeviceReady() {
-			rl.CloseAudioDevice()
-		}
-	}()
+	otherPlayers := make(map[int32]*Player)
+
+	go HandleServerCommunication(conn, playerID, &player, otherPlayers)
+
+	models, err := LoadModels()
+	if err != nil {
+		log.Fatalf("Failed to load models: %v", err)
+	}
+	defer UnloadModels(models)
+
+	modelIndex := int(playerID) % len(models)
+	player.Model = models[modelIndex].Model
+	player.Texture = models[modelIndex].Texture
+
+	music, err := LoadMusic("resources/audio/GoonScape2.mp3")
+	if err != nil {
+		log.Fatalf("Failed to load music: %v", err)
+	}
+	defer UnloadMusic(music)
+	rl.PlayMusicStream(music)
+	rl.SetMusicVolume(music, 0.5)

 	rl.SetTargetFPS(60)

-	// Play music if available
-	if gameInstance.AssetManager.Music.Stream.Buffer != nil {
-		rl.PlayMusicStream(gameInstance.AssetManager.Music)
-		rl.SetMusicVolume(gameInstance.AssetManager.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()

-		// Update music if available
-		if gameInstance.AssetManager.Music.Stream.Buffer != nil {
-			rl.UpdateMusicStream(gameInstance.AssetManager.Music)
+		// Handle input
+		HandleInput(&player, &camera)
+
+		// Update player
+		if len(player.TargetPath) > 0 {
+			player.MoveTowards(player.TargetPath[0], deltaTime)
 		}

-		func() {
-			defer func() {
-				if r := recover(); r != nil {
-					log.Printf("Recovered from panic in game update: %v", r)
-				}
-			}()
-			gameInstance.Update(deltaTime)
-		}()
+		// Update camera
+		UpdateCamera(&camera, player.PosActual, deltaTime)

-		func() {
-			defer func() {
-				if r := recover(); r != nil {
-					log.Printf("Recovered from panic in game render: %v", r)
-				}
-			}()
-			gameInstance.Render()
-		}()
+		// Rendering
+		rl.BeginDrawing()
+		rl.ClearBackground(rl.RayWhite)
+		rl.BeginMode3D(camera)
+		DrawMap()
+		DrawPlayer(player, player.Model)

-		// Check if game requested shutdown
-		select {
-		case <-gameInstance.QuitChan():
-			return
-		default:
+		for id, other := range otherPlayers {
+			if len(other.TargetPath) > 0 {
+				other.MoveTowards(other.TargetPath[0], deltaTime)
+			}
+			DrawPlayer(*other, models[int(id)%len(models)].Model)
 		}
+
+		rl.EndMode3D()
+		rl.DrawFPS(10, 10)
+		rl.EndDrawing()
 	}
 }
+
+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)
+}
--- a/map.go
+++ b/map.go
@ -0,0 +1,48 @@
+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
+		}
+	}
+}
--- a/network.go
+++ b/network.go
@ -0,0 +1,121 @@
+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,
+					}
+				}
+			}
+		}
+	}
+}
--- a/network/network.go
+++ b/network/network.go
@ -1,539 +0,0 @@
-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
-}
--- a/pathfinding.go
+++ b/pathfinding.go
@ -0,0 +1,114 @@
+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
+}
--- a/player.go
+++ b/player.go
@ -0,0 +1,63 @@
+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
+		}
+	}
+}
--- a/render.go
+++ b/render.go
@ -0,0 +1 @@
+package main
--- a/resources/models/coomer/Animation_Confused_Scratch_withSkin.glb
+++ b/resources/models/coomer/Animation_Confused_Scratch_withSkin.glb
--- a/resources/models/coomer/Animation_Idle_withSkin.glb
+++ b/resources/models/coomer/Animation_Idle_withSkin.glb
--- a/resources/models/coomer/Animation_Running_withSkin.glb
+++ b/resources/models/coomer/Animation_Running_withSkin.glb
--- a/resources/models/coomer/Animation_Unsteady_Walk_withSkin.glb
+++ b/resources/models/coomer/Animation_Unsteady_Walk_withSkin.glb
--- a/resources/models/coomer/Animation_Walking_withSkin.glb
+++ b/resources/models/coomer/Animation_Walking_withSkin.glb
--- a/resources/models/coomer/idle_notransy.glb
+++ b/resources/models/coomer/idle_notransy.glb
--- a/resources/models/coomer/unsteadywalk_notransy.glb
+++ b/resources/models/coomer/unsteadywalk_notransy.glb
--- a/resources/models/coomerAnim.zip
+++ b/resources/models/coomerAnim.zip
--- a/resources/models/gooner/idle_no_y_transform.glb
+++ b/resources/models/gooner/idle_no_y_transform.glb
--- a/resources/models/gooner/walk_no_y_transform.glb
+++ b/resources/models/gooner/walk_no_y_transform.glb
--- a/resources/screenshot.png
+++ b/resources/screenshot.png
--- a/scripts/build.sh
+++ b/scripts/build.sh
@ -1,27 +0,0 @@
-#!/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" 
--- a/scripts/platforms.mk
+++ b/scripts/platforms.mk
@ -1 +0,0 @@
-PLATFORMS=windows/amd64 linux/amd64 
--- a/types.go
+++ b/types.go
@ -0,0 +1,31 @@
+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
+}
--- a/types/player.go
+++ b/types/player.go
@ -1,196 +0,0 @@
-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
-}
--- a/types/types.go
+++ b/types/types.go
@ -1,70 +0,0 @@
-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
-)
				`@ -1 +0,0 @@`
				`Subproject commit 00aa3022292b8f4eec6c01522b6a91cf6769155b`