399 lines
9.6 KiB
Go
399 lines
9.6 KiB
Go
//go:build wasm
|
|
// +build wasm
|
|
|
|
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"log"
|
|
"syscall/js"
|
|
"time"
|
|
|
|
"git.zb-server.de/ZB-Server/EscapeFromTeacher/pkg/game"
|
|
)
|
|
|
|
// WebSocketMessage ist das Format für WebSocket-Nachrichten
|
|
type WebSocketMessage struct {
|
|
Type string `json:"type"`
|
|
Payload interface{} `json:"payload"`
|
|
}
|
|
|
|
// wsConn verwaltet die WebSocket-Verbindung im Browser
|
|
type wsConn struct {
|
|
ws js.Value
|
|
messagesChan chan []byte
|
|
connected bool
|
|
}
|
|
|
|
// disconnectFromServer trennt die bestehende WebSocket-Verbindung sauber
|
|
func (g *Game) disconnectFromServer() {
|
|
if g.wsConn != nil {
|
|
g.wsConn.ws.Call("close")
|
|
g.wsConn = nil
|
|
}
|
|
g.connected = false
|
|
}
|
|
|
|
// connectToServer verbindet sich über WebSocket mit dem Gateway
|
|
func (g *Game) connectToServer() {
|
|
// Automatisch die richtige WebSocket-URL basierend auf der aktuellen Domain
|
|
protocol := "ws:"
|
|
if js.Global().Get("location").Get("protocol").String() == "https:" {
|
|
protocol = "wss:"
|
|
}
|
|
host := js.Global().Get("location").Get("host").String()
|
|
serverURL := protocol + "//" + host + "/ws"
|
|
log.Printf("🔌 Verbinde zu WebSocket-Gateway: %s", serverURL)
|
|
|
|
ws := js.Global().Get("WebSocket").New(serverURL)
|
|
|
|
conn := &wsConn{
|
|
ws: ws,
|
|
messagesChan: make(chan []byte, 100),
|
|
connected: false,
|
|
}
|
|
|
|
// OnOpen Handler
|
|
ws.Call("addEventListener", "open", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
|
|
log.Println("✅ WebSocket verbunden!")
|
|
conn.connected = true
|
|
g.connected = true
|
|
return nil
|
|
}))
|
|
|
|
// OnMessage Handler
|
|
ws.Call("addEventListener", "message", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
|
|
if len(args) == 0 {
|
|
return nil
|
|
}
|
|
|
|
data := args[0].Get("data").String()
|
|
|
|
var msg WebSocketMessage
|
|
if err := json.Unmarshal([]byte(data), &msg); err != nil {
|
|
log.Printf("❌ Fehler beim Parsen der Nachricht: %v", err)
|
|
return nil
|
|
}
|
|
|
|
switch msg.Type {
|
|
case "game_update":
|
|
// GameState Update
|
|
payloadBytes, _ := json.Marshal(msg.Payload)
|
|
var state game.GameState
|
|
if err := json.Unmarshal(payloadBytes, &state); err == nil {
|
|
// Out-of-Order-Erkennung: Ignoriere alte Updates
|
|
if state.Sequence > 0 && state.Sequence <= g.lastRecvSeq {
|
|
// Alte Nachricht - ignorieren
|
|
g.outOfOrderCount++
|
|
return nil
|
|
}
|
|
g.lastRecvSeq = state.Sequence
|
|
g.totalUpdates++
|
|
g.lastUpdateTime = time.Now()
|
|
|
|
// Aktualisiere CurrentSpeed für Client-Prediction
|
|
g.predictionMutex.Lock()
|
|
g.currentSpeed = state.CurrentSpeed
|
|
g.predictionMutex.Unlock()
|
|
|
|
// Server Reconciliation für lokalen Spieler (VOR dem Lock)
|
|
for _, p := range state.Players {
|
|
if p.Name == g.playerName {
|
|
g.ReconcileWithServer(p)
|
|
break
|
|
}
|
|
}
|
|
|
|
g.stateMutex.Lock()
|
|
oldPlayerCount := len(g.gameState.Players)
|
|
g.gameState = state
|
|
newPlayerCount := len(g.gameState.Players)
|
|
g.stateMutex.Unlock()
|
|
|
|
// Lobby-UI aktualisieren wenn sich Spieleranzahl geändert hat
|
|
if oldPlayerCount != newPlayerCount {
|
|
g.sendLobbyUpdateToJS()
|
|
}
|
|
}
|
|
|
|
case "leaderboard_response":
|
|
// Leaderboard Response
|
|
payloadBytes, _ := json.Marshal(msg.Payload)
|
|
var resp game.LeaderboardResponse
|
|
if err := json.Unmarshal(payloadBytes, &resp); err == nil {
|
|
g.leaderboardMutex.Lock()
|
|
g.leaderboard = resp.Entries
|
|
g.leaderboardMutex.Unlock()
|
|
log.Printf("📊 Leaderboard empfangen: %d Einträge", len(resp.Entries))
|
|
|
|
// An JavaScript senden
|
|
g.sendLeaderboardToJS()
|
|
}
|
|
|
|
case "score_response":
|
|
// Score Submission Response mit Proof-Code
|
|
payloadBytes, _ := json.Marshal(msg.Payload)
|
|
var resp game.ScoreSubmissionResponse
|
|
if err := json.Unmarshal(payloadBytes, &resp); err == nil {
|
|
log.Printf("🎯 Proof-Code empfangen: %s für Score: %d", resp.ProofCode, resp.Score)
|
|
|
|
// Proof-Code an JavaScript senden
|
|
if saveFunc := js.Global().Get("saveHighscoreCode"); !saveFunc.IsUndefined() {
|
|
saveFunc.Invoke(resp.Score, resp.ProofCode, g.playerName)
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}))
|
|
|
|
// OnError Handler
|
|
ws.Call("addEventListener", "error", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
|
|
log.Println("❌ WebSocket Fehler!")
|
|
conn.connected = false
|
|
g.connected = false
|
|
return nil
|
|
}))
|
|
|
|
// OnClose Handler
|
|
ws.Call("addEventListener", "close", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
|
|
log.Println("🔌 WebSocket geschlossen")
|
|
conn.connected = false
|
|
g.connected = false
|
|
return nil
|
|
}))
|
|
|
|
// Warte bis Verbindung hergestellt ist
|
|
for i := 0; i < 50; i++ {
|
|
if conn.connected {
|
|
break
|
|
}
|
|
time.Sleep(100 * time.Millisecond)
|
|
}
|
|
|
|
if !conn.connected {
|
|
log.Println("❌ WebSocket-Verbindung Timeout")
|
|
return
|
|
}
|
|
|
|
// WebSocket-Wrapper speichern
|
|
g.wsConn = conn
|
|
|
|
// JOIN senden
|
|
joinMsg := WebSocketMessage{
|
|
Type: "join",
|
|
Payload: game.JoinRequest{
|
|
Name: g.playerName,
|
|
RoomID: g.roomID,
|
|
GameMode: g.gameMode,
|
|
IsHost: g.isHost,
|
|
TeamName: g.teamName,
|
|
PlayerCode: g.playerCode,
|
|
},
|
|
}
|
|
g.sendWebSocketMessage(joinMsg)
|
|
|
|
log.Printf("➡️ JOIN gesendet über WebSocket: Name=%s, RoomID=%s, PlayerCode=%s", g.playerName, g.roomID, g.playerCode)
|
|
}
|
|
|
|
// sendWebSocketMessage sendet eine Nachricht über WebSocket
|
|
func (g *Game) sendWebSocketMessage(msg WebSocketMessage) {
|
|
if g.wsConn == nil || !g.wsConn.connected {
|
|
log.Println("⚠️ WebSocket nicht verbunden")
|
|
return
|
|
}
|
|
|
|
data, err := json.Marshal(msg)
|
|
if err != nil {
|
|
log.Printf("❌ Fehler beim Marshallen: %v", err)
|
|
return
|
|
}
|
|
|
|
g.wsConn.ws.Call("send", string(data))
|
|
}
|
|
|
|
// sendInput sendet einen Input über WebSocket
|
|
func (g *Game) sendInput(input game.ClientInput) {
|
|
msg := WebSocketMessage{
|
|
Type: "input",
|
|
Payload: input,
|
|
}
|
|
g.sendWebSocketMessage(msg)
|
|
}
|
|
|
|
// startGame sendet den Start-Befehl über WebSocket
|
|
func (g *Game) startGame() {
|
|
// PlayerID ist der playerName (Server verwendet req.Name als PlayerID)
|
|
myID := g.playerName
|
|
msg := WebSocketMessage{
|
|
Type: "start",
|
|
Payload: game.StartRequest{
|
|
RoomID: g.roomID,
|
|
PlayerID: myID,
|
|
},
|
|
}
|
|
g.sendWebSocketMessage(msg)
|
|
log.Printf("▶️ START gesendet über WebSocket: RoomID=%s, PlayerID=%s", g.roomID, myID)
|
|
}
|
|
|
|
// connectForLeaderboard verbindet für Leaderboard-Abfrage
|
|
func (g *Game) connectForLeaderboard() {
|
|
if g.wsConn != nil && g.wsConn.connected {
|
|
// Bereits verbunden
|
|
g.requestLeaderboard()
|
|
return
|
|
}
|
|
|
|
// Temporäre Daten für Leaderboard-Verbindung
|
|
if g.playerName == "" {
|
|
g.playerName = "LeaderboardViewer"
|
|
}
|
|
if g.roomID == "" {
|
|
g.roomID = "leaderboard_only"
|
|
}
|
|
if g.gameMode == "" {
|
|
g.gameMode = "solo"
|
|
}
|
|
|
|
// Neue Verbindung aufbauen
|
|
g.connectToServer()
|
|
|
|
// Kurz warten und dann Leaderboard anfragen
|
|
time.Sleep(500 * time.Millisecond)
|
|
g.requestLeaderboard()
|
|
}
|
|
|
|
// requestLeaderboard fordert das Leaderboard an
|
|
func (g *Game) requestLeaderboard() {
|
|
// Verbindung aufbauen falls nicht vorhanden
|
|
if g.wsConn == nil || !g.wsConn.connected {
|
|
log.Println("📡 Keine Verbindung für Leaderboard, stelle Verbindung her...")
|
|
go g.connectForLeaderboard()
|
|
return
|
|
}
|
|
|
|
mode := "solo"
|
|
if g.gameMode == "coop" {
|
|
mode = "coop"
|
|
}
|
|
|
|
msg := WebSocketMessage{
|
|
Type: "leaderboard_request",
|
|
Payload: game.LeaderboardRequest{
|
|
Mode: mode,
|
|
},
|
|
}
|
|
g.sendWebSocketMessage(msg)
|
|
log.Printf("🏆 Leaderboard-Request gesendet: Mode=%s", mode)
|
|
}
|
|
|
|
// submitScore sendet den Score ans Leaderboard
|
|
func (g *Game) submitScore() {
|
|
if g.scoreSubmitted {
|
|
return
|
|
}
|
|
|
|
g.stateMutex.Lock()
|
|
score := 0
|
|
for _, p := range g.gameState.Players {
|
|
if p.Name == g.playerName {
|
|
score = p.Score
|
|
break
|
|
}
|
|
}
|
|
g.stateMutex.Unlock()
|
|
|
|
if score == 0 {
|
|
log.Println("⚠️ Score ist 0, überspringe Submission")
|
|
return
|
|
}
|
|
|
|
name := g.playerName
|
|
if g.gameMode == "coop" && g.teamName != "" {
|
|
name = g.teamName
|
|
}
|
|
|
|
// Verwende Team-Name für Coop-Mode, sonst Player-Name
|
|
displayName := name
|
|
teamName := ""
|
|
playerCodeToUse := g.playerCode
|
|
|
|
if g.gameMode == "coop" {
|
|
g.stateMutex.Lock()
|
|
teamName = g.gameState.TeamName
|
|
hostPlayerCode := g.gameState.HostPlayerCode
|
|
g.stateMutex.Unlock()
|
|
|
|
if teamName != "" {
|
|
displayName = teamName
|
|
}
|
|
|
|
// In Coop: Verwende Host's PlayerCode für Score
|
|
if hostPlayerCode != "" {
|
|
playerCodeToUse = hostPlayerCode
|
|
log.Printf("🔑 Coop-Mode: Verwende Host PlayerCode für Score-Submission")
|
|
}
|
|
}
|
|
|
|
msg := WebSocketMessage{
|
|
Type: "score_submit",
|
|
Payload: game.ScoreSubmission{
|
|
PlayerName: displayName,
|
|
PlayerCode: playerCodeToUse,
|
|
Name: displayName, // Für Kompatibilität
|
|
Score: score,
|
|
Mode: g.gameMode,
|
|
TeamName: teamName, // Team-Name für Coop
|
|
},
|
|
}
|
|
g.sendWebSocketMessage(msg)
|
|
|
|
g.scoreSubmitted = true
|
|
log.Printf("📊 Score submitted: %s = %d (PlayerCode: %s, TeamName: %s)", displayName, score, playerCodeToUse, teamName)
|
|
}
|
|
|
|
// Dummy-Funktionen für Kompatibilität mit anderen Teilen des Codes
|
|
func (g *Game) sendJoinRequest() {
|
|
// Wird in connectToServer aufgerufen
|
|
}
|
|
|
|
func (g *Game) sendStartRequest() {
|
|
// Warte bis WebSocket verbunden ist
|
|
for i := 0; i < 30; i++ {
|
|
if g.connected && g.wsConn != nil && g.wsConn.connected {
|
|
break
|
|
}
|
|
time.Sleep(100 * time.Millisecond)
|
|
}
|
|
|
|
if !g.connected {
|
|
log.Println("❌ Kann START nicht senden - keine Verbindung")
|
|
return
|
|
}
|
|
|
|
g.startGame()
|
|
}
|
|
|
|
func (g *Game) publishInput(input game.ClientInput) {
|
|
g.sendInput(input)
|
|
}
|
|
|
|
// sendSetTeamNameInput sendet SET_TEAM_NAME Input über WebSocket
|
|
func (g *Game) sendSetTeamNameInput(teamName string) {
|
|
if !g.connected {
|
|
log.Println("❌ Kann Team-Name nicht senden - keine Verbindung")
|
|
return
|
|
}
|
|
|
|
myID := g.getMyPlayerID()
|
|
input := game.ClientInput{
|
|
Type: "SET_TEAM_NAME",
|
|
RoomID: g.roomID,
|
|
PlayerID: myID,
|
|
TeamName: teamName,
|
|
}
|
|
|
|
g.sendInput(input)
|
|
log.Printf("🏷️ SET_TEAM_NAME gesendet: '%s'", teamName)
|
|
}
|