955 lines
29 KiB
Go
955 lines
29 KiB
Go
package main
|
||
|
||
import (
|
||
"fmt"
|
||
"image/color"
|
||
"log"
|
||
"math"
|
||
"math/rand"
|
||
"time"
|
||
|
||
"github.com/hajimehoshi/ebiten/v2"
|
||
"github.com/hajimehoshi/ebiten/v2/inpututil"
|
||
"github.com/hajimehoshi/ebiten/v2/text"
|
||
"github.com/hajimehoshi/ebiten/v2/vector"
|
||
"golang.org/x/image/font/basicfont"
|
||
|
||
"git.zb-server.de/ZB-Server/EscapeFromTeacher/pkg/game"
|
||
)
|
||
|
||
// --- KONSTANTEN ---
|
||
|
||
const (
|
||
physicsStep = 50 * time.Millisecond // Server-Physics-Rate (20 TPS)
|
||
jumpBufferFrames = 6 // Sprung-Buffer: ~300ms bei 20 TPS
|
||
coyoteTimeFrames = 4 // Coyote Time: ~200ms bei 20 TPS
|
||
inputCap = 60 // Max unbestätigte Inputs (~3s bei 20 TPS)
|
||
|
||
joystickDeadzone = 0.15 // Minimale Joystick-Auslenkung
|
||
joyDownThreshold = 0.5 // Joystick-Down-Schwellenwert (Anteil am Radius)
|
||
correctionDecay = 0.85 // Visueller Korrektur-Decay pro Frame
|
||
|
||
// Touch-Control Größen (relativ zur kleineren Screendimension)
|
||
joyRadiusScale = 0.13 // Joystick-Außenring
|
||
joyKnobRatio = 0.48 // Knob ~halb so groß wie Ring
|
||
jumpBtnScale = 0.11 // Sprung-Button
|
||
downBtnScale = 0.08 // Down-Button
|
||
|
||
// Touch-Control Positionen (X als Anteil der Canvas-Breite)
|
||
joyDefaultXRatio = 0.18
|
||
jumpBtnXRatio = 0.82
|
||
downBtnXRatio = 0.62
|
||
|
||
// Culling-Puffer: Objekte die ±800px außerhalb des Canvas liegen werden übersprungen
|
||
cullingBuffer = 800.0
|
||
)
|
||
|
||
// --- RENDER SNAPSHOT ---
|
||
|
||
// renderSnapshot hält eine Momentaufnahme aller für DrawGame benötigten Daten.
|
||
// Beide Mutexe werden kurz gehalten, um den Snapshot zu befüllen, und dann
|
||
// sofort freigegeben – so gibt es keine Lock-Verschachtelung beim Zeichnen.
|
||
type renderSnapshot struct {
|
||
// Canvas
|
||
canvasW, canvasH int
|
||
viewScale float64
|
||
|
||
// Lokaler Spieler
|
||
isDead bool
|
||
myScore int
|
||
|
||
// Spielzustand (aus stateMutex)
|
||
status string
|
||
timeLeft int
|
||
difficultyFactor float64
|
||
chunks []game.ActiveChunk
|
||
movingPlatforms []game.MovingPlatformSync
|
||
collectedCoins map[string]bool
|
||
collectedPowerups map[string]bool
|
||
players map[string]game.PlayerState
|
||
|
||
// Powerup Timer HUD
|
||
myHasDoubleJump bool
|
||
myDoubleJumpRemaining float64
|
||
myDoubleJumpUsed bool
|
||
myHasGodMode bool
|
||
myGodModeRemaining float64
|
||
myHasMagnet bool
|
||
myMagnetRemaining float64
|
||
|
||
// Client-Prediction (aus predictionMutex)
|
||
prevPredX, prevPredY float64
|
||
predX, predY float64
|
||
offsetX, offsetY float64
|
||
physicsTime time.Time
|
||
}
|
||
|
||
// takeRenderSnapshot liest alle benötigten Daten unter den jeweiligen Mutexen
|
||
// und gibt einen lock-freien Snapshot zurück.
|
||
func (g *Game) takeRenderSnapshot(screen *ebiten.Image) renderSnapshot {
|
||
canvasW, canvasH := screen.Size()
|
||
snap := renderSnapshot{
|
||
canvasW: canvasW,
|
||
canvasH: canvasH,
|
||
viewScale: GetScaleFromHeight(canvasH),
|
||
}
|
||
|
||
// Prediction-Daten (kurzer Lock)
|
||
g.predictionMutex.Lock()
|
||
snap.prevPredX = g.prevPredictedX
|
||
snap.prevPredY = g.prevPredictedY
|
||
snap.predX = g.predictedX
|
||
snap.predY = g.predictedY
|
||
snap.offsetX = g.correctionOffsetX
|
||
snap.offsetY = g.correctionOffsetY
|
||
snap.physicsTime = g.lastPhysicsTime
|
||
g.predictionMutex.Unlock()
|
||
|
||
// Spielzustand (kurzer Lock)
|
||
g.stateMutex.Lock()
|
||
snap.status = g.gameState.Status
|
||
snap.timeLeft = g.gameState.TimeLeft
|
||
snap.difficultyFactor = g.gameState.DifficultyFactor
|
||
snap.chunks = g.gameState.WorldChunks
|
||
snap.movingPlatforms = g.gameState.MovingPlatforms
|
||
snap.collectedCoins = g.gameState.CollectedCoins
|
||
snap.collectedPowerups = g.gameState.CollectedPowerups
|
||
snap.players = g.gameState.Players
|
||
for _, p := range g.gameState.Players {
|
||
if p.Name == g.playerName {
|
||
snap.isDead = !p.IsAlive || p.IsSpectator
|
||
snap.myScore = p.Score
|
||
snap.myHasDoubleJump = p.HasDoubleJump
|
||
snap.myDoubleJumpRemaining = p.DoubleJumpRemainingSeconds
|
||
snap.myDoubleJumpUsed = p.DoubleJumpUsed
|
||
snap.myHasGodMode = p.HasGodMode
|
||
snap.myGodModeRemaining = p.GodModeRemainingSeconds
|
||
snap.myHasMagnet = p.HasMagnet
|
||
snap.myMagnetRemaining = p.MagnetRemainingSeconds
|
||
break
|
||
}
|
||
}
|
||
g.stateMutex.Unlock()
|
||
|
||
return snap
|
||
}
|
||
|
||
// --- INPUT & UPDATE LOGIC ---
|
||
|
||
func (g *Game) UpdateGame() {
|
||
// --- 1. MUTE TOGGLE ---
|
||
if inpututil.IsKeyJustPressed(ebiten.KeyM) {
|
||
g.audio.ToggleMute()
|
||
}
|
||
|
||
// --- 2. KEYBOARD INPUT ---
|
||
keyLeft := ebiten.IsKeyPressed(ebiten.KeyA) || ebiten.IsKeyPressed(ebiten.KeyLeft)
|
||
keyRight := ebiten.IsKeyPressed(ebiten.KeyD) || ebiten.IsKeyPressed(ebiten.KeyRight)
|
||
keyDown := inpututil.IsKeyJustPressed(ebiten.KeyS) || inpututil.IsKeyJustPressed(ebiten.KeyDown)
|
||
keyJump := inpututil.IsKeyJustPressed(ebiten.KeySpace) || inpututil.IsKeyJustPressed(ebiten.KeyW) || inpututil.IsKeyJustPressed(ebiten.KeyUp)
|
||
|
||
if keyLeft || keyRight || keyDown || keyJump {
|
||
g.keyboardUsed = true
|
||
}
|
||
|
||
// --- 3. TOUCH INPUT HANDLING ---
|
||
g.handleTouchInput()
|
||
|
||
// --- 4. JOYSTICK RICHTUNG BERECHNEN ---
|
||
joyDir := 0.0
|
||
if g.joyActive {
|
||
maxDist := g.joyRadius
|
||
if maxDist == 0 {
|
||
maxDist = 60.0
|
||
}
|
||
joyDir = (g.joyStickX - g.joyBaseX) / maxDist
|
||
if joyDir < -1.0 {
|
||
joyDir = -1.0
|
||
} else if joyDir > 1.0 {
|
||
joyDir = 1.0
|
||
}
|
||
if joyDir > -joystickDeadzone && joyDir < joystickDeadzone {
|
||
joyDir = 0
|
||
}
|
||
}
|
||
|
||
isJoyDown := g.joyActive && (g.joyStickY-g.joyBaseY) > g.joyRadius*joyDownThreshold
|
||
|
||
wantsJump := keyJump || g.btnJumpActive
|
||
g.btnJumpActive = false
|
||
g.btnDownActive = false
|
||
|
||
// Jump Buffer: Sprung-Wunsch für bis zu jumpBufferFrames speichern
|
||
if wantsJump {
|
||
g.jumpBufferFrames = jumpBufferFrames
|
||
}
|
||
|
||
// --- 5. INPUT SENDEN (MIT CLIENT PREDICTION, 20 TPS) ---
|
||
if g.connected && time.Since(g.lastInputTime) >= physicsStep {
|
||
g.lastInputTime = time.Now()
|
||
|
||
g.predictionMutex.Lock()
|
||
wasOnGround := g.predictedGround
|
||
g.predictionMutex.Unlock()
|
||
|
||
if g.coyoteFrames > 0 {
|
||
g.coyoteFrames--
|
||
}
|
||
if g.jumpBufferFrames > 0 {
|
||
g.jumpBufferFrames--
|
||
}
|
||
|
||
g.predictionMutex.Lock()
|
||
onGround := g.predictedGround
|
||
g.predictionMutex.Unlock()
|
||
|
||
if wasOnGround && !onGround {
|
||
g.coyoteFrames = coyoteTimeFrames
|
||
}
|
||
|
||
effectiveJump := wantsJump ||
|
||
(g.jumpBufferFrames > 0 && onGround) ||
|
||
(wantsJump && g.coyoteFrames > 0)
|
||
|
||
if effectiveJump {
|
||
g.jumpBufferFrames = 0
|
||
}
|
||
|
||
input := InputState{
|
||
Sequence: g.inputSequence,
|
||
Left: keyLeft || joyDir < -0.1,
|
||
Right: keyRight || joyDir > 0.1,
|
||
Jump: effectiveJump,
|
||
Down: keyDown || isJoyDown,
|
||
JoyX: joyDir,
|
||
}
|
||
|
||
g.predictionMutex.Lock()
|
||
g.prevPredictedX = g.predictedX
|
||
g.prevPredictedY = g.predictedY
|
||
g.lastPhysicsTime = time.Now()
|
||
g.inputSequence++
|
||
input.Sequence = g.inputSequence
|
||
g.ApplyInput(input)
|
||
g.pendingInputs[input.Sequence] = input
|
||
|
||
if len(g.pendingInputs) > inputCap {
|
||
oldest := g.inputSequence - inputCap
|
||
for seq := range g.pendingInputs {
|
||
if seq < oldest {
|
||
delete(g.pendingInputs, seq)
|
||
}
|
||
}
|
||
}
|
||
g.predictionMutex.Unlock()
|
||
|
||
g.SendInputWithSequence(input)
|
||
|
||
// Trail: store predicted position every physics step
|
||
g.trail = append(g.trail, trailPoint{X: g.predictedX, Y: g.predictedY})
|
||
if len(g.trail) > 8 {
|
||
g.trail = g.trail[1:]
|
||
}
|
||
}
|
||
|
||
// --- 6. KAMERA LOGIK (mit Smoothing) ---
|
||
g.stateMutex.Lock()
|
||
targetCam := g.gameState.ScrollX
|
||
g.stateMutex.Unlock()
|
||
|
||
if targetCam < 0 {
|
||
targetCam = 0
|
||
}
|
||
g.camX += (targetCam - g.camX) * 0.2
|
||
|
||
// --- 7. CORRECTION OFFSET ABKLINGEN ---
|
||
g.predictionMutex.Lock()
|
||
g.correctionOffsetX *= correctionDecay
|
||
g.correctionOffsetY *= correctionDecay
|
||
if g.correctionOffsetX*g.correctionOffsetX < 0.09 {
|
||
g.correctionOffsetX = 0
|
||
}
|
||
if g.correctionOffsetY*g.correctionOffsetY < 0.09 {
|
||
g.correctionOffsetY = 0
|
||
}
|
||
g.predictionMutex.Unlock()
|
||
|
||
// --- 8. PARTIKEL ---
|
||
g.UpdateParticles(1.0 / 60.0)
|
||
g.DetectAndSpawnParticles()
|
||
}
|
||
|
||
// handleTouchInput verarbeitet Touch-Eingaben für Joystick und Buttons.
|
||
func (g *Game) handleTouchInput() {
|
||
touches := ebiten.TouchIDs()
|
||
|
||
halfW := float64(g.lastCanvasWidth) * 0.55
|
||
if halfW == 0 {
|
||
halfW = float64(ScreenWidth) * 0.55
|
||
}
|
||
|
||
joyRadius := g.joyRadius
|
||
if joyRadius == 0 {
|
||
joyRadius = 60.0
|
||
}
|
||
|
||
justPressed := inpututil.JustPressedTouchIDs()
|
||
isJustPressed := func(id ebiten.TouchID) bool {
|
||
for _, j := range justPressed {
|
||
if id == j {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
if len(touches) == 0 {
|
||
g.joyActive = false
|
||
g.btnJumpPressed = false
|
||
g.joyStickX = g.joyBaseX
|
||
g.joyStickY = g.joyBaseY
|
||
return
|
||
}
|
||
|
||
joyFound := false
|
||
|
||
for _, id := range touches {
|
||
x, y := ebiten.TouchPosition(id)
|
||
fx, fy := float64(x), float64(y)
|
||
|
||
if fx >= halfW {
|
||
// ── RECHTE SEITE: Jump und Down ──────────────────────────────────────
|
||
g.btnJumpPressed = true
|
||
|
||
if isJustPressed(id) {
|
||
if g.downBtnR > 0 {
|
||
dx := fx - g.downBtnX
|
||
dy := fy - g.downBtnY
|
||
if dx*dx+dy*dy < g.downBtnR*g.downBtnR*1.5 {
|
||
g.btnDownActive = true
|
||
continue
|
||
}
|
||
}
|
||
g.btnJumpActive = true
|
||
}
|
||
continue
|
||
}
|
||
|
||
// ── LINKE SEITE: Floating Joystick ───────────────────────────────────
|
||
if !g.joyActive {
|
||
g.joyActive = true
|
||
g.joyTouchID = id
|
||
g.joyBaseX = fx
|
||
g.joyBaseY = fy
|
||
g.joyStickX = fx
|
||
g.joyStickY = fy
|
||
}
|
||
|
||
if g.joyActive && id == g.joyTouchID {
|
||
joyFound = true
|
||
dx := fx - g.joyBaseX
|
||
dy := fy - g.joyBaseY
|
||
dist := math.Sqrt(dx*dx + dy*dy)
|
||
if dist > joyRadius {
|
||
scale := joyRadius / dist
|
||
dx *= scale
|
||
dy *= scale
|
||
}
|
||
g.joyStickX = g.joyBaseX + dx
|
||
g.joyStickY = g.joyBaseY + dy
|
||
}
|
||
}
|
||
|
||
if !joyFound {
|
||
g.joyActive = false
|
||
g.btnJumpPressed = false
|
||
g.joyStickX = g.joyBaseX
|
||
g.joyStickY = g.joyBaseY
|
||
}
|
||
}
|
||
|
||
// --- RENDERING LOGIC ---
|
||
|
||
// DrawGame ist der zentrale Render-Einstiegspunkt für den Spielzustand.
|
||
// Es nimmt einen lock-freien Snapshot aller benötigten Daten und delegiert
|
||
// das Zeichnen an spezialisierte Sub-Funktionen.
|
||
func (g *Game) DrawGame(screen *ebiten.Image) {
|
||
// GAMEOVER wird separat behandelt und beendet die Funktion früh.
|
||
g.stateMutex.Lock()
|
||
status := g.gameState.Status
|
||
g.stateMutex.Unlock()
|
||
|
||
if status == "GAMEOVER" {
|
||
g.drawGameOver(screen)
|
||
return
|
||
}
|
||
|
||
snap := g.takeRenderSnapshot(screen)
|
||
|
||
// Screen Shake: draw to offscreen buffer when active
|
||
target := screen
|
||
if g.shakeFrames > 0 {
|
||
w, h := screen.Size()
|
||
if g.shakeBuffer == nil {
|
||
g.shakeBuffer = ebiten.NewImage(w, h)
|
||
} else if bw, bh := g.shakeBuffer.Size(); bw != w || bh != h {
|
||
g.shakeBuffer = ebiten.NewImage(w, h)
|
||
}
|
||
g.shakeBuffer.Clear()
|
||
target = g.shakeBuffer
|
||
g.shakeFrames--
|
||
}
|
||
|
||
g.drawBackground(target, snap)
|
||
g.RenderGround(target, g.camX, snap.viewScale)
|
||
g.drawTeacher(target, snap)
|
||
g.drawWorldObjects(target, snap)
|
||
g.drawPlayers(target, snap)
|
||
g.drawStatusUI(target, snap)
|
||
g.drawDeathZoneLine(target, snap.canvasH)
|
||
g.RenderParticles(target)
|
||
|
||
if g.showDebug {
|
||
g.drawDebugOverlay(target)
|
||
}
|
||
if !g.keyboardUsed {
|
||
g.drawTouchControls(target)
|
||
}
|
||
|
||
// Blit shakeBuffer to screen with random offset
|
||
if target != screen {
|
||
ox := (rand.Float64()*2 - 1) * g.shakeIntensity
|
||
oy := (rand.Float64()*2 - 1) * g.shakeIntensity
|
||
if g.shakeFrames == 0 {
|
||
g.shakeIntensity = 0
|
||
}
|
||
op := &ebiten.DrawImageOptions{}
|
||
op.GeoM.Translate(ox, oy)
|
||
screen.DrawImage(g.shakeBuffer, op)
|
||
}
|
||
}
|
||
|
||
// drawGameOver behandelt den GAMEOVER-Bildschirm inkl. Score-Übermittlung.
|
||
func (g *Game) drawGameOver(screen *ebiten.Image) {
|
||
g.stateMutex.Lock()
|
||
myScore := 0
|
||
for _, p := range g.gameState.Players {
|
||
if p.Name == g.playerName {
|
||
myScore = p.Score
|
||
break
|
||
}
|
||
}
|
||
g.stateMutex.Unlock()
|
||
|
||
if !g.scoreSubmitted {
|
||
g.submitScore()
|
||
g.sendGameOverToJS(myScore)
|
||
}
|
||
|
||
g.drawGameOverScreen(screen, myScore)
|
||
}
|
||
|
||
// drawBackground zeichnet das Hintergrundbild (wechselt nach Score).
|
||
func (g *Game) drawBackground(screen *ebiten.Image, snap renderSnapshot) {
|
||
bgID := "background"
|
||
if snap.myScore >= 10000 {
|
||
bgID = "background2"
|
||
} else if snap.myScore >= 5000 {
|
||
bgID = "background1"
|
||
}
|
||
|
||
bgImg, exists := g.assetsImages[bgID]
|
||
if !exists || bgImg == nil {
|
||
screen.Fill(ColSky)
|
||
return
|
||
}
|
||
|
||
bgW, bgH := bgImg.Size()
|
||
scaleX := float64(snap.canvasW) / float64(bgW)
|
||
scaleY := float64(snap.canvasH) / float64(bgH)
|
||
scale := math.Max(scaleX, scaleY)
|
||
|
||
op := &ebiten.DrawImageOptions{}
|
||
op.GeoM.Scale(scale, scale)
|
||
op.GeoM.Translate(
|
||
(float64(snap.canvasW)-float64(bgW)*scale)/2,
|
||
(float64(snap.canvasH)-float64(bgH)*scale)/2,
|
||
)
|
||
screen.DrawImage(bgImg, op)
|
||
}
|
||
|
||
// drawWorldObjects zeichnet Chunk-Objekte und bewegende Plattformen.
|
||
func (g *Game) drawWorldObjects(screen *ebiten.Image, snap renderSnapshot) {
|
||
for _, activeChunk := range snap.chunks {
|
||
chunkDef, exists := g.world.ChunkLibrary[activeChunk.ChunkID]
|
||
if !exists {
|
||
log.Printf("⚠️ Chunk '%s' nicht in Library gefunden!", activeChunk.ChunkID)
|
||
continue
|
||
}
|
||
for objIdx, obj := range chunkDef.Objects {
|
||
if obj.MovingPlatform != nil {
|
||
continue // Bewegende Plattformen separat gerendert
|
||
}
|
||
if assetDef, ok := g.world.Manifest.Assets[obj.AssetID]; ok {
|
||
key := fmt.Sprintf("%s_%d", activeChunk.ChunkID, objIdx)
|
||
if assetDef.Type == "coin" && snap.collectedCoins[key] {
|
||
continue
|
||
}
|
||
if assetDef.Type == "powerup" && snap.collectedPowerups[key] {
|
||
continue
|
||
}
|
||
}
|
||
g.DrawAsset(screen, obj.AssetID, activeChunk.X+obj.X, WorldToScreenYWithHeight(obj.Y, snap.canvasH))
|
||
}
|
||
}
|
||
|
||
for _, mp := range snap.movingPlatforms {
|
||
g.DrawAsset(screen, mp.AssetID, mp.X, WorldToScreenYWithHeight(mp.Y, snap.canvasH))
|
||
}
|
||
|
||
// Debug: Boden-Collider visualisieren (GRÜN)
|
||
if g.showDebug {
|
||
vector.StrokeRect(screen,
|
||
float32(-g.camX*snap.viewScale), float32(WorldToScreenYWithHeight(540, snap.canvasH)),
|
||
10000, 5000, 2, color.RGBA{0, 255, 0, 255}, false)
|
||
}
|
||
}
|
||
|
||
// drawPlayers zeichnet alle Spieler mit Sprites, Nametags und optionalen Hitboxen.
|
||
func (g *Game) drawPlayers(screen *ebiten.Image, snap renderSnapshot) {
|
||
for id, p := range snap.players {
|
||
posX, posY := p.X, p.Y
|
||
|
||
if p.Name == g.playerName {
|
||
// Lokaler Spieler: Interpolation zwischen Physics-Steps (20 TPS → 60 fps)
|
||
alpha := float64(time.Since(snap.physicsTime)) / float64(physicsStep)
|
||
if alpha > 1 {
|
||
alpha = 1
|
||
}
|
||
posX = snap.prevPredX + (snap.predX-snap.prevPredX)*alpha + snap.offsetX
|
||
posY = snap.prevPredY + (snap.predY-snap.prevPredY)*alpha + snap.offsetY
|
||
}
|
||
|
||
sprite := g.selectPlayerSprite(p.OnGround, p.VY)
|
||
screenY := WorldToScreenYWithHeight(posY, snap.canvasH)
|
||
|
||
if p.Name == g.playerName && len(g.trail) > 1 {
|
||
for i, tp := range g.trail {
|
||
ratio := float32(i+1) / float32(len(g.trail))
|
||
alpha := uint8(ratio * 80)
|
||
r := float32(8 * ratio)
|
||
tx := float32((tp.X - g.camX) * snap.viewScale)
|
||
ty := float32(WorldToScreenYWithHeight(tp.Y, snap.canvasH))
|
||
vector.DrawFilledCircle(screen, tx, ty, r, color.RGBA{200, 220, 255, alpha}, false)
|
||
}
|
||
}
|
||
|
||
g.DrawAsset(screen, sprite, posX, screenY)
|
||
|
||
name := p.Name
|
||
if name == "" {
|
||
name = id
|
||
}
|
||
text.Draw(screen, name, basicfont.Face7x13, int((posX-g.camX)*snap.viewScale), int(screenY-25), ColText)
|
||
|
||
if g.showDebug {
|
||
g.drawPlayerHitbox(screen, posX, screenY, snap.viewScale)
|
||
}
|
||
}
|
||
}
|
||
|
||
// selectPlayerSprite gibt den Sprite-Namen basierend auf dem Bewegungszustand zurück.
|
||
func (g *Game) selectPlayerSprite(onGround bool, vy float64) string {
|
||
if onGround || (vy >= -3.0 && vy <= 3.0) {
|
||
return "player"
|
||
}
|
||
if vy < -5.0 {
|
||
return "jump0" // Springt nach oben
|
||
}
|
||
return "jump1" // Fällt oder höchster Punkt
|
||
}
|
||
|
||
// drawPlayerHitbox visualisiert die Spieler-Hitbox im Debug-Modus.
|
||
func (g *Game) drawPlayerHitbox(screen *ebiten.Image, posX, screenY, viewScale float64) {
|
||
def, ok := g.world.Manifest.Assets["player"]
|
||
if !ok {
|
||
return
|
||
}
|
||
hx := float32((posX + def.DrawOffX + def.Hitbox.OffsetX - g.camX) * viewScale)
|
||
hy := float32(screenY + def.DrawOffY + def.Hitbox.OffsetY)
|
||
vector.StrokeRect(screen, hx, hy, float32(def.Hitbox.W), float32(def.Hitbox.H), 3, color.RGBA{255, 0, 0, 255}, false)
|
||
vector.DrawFilledCircle(screen, float32((posX-g.camX)*viewScale), float32(screenY), 5, color.RGBA{255, 255, 0, 255}, false)
|
||
}
|
||
|
||
// drawStatusUI zeichnet das spielzustandsabhängige UI (Countdown, Score, Spectator).
|
||
func (g *Game) drawStatusUI(screen *ebiten.Image, snap renderSnapshot) {
|
||
switch snap.status {
|
||
case "COUNTDOWN":
|
||
msg := fmt.Sprintf("GO IN: %d", snap.timeLeft)
|
||
text.Draw(screen, msg, basicfont.Face7x13, snap.canvasW/2-40, snap.canvasH/2, color.RGBA{255, 255, 0, 255})
|
||
case "RUNNING":
|
||
g.drawPowerupHUD(screen, snap)
|
||
g.drawDangerOverlay(screen, snap)
|
||
g.drawScoreBox(screen, snap)
|
||
if snap.isDead {
|
||
g.drawSpectatorOverlay(screen, snap)
|
||
}
|
||
}
|
||
}
|
||
|
||
// drawDangerOverlay zeichnet einen roten Bildschirmrand wenn DifficultyFactor > 0.5.
|
||
func (g *Game) drawDangerOverlay(screen *ebiten.Image, snap renderSnapshot) {
|
||
if snap.difficultyFactor <= 0.5 {
|
||
return
|
||
}
|
||
alpha := uint8((snap.difficultyFactor - 0.5) * 2.0 * 60)
|
||
col := color.RGBA{200, 0, 0, alpha}
|
||
w, h := float32(snap.canvasW), float32(snap.canvasH)
|
||
bw := float32(8)
|
||
vector.DrawFilledRect(screen, 0, 0, w, bw, col, false)
|
||
vector.DrawFilledRect(screen, 0, h-bw, w, bw, col, false)
|
||
vector.DrawFilledRect(screen, 0, 0, bw, h, col, false)
|
||
vector.DrawFilledRect(screen, w-bw, 0, bw, h, col, false)
|
||
}
|
||
|
||
// drawScoreBox zeichnet die Distanz- und Score-Anzeige oben rechts.
|
||
func (g *Game) drawScoreBox(screen *ebiten.Image, snap renderSnapshot) {
|
||
dist := fmt.Sprintf("Distance: %.0f m", g.camX/64.0)
|
||
scoreStr := fmt.Sprintf("Score: %d", snap.myScore)
|
||
|
||
maxWidth := len(dist) * 7
|
||
if sw := len(scoreStr) * 7; sw > maxWidth {
|
||
maxWidth = sw
|
||
}
|
||
|
||
boxW := float32(maxWidth + 20)
|
||
boxH := float32(50)
|
||
boxX := float32(snap.canvasW) - boxW - 10
|
||
boxY := float32(10)
|
||
|
||
vector.DrawFilledRect(screen, boxX, boxY, boxW, boxH, color.RGBA{60, 60, 60, 200}, false)
|
||
vector.StrokeRect(screen, boxX, boxY, boxW, boxH, 2, color.RGBA{100, 100, 100, 255}, false)
|
||
textX := int(boxX) + 10
|
||
text.Draw(screen, dist, basicfont.Face7x13, textX, int(boxY)+22, color.White)
|
||
text.Draw(screen, scoreStr, basicfont.Face7x13, textX, int(boxY)+40, color.RGBA{255, 215, 0, 255})
|
||
}
|
||
|
||
// drawSpectatorOverlay zeigt das Spectator-Banner wenn der lokale Spieler tot ist.
|
||
func (g *Game) drawSpectatorOverlay(screen *ebiten.Image, snap renderSnapshot) {
|
||
vector.DrawFilledRect(screen, 0, 0, float32(snap.canvasW), 80, color.RGBA{150, 0, 0, 180}, false)
|
||
text.Draw(screen, "☠ DU BIST TOT - SPECTATOR MODE ☠", basicfont.Face7x13, snap.canvasW/2-140, 30, color.White)
|
||
text.Draw(screen, fmt.Sprintf("Dein Final Score: %d", snap.myScore), basicfont.Face7x13, snap.canvasW/2-90, 55, color.RGBA{255, 255, 0, 255})
|
||
}
|
||
|
||
// drawPowerupHUD zeichnet Timer-Balken für aktive Powerups (oben links).
|
||
func (g *Game) drawPowerupHUD(screen *ebiten.Image, snap renderSnapshot) {
|
||
type bar struct {
|
||
label string
|
||
remaining float64
|
||
maxTime float64
|
||
col color.RGBA
|
||
active bool
|
||
used bool
|
||
}
|
||
bars := []bar{
|
||
{"JUMP x2", snap.myDoubleJumpRemaining, 15.0, color.RGBA{100, 200, 255, 255}, snap.myHasDoubleJump, snap.myDoubleJumpUsed},
|
||
{"GODMODE", snap.myGodModeRemaining, 10.0, color.RGBA{255, 215, 0, 255}, snap.myHasGodMode, false},
|
||
{"MAGNET", snap.myMagnetRemaining, 8.0, color.RGBA{255, 80, 220, 255}, snap.myHasMagnet, false},
|
||
}
|
||
x := float32(10)
|
||
y := float32(60)
|
||
barW := float32(110)
|
||
barH := float32(13)
|
||
for _, b := range bars {
|
||
if !b.active {
|
||
continue
|
||
}
|
||
ratio := float32(b.remaining / b.maxTime)
|
||
if ratio > 1 {
|
||
ratio = 1
|
||
}
|
||
if ratio < 0 {
|
||
ratio = 0
|
||
}
|
||
// Background
|
||
vector.DrawFilledRect(screen, x, y, barW, barH, color.RGBA{30, 30, 30, 200}, false)
|
||
// Fill — blinks red when < 30%
|
||
fillCol := b.col
|
||
if b.used {
|
||
fillCol = color.RGBA{fillCol.R / 3, fillCol.G / 3, fillCol.B / 3, fillCol.A}
|
||
}
|
||
if ratio < 0.3 && (time.Now().UnixMilli()/250)%2 == 0 {
|
||
fillCol = color.RGBA{255, 60, 60, 255}
|
||
}
|
||
vector.DrawFilledRect(screen, x, y, barW*ratio, barH, fillCol, false)
|
||
vector.StrokeRect(screen, x, y, barW, barH, 1, color.RGBA{140, 140, 140, 180}, false)
|
||
label := fmt.Sprintf("%s %.0fs", b.label, b.remaining)
|
||
text.Draw(screen, label, basicfont.Face7x13, int(x)+2, int(y)+10, color.White)
|
||
y += barH + 5
|
||
}
|
||
}
|
||
|
||
// drawDeathZoneLine zeichnet die rote Todes-Linie am linken Bildschirmrand.
|
||
func (g *Game) drawDeathZoneLine(screen *ebiten.Image, canvasH int) {
|
||
vector.StrokeLine(screen, 0, 0, 0, float32(canvasH), 10, color.RGBA{255, 0, 0, 128}, false)
|
||
text.Draw(screen, "! DEATH ZONE !", basicfont.Face7x13, 10, canvasH/2, color.RGBA{255, 0, 0, 255})
|
||
}
|
||
|
||
// drawTouchControls zeichnet den virtuellen Joystick und die Touch-Buttons.
|
||
// Wird nur angezeigt wenn keine Tastatur benutzt wurde.
|
||
func (g *Game) drawTouchControls(screen *ebiten.Image) {
|
||
tcW, tcH := screen.Size()
|
||
|
||
// Canvas-Maße cachen (werden in handleTouchInput benötigt)
|
||
g.lastCanvasHeight = tcH
|
||
g.lastCanvasWidth = tcW
|
||
|
||
floorY := GetFloorYFromHeight(tcH)
|
||
refDim := math.Min(float64(tcW), float64(tcH))
|
||
|
||
joyR := refDim * joyRadiusScale
|
||
knobR := joyR * joyKnobRatio
|
||
jumpR := refDim * jumpBtnScale
|
||
downR := refDim * downBtnScale
|
||
|
||
g.joyRadius = joyR
|
||
|
||
// ── A) Floating Joystick (links) ─────────────────────────────────────────
|
||
if !g.joyActive {
|
||
g.joyBaseX = float64(tcW) * joyDefaultXRatio
|
||
g.joyBaseY = floorY - joyR - 12
|
||
g.joyStickX = g.joyBaseX
|
||
g.joyStickY = g.joyBaseY
|
||
}
|
||
|
||
ringAlpha := uint8(40)
|
||
if g.joyActive {
|
||
ringAlpha = 70
|
||
}
|
||
vector.DrawFilledCircle(screen, float32(g.joyBaseX), float32(g.joyBaseY), float32(joyR), color.RGBA{80, 80, 80, ringAlpha}, false)
|
||
vector.StrokeCircle(screen, float32(g.joyBaseX), float32(g.joyBaseY), float32(joyR), 2, color.RGBA{120, 120, 120, 90}, false)
|
||
|
||
knobCol := color.RGBA{180, 180, 180, 100}
|
||
if g.joyActive {
|
||
knobCol = color.RGBA{80, 220, 80, 160}
|
||
}
|
||
vector.DrawFilledCircle(screen, float32(g.joyStickX), float32(g.joyStickY), float32(knobR), knobCol, false)
|
||
|
||
// ── B) Jump Button (rechts) ───────────────────────────────────────────────
|
||
jumpX := float64(tcW) * jumpBtnXRatio
|
||
jumpY := floorY - jumpR - 12
|
||
|
||
jumpFill := color.RGBA{220, 50, 50, 60}
|
||
jumpStroke := color.RGBA{255, 80, 80, 130}
|
||
if g.btnJumpPressed {
|
||
jumpFill = color.RGBA{255, 80, 80, 130}
|
||
jumpStroke = color.RGBA{255, 160, 160, 200}
|
||
}
|
||
vector.DrawFilledCircle(screen, float32(jumpX), float32(jumpY), float32(jumpR), jumpFill, false)
|
||
vector.StrokeCircle(screen, float32(jumpX), float32(jumpY), float32(jumpR), 2.5, jumpStroke, false)
|
||
text.Draw(screen, "JUMP", basicfont.Face7x13, int(jumpX)-14, int(jumpY)+5, color.RGBA{255, 255, 255, 180})
|
||
|
||
// ── C) Down/FastFall Button (mitte-rechts) ────────────────────────────────
|
||
downX := float64(tcW) * downBtnXRatio
|
||
downY := floorY - downR - 12
|
||
g.downBtnX = downX
|
||
g.downBtnY = downY
|
||
g.downBtnR = downR
|
||
|
||
vector.DrawFilledCircle(screen, float32(downX), float32(downY), float32(downR), color.RGBA{50, 120, 220, 55}, false)
|
||
vector.StrokeCircle(screen, float32(downX), float32(downY), float32(downR), 2, color.RGBA{80, 160, 255, 120}, false)
|
||
text.Draw(screen, "▼", basicfont.Face7x13, int(downX)-4, int(downY)+5, color.RGBA{200, 220, 255, 180})
|
||
}
|
||
|
||
// TriggerShake aktiviert den Screen-Shake-Effekt.
|
||
func (g *Game) TriggerShake(frames int, intensity float64) {
|
||
if frames > g.shakeFrames {
|
||
g.shakeFrames = frames
|
||
}
|
||
if intensity > g.shakeIntensity {
|
||
g.shakeIntensity = intensity
|
||
}
|
||
}
|
||
|
||
// drawTeacher zeichnet den Lehrer-Charakter am linken Bildschirmrand.
|
||
func (g *Game) drawTeacher(screen *ebiten.Image, snap renderSnapshot) {
|
||
if snap.status != "RUNNING" && snap.status != "COUNTDOWN" {
|
||
return
|
||
}
|
||
|
||
danger := snap.difficultyFactor
|
||
groundY := float32(GetFloorYFromHeight(snap.canvasH))
|
||
|
||
// Teacher slides in from the left as danger increases
|
||
// At danger=0: fully offscreen (-70). At danger=1: at X=5.
|
||
teacherCX := float32(-70 + danger*75)
|
||
|
||
bodyW := float32(28)
|
||
bodyH := float32(55 + danger*15)
|
||
headR := float32(14)
|
||
|
||
bodyX := teacherCX - bodyW/2
|
||
bodyY := groundY - bodyH
|
||
|
||
alpha := uint8(40 + danger*215)
|
||
|
||
// Shadow on left edge (red vignette)
|
||
shadowW := int(20 + danger*40)
|
||
for i := 0; i < shadowW; i++ {
|
||
a := uint8(float64(70) * float64(shadowW-i) / float64(shadowW) * danger)
|
||
vector.DrawFilledRect(screen, float32(i), 0, 1, float32(snap.canvasH), color.RGBA{200, 0, 0, a}, false)
|
||
}
|
||
|
||
// Only draw body when partially visible
|
||
if teacherCX > -40 {
|
||
// Body (dark suit)
|
||
vector.DrawFilledRect(screen, bodyX, bodyY, bodyW, bodyH, color.RGBA{100, 10, 10, alpha}, false)
|
||
// Tie
|
||
vector.DrawFilledRect(screen, teacherCX-3, bodyY+4, 6, bodyH-8, color.RGBA{180, 0, 0, alpha}, false)
|
||
// Head
|
||
vector.DrawFilledCircle(screen, teacherCX, bodyY-headR, headR, color.RGBA{210, 160, 110, alpha}, false)
|
||
// Angry eyes
|
||
eyeA := uint8(200)
|
||
vector.DrawFilledCircle(screen, teacherCX-5, bodyY-headR-1, 3, color.RGBA{255, 0, 0, eyeA}, false)
|
||
vector.DrawFilledCircle(screen, teacherCX+5, bodyY-headR-1, 3, color.RGBA{255, 0, 0, eyeA}, false)
|
||
// Legs
|
||
vector.DrawFilledRect(screen, bodyX+1, groundY, bodyW/2-2, float32(snap.canvasH), color.RGBA{60, 10, 10, alpha}, false)
|
||
vector.DrawFilledRect(screen, bodyX+bodyW/2+1, groundY, bodyW/2-2, float32(snap.canvasH), color.RGBA{60, 10, 10, alpha}, false)
|
||
}
|
||
|
||
// Warning text — blinks when close
|
||
if danger > 0.55 {
|
||
if (time.Now().UnixMilli()/300)%2 == 0 {
|
||
warnX := int(teacherCX) - 20
|
||
if warnX < 2 {
|
||
warnX = 2
|
||
}
|
||
text.Draw(screen, "LEHRER!", basicfont.Face7x13, warnX, int(bodyY)-20, color.RGBA{255, 50, 50, 255})
|
||
}
|
||
}
|
||
}
|
||
|
||
// --- ASSET HELPER ---
|
||
|
||
// DrawAsset zeichnet ein Asset an einer Welt-Position auf den Screen.
|
||
// Objekte außerhalb des sichtbaren Bereichs (±cullingBuffer) werden übersprungen.
|
||
func (g *Game) DrawAsset(screen *ebiten.Image, assetID string, worldX, worldY float64) {
|
||
def, ok := g.world.Manifest.Assets[assetID]
|
||
if !ok {
|
||
return
|
||
}
|
||
|
||
canvasW, canvasH := screen.Size()
|
||
viewScale := GetScaleFromHeight(canvasH)
|
||
screenX := (worldX - g.camX) * viewScale
|
||
|
||
if screenX < -cullingBuffer || screenX > float64(canvasW)+cullingBuffer {
|
||
return
|
||
}
|
||
|
||
img := g.assetsImages[assetID]
|
||
if img != nil {
|
||
op := &ebiten.DrawImageOptions{}
|
||
op.Filter = ebiten.FilterLinear
|
||
finalScale := def.Scale * viewScale
|
||
op.GeoM.Scale(finalScale, finalScale)
|
||
op.GeoM.Translate(
|
||
screenX+(def.DrawOffX*viewScale),
|
||
worldY+(def.DrawOffY*viewScale),
|
||
)
|
||
if def.Color.R != 0 || def.Color.G != 0 || def.Color.B != 0 || def.Color.A != 0 {
|
||
op.ColorScale.ScaleWithColor(def.Color.ToRGBA())
|
||
}
|
||
screen.DrawImage(img, op)
|
||
} else {
|
||
// Fallback: farbiges Rechteck wenn Bild fehlt
|
||
vector.DrawFilledRect(screen,
|
||
float32(screenX+def.Hitbox.OffsetX),
|
||
float32(worldY+def.Hitbox.OffsetY),
|
||
float32(def.Hitbox.W),
|
||
float32(def.Hitbox.H),
|
||
def.Color.ToRGBA(),
|
||
false,
|
||
)
|
||
}
|
||
}
|
||
|
||
// --- DEBUG OVERLAY ---
|
||
|
||
// drawDebugOverlay zeigt Performance- und Netzwerk-Stats (F3 zum Umschalten).
|
||
func (g *Game) drawDebugOverlay(screen *ebiten.Image) {
|
||
vector.DrawFilledRect(screen, 10, 80, 350, 170, color.RGBA{0, 0, 0, 180}, false)
|
||
vector.StrokeRect(screen, 10, 80, 350, 170, 2, color.RGBA{255, 255, 0, 255}, false)
|
||
|
||
y := 95
|
||
lh := 15 // line height
|
||
|
||
text.Draw(screen, "=== DEBUG INFO (F3) ===", basicfont.Face7x13, 20, y, color.RGBA{255, 255, 0, 255})
|
||
y += lh + 5
|
||
|
||
fpsCol := color.RGBA{0, 255, 0, 255}
|
||
if g.currentFPS < 15 {
|
||
fpsCol = color.RGBA{255, 0, 0, 255}
|
||
} else if g.currentFPS < 30 {
|
||
fpsCol = color.RGBA{255, 165, 0, 255}
|
||
}
|
||
text.Draw(screen, fmt.Sprintf("FPS: %.1f", g.currentFPS), basicfont.Face7x13, 20, y, fpsCol)
|
||
y += lh
|
||
|
||
updateAge := time.Since(g.lastUpdateTime).Milliseconds()
|
||
latencyCol := color.RGBA{0, 255, 0, 255}
|
||
if updateAge > 200 {
|
||
latencyCol = color.RGBA{255, 0, 0, 255}
|
||
} else if updateAge > 100 {
|
||
latencyCol = color.RGBA{255, 165, 0, 255}
|
||
}
|
||
text.Draw(screen, fmt.Sprintf("Update Age: %dms", updateAge), basicfont.Face7x13, 20, y, latencyCol)
|
||
y += lh
|
||
|
||
text.Draw(screen, fmt.Sprintf("Total Updates: %d", g.totalUpdates), basicfont.Face7x13, 20, y, color.White)
|
||
y += lh
|
||
|
||
oooCol := color.RGBA{0, 255, 0, 255}
|
||
if g.outOfOrderCount > 50 {
|
||
oooCol = color.RGBA{255, 0, 0, 255}
|
||
} else if g.outOfOrderCount > 10 {
|
||
oooCol = color.RGBA{255, 165, 0, 255}
|
||
}
|
||
text.Draw(screen, fmt.Sprintf("Out-of-Order: %d", g.outOfOrderCount), basicfont.Face7x13, 20, y, oooCol)
|
||
y += lh
|
||
|
||
if g.totalUpdates > 0 {
|
||
lossRate := float64(g.outOfOrderCount) / float64(g.totalUpdates+g.outOfOrderCount) * 100
|
||
lossCol := color.RGBA{0, 255, 0, 255}
|
||
if lossRate > 10 {
|
||
lossCol = color.RGBA{255, 0, 0, 255}
|
||
} else if lossRate > 5 {
|
||
lossCol = color.RGBA{255, 165, 0, 255}
|
||
}
|
||
text.Draw(screen, fmt.Sprintf("Loss Rate: %.1f%%", lossRate), basicfont.Face7x13, 20, y, lossCol)
|
||
y += lh
|
||
}
|
||
|
||
text.Draw(screen, fmt.Sprintf("Pending Inputs: %d", g.pendingInputCount), basicfont.Face7x13, 20, y, color.White)
|
||
y += lh
|
||
|
||
corrCol := color.RGBA{0, 255, 0, 255}
|
||
if g.correctionCount > 500 {
|
||
corrCol = color.RGBA{255, 0, 0, 255}
|
||
} else if g.correctionCount > 100 {
|
||
corrCol = color.RGBA{255, 165, 0, 255}
|
||
}
|
||
text.Draw(screen, fmt.Sprintf("Corrections: %d", g.correctionCount), basicfont.Face7x13, 20, y, corrCol)
|
||
y += lh
|
||
|
||
corrMag := math.Sqrt(g.correctionX*g.correctionX + g.correctionY*g.correctionY)
|
||
corrMagCol := color.RGBA{0, 255, 0, 255}
|
||
if corrMag > 0.1 {
|
||
corrMagCol = color.RGBA{255, 165, 0, 255}
|
||
}
|
||
text.Draw(screen, fmt.Sprintf("Corr Mag: %.1f", corrMag), basicfont.Face7x13, 20, y, corrMagCol)
|
||
y += lh
|
||
|
||
text.Draw(screen, fmt.Sprintf("Server Seq: %d", g.lastRecvSeq), basicfont.Face7x13, 20, y, color.White)
|
||
}
|