Add leaderboard functionality with Redis integration for scores. This includes a global leaderboard system, server-side score submission handling, and real-time player ranking updates. Refactor and improve collision logic and game state management for better player experience.

2026-01-01 19:23:09 +01:00
parent 5e6b8a2304
commit de64329ce4
12 changed files with 768 additions and 43 deletions
--- a/pkg/server/leaderboard.go
+++ b/pkg/server/leaderboard.go
@@ -0,0 +1,97 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+	"time"
+
+	"git.zb-server.de/ZB-Server/EscapeFromTeacher/pkg/game"
+	"github.com/redis/go-redis/v9"
+)
+
+type Leaderboard struct {
+	rdb *redis.Client
+	ctx context.Context
+}
+
+var GlobalLeaderboard *Leaderboard
+
+const leaderboardKey = "leaderboard:top"
+
+func InitLeaderboard(redisAddr string) error {
+	rdb := redis.NewClient(&redis.Options{
+		Addr: redisAddr,
+		DB:   0,
+	})
+
+	ctx := context.Background()
+	if err := rdb.Ping(ctx).Err(); err != nil {
+		return err
+	}
+
+	GlobalLeaderboard = &Leaderboard{
+		rdb: rdb,
+		ctx: ctx,
+	}
+
+	log.Println("📊 Redis-Leaderboard verbunden")
+	return nil
+}
+
+func (lb *Leaderboard) AddScore(name, code string, score int) bool {
+	// Prüfe ob Spieler bereits existiert
+	existingScoreStr, err := lb.rdb.HGet(lb.ctx, "leaderboard:players", code).Result()
+	if err == nil {
+		var existingScore int
+		json.Unmarshal([]byte(existingScoreStr), &existingScore)
+		if score <= existingScore {
+			return false // Neuer Score nicht besser
+		}
+	}
+
+	// Score speichern
+	entry := game.LeaderboardEntry{
+		PlayerName: name,
+		PlayerCode: code,
+		Score:      score,
+		Timestamp:  time.Now().Unix(),
+	}
+
+	data, _ := json.Marshal(entry)
+	lb.rdb.HSet(lb.ctx, "leaderboard:players", code, string(data))
+
+	// In Sorted Set mit Score als Wert
+	lb.rdb.ZAdd(lb.ctx, leaderboardKey, redis.Z{
+		Score:  float64(score),
+		Member: code,
+	})
+
+	log.Printf("🏆 Leaderboard Update: %s mit %d Punkten", name, score)
+	return true
+}
+
+func (lb *Leaderboard) GetTop10() []game.LeaderboardEntry {
+	// Hole Top 10 (höchste Scores zuerst)
+	codes, err := lb.rdb.ZRevRange(lb.ctx, leaderboardKey, 0, 9).Result()
+	if err != nil {
+		log.Printf("⚠️ Fehler beim Abrufen des Leaderboards: %v", err)
+		return []game.LeaderboardEntry{}
+	}
+
+	entries := make([]game.LeaderboardEntry, 0)
+	for _, code := range codes {
+		dataStr, err := lb.rdb.HGet(lb.ctx, "leaderboard:players", code).Result()
+		if err != nil {
+			continue
+		}
+
+		var entry game.LeaderboardEntry
+		if err := json.Unmarshal([]byte(dataStr), &entry); err != nil {
+			continue
+		}
+		entries = append(entries, entry)
+	}
+
+	return entries
+}
--- a/pkg/server/room.go
+++ b/pkg/server/room.go
@@ -90,6 +90,18 @@ func NewRoom(id string, nc *nats.Conn, w *game.World) *Room {
 	r.SpawnNextChunk()
 	r.Colliders = r.World.GenerateColliders(r.ActiveChunks)

+	// DEBUG: Collider-Typen zählen
+	obstacleCount := 0
+	platformCount := 0
+	for _, c := range r.Colliders {
+		if c.Type == "obstacle" {
+			obstacleCount++
+		} else if c.Type == "platform" {
+			platformCount++
+		}
+	}
+	log.Printf("🔍 Initial Colliders: %d total (%d obstacles, %d platforms)", len(r.Colliders), obstacleCount, platformCount)
+
 	log.Printf("🎬 Raum %s gestartet mit %d Chunks", id, len(r.ActiveChunks))
 	for _, ac := range r.ActiveChunks {
 		log.Printf("   - Chunk '%s' bei X=%.0f", ac.ChunkID, ac.X)
@@ -269,13 +281,6 @@ func (r *Room) Update() {
 			continue
 		}

-		// Prüfe aktuelle Position auf Obstacles (falls reingesprungen)
-		currentHit, currentType := r.CheckCollision(p.X+r.pDrawOffX+r.pHitboxOffX, p.Y+r.pDrawOffY+r.pHitboxOffY, r.pW, r.pH)
-		if currentHit && currentType == "obstacle" {
-			r.KillPlayer(p)
-			continue
-		}
-
 		// X Bewegung
 		currentSpeed := config.RunSpeed + (p.InputX * 4.0)
 		nextX := p.X + currentSpeed
@@ -283,9 +288,12 @@ func (r *Room) Update() {
 		hitX, typeX := r.CheckCollision(nextX+r.pDrawOffX+r.pHitboxOffX, p.Y+r.pDrawOffY+r.pHitboxOffY, r.pW, r.pH)
 		if hitX {
 			if typeX == "obstacle" {
+				// Nicht blocken, sondern weiterlaufen und töten
+				p.X = nextX
 				r.KillPlayer(p)
 				continue
 			}
+			// Platform blockiert
 		} else {
 			p.X = nextX
 		}
@@ -313,9 +321,12 @@ func (r *Room) Update() {
 		hitY, typeY := r.CheckCollision(p.X+r.pDrawOffX+r.pHitboxOffX, nextY+r.pDrawOffY+r.pHitboxOffY, r.pW, r.pH)
 		if hitY {
 			if typeY == "obstacle" {
+				// Nicht blocken, sondern weiterlaufen und töten
+				p.Y = nextY
 				r.KillPlayer(p)
 				continue
 			}
+			// Platform blockiert
 			if p.VY > 0 {
 				p.OnGround = true
 			}
@@ -341,7 +352,21 @@ func (r *Room) Update() {
 	// 3. Map Management
 	r.UpdateMapLogic(maxX)

-	// 4. Host Check
+	// 4. Prüfen ob alle Spieler tot sind (GAMEOVER Check)
+	if r.Status == "RUNNING" {
+		aliveCount := 0
+		for _, p := range r.Players {
+			if p.IsAlive && !p.IsSpectator {
+				aliveCount++
+			}
+		}
+		if aliveCount == 0 && len(r.Players) > 0 {
+			log.Printf("🏁 Alle Spieler tot - Game Over!")
+			r.Status = "GAMEOVER"
+		}
+	}
+
+	// 5. Host Check
 	if _, ok := r.Players[r.HostID]; !ok && len(r.Players) > 0 {
 		for id := range r.Players {
 			r.HostID = id
@@ -354,16 +379,17 @@ func (r *Room) Update() {

 func (r *Room) CheckCollision(x, y, w, h float64) (bool, string) {
 	playerRect := game.Rect{OffsetX: x, OffsetY: y, W: w, H: h}
+
 	for _, c := range r.Colliders {
 		if game.CheckRectCollision(playerRect, c.Rect) {
-			if c.Type == "obstacle" {
-				log.Printf("🔴 OBSTACLE HIT! Player: (%.0f, %.0f, %.0f, %.0f), Obstacle: (%.0f, %.0f, %.0f, %.0f)",
-					playerRect.OffsetX, playerRect.OffsetY, playerRect.W, playerRect.H,
-					c.Rect.OffsetX, c.Rect.OffsetY, c.Rect.W, c.Rect.H)
-			}
+			log.Printf("🔴 COLLISION! Type=%s, Player: (%.1f, %.1f, %.1f x %.1f), Collider: (%.1f, %.1f, %.1f x %.1f)",
+				c.Type,
+				playerRect.OffsetX, playerRect.OffsetY, playerRect.W, playerRect.H,
+				c.Rect.OffsetX, c.Rect.OffsetY, c.Rect.W, c.Rect.H)
 			return true, c.Type
 		}
 	}
+
 	return false, ""
 }

@@ -375,7 +401,9 @@ func (r *Room) UpdateMapLogic(maxX float64) {
 	// Neue Chunks spawnen
 	if maxX > r.MapEndX-2000 {
 		r.SpawnNextChunk()
+		oldCount := len(r.Colliders)
 		r.Colliders = r.World.GenerateColliders(r.ActiveChunks)
+		log.Printf("🆕 Chunk gespawnt - Colliders: %d -> %d", oldCount, len(r.Colliders))
 	}

 	// Alte Chunks löschen