add a bunch of mutexes and shit but still have racist conditions and panics LOL

.gitignore

@@ -10,4 +10,6 @@ goonscape.exe
 
 # OS files
 .DS_Store
-Thumbs.db 
+Thumbs.db 
+
+resources/models/old_and_test/

LICENSE

@@ -1,11 +1,21 @@
-“Commons Clause” License Condition v1.0
+MIT License
 
-The Software is provided to you by the Licensor under the License, as defined below, subject to the following condition.
+Copyright (c) 2025 bdnugget
 
-Without limiting other conditions in the License, the grant of rights under the License will not include, and the License does not grant to you,  right to Sell the Software.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-For purposes of the foregoing, “Sell” means practicing any or all of the rights granted to you under the License to provide to third parties, for a fee or other consideration (including without limitation fees for hosting or consulting/ support services related to the Software), a product or service whose value derives, entirely or substantially, from the functionality of the Software.  Any license notice or attribution required by the License must also include this Commons Cause License Condition notice.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-Software: GoonScape
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-License: Commons Clause v1.0
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-Licensor: bdnugget
+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.

assets/assets.go

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

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,7 @@ package game
 
 import (
 	"fmt"
+	"sync"
 	"time"
 
 	"gitea.boner.be/bdnugget/goonscape/types"
@@ -25,6 +26,7 @@ type Chat struct {
 	cursorPos    int
 	scrollOffset int
 	userData     interface{}
+	mutex        sync.RWMutex
 }
 
 func NewChat() *Chat {
@@ -49,6 +51,9 @@ func (c *Chat) AddMessage(playerID int32, content string) {
 }
 
 func (c *Chat) HandleServerMessages(messages []*pb.ChatMessage) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
 	// Convert protobuf messages to our local type
 	for _, msg := range messages {
 		localMsg := types.ChatMessage{
@@ -94,6 +99,9 @@ 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)
 

game/game.go

@@ -1,7 +1,8 @@
 package game
 
 import (
-	"os"
+	"fmt"
+	"sync"
 	"time"
 
 	"gitea.boner.be/bdnugget/goonscape/assets"
@@ -19,9 +20,10 @@ type Game struct {
 	Music        rl.Music
 	Chat         *Chat
 	MenuOpen     bool
-	QuitChan     chan struct{} // Channel to signal shutdown
+	quitChan     chan struct{}
 	loginScreen  *LoginScreen
 	isLoggedIn   bool
+	cleanupOnce  sync.Once
 }
 
 func New() *Game {
@@ -36,7 +38,7 @@ func New() *Game {
 			Projection: rl.CameraPerspective,
 		},
 		Chat:        NewChat(),
-		QuitChan:    make(chan struct{}),
+		quitChan:    make(chan struct{}),
 		loginScreen: NewLoginScreen(),
 	}
 	game.Chat.userData = game
@@ -44,15 +46,32 @@ func New() *Game {
 }
 
 func (g *Game) LoadAssets() error {
-	var err error
+	var loadErr error
-	g.Models, err = assets.LoadModels()
+	defer func() {
-	if err != nil {
+		if r := recover(); r != nil {
-		return err
+			loadErr = fmt.Errorf("panic during asset loading: %v", r)
+			// Cleanup any partially loaded assets
+			g.Cleanup()
+		}
+	}()
+
+	// Load models with better error handling
+	g.Models, loadErr = assets.LoadModels()
+	if loadErr != nil {
+		return fmt.Errorf("failed to load models: %v", loadErr)
 	}
 
-	g.Music, err = assets.LoadMusic("resources/audio/GoonScape2.mp3")
+	// Verify model loading
-	if err != nil {
+	for i, model := range g.Models {
-		return err
+		if model.Model.Meshes == nil {
+			return fmt.Errorf("model %d failed to load properly", i)
+		}
+	}
+
+	// Load music with better error handling
+	g.Music, loadErr = assets.LoadMusic("resources/audio/GoonScape2.mp3")
+	if loadErr != nil {
+		return fmt.Errorf("failed to load music: %v", loadErr)
 	}
 
 	return nil
@@ -68,23 +87,18 @@ func (g *Game) Update(deltaTime float32) {
 				return
 			}
 
-			// Assign model based on player ID
-			modelIndex := int(playerID) % len(g.Models)
 			g.Player = &types.Player{
 				Speed:      50.0,
 				TargetPath: []types.Tile{},
 				UserData:   g,
 				QuitDone:   make(chan struct{}),
 				ID:         playerID,
-				Model:      g.Models[modelIndex].Model,
-				Texture:    g.Models[modelIndex].Texture,
 			}
+			g.AssignModelToPlayer(g.Player)
 
-			go network.HandleServerCommunication(conn, playerID, g.Player, g.OtherPlayers, g.QuitChan)
+			go network.HandleServerCommunication(conn, playerID, g.Player, g.OtherPlayers, g.quitChan)
 			g.isLoggedIn = true
-			return
 		}
-		g.loginScreen.Draw()
 		return
 	}
 
@@ -157,14 +171,32 @@ func (g *Game) DrawPlayer(player *types.Player, model rl.Model) {
 	defer player.Unlock()
 
 	grid := GetMapGrid()
+	modelIndex := int(player.ID) % len(g.Models)
+	modelAsset := g.Models[modelIndex]
+
+	const defaultHeight = 8.0 // Default height above tile, fine tune per model in types.ModelAsset
 	playerPos := rl.Vector3{
 		X: player.PosActual.X,
-		Y: grid[player.PosTile.X][player.PosTile.Y].Height*types.TileHeight + 16.0,
+		Y: grid[player.PosTile.X][player.PosTile.Y].Height*types.TileHeight + defaultHeight + modelAsset.YOffset,
 		Z: player.PosActual.Z,
 	}
 
+	// Check if model has animations
+	if modelAsset.Animations.Idle != nil || modelAsset.Animations.Walk != nil {
+		if player.IsMoving && len(modelAsset.Animations.Walk) > 0 {
+			anim := modelAsset.Animations.Walk[0] // Use first walk animation
+			player.AnimationFrame = player.AnimationFrame % anim.FrameCount
+			rl.UpdateModelAnimation(model, anim, player.AnimationFrame)
+		} else if len(modelAsset.Animations.Idle) > 0 {
+			anim := modelAsset.Animations.Idle[0] // Use first idle animation
+			player.AnimationFrame = player.AnimationFrame % anim.FrameCount
+			rl.UpdateModelAnimation(model, anim, player.AnimationFrame)
+		}
+	}
+
 	rl.DrawModel(model, playerPos, 16, rl.White)
 
+	// Draw floating messages and path indicators
 	if player.FloatingMessage != nil {
 		screenPos := rl.GetWorldToScreen(rl.Vector3{
 			X: playerPos.X,
@@ -207,12 +239,9 @@ func (g *Game) Render() {
 	rl.BeginMode3D(g.Camera)
 	g.DrawMap()
 	g.DrawPlayer(g.Player, g.Player.Model)
-	for id, other := range g.OtherPlayers {
+	for _, other := range g.OtherPlayers {
 		if other.Model.Meshes == nil {
-			// Assign model based on player ID for consistency
+			g.AssignModelToPlayer(other)
-			modelIndex := int(id) % len(g.Models)
-			other.Model = g.Models[modelIndex].Model
-			other.Texture = g.Models[modelIndex].Texture
 		}
 		g.DrawPlayer(other, other.Model)
 	}
@@ -262,8 +291,20 @@ func (g *Game) Render() {
 }
 
 func (g *Game) Cleanup() {
-	assets.UnloadModels(g.Models)
+	g.cleanupOnce.Do(func() {
-	assets.UnloadMusic(g.Music)
+		// Stop music first
+		if g.Music.Stream.Buffer != nil {
+			rl.StopMusicStream(g.Music)
+			rl.UnloadMusicStream(g.Music)
+		}
+
+		// Unload textures
+		for _, model := range g.Models {
+			if model.Texture.ID > 0 {
+				rl.UnloadTexture(model.Texture)
+			}
+		}
+	})
 }
 
 func (g *Game) HandleInput() {
@@ -343,12 +384,22 @@ func (g *Game) DrawMenu() {
 }
 
 func (g *Game) Shutdown() {
-	close(g.QuitChan)
+	close(g.quitChan)
-	<-g.Player.QuitDone
-	rl.CloseWindow()
-	os.Exit(0)
 }
 
 func (g *Game) HandleServerMessages(messages []*pb.ChatMessage) {
 	g.Chat.HandleServerMessages(messages)
 }
+
+func (g *Game) AssignModelToPlayer(player *types.Player) {
+	modelIndex := int(player.ID) % len(g.Models)
+	modelAsset := g.Models[modelIndex]
+
+	// Just use the original model - don't try to copy it
+	player.Model = modelAsset.Model
+	player.Texture = modelAsset.Texture
+}
+
+func (g *Game) QuitChan() <-chan struct{} {
+	return g.quitChan
+}

main.go

@@ -3,7 +3,10 @@ package main
 import (
 	"flag"
 	"log"
+	"os"
+	"os/signal"
 	"strings"
+	"syscall"
 
 	"gitea.boner.be/bdnugget/goonscape/game"
 	"gitea.boner.be/bdnugget/goonscape/network"
@@ -11,11 +14,24 @@ import (
 )
 
 func main() {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Printf("Recovered from panic in main: %v", r)
+		}
+	}()
+
 	// 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 != "" {
@@ -32,29 +48,63 @@ func main() {
 
 	rl.InitWindow(1024, 768, "GoonScape")
 	rl.SetExitKey(0)
-	defer rl.CloseWindow()
-
 	rl.InitAudioDevice()
-	defer rl.CloseAudioDevice()
+
+	gameInstance := game.New()
+	if err := gameInstance.LoadAssets(); err != nil {
+		log.Printf("Failed to load assets: %v", err)
+		return
+	}
+
+	defer func() {
+		gameInstance.Cleanup()
+		rl.CloseWindow()
+		rl.CloseAudioDevice()
+	}()
 
 	rl.SetTargetFPS(60)
 
-	game := game.New()
+	rl.PlayMusicStream(gameInstance.Music)
-	if err := game.LoadAssets(); err != nil {
+	rl.SetMusicVolume(gameInstance.Music, 0.5)
-		log.Fatalf("Failed to load assets: %v", err)
-	}
-	defer game.Cleanup()
 
-	rl.PlayMusicStream(game.Music)
+	// Handle OS signals for clean shutdown
-	rl.SetMusicVolume(game.Music, 0.5)
+	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)
+		rl.UpdateMusicStream(gameInstance.Music)
-		game.Update(deltaTime)
-		game.Render()
-	}
 
-	// Wait for clean shutdown
+		func() {
-	<-game.QuitChan
+			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"
@@ -91,19 +92,32 @@ func ConnectToServer(username, password string, isRegistering bool) (net.Conn, i
 
 func HandleServerCommunication(conn net.Conn, playerID int32, player *types.Player, otherPlayers map[int32]*types.Player, quitChan <-chan struct{}) {
 	reader := bufio.NewReader(conn)
+	defer func() {
+		if r := recover(); r != nil {
+			log.Printf("Recovered from panic in HandleServerCommunication: %v", r)
+		}
+		conn.Close()
+		if player.QuitDone != nil {
+			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
+	// Create error channel for goroutine communication
+	errChan := make(chan error, 1)
 	done := make(chan struct{})
 
-	// Create a set of current players to track disconnects
+	// Start message sending goroutine
-	currentPlayers := make(map[int32]bool)
-
 	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				log.Printf("Recovered from panic in message sender: %v", r)
+				errChan <- fmt.Errorf("message sender panic: %v", r)
+			}
+		}()
+
 		for {
 			select {
 			case <-quitChan:
@@ -118,23 +132,23 @@ func HandleServerCommunication(conn net.Conn, playerID int32, player *types.Play
 				writeMessage(conn, disconnectMsg)
 				done <- struct{}{}
 				return
+			case <-done:
+				return
 			case <-actionTicker.C:
 				player.Lock()
 				if len(player.ActionQueue) > 0 {
 					actions := make([]*pb.Action, len(player.ActionQueue))
 					copy(actions, player.ActionQueue)
-
 					batch := &pb.ActionBatch{
 						PlayerId: playerID,
 						Actions:  actions,
 						Tick:     player.CurrentTick,
 					}
-
 					player.ActionQueue = player.ActionQueue[:0]
 					player.Unlock()
 
 					if err := writeMessage(conn, batch); err != nil {
-						log.Printf("Failed to send actions to server: %v", err)
+						errChan <- err
 						return
 					}
 				} else {
@@ -144,93 +158,106 @@ func HandleServerCommunication(conn net.Conn, playerID int32, player *types.Play
 		}
 	}()
 
-	for {
+	// Main message receiving loop
-		select {
+	go func() {
-		case <-quitChan:
+		defer func() {
-			done := make(chan struct{})
+			if r := recover(); r != nil {
-			go func() {
+				log.Printf("Recovered from panic in message receiver: %v", r)
-				<-done
+				errChan <- fmt.Errorf("message receiver panic: %v", r)
-				close(player.QuitDone)
+			}
-			}()
+		}()
 
+		for {
 			select {
-			case <-done:
+			case <-quitChan:
-				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
-			}
+			default:
-			messageLength := binary.BigEndian.Uint32(lengthBuf)
+				lengthBuf := make([]byte, 4)
-
+				if _, err := io.ReadFull(reader, lengthBuf); err != nil {
-			// Read the full message
+					if err != io.EOF {
-			messageBuf := make([]byte, messageLength)
+						errChan <- fmt.Errorf("failed to read message length: %v", err)
-			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
 					}
+					return
 				}
-			}
+				messageLength := binary.BigEndian.Uint32(lengthBuf)
-			player.Unlock()
 
-			for _, state := range serverMessage.Players {
+				messageBuf := make([]byte, messageLength)
-				currentPlayers[state.PlayerId] = true
+				if _, err := io.ReadFull(reader, messageBuf); err != nil {
-				if state.PlayerId == playerID {
+					log.Printf("Failed to read message body: %v", err)
-					player.Lock()
+					return
-					// Update initial position if not set
+				}
-					if player.PosActual.X == 0 && player.PosActual.Z == 0 {
+
-						player.PosActual = rl.Vector3{
+				var serverMessage pb.ServerMessage
-							X: float32(state.X * types.TileSize),
+				if err := proto.Unmarshal(messageBuf, &serverMessage); err != nil {
-							Y: 0,
+					log.Printf("Failed to unmarshal server message: %v", err)
-							Z: float32(state.Y * types.TileSize),
-						}
-						player.PosTile = types.Tile{X: int(state.X), Y: int(state.Y)}
-					}
-					player.Unlock()
 					continue
 				}
 
-				if otherPlayer, exists := otherPlayers[state.PlayerId]; exists {
+				player.Lock()
-					otherPlayer.UpdatePosition(state, types.ServerTickRate)
+				player.CurrentTick = serverMessage.CurrentTick
-				} else {
-					otherPlayers[state.PlayerId] = types.NewPlayer(state)
-				}
-			}
 
-			// Remove players that are no longer in the server state
+				tickDiff := serverMessage.CurrentTick - player.CurrentTick
-			for id := range otherPlayers {
+				if tickDiff > types.MaxTickDesync {
-				if !currentPlayers[id] {
+					for _, state := range serverMessage.Players {
-					delete(otherPlayers, id)
+						if state.PlayerId == playerID {
+							player.ForceResync(state)
+							break
+						}
+					}
 				}
-			}
+				player.Unlock()
 
-			if handler, ok := player.UserData.(types.ChatMessageHandler); ok && len(serverMessage.ChatMessages) > 0 {
+				for _, state := range serverMessage.Players {
-				handler.HandleServerMessages(serverMessage.ChatMessages)
+					if state.PlayerId == playerID {
+						player.Lock()
+						// Update initial position if not set
+						if player.PosActual.X == 0 && player.PosActual.Z == 0 {
+							player.PosActual = rl.Vector3{
+								X: float32(state.X * types.TileSize),
+								Y: 0,
+								Z: float32(state.Y * types.TileSize),
+							}
+							player.PosTile = types.Tile{X: int(state.X), Y: int(state.Y)}
+						}
+						player.Unlock()
+						continue
+					}
+
+					if otherPlayer, exists := otherPlayers[state.PlayerId]; exists {
+						otherPlayer.UpdatePosition(state, types.ServerTickRate)
+					} else {
+						otherPlayers[state.PlayerId] = types.NewPlayer(state)
+					}
+				}
+
+				// Remove players that are no longer in the server state
+				for id := range otherPlayers {
+					if id != playerID {
+						delete(otherPlayers, id)
+					}
+				}
+
+				if handler, ok := player.UserData.(types.ChatMessageHandler); ok && len(serverMessage.ChatMessages) > 0 {
+					handler.HandleServerMessages(serverMessage.ChatMessages)
+				}
 			}
 		}
+	}()
+
+	// Wait for error or quit signal
+	select {
+	case <-quitChan:
+		// Send disconnect message
+		disconnectMsg := &pb.ActionBatch{
+			PlayerId: playerID,
+			Actions: []*pb.Action{{
+				Type:     pb.Action_DISCONNECT,
+				PlayerId: playerID,
+			}},
+		}
+		writeMessage(conn, disconnectMsg)
+	case err := <-errChan:
+		log.Printf("Network error: %v", err)
 	}
 }
 
@@ -252,3 +279,50 @@ func writeMessage(conn net.Conn, msg proto.Message) error {
 	_, err = conn.Write(data)
 	return err
 }
+
+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() {
+		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")
+		}
+		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
+}

types/player.go

@@ -1,12 +1,34 @@
 package types
 
 import (
+	"sync"
 	"time"
 
 	pb "gitea.boner.be/bdnugget/goonserver/actions"
 	rl "github.com/gen2brain/raylib-go/raylib"
 )
 
+type Player struct {
+	sync.RWMutex
+	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
+}
+
 func (p *Player) MoveTowards(target Tile, deltaTime float32, mapGrid [][]Tile) {
 	p.Lock()
 	defer p.Unlock()
@@ -19,6 +41,33 @@ func (p *Player) MoveTowards(target Tile, deltaTime float32, mapGrid [][]Tile) {
 
 	direction := rl.Vector3Subtract(targetPos, p.PosActual)
 	distance := rl.Vector3Length(direction)
+
+	if distance > 1.0 {
+		wasMoving := p.IsMoving
+		p.IsMoving = true
+
+		if !wasMoving {
+			p.AnimationFrame = 0
+		}
+
+		oldFrame := p.AnimationFrame
+		p.AnimationFrame += int32(deltaTime * 60)
+		rl.TraceLog(rl.LogInfo, "Walk frame update: %d -> %d (delta: %f)",
+			oldFrame, p.AnimationFrame, deltaTime)
+	} else {
+		wasMoving := p.IsMoving
+		p.IsMoving = false
+
+		if wasMoving {
+			p.AnimationFrame = 0
+		}
+
+		oldFrame := p.AnimationFrame
+		p.AnimationFrame += int32(deltaTime * 60)
+		rl.TraceLog(rl.LogInfo, "Idle frame update: %d -> %d (delta: %f)",
+			oldFrame, p.AnimationFrame, deltaTime)
+	}
+
 	if distance > 0 {
 		direction = rl.Vector3Scale(direction, p.Speed*deltaTime/distance)
 	}
@@ -41,9 +90,14 @@ 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)},
+		PosTile:               Tile{X: int(state.X), Y: int(state.Y)},
-		Speed:   50.0,
+		Speed:                 50.0,
-		ID:      state.PlayerId,
+		ID:                    state.PlayerId,
+		IsMoving:              false,
+		AnimationFrame:        0,
+		LastAnimUpdate:        time.Now(),
+		LastUpdateTime:        time.Now(),
+		InterpolationProgress: 1.0,
 	}
 }
 

types/types.go

@@ -1,7 +1,6 @@
 package types
 
 import (
-	"sync"
 	"time"
 
 	pb "gitea.boner.be/bdnugget/goonserver/actions"
@@ -14,27 +13,21 @@ type Tile struct {
 	Walkable bool
 }
 
-type Player struct {
+type AnimationSet struct {
-	sync.Mutex
+	Idle []rl.ModelAnimation
-	PosActual             rl.Vector3
+	Walk []rl.ModelAnimation
-	PosTile               Tile
+	// Can add more animation types later like:
-	TargetPath            []Tile
+	// Attack []ModelAnimation
-	ActionQueue           []*pb.Action
+	// Jump   []ModelAnimation
-	Speed                 float32
-	Model                 rl.Model
-	Texture               rl.Texture2D
-	ID                    int32
-	CurrentTick           int64
-	LastUpdateTime        time.Time
-	InterpolationProgress float32
-	UserData              interface{}
-	FloatingMessage       *FloatingMessage
-	QuitDone              chan struct{}
 }
 
 type ModelAsset struct {
-	Model   rl.Model
+	Model      rl.Model
-	Texture rl.Texture2D
+	Texture    rl.Texture2D
+	Animation  []rl.ModelAnimation // Keep this for compatibility
+	AnimFrames int32               // Keep this for compatibility
+	Animations AnimationSet        // New field for organized animations
+	YOffset    float32             // Additional height offset (added to default 8.0)
 }
 
 type ChatMessage struct {