Update goonserver submodule

assets/assets.go

@@ -1,14 +1,88 @@
 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)
@@ -32,68 +106,190 @@ func loadModelAnimations(animPaths map[string]string) (types.AnimationSet, error
 	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) {
-	// Goonion model and animations
-	goonerModel := rl.LoadModel("resources/models/biped/Animation_Unsteady_Walk_withSkin.glb")
-	goonerAnims, _ := loadModelAnimations(map[string]string{"idle": "resources/models/biped/Animation_Idle_withSkin.glb", "walk": "resources/models/biped/Animation_Unsteady_Walk_withSkin.glb"})
+	// Force safe mode for now until we fix the segfault
+	os.Setenv("GOONSCAPE_SAFE_MODE", "1")
 
-	// 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
+	models := make([]types.ModelAsset, 0, 3)
+	modelLoader := NewModelLoader()
 
-	// Coomer model (ready for animations)
-	coomerModel := rl.LoadModel("resources/models/coomer.obj")
-	coomerTexture := rl.LoadTexture("resources/models/coomer.png")
-	rl.SetMaterialTexture(coomerModel.Materials, rl.MapDiffuse, coomerTexture)
-	// When you have animations, add them like:
-	// coomerAnims, _ := loadModelAnimations("resources/models/coomer.glb",
-	//     map[string]string{
-	//         "idle": "resources/models/coomer_idle.glb",
-	//         "walk": "resources/models/coomer_walk.glb",
-	//     })
+	// 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
 
-	// Shreke model (ready for animations)
-	shrekeModel := rl.LoadModel("resources/models/shreke.obj")
-	shrekeTexture := rl.LoadTexture("resources/models/shreke.png")
-	rl.SetMaterialTexture(shrekeModel.Materials, rl.MapDiffuse, shrekeTexture)
-	// When you have animations, add them like:
-	// shrekeAnims, _ := loadModelAnimations("resources/models/shreke.glb",
-	//     map[string]string{
-	//         "idle": "resources/models/shreke_idle.glb",
-	//         "walk": "resources/models/shreke_walk.glb",
-	//     })
+	// 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,
+		})
 
-	return []types.ModelAsset{
-		{
-			Model:      goonerModel,
-			Animation:  append(goonerAnims.Idle, goonerAnims.Walk...), // For compatibility
-			AnimFrames: int32(len(goonerAnims.Idle) + len(goonerAnims.Walk)),
-			Animations: goonerAnims,
-		},
-		{Model: coomerModel, Texture: coomerTexture},
-		{Model: shrekeModel, Texture: shrekeTexture},
-	}, nil
+		// 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) {
-	return rl.LoadMusicStream(filename), nil
-}
-
-func UnloadModels(models []types.ModelAsset) {
-	for _, model := range models {
-		if model.Animation != nil {
-			for i := int32(0); i < model.AnimFrames; i++ {
-				rl.UnloadModelAnimation(model.Animation[i])
-			}
+	defer func() {
+		// Recover from any panics during music loading
+		if r := recover(); r != nil {
+			rl.TraceLog(rl.LogError, "Panic in LoadMusic: %v", r)
 		}
-		rl.UnloadModel(model.Model)
-		rl.UnloadTexture(model.Texture)
-	}
-}
+	}()
 
-func UnloadMusic(music rl.Music) {
-	rl.UnloadMusicStream(music)
+	// 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
 }

constants.go

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

game/camera.go

@@ -10,6 +10,7 @@ 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) {
@@ -32,6 +33,34 @@ func UpdateCamera(camera *rl.Camera3D, player rl.Vector3, deltaTime float32) {
 		}
 	}
 
+	// 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
 	}

game/chat.go

@@ -2,6 +2,8 @@ package game
 
 import (
 	"fmt"
+	"log"
+	"sync"
 	"time"
 
 	"gitea.boner.be/bdnugget/goonscape/types"
@@ -9,13 +11,9 @@ import (
 	rl "github.com/gen2brain/raylib-go/raylib"
 )
 
+// Local UI constants (these could be moved to a centralized constants package later)
 const (
-	maxMessages   = 50
-	chatMargin    = 10 // Margin from screen edges
-	chatHeight    = 200
-	messageHeight = 20
-	inputHeight   = 30
-	runeLimit     = 256
+	runeLimit = 256
 )
 
 type Chat struct {
@@ -25,11 +23,12 @@ type Chat struct {
 	cursorPos    int
 	scrollOffset int
 	userData     interface{}
+	mutex        sync.RWMutex
 }
 
 func NewChat() *Chat {
 	return &Chat{
-		messages:    make([]types.ChatMessage, 0, maxMessages),
+		messages:    make([]types.ChatMessage, 0, types.MaxChatMessages),
 		inputBuffer: make([]rune, 0, runeLimit),
 	}
 }
@@ -41,7 +40,7 @@ func (c *Chat) AddMessage(playerID int32, content string) {
 		Time:     time.Now(),
 	}
 
-	if len(c.messages) >= maxMessages {
+	if len(c.messages) >= types.MaxChatMessages {
 		c.messages = c.messages[1:]
 	}
 	c.messages = append(c.messages, msg)
@@ -49,8 +48,23 @@ func (c *Chat) AddMessage(playerID int32, content string) {
 }
 
 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,
@@ -60,33 +74,54 @@ func (c *Chat) HandleServerMessages(messages []*pb.ChatMessage) {
 
 		// Only add if it's not already in our history
 		if len(c.messages) == 0 || c.messages[len(c.messages)-1].Time.UnixNano() < msg.Timestamp {
-			if len(c.messages) >= maxMessages {
+			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((chatHeight - inputHeight) / messageHeight)
+			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 {
-				if msg.PlayerId == game.Player.ID {
-					game.Player.Lock()
-					game.Player.FloatingMessage = &types.FloatingMessage{
+			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.Player.Unlock()
-				} else if otherPlayer, exists := game.OtherPlayers[msg.PlayerId]; exists {
-					otherPlayer.Lock()
-					otherPlayer.FloatingMessage = &types.FloatingMessage{
+					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),
 					}
-					otherPlayer.Unlock()
+					player.Unlock()
+					log.Printf("Added floating message to other player %d", msg.PlayerId)
 				}
 			}
 		}
@@ -94,17 +129,20 @@ func (c *Chat) HandleServerMessages(messages []*pb.ChatMessage) {
 }
 
 func (c *Chat) Draw(screenWidth, screenHeight int32) {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
 	// Calculate chat window width based on screen width
-	chatWindowWidth := screenWidth - (chatMargin * 2)
+	chatWindowWidth := screenWidth - (types.ChatMargin * 2)
 
 	// Draw chat window background
-	chatX := float32(chatMargin)
-	chatY := float32(screenHeight - chatHeight - chatMargin)
-	rl.DrawRectangle(int32(chatX), int32(chatY), chatWindowWidth, chatHeight, rl.ColorAlpha(rl.Black, 0.5))
+	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((chatHeight - inputHeight) / messageHeight)
+	visibleMessages := int((types.ChatHeight - types.InputHeight) / types.MessageHeight)
 
 	// Auto-scroll to bottom if no manual scrolling has occurred
 	if c.scrollOffset == 0 {
@@ -126,12 +164,12 @@ func (c *Chat) Draw(screenWidth, screenHeight int32) {
 		}
 		text := fmt.Sprintf("%s: %s", msg.Username, msg.Content)
 		rl.DrawText(text, int32(chatX)+5, int32(messageY), 20, color)
-		messageY += messageHeight
+		messageY += types.MessageHeight
 	}
 
 	// Draw input field
-	inputY := chatY + float32(chatHeight-inputHeight)
-	rl.DrawRectangle(int32(chatX), int32(inputY), chatWindowWidth, inputHeight, rl.ColorAlpha(rl.White, 0.3))
+	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)
@@ -149,7 +187,7 @@ func (c *Chat) Update() (string, bool) {
 	if !c.isTyping {
 		wheelMove := rl.GetMouseWheelMove()
 		if wheelMove != 0 {
-			maxScroll := max(0, len(c.messages)-int((chatHeight-inputHeight)/messageHeight))
+			maxScroll := max(0, len(c.messages)-int((types.ChatHeight-types.InputHeight)/types.MessageHeight))
 			c.scrollOffset = clamp(c.scrollOffset-int(wheelMove), 0, maxScroll)
 		}
 

game/components.go

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

game/game.go

@@ -1,7 +1,8 @@
 package game
 
 import (
-	"os"
+	"log"
+	"sync"
 	"time"
 
 	"gitea.boner.be/bdnugget/goonscape/assets"
@@ -12,113 +13,213 @@ import (
 )
 
 type Game struct {
-	Player       *types.Player
-	OtherPlayers map[int32]*types.Player
+	// Component-based architecture
+	PlayerManager *PlayerManager
+	AssetManager  *AssetManager
+	UIManager     *UIManager
+
+	// Core game state
 	Camera       rl.Camera3D
-	Models       []types.ModelAsset
-	Music        rl.Music
-	Chat         *Chat
-	MenuOpen     bool
-	QuitChan     chan struct{} // Channel to signal shutdown
-	loginScreen  *LoginScreen
-	isLoggedIn   bool
+	quitChan     chan struct{}
+	cleanupOnce  sync.Once
+	frameCounter int // For periodic logging
+
+	// Legacy fields for backward compatibility
+	Player       *types.Player           // Use PlayerManager.LocalPlayer instead
+	OtherPlayers map[int32]*types.Player // Use PlayerManager.OtherPlayers instead
+	Models       []types.ModelAsset      // Use AssetManager.Models instead
+	Music        rl.Music                // Use AssetManager.Music instead
+	Chat         *Chat                   // Use UIManager.Chat instead
+	MenuOpen     bool                    // Use UIManager.MenuOpen instead
+	loginScreen  *LoginScreen            // Use UIManager.LoginScreen instead
+	isLoggedIn   bool                    // Use UIManager.IsLoggedIn instead
 }
 
 func New() *Game {
-	InitWorld()
-	game := &Game{
-		OtherPlayers: make(map[int32]*types.Player),
+	// Create managers
+	playerManager := NewPlayerManager()
+	assetManager := NewAssetManager()
+	uiManager := NewUIManager()
+
+	g := &Game{
+		PlayerManager: playerManager,
+		AssetManager:  assetManager,
+		UIManager:     uiManager,
 		Camera: rl.Camera3D{
-			Position:   rl.NewVector3(0, 10, 10),
-			Target:     rl.NewVector3(0, 0, 0),
-			Up:         rl.NewVector3(0, 1, 0),
+			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,
 		},
-		Chat:        NewChat(),
-		QuitChan:    make(chan struct{}),
-		loginScreen: NewLoginScreen(),
+		quitChan: make(chan struct{}),
+		// Initialize empty maps to avoid nil references
+		OtherPlayers: make(map[int32]*types.Player),
 	}
-	game.Chat.userData = game
-	return game
+
+	// Initialize legacy fields (for backward compatibility)
+	g.Player = g.PlayerManager.LocalPlayer
+	g.OtherPlayers = g.PlayerManager.OtherPlayers
+	g.Models = g.AssetManager.Models
+	g.Music = g.AssetManager.Music
+	g.Chat = g.UIManager.Chat
+	g.MenuOpen = g.UIManager.MenuOpen
+	g.loginScreen = g.UIManager.LoginScreen
+	g.isLoggedIn = g.UIManager.IsLoggedIn
+
+	// Set up inter-component references
+	g.Chat.userData = g // Pass game instance to chat for callbacks
+
+	// Initialize world
+	InitWorld()
+
+	return g
 }
 
 func (g *Game) LoadAssets() error {
-	var err error
-	g.Models, err = assets.LoadModels()
-	if err != nil {
-		return err
-	}
+	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
 
-	g.Music, err = assets.LoadMusic("resources/audio/GoonScape2.mp3")
-	if err != nil {
-		return err
-	}
+		// Update legacy field
+		g.Models = models
 
-	return nil
+		// Try to load music
+		music, err := assets.LoadMusic("resources/audio/music.mp3")
+		if err != nil {
+			log.Printf("Warning: Failed to load music: %v", err)
+		} else {
+			g.AssetManager.Music = music
+			// Update legacy field
+			g.Music = music
+		}
+
+		return nil
+	})
 }
 
 func (g *Game) Update(deltaTime float32) {
-	if !g.isLoggedIn {
-		username, password, isRegistering, submitted := g.loginScreen.Update()
-		if submitted {
+	// Legacy code to maintain compatibility
+	if !g.UIManager.IsLoggedIn {
+		// Handle login
+		username, password, isRegistering, doAuth := g.UIManager.LoginScreen.Update()
+		// Update legacy fields
+		g.isLoggedIn = g.UIManager.IsLoggedIn
+
+		if doAuth {
 			conn, playerID, err := network.ConnectToServer(username, password, isRegistering)
 			if err != nil {
-				g.loginScreen.SetError(err.Error())
+				g.UIManager.LoginScreen.SetError(err.Error())
 				return
 			}
 
-			g.Player = &types.Player{
-				Speed:      50.0,
-				TargetPath: []types.Tile{},
-				UserData:   g,
-				QuitDone:   make(chan struct{}),
-				ID:         playerID,
+			g.PlayerManager.LocalPlayer = &types.Player{
+				Speed:       50.0,
+				TargetPath:  []types.Tile{},
+				ActionQueue: []*pb.Action{},
+				QuitDone:    make(chan struct{}),
+				ID:          playerID,
 			}
-			g.AssignModelToPlayer(g.Player)
+			g.AssignModelToPlayer(g.PlayerManager.LocalPlayer)
 
-			go network.HandleServerCommunication(conn, playerID, g.Player, g.OtherPlayers, g.QuitChan)
-			g.isLoggedIn = true
-			return
+			// Update the legacy Player field
+			g.Player = g.PlayerManager.LocalPlayer
+
+			// Set user data to allow chat message handling
+			g.PlayerManager.LocalPlayer.UserData = g
+
+			go network.HandleServerCommunication(conn, playerID, g.PlayerManager.LocalPlayer, g.PlayerManager.OtherPlayers, g.quitChan)
+			g.UIManager.IsLoggedIn = true
 		}
-		g.loginScreen.Draw()
+		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.MenuOpen = !g.MenuOpen
+		g.UIManager.MenuOpen = !g.UIManager.MenuOpen
 		return
 	}
 
 	// Don't process other inputs if menu is open
-	if g.MenuOpen {
+	if g.UIManager.MenuOpen {
 		return
 	}
 
-	if message, sent := g.Chat.Update(); sent {
-		g.Player.Lock()
-		g.Player.ActionQueue = append(g.Player.ActionQueue, &pb.Action{
+	// 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.Player.ID,
+			PlayerId:    g.PlayerManager.LocalPlayer.ID,
 		})
-		g.Player.Unlock()
+		g.PlayerManager.LocalPlayer.Unlock()
 	}
 
+	// Process player input
 	g.HandleInput()
 
-	if len(g.Player.TargetPath) > 0 {
-		g.Player.MoveTowards(g.Player.TargetPath[0], deltaTime, GetMapGrid())
+	// 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())
 	}
 
-	for _, other := range g.OtherPlayers {
-		if len(other.TargetPath) > 0 {
-			other.MoveTowards(other.TargetPath[0], deltaTime, GetMapGrid())
+	// Periodically log information about other players
+	g.frameCounter++
+	if g.frameCounter%300 == 0 {
+		rl.TraceLog(rl.LogInfo, "There are %d other players", len(g.PlayerManager.OtherPlayers))
+		for id, other := range g.PlayerManager.OtherPlayers {
+			if other != nil {
+				rl.TraceLog(rl.LogInfo, "Other player ID: %d, Position: (%f, %f, %f), Has model: %v",
+					id, other.PosActual.X, other.PosActual.Y, other.PosActual.Z, other.Model.Meshes != nil)
+			} else {
+				rl.TraceLog(rl.LogInfo, "Other player ID: %d is nil", id)
+			}
 		}
 	}
 
-	UpdateCamera(&g.Camera, g.Player.PosActual, deltaTime)
+	// Process other players
+	for _, other := range g.PlayerManager.OtherPlayers {
+		if other == nil {
+			continue
+		}
+
+		if other.TargetPath != nil && len(other.TargetPath) > 0 {
+			target := other.TargetPath[0]
+			other.MoveTowards(target, deltaTime, GetMapGrid())
+		}
+
+		// Assign model if needed
+		if other.Model.Meshes == nil {
+			g.AssignModelToPlayer(other)
+		}
+	}
+
+	// Update camera position
+	UpdateCamera(&g.Camera, g.PlayerManager.LocalPlayer.PosActual, deltaTime)
+
+	// Update music if available
+	if g.AssetManager.Music.Stream.Buffer != nil {
+		rl.UpdateMusicStream(g.AssetManager.Music)
+	}
+
+	// Update legacy fields
+	g.Player = g.PlayerManager.LocalPlayer
+	g.OtherPlayers = g.PlayerManager.OtherPlayers
+	g.Models = g.AssetManager.Models
+	g.Music = g.AssetManager.Music
+	g.MenuOpen = g.UIManager.MenuOpen
 }
 
 func (g *Game) DrawMap() {
@@ -150,34 +251,53 @@ func (g *Game) DrawMap() {
 }
 
 func (g *Game) DrawPlayer(player *types.Player, model rl.Model) {
-	player.Lock()
-	defer player.Unlock()
+	// No need for lock in rendering, we'll use a "take snapshot" approach
+	// This avoids potential deadlocks and makes the rendering more consistent
+
+	// Check for invalid model
+	if model.Meshes == nil || model.Meshes.VertexCount <= 0 {
+		// Don't try to draw invalid models
+		return
+	}
 
 	grid := GetMapGrid()
+	modelIndex := int(player.ID) % len(g.Models)
+	if modelIndex < 0 || modelIndex >= len(g.Models) {
+		// Prevent out of bounds access
+		modelIndex = 0
+	}
+	modelAsset := g.Models[modelIndex]
+
+	const defaultHeight = 8.0 // Default height above tile, fine tune per model in types.ModelAsset
 	playerPos := rl.Vector3{
 		X: player.PosActual.X,
-		Y: grid[player.PosTile.X][player.PosTile.Y].Height*types.TileHeight + 16.0,
+		Y: grid[player.PosTile.X][player.PosTile.Y].Height*types.TileHeight + defaultHeight + modelAsset.YOffset,
 		Z: player.PosActual.Z,
 	}
 
-	if player.ID%int32(len(g.Models)) == 0 {
-		modelAsset := g.Models[0]
-
-		// Check if model has animations
-		if modelAsset.Animations.Idle != nil || modelAsset.Animations.Walk != nil {
-			if player.IsMoving && len(modelAsset.Animations.Walk) > 0 {
-				anim := modelAsset.Animations.Walk[0] // Use first walk animation
-				player.AnimationFrame = player.AnimationFrame % anim.FrameCount
-				rl.UpdateModelAnimation(model, anim, player.AnimationFrame)
-			} else if len(modelAsset.Animations.Idle) > 0 {
-				anim := modelAsset.Animations.Idle[0] // Use first idle animation
-				player.AnimationFrame = player.AnimationFrame % anim.FrameCount
-				rl.UpdateModelAnimation(model, anim, player.AnimationFrame)
+	// Check if model has animations
+	if modelAsset.Animations.Idle != nil || modelAsset.Animations.Walk != nil {
+		if player.IsMoving && len(modelAsset.Animations.Walk) > 0 {
+			anim := modelAsset.Animations.Walk[0] // Use first walk animation
+			if anim.FrameCount > 0 {
+				currentFrame := player.AnimationFrame % anim.FrameCount
+				rl.UpdateModelAnimation(model, anim, currentFrame)
+			}
+		} else if len(modelAsset.Animations.Idle) > 0 {
+			anim := modelAsset.Animations.Idle[0] // Use first idle animation
+			if anim.FrameCount > 0 {
+				currentFrame := player.AnimationFrame % anim.FrameCount
+				rl.UpdateModelAnimation(model, anim, currentFrame)
 			}
 		}
 	}
 
-	rl.DrawModel(model, playerPos, 16, rl.White)
+	// Use placeholder color if it's set, otherwise use white
+	var drawColor rl.Color = rl.White
+	if player.PlaceholderColor.A > 0 {
+		drawColor = player.PlaceholderColor
+	}
+	rl.DrawModel(model, playerPos, 16, drawColor)
 
 	// Draw floating messages and path indicators
 	if player.FloatingMessage != nil {
@@ -211,20 +331,43 @@ func (g *Game) DrawPlayer(player *types.Player, model rl.Model) {
 
 func (g *Game) Render() {
 	rl.BeginDrawing()
+	defer func() {
+		// This defer will catch any panics that might occur during rendering
+		// and ensure EndDrawing gets called to maintain proper graphics state
+		if r := recover(); r != nil {
+			rl.TraceLog(rl.LogError, "Panic during rendering: %v", r)
+		}
+		rl.EndDrawing()
+	}()
+
 	rl.ClearBackground(rl.RayWhite)
 
-	if !g.isLoggedIn {
-		g.loginScreen.Draw()
-		rl.EndDrawing()
+	if !g.UIManager.IsLoggedIn {
+		g.UIManager.LoginScreen.Draw()
 		return
 	}
 
 	rl.BeginMode3D(g.Camera)
 	g.DrawMap()
-	g.DrawPlayer(g.Player, g.Player.Model)
-	for _, other := range g.OtherPlayers {
+
+	// Draw player only if valid
+	if g.PlayerManager.LocalPlayer != nil && g.PlayerManager.LocalPlayer.Model.Meshes != nil {
+		g.DrawPlayer(g.PlayerManager.LocalPlayer, g.PlayerManager.LocalPlayer.Model)
+	}
+
+	// Draw other players with defensive checks
+	for _, other := range g.PlayerManager.OtherPlayers {
+		if other == nil {
+			continue
+		}
+
+		// Make sure model is assigned
 		if other.Model.Meshes == nil {
 			g.AssignModelToPlayer(other)
+			// Skip this frame if assignment failed
+			if other.Model.Meshes == nil {
+				continue
+			}
 		}
 		g.DrawPlayer(other, other.Model)
 	}
@@ -251,47 +394,68 @@ func (g *Game) Render() {
 		rl.DrawText(text, int32(pos.X)-textWidth/2, int32(pos.Y), 20, rl.Yellow)
 	}
 
-	if g.Player.FloatingMessage != nil {
-		drawFloatingMessage(g.Player.FloatingMessage)
+	if g.PlayerManager.LocalPlayer != nil && g.PlayerManager.LocalPlayer.FloatingMessage != nil {
+		drawFloatingMessage(g.PlayerManager.LocalPlayer.FloatingMessage)
 	}
 
-	for _, other := range g.OtherPlayers {
-		drawFloatingMessage(other.FloatingMessage)
+	for _, other := range g.PlayerManager.OtherPlayers {
+		if other != nil && other.FloatingMessage != nil {
+			drawFloatingMessage(other.FloatingMessage)
+		}
 	}
 
 	// Draw menu if open
-	if g.MenuOpen {
+	if g.UIManager.MenuOpen {
 		g.DrawMenu()
 	}
 
 	// Only draw chat if menu is not open
-	if !g.MenuOpen {
-		g.Chat.Draw(int32(rl.GetScreenWidth()), int32(rl.GetScreenHeight()))
+	if !g.UIManager.MenuOpen && g.UIManager.Chat != nil {
+		g.UIManager.Chat.Draw(int32(rl.GetScreenWidth()), int32(rl.GetScreenHeight()))
 	}
 
 	rl.DrawFPS(10, 10)
-	rl.EndDrawing()
 }
 
 func (g *Game) Cleanup() {
-	assets.UnloadModels(g.Models)
-	assets.UnloadMusic(g.Music)
+	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.Player.PosTile.X, g.Player.PosTile.Y), clickedTile)
+		path := FindPath(GetTile(g.PlayerManager.LocalPlayer.PosTile.X, g.PlayerManager.LocalPlayer.PosTile.Y), clickedTile)
 		if len(path) > 1 {
-			g.Player.Lock()
-			g.Player.TargetPath = path[1:]
-			g.Player.ActionQueue = append(g.Player.ActionQueue, &pb.Action{
+			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.Player.ID,
+				PlayerId: g.PlayerManager.LocalPlayer.ID,
 			})
-			g.Player.Unlock()
+			g.PlayerManager.LocalPlayer.Unlock()
 		}
 	}
 }
@@ -334,7 +498,7 @@ func (g *Game) DrawMenu() {
 			if rl.IsMouseButtonPressed(rl.MouseLeftButton) {
 				switch item {
 				case "Resume":
-					g.MenuOpen = false
+					g.UIManager.MenuOpen = false
 				case "Settings":
 					// TODO: Implement settings
 				case "Exit Game":
@@ -355,21 +519,38 @@ func (g *Game) DrawMenu() {
 }
 
 func (g *Game) Shutdown() {
-	close(g.QuitChan)
-	<-g.Player.QuitDone
-	rl.CloseWindow()
-	os.Exit(0)
+	// Use the cleanup method which has channel-closing safety
+	g.Cleanup()
 }
 
 func (g *Game) HandleServerMessages(messages []*pb.ChatMessage) {
-	g.Chat.HandleServerMessages(messages)
+	// Check if Chat is properly initialized
+	if g.UIManager != nil && g.UIManager.Chat != nil {
+		g.UIManager.Chat.HandleServerMessages(messages)
+	} else {
+		log.Printf("Warning: Cannot handle server messages, Chat is not initialized")
+	}
 }
 
 func (g *Game) AssignModelToPlayer(player *types.Player) {
-	modelIndex := int(player.ID) % len(g.Models)
-	modelAsset := g.Models[modelIndex]
+	if player == nil {
+		return
+	}
+
+	modelAsset, found := g.AssetManager.GetModelForPlayer(player.ID)
+	if !found {
+		return
+	}
 
-	// Just use the original model - don't try to copy it
 	player.Model = modelAsset.Model
-	player.Texture = modelAsset.Texture
+	player.PlaceholderColor = modelAsset.PlaceholderColor
+
+	// Initialize animations if available
+	if len(modelAsset.Animations.Idle) > 0 || len(modelAsset.Animations.Walk) > 0 {
+		player.InitializeAnimations(modelAsset.Animations)
+	}
+}
+
+func (g *Game) QuitChan() <-chan struct{} {
+	return g.quitChan
 }

game/pathfinding.go

@@ -1,91 +1,157 @@
 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, 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 {
-	openList := []*Node{}
-	closedList := make(map[[2]int]bool)
+	// Initialize open and closed sets
+	openSet := &PriorityQueue{}
+	heap.Init(openSet)
 
-	startNode := &Node{Tile: start, G: 0, H: heuristic(start, end)}
+	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
-	openList = append(openList, startNode)
+	heap.Push(openSet, startNode)
 
-	for len(openList) > 0 {
-		current := openList[0]
-		currentIndex := 0
-		for i, node := range openList {
-			if node.F < current.F {
-				current = node
-				currentIndex = i
-			}
-		}
-
-		openList = append(openList[:currentIndex], openList[currentIndex+1:]...)
-		closedList[[2]int{current.Tile.X, current.Tile.Y}] = true
+	// 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 {
-			path := []types.Tile{}
-			node := current
-			for node != nil {
-				path = append([]types.Tile{node.Tile}, path...)
-				node = node.Parent
-			}
-			fmt.Printf("Path found: %v\n", path)
-			return path
+			return reconstructPath(current)
 		}
 
-		neighbors := GetNeighbors(current.Tile)
-		for _, neighbor := range neighbors {
-			if !neighbor.Walkable || closedList[[2]int{neighbor.X, neighbor.Y}] {
+		// 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)
-			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
-				}
-			}
 
+			// Check if in open set
+			inOpen, existingNode := isInQueue(openSet, neighbor)
+
+			// If not in open set or better path found
 			if !inOpen || tentativeG < existingNode.G {
-				newNode := &Node{
-					Tile:   neighbor,
-					Parent: current,
-					G:      tentativeG,
-					H:      heuristic(neighbor, end),
+				// Create or update the node
+				var neighborNode *Node
+				if inOpen {
+					neighborNode = existingNode
+				} else {
+					neighborNode = &Node{
+						Tile:   neighbor,
+						Parent: current,
+					}
 				}
-				newNode.F = newNode.G + newNode.H
+
+				// 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 {
-					openList = append(openList, newNode)
+					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},
@@ -104,6 +170,7 @@ func GetNeighbors(tile types.Tile) []types.Tile {
 	return neighbors
 }
 
+// abs returns the absolute value of x
 func abs(x int) int {
 	if x < 0 {
 		return -x

game/utils.go

@@ -1,9 +1,36 @@
 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

main.go

@@ -3,7 +3,11 @@ package main
 import (
 	"flag"
 	"log"
+	"os"
+	"os/signal"
 	"strings"
+	"syscall"
+	"time"
 
 	"gitea.boner.be/bdnugget/goonscape/game"
 	"gitea.boner.be/bdnugget/goonscape/network"
@@ -11,11 +15,27 @@ import (
 )
 
 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 != "" {
@@ -30,31 +50,104 @@ func main() {
 		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")
-	rl.SetExitKey(0)
-	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")
+		}
+	}
+
+	// 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)
+		}
+	}
+
+	if loadErr != nil {
+		log.Printf("Failed to load assets after %d attempts. Starting with default assets.", maxAttempts)
+	}
+
+	defer func() {
+		if gameInstance != nil {
+			gameInstance.Cleanup()
+		}
+		rl.CloseWindow()
+		if rl.IsAudioDeviceReady() {
+			rl.CloseAudioDevice()
+		}
+	}()
 
 	rl.SetTargetFPS(60)
 
-	game := game.New()
-	if err := game.LoadAssets(); err != nil {
-		log.Fatalf("Failed to load assets: %v", err)
+	// Play music if available
+	if gameInstance.Music.Stream.Buffer != nil {
+		rl.PlayMusicStream(gameInstance.Music)
+		rl.SetMusicVolume(gameInstance.Music, 0.5)
 	}
-	defer game.Cleanup()
 
-	rl.PlayMusicStream(game.Music)
-	rl.SetMusicVolume(game.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() {
 		deltaTime := rl.GetFrameTime()
-		rl.UpdateMusicStream(game.Music)
-		game.Update(deltaTime)
-		game.Render()
-	}
 
-	// Wait for clean shutdown
-	<-game.QuitChan
+		// Update music if available
+		if gameInstance.Music.Stream.Buffer != nil {
+			rl.UpdateMusicStream(gameInstance.Music)
+		}
+
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("Recovered from panic in game update: %v", r)
+				}
+			}()
+			gameInstance.Update(deltaTime)
+		}()
+
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("Recovered from panic in game render: %v", r)
+				}
+			}()
+			gameInstance.Render()
+		}()
+
+		// Check if game requested shutdown
+		select {
+		case <-gameInstance.QuitChan():
+			return
+		default:
+		}
+	}
 }

network/network.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"log"
 	"net"
+	"sync"
 	"time"
 
 	"gitea.boner.be/bdnugget/goonscape/types"
@@ -17,21 +18,226 @@ import (
 
 const protoVersion = 1
 
-var serverAddr = "boner.be:6969"
+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) {
-	conn, err := net.Dial("tcp", serverAddr)
-	if err != nil {
-		log.Printf("Failed to dial server: %v", err)
-		return nil, 0, err
+	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,
@@ -47,31 +253,23 @@ func ConnectToServer(username, password string, isRegistering bool) (net.Conn, i
 		ProtocolVersion: protoVersion,
 	}
 
-	if err := writeMessage(conn, authBatch); err != nil {
+	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
-	reader := bufio.NewReader(conn)
-	lengthBuf := make([]byte, 4)
-	if _, err := io.ReadFull(reader, lengthBuf); err != nil {
+	response, err := msgHandler.ReadMessage()
+	if err != nil {
 		conn.Close()
 		return nil, 0, fmt.Errorf("failed to read auth response: %v", err)
 	}
-	messageLength := binary.BigEndian.Uint32(lengthBuf)
 
-	messageBuf := make([]byte, messageLength)
-	if _, err := io.ReadFull(reader, messageBuf); err != nil {
-		conn.Close()
-		return nil, 0, fmt.Errorf("failed to read auth response body: %v", err)
-	}
-
-	var response pb.ServerMessage
-	if err := proto.Unmarshal(messageBuf, &response); err != nil {
-		conn.Close()
-		return nil, 0, fmt.Errorf("failed to unmarshal auth response: %v", err)
-	}
+	// Clear read deadline after authentication
+	conn.SetReadDeadline(time.Time{})
 
 	if response.ProtocolVersion > protoVersion {
 		conn.Close()
@@ -86,24 +284,74 @@ func ConnectToServer(username, password string, isRegistering bool) (net.Conn, i
 
 	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{}) {
-	reader := bufio.NewReader(conn)
+	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()
-	defer conn.Close()
-	defer close(player.QuitDone)
 
-	// Create a channel to signal when goroutines are done
-	done := make(chan struct{})
+	// Add a heartbeat ticker to detect connection issues
+	heartbeatTicker := time.NewTicker(5 * time.Second)
+	defer heartbeatTicker.Stop()
 
-	// Create a set of current players to track disconnects
-	currentPlayers := make(map[int32]bool)
+	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:
@@ -115,28 +363,55 @@ func HandleServerCommunication(conn net.Conn, playerID int32, player *types.Play
 						PlayerId: playerID,
 					}},
 				}
-				writeMessage(conn, disconnectMsg)
-				done <- struct{}{}
+
+				// 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,
+						PlayerId:                 playerID,
+						Actions:                  actions,
+						Tick:                     player.CurrentTick,
+						LastSeenMessageTimestamp: lastSeenMessageTimestamp,
 					}
-
 					player.ActionQueue = player.ActionQueue[:0]
 					player.Unlock()
 
-					if err := writeMessage(conn, batch); err != nil {
-						log.Printf("Failed to send actions to server: %v", err)
-						return
+					if err := msgHandler.WriteMessage(batch); err != nil {
+						select {
+						case errChan <- err:
+						case <-done:
+							return
+						}
 					}
+					lastMessageTime = time.Now()
 				} else {
 					player.Unlock()
 				}
@@ -144,111 +419,121 @@ func HandleServerCommunication(conn net.Conn, playerID int32, player *types.Play
 		}
 	}()
 
-	for {
-		select {
-		case <-quitChan:
-			done := make(chan struct{})
-			go func() {
-				<-done
-				close(player.QuitDone)
-			}()
+	// 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:
-				time.Sleep(100 * time.Millisecond)
-			case <-time.After(1 * time.Second):
-				log.Println("Shutdown timed out")
-			}
-			return
-		default:
-			// Read message length (4 bytes)
-			lengthBuf := make([]byte, 4)
-			if _, err := io.ReadFull(reader, lengthBuf); err != nil {
-				log.Printf("Failed to read message length: %v", err)
 				return
-			}
-			messageLength := binary.BigEndian.Uint32(lengthBuf)
-
-			// Read the full message
-			messageBuf := make([]byte, messageLength)
-			if _, err := io.ReadFull(reader, messageBuf); err != nil {
-				log.Printf("Failed to read message body: %v", err)
-				return
-			}
-
-			var serverMessage pb.ServerMessage
-			if err := proto.Unmarshal(messageBuf, &serverMessage); err != nil {
-				log.Printf("Failed to unmarshal server message: %v", err)
-				continue
-			}
-
-			player.Lock()
-			player.CurrentTick = serverMessage.CurrentTick
-
-			tickDiff := serverMessage.CurrentTick - player.CurrentTick
-			if tickDiff > types.MaxTickDesync {
-				for _, state := range serverMessage.Players {
-					if state.PlayerId == playerID {
-						player.ForceResync(state)
-						break
-					}
-				}
-			}
-			player.Unlock()
-
-			for _, state := range serverMessage.Players {
-				currentPlayers[state.PlayerId] = true
-				if state.PlayerId == playerID {
-					player.Lock()
-					// Update initial position if not set
-					if player.PosActual.X == 0 && player.PosActual.Z == 0 {
-						player.PosActual = rl.Vector3{
-							X: float32(state.X * types.TileSize),
-							Y: 0,
-							Z: float32(state.Y * types.TileSize),
+			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
 						}
-						player.PosTile = types.Tile{X: int(state.X), Y: int(state.Y)}
+					} else {
+						log.Printf("Connection closed by server")
 					}
-					player.Unlock()
-					continue
+					return
 				}
 
-				if otherPlayer, exists := otherPlayers[state.PlayerId]; exists {
-					otherPlayer.UpdatePosition(state, types.ServerTickRate)
-				} else {
-					otherPlayers[state.PlayerId] = types.NewPlayer(state)
-				}
-			}
-
-			// Remove players that are no longer in the server state
-			for id := range otherPlayers {
-				if !currentPlayers[id] {
-					delete(otherPlayers, id)
-				}
-			}
-
-			if handler, ok := player.UserData.(types.ChatMessageHandler); ok && len(serverMessage.ChatMessages) > 0 {
-				handler.HandleServerMessages(serverMessage.ChatMessages)
+				// 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 {
-	data, err := proto.Marshal(msg)
-	if err != nil {
-		return err
-	}
-
-	// Write length prefix
-	lengthBuf := make([]byte, 4)
-	binary.BigEndian.PutUint32(lengthBuf, uint32(len(data)))
-	if _, err := conn.Write(lengthBuf); err != nil {
-		return err
-	}
-
-	// Write message body
-	_, err = conn.Write(data)
-	return err
+	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
 }

segfault.txt

@@ -1,245 +0,0 @@
-INFO: Initializing raylib 5.5
-INFO: Platform backend: DESKTOP (GLFW)
-INFO: Supported raylib modules:
-INFO:     > rcore:..... loaded (mandatory)
-INFO:     > rlgl:...... loaded (mandatory)
-INFO:     > rshapes:... loaded (optional)
-INFO:     > rtextures:. loaded (optional)
-INFO:     > rtext:..... loaded (optional)
-INFO:     > rmodels:... loaded (optional)
-INFO:     > raudio:.... loaded (optional)
-INFO: DISPLAY: Device initialized successfully
-INFO:     > Display size: 1920 x 1080
-INFO:     > Screen size:  1024 x 768
-INFO:     > Render size:  1024 x 768
-INFO:     > Viewport offsets: 0, 0
-INFO: GLAD: OpenGL extensions loaded successfully
-INFO: GL: Supported extensions count: 390
-INFO: GL: OpenGL device information:
-INFO:     > Vendor:   NVIDIA Corporation
-INFO:     > Renderer: NVIDIA GeForce GTX 1070/PCIe/SSE2
-INFO:     > Version:  3.3.0 NVIDIA 565.77
-INFO:     > GLSL:     3.30 NVIDIA via Cg compiler
-INFO: GL: VAO extension detected, VAO functions loaded successfully
-INFO: GL: NPOT textures extension detected, full NPOT textures supported
-INFO: GL: DXT compressed textures supported
-INFO: GL: ETC2/EAC compressed textures supported
-INFO: PLATFORM: DESKTOP (GLFW - X11): Initialized successfully
-INFO: TEXTURE: [ID 1] Texture loaded successfully (1x1 | R8G8B8A8 | 1 mipmaps)
-INFO: TEXTURE: [ID 1] Default texture loaded successfully
-INFO: SHADER: [ID 1] Vertex shader compiled successfully
-INFO: SHADER: [ID 2] Fragment shader compiled successfully
-INFO: SHADER: [ID 3] Program shader loaded successfully
-INFO: SHADER: [ID 3] Default shader loaded successfully
-INFO: RLGL: Render batch vertex buffers loaded successfully in RAM (CPU)
-INFO: RLGL: Render batch vertex buffers loaded successfully in VRAM (GPU)
-INFO: RLGL: Default OpenGL state initialized successfully
-INFO: TEXTURE: [ID 2] Texture loaded successfully (128x128 | GRAY_ALPHA | 1 mipmaps)
-INFO: FONT: Default font loaded successfully (224 glyphs)
-INFO: SYSTEM: Working Directory: /home/bd/Projects/go/goonscape
-INFO: AUDIO: Device initialized successfully
-INFO:     > Backend:       miniaudio | PulseAudio
-INFO:     > Format:        32-bit IEEE Floating Point -> 32-bit Signed Integer
-INFO:     > Channels:      2 -> 2
-INFO:     > Sample rate:   48000 -> 48000
-INFO:     > Periods size:  3600
-INFO: TIMER: Target time per frame: 16.667 milliseconds
-INFO: FILEIO: [resources/models/goonion.obj] Text file loaded successfully
-INFO: FILEIO: [goonion.png] File loaded successfully
-INFO: IMAGE: Data loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: TEXTURE: [ID 3] Texture loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: VAO: [ID 2] Mesh uploaded successfully to VRAM (GPU)
-WARNING: VAO: [ID 2] Trying to re-load an already loaded mesh
-INFO: FILEIO: [resources/models/goonion.png] File loaded successfully
-INFO: IMAGE: Data loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: TEXTURE: [ID 4] Texture loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: FILEIO: [resources/models/biped/Animation_Unsteady_Walk_withSkin.glb] File loaded successfully
-INFO: MODEL: [resources/models/biped/Animation_Unsteady_Walk_withSkin.glb] Loaded animation: Armature|Unsteady_Walk|baselayer (177 frames, 3.000000s)
-INFO: FILEIO: [resources/models/coomer.obj] Text file loaded successfully
-INFO: FILEIO: [coomer.png] File loaded successfully
-INFO: IMAGE: Data loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: TEXTURE: [ID 5] Texture loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: VAO: [ID 3] Mesh uploaded successfully to VRAM (GPU)
-WARNING: VAO: [ID 3] Trying to re-load an already loaded mesh
-INFO: FILEIO: [resources/models/coomer.png] File loaded successfully
-INFO: IMAGE: Data loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: TEXTURE: [ID 6] Texture loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: FILEIO: [resources/models/shreke.obj] Text file loaded successfully
-INFO: FILEIO: [shreke.png] File loaded successfully
-INFO: IMAGE: Data loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: TEXTURE: [ID 7] Texture loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: VAO: [ID 4] Mesh uploaded successfully to VRAM (GPU)
-WARNING: VAO: [ID 4] Trying to re-load an already loaded mesh
-INFO: FILEIO: [resources/models/shreke.png] File loaded successfully
-INFO: IMAGE: Data loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: TEXTURE: [ID 8] Texture loaded successfully (2048x2048 | R8G8B8 | 1 mipmaps)
-INFO: STREAM: Initialized successfully (48000 Hz, 32 bit, Stereo)
-INFO: FILEIO: [resources/audio/GoonScape2.mp3] Music file loaded successfully
-INFO:     > Sample rate:   48000 Hz
-INFO:     > Sample size:   32 bits
-INFO:     > Channels:      2 (Stereo)
-INFO:     > Total frames:  3487104
-2025/01/20 12:28:12 Connected to server. Authenticating...
-2025/01/20 12:28:12 Successfully authenticated with player ID: 6
-Clicked: 2, 1
-Path found: [{5 1 1 true} {4 1 5 true} {3 1 4 true} {2 1 3 true}]
-SIGSEGV: segmentation violation
-PC=0x69da90 m=0 sigcode=1 addr=0x0
-signal arrived during cgo execution
-
-goroutine 1 gp=0xc0000061c0 m=0 mp=0x991ca0 [syscall, locked to thread]:
-runtime.cgocall(0x5ef7f0, 0xc00002b858)
-	/usr/lib/go/src/runtime/cgocall.go:167 +0x4b fp=0xc00002b830 sp=0xc00002b7f8 pc=0x46a0ab
-github.com/gen2brain/raylib-go/raylib._Cfunc_UpdateModelAnimation({{0x3f800000, 0x0, 0x0, 0x0, 0x0, 0x3f800000, 0x0, 0x0, 0x0, 0x0, ...}, ...}, ...)
-	_cgo_gotypes.go:7298 +0x45 fp=0xc00002b858 sp=0xc00002b830 pc=0x4db8c5
-github.com/gen2brain/raylib-go/raylib.UpdateModelAnimation.func1(0x47731a?, 0x1000000?, 0x0)
-	/home/bd/.cache/go/mod/github.com/gen2brain/raylib-go/raylib@v0.0.0-20250109172833-6dbba4f81a9b/rmodels.go:613 +0x1a5 fp=0xc00002ba80 sp=0xc00002b858 pc=0x4dd265
-github.com/gen2brain/raylib-go/raylib.UpdateModelAnimation({{0x3f800000, 0x0, 0x0, 0x0, 0x0, 0x3f800000, 0x0, 0x0, 0x0, 0x0, ...}, ...}, ...)
-	/home/bd/.cache/go/mod/github.com/gen2brain/raylib-go/raylib@v0.0.0-20250109172833-6dbba4f81a9b/rmodels.go:613 +0x25 fp=0xc00002baa8 sp=0xc00002ba80 pc=0x4dd085
-gitea.boner.be/bdnugget/goonscape/game.(*Game).DrawPlayer(0xc0001a4000, 0xc0001de160, {{0x3f800000, 0x0, 0x0, 0x0, 0x0, 0x3f800000, 0x0, 0x0, ...}, ...})
-	/home/bd/Projects/go/goonscape/game/game.go:172 +0x2d5 fp=0xc00002bc58 sp=0xc00002baa8 pc=0x5c5c95
-gitea.boner.be/bdnugget/goonscape/game.(*Game).Render(0xc0001a4000)
-	/home/bd/Projects/go/goonscape/game/game.go:221 +0x147 fp=0xc00002be00 sp=0xc00002bc58 pc=0x5c61e7
-main.main()
-	/home/bd/Projects/go/goonscape/main.go:55 +0x4ac fp=0xc00002bf50 sp=0xc00002be00 pc=0x5c924c
-runtime.main()
-	/usr/lib/go/src/runtime/proc.go:272 +0x28b fp=0xc00002bfe0 sp=0xc00002bf50 pc=0x43c42b
-runtime.goexit({})
-	/usr/lib/go/src/runtime/asm_amd64.s:1700 +0x1 fp=0xc00002bfe8 sp=0xc00002bfe0 pc=0x4776c1
-
-goroutine 2 gp=0xc000006c40 m=nil [force gc (idle)]:
-runtime.gopark(0x0?, 0x0?, 0x0?, 0x0?, 0x0?)
-	/usr/lib/go/src/runtime/proc.go:424 +0xce fp=0xc000054fa8 sp=0xc000054f88 pc=0x46ff0e
-runtime.goparkunlock(...)
-	/usr/lib/go/src/runtime/proc.go:430
-runtime.forcegchelper()
-	/usr/lib/go/src/runtime/proc.go:337 +0xb3 fp=0xc000054fe0 sp=0xc000054fa8 pc=0x43c773
-runtime.goexit({})
-	/usr/lib/go/src/runtime/asm_amd64.s:1700 +0x1 fp=0xc000054fe8 sp=0xc000054fe0 pc=0x4776c1
-created by runtime.init.7 in goroutine 1
-	/usr/lib/go/src/runtime/proc.go:325 +0x1a
-
-goroutine 3 gp=0xc000007180 m=nil [GC sweep wait]:
-runtime.gopark(0x0?, 0x0?, 0x0?, 0x0?, 0x0?)
-	/usr/lib/go/src/runtime/proc.go:424 +0xce fp=0xc000055780 sp=0xc000055760 pc=0x46ff0e
-runtime.goparkunlock(...)
-	/usr/lib/go/src/runtime/proc.go:430
-runtime.bgsweep(0xc00007e000)
-	/usr/lib/go/src/runtime/mgcsweep.go:277 +0x94 fp=0xc0000557c8 sp=0xc000055780 pc=0x427394
-runtime.gcenable.gowrap1()
-	/usr/lib/go/src/runtime/mgc.go:204 +0x25 fp=0xc0000557e0 sp=0xc0000557c8 pc=0x41baa5
-runtime.goexit({})
-	/usr/lib/go/src/runtime/asm_amd64.s:1700 +0x1 fp=0xc0000557e8 sp=0xc0000557e0 pc=0x4776c1
-created by runtime.gcenable in goroutine 1
-	/usr/lib/go/src/runtime/mgc.go:204 +0x66
-
-goroutine 4 gp=0xc000007340 m=nil [GC scavenge wait]:
-runtime.gopark(0xc00007e000?, 0x7b0098?, 0x1?, 0x0?, 0xc000007340?)
-	/usr/lib/go/src/runtime/proc.go:424 +0xce fp=0xc000055f78 sp=0xc000055f58 pc=0x46ff0e
-runtime.goparkunlock(...)
-	/usr/lib/go/src/runtime/proc.go:430
-runtime.(*scavengerState).park(0x990ee0)
-	/usr/lib/go/src/runtime/mgcscavenge.go:425 +0x49 fp=0xc000055fa8 sp=0xc000055f78 pc=0x424dc9
-runtime.bgscavenge(0xc00007e000)
-	/usr/lib/go/src/runtime/mgcscavenge.go:653 +0x3c fp=0xc000055fc8 sp=0xc000055fa8 pc=0x42533c
-runtime.gcenable.gowrap2()
-	/usr/lib/go/src/runtime/mgc.go:205 +0x25 fp=0xc000055fe0 sp=0xc000055fc8 pc=0x41ba45
-runtime.goexit({})
-	/usr/lib/go/src/runtime/asm_amd64.s:1700 +0x1 fp=0xc000055fe8 sp=0xc000055fe0 pc=0x4776c1
-created by runtime.gcenable in goroutine 1
-	/usr/lib/go/src/runtime/mgc.go:205 +0xa5
-
-goroutine 5 gp=0xc000007c00 m=nil [finalizer wait]:
-runtime.gopark(0x0?, 0x0?, 0x0?, 0x0?, 0x0?)
-	/usr/lib/go/src/runtime/proc.go:424 +0xce fp=0xc000056620 sp=0xc000056600 pc=0x46ff0e
-runtime.runfinq()
-	/usr/lib/go/src/runtime/mfinal.go:193 +0x107 fp=0xc0000567e0 sp=0xc000056620 pc=0x41ab27
-runtime.goexit({})
-	/usr/lib/go/src/runtime/asm_amd64.s:1700 +0x1 fp=0xc0000567e8 sp=0xc0000567e0 pc=0x4776c1
-created by runtime.createfing in goroutine 1
-	/usr/lib/go/src/runtime/mfinal.go:163 +0x3d
-
-goroutine 6 gp=0xc000007dc0 m=nil [chan receive]:
-runtime.gopark(0x6f63a0?, 0x0?, 0x48?, 0x69?, 0x986948?)
-	/usr/lib/go/src/runtime/proc.go:424 +0xce fp=0xc000054718 sp=0xc0000546f8 pc=0x46ff0e
-runtime.chanrecv(0xc00008a0e0, 0x0, 0x1)
-	/usr/lib/go/src/runtime/chan.go:639 +0x41c fp=0xc000054790 sp=0xc000054718 pc=0x40bb1c
-runtime.chanrecv1(0x43c5c0?, 0xc000054776?)
-	/usr/lib/go/src/runtime/chan.go:489 +0x12 fp=0xc0000547b8 sp=0xc000054790 pc=0x40b6f2
-runtime.unique_runtime_registerUniqueMapCleanup.func1(...)
-	/usr/lib/go/src/runtime/mgc.go:1781
-runtime.unique_runtime_registerUniqueMapCleanup.gowrap1()
-	/usr/lib/go/src/runtime/mgc.go:1784 +0x2f fp=0xc0000547e0 sp=0xc0000547b8 pc=0x41eacf
-runtime.goexit({})
-	/usr/lib/go/src/runtime/asm_amd64.s:1700 +0x1 fp=0xc0000547e8 sp=0xc0000547e0 pc=0x4776c1
-created by unique.runtime_registerUniqueMapCleanup in goroutine 1
-	/usr/lib/go/src/runtime/mgc.go:1779 +0x96
-
-goroutine 20 gp=0xc0001b8000 m=nil [IO wait]:
-runtime.gopark(0xc0000bdad0?, 0x55fcb8?, 0x8?, 0xaa?, 0xb?)
-	/usr/lib/go/src/runtime/proc.go:424 +0xce fp=0xc0000bda68 sp=0xc0000bda48 pc=0x46ff0e
-runtime.netpollblock(0x4b0778?, 0x408f46?, 0x0?)
-	/usr/lib/go/src/runtime/netpoll.go:575 +0xf7 fp=0xc0000bdaa0 sp=0xc0000bda68 pc=0x434fd7
-internal/poll.runtime_pollWait(0x7094ad4a5680, 0x72)
-	/usr/lib/go/src/runtime/netpoll.go:351 +0x85 fp=0xc0000bdac0 sp=0xc0000bdaa0 pc=0x46f205
-internal/poll.(*pollDesc).wait(0xc0001e2080?, 0xc0000d2000?, 0x0)
-	/usr/lib/go/src/internal/poll/fd_poll_runtime.go:84 +0x27 fp=0xc0000bdae8 sp=0xc0000bdac0 pc=0x4bf127
-internal/poll.(*pollDesc).waitRead(...)
-	/usr/lib/go/src/internal/poll/fd_poll_runtime.go:89
-internal/poll.(*FD).Read(0xc0001e2080, {0xc0000d2000, 0x1000, 0x1000})
-	/usr/lib/go/src/internal/poll/fd_unix.go:165 +0x27a fp=0xc0000bdb80 sp=0xc0000bdae8 pc=0x4bfa5a
-net.(*netFD).Read(0xc0001e2080, {0xc0000d2000?, 0xc0000961e0?, 0x2710?})
-	/usr/lib/go/src/net/fd_posix.go:55 +0x25 fp=0xc0000bdbc8 sp=0xc0000bdb80 pc=0x5ae0c5
-net.(*conn).Read(0xc0001b4030, {0xc0000d2000?, 0x10000000006?, 0xc0001a7b00?})
-	/usr/lib/go/src/net/net.go:189 +0x45 fp=0xc0000bdc10 sp=0xc0000bdbc8 pc=0x5b6345
-net.(*TCPConn).Read(0x7094f4718a68?, {0xc0000d2000?, 0xedf202a1b?, 0x990e60?})
-	<autogenerated>:1 +0x25 fp=0xc0000bdc40 sp=0xc0000bdc10 pc=0x5c0c05
-bufio.(*Reader).Read(0xc0000802a0, {0xc0001a7b0c, 0x4, 0x471809?})
-	/usr/lib/go/src/bufio/bufio.go:241 +0x197 fp=0xc0000bdc78 sp=0xc0000bdc40 pc=0x4d93b7
-io.ReadAtLeast({0x7b2640, 0xc0000802a0}, {0xc0001a7b0c, 0x4, 0x4}, 0x4)
-	/usr/lib/go/src/io/io.go:335 +0x90 fp=0xc0000bdcc0 sp=0xc0000bdc78 pc=0x4aaa10
-io.ReadFull(...)
-	/usr/lib/go/src/io/io.go:354
-gitea.boner.be/bdnugget/goonscape/network.HandleServerCommunication({0x7b4bb8, 0xc0001b4030}, 0x6, 0xc0001de160, 0xc000194000, 0xc0001a0000)
-	/home/bd/Projects/go/goonscape/network/network.go:166 +0x412 fp=0xc0000bdfa0 sp=0xc0000bdcc0 pc=0x5c27b2
-gitea.boner.be/bdnugget/goonscape/game.(*Game).Update.gowrap1()
-	/home/bd/Projects/go/goonscape/game/game.go:80 +0x33 fp=0xc0000bdfe0 sp=0xc0000bdfa0 pc=0x5c57d3
-runtime.goexit({})
-	/usr/lib/go/src/runtime/asm_amd64.s:1700 +0x1 fp=0xc0000bdfe8 sp=0xc0000bdfe0 pc=0x4776c1
-created by gitea.boner.be/bdnugget/goonscape/game.(*Game).Update in goroutine 1
-	/home/bd/Projects/go/goonscape/game/game.go:80 +0x45e
-
-goroutine 7 gp=0xc0000c6380 m=nil [select]:
-runtime.gopark(0xc000050f80?, 0x2?, 0x0?, 0x0?, 0xc000050f10?)
-	/usr/lib/go/src/runtime/proc.go:424 +0xce fp=0xc000050db0 sp=0xc000050d90 pc=0x46ff0e
-runtime.selectgo(0xc000050f80, 0xc000050f0c, 0x0?, 0x0, 0x0?, 0x1)
-	/usr/lib/go/src/runtime/select.go:335 +0x7a5 fp=0xc000050ed8 sp=0xc000050db0 pc=0x44e2a5
-gitea.boner.be/bdnugget/goonscape/network.HandleServerCommunication.func1()
-	/home/bd/Projects/go/goonscape/network/network.go:108 +0xb2 fp=0xc000050fe0 sp=0xc000050ed8 pc=0x5c3492
-runtime.goexit({})
-	/usr/lib/go/src/runtime/asm_amd64.s:1700 +0x1 fp=0xc000050fe8 sp=0xc000050fe0 pc=0x4776c1
-created by gitea.boner.be/bdnugget/goonscape/network.HandleServerCommunication in goroutine 20
-	/home/bd/Projects/go/goonscape/network/network.go:106 +0x3bd
-
-rax    0x0
-rbx    0x0
-rcx    0x0
-rdx    0x0
-rdi    0x13ee9800
-rsi    0xb1
-rbp    0x13bd6580
-rsp    0x7ffc9d661890
-r8     0x140baba0
-r9     0x0
-r10    0x0
-r11    0x0
-r12    0x13bd1f20
-r13    0x744e4
-r14    0x4d898
-r15    0x26c4c
-rip    0x69da90
-rflags 0x10246
-cs     0x33
-fs     0x0
-gs     0x0
-exit status 2

types/player.go

@@ -1,16 +1,98 @@
 package types
 
 import (
+	"sync"
 	"time"
 
 	pb "gitea.boner.be/bdnugget/goonserver/actions"
 	rl "github.com/gen2brain/raylib-go/raylib"
 )
 
-func (p *Player) MoveTowards(target Tile, deltaTime float32, mapGrid [][]Tile) {
-	p.Lock()
-	defer p.Unlock()
+// 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,
@@ -21,29 +103,29 @@ func (p *Player) MoveTowards(target Tile, deltaTime float32, mapGrid [][]Tile) {
 	distance := rl.Vector3Length(direction)
 
 	if distance > 1.0 {
-		wasMoving := p.IsMoving
 		p.IsMoving = true
-
-		if !wasMoving {
-			p.AnimationFrame = 0
-		}
-
-		oldFrame := p.AnimationFrame
-		p.AnimationFrame += int32(deltaTime * 60)
-		rl.TraceLog(rl.LogInfo, "Walk frame update: %d -> %d (delta: %f)",
-			oldFrame, p.AnimationFrame, deltaTime)
 	} else {
-		wasMoving := p.IsMoving
 		p.IsMoving = false
+	}
 
-		if wasMoving {
-			p.AnimationFrame = 0
+	// 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)
 		}
-
-		oldFrame := p.AnimationFrame
-		p.AnimationFrame += int32(deltaTime * 60)
-		rl.TraceLog(rl.LogInfo, "Idle frame update: %d -> %d (delta: %f)",
-			oldFrame, p.AnimationFrame, deltaTime)
 	}
 
 	if distance > 0 {
@@ -68,15 +150,22 @@ func NewPlayer(state *pb.PlayerState) *Player {
 			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(),
+		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()
@@ -91,6 +180,7 @@ func (p *Player) UpdatePosition(state *pb.PlayerState, tickRate time.Duration) {
 }
 
 func (p *Player) ForceResync(state *pb.PlayerState) {
+	// Keep this lock since it's called from the network goroutine
 	p.Lock()
 	defer p.Unlock()
 

types/types.go

@@ -1,7 +1,6 @@
 package types
 
 import (
-	"sync"
 	"time"
 
 	pb "gitea.boner.be/bdnugget/goonserver/actions"
@@ -14,27 +13,6 @@ type Tile struct {
 	Walkable bool
 }
 
-type Player struct {
-	sync.Mutex
-	PosActual             rl.Vector3
-	PosTile               Tile
-	TargetPath            []Tile
-	ActionQueue           []*pb.Action
-	Speed                 float32
-	Model                 rl.Model
-	Texture               rl.Texture2D
-	ID                    int32
-	CurrentTick           int64
-	LastUpdateTime        time.Time
-	LastAnimUpdate        time.Time
-	InterpolationProgress float32
-	UserData              interface{}
-	FloatingMessage       *FloatingMessage
-	QuitDone              chan struct{}
-	AnimationFrame        int32
-	IsMoving              bool
-}
-
 type AnimationSet struct {
 	Idle []rl.ModelAnimation
 	Walk []rl.ModelAnimation
@@ -44,11 +22,13 @@ type AnimationSet struct {
 }
 
 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
+	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 {
@@ -79,3 +59,12 @@ const (
 	ClientTickRate = 50 * time.Millisecond
 	MaxTickDesync  = 5
 )
+
+// UI constants
+const (
+	ChatMargin      = 10
+	ChatHeight      = 200
+	MessageHeight   = 20
+	InputHeight     = 30
+	MaxChatMessages = 50
+)