package com.example.snake

import android.content.Context
import android.graphics.*
import android.media.AudioAttributes
import android.media.AudioFormat
import android.media.AudioManager
import android.media.AudioTrack
import android.media.ToneGenerator
import android.os.Build
import android.os.Bundle
import android.os.Parcelable
import android.os.VibrationEffect
import android.os.Vibrator
import android.os.VibratorManager
import android.util.AttributeSet
import android.util.Log
import android.view.Choreographer
import android.view.MotionEvent
import android.view.View
import java.io.BufferedInputStream
import java.io.BufferedOutputStream
import java.io.DataInputStream
import java.io.DataOutputStream
import java.io.FileInputStream
import java.io.FileOutputStream
import java.util.ArrayDeque
import java.util.concurrent.Callable
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.Future
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min
import kotlin.random.Random

class SnakeView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : View(context, attrs) {

    private val cols = 15
    private val rows = 15
    private val total = cols * rows

    private var cell = 0f
    private var ox = 0f
    private var oy = 0f

    private data class P(val x: Int, val y: Int)

    private data class Candidate(
        val d: P, val score: Float, val reason: String, val legal: Boolean,
        val regionScore: Float = 0f, val mobilityScore: Float = 0f,
        val tailScore: Float = 0f, val foodScore: Float = 0f,
        val edgeScore: Float = 0f, val spaceScore: Float = 0f,
        val region: Int = 0, val mobility: Int = 0,
        val tailOk: Boolean = false, val foodDist: Int = -1,
        val ate: Boolean = false, val qValue: Float = 0f
    )

    private data class Snapshot(
        var strategy: String = "V2 AUTO", var reason: String = "初始化",
        var danger: Int = 1, var region: Int = 1, var spaceRatio: Float = 1f,
        var tailReachable: Boolean = false, var foodReachable: Boolean = false,
        var foodDistance: Int = -1, var hunger: Int = 0, var chosen: P = P(0, 0),
        var candidates: List<Candidate> = emptyList(),
        var depth: Int = 0, var nodes: Int = 0, var hungerFactor: Float = 1f,
        var regionWeight: Float = 11f, var strategyId: Int = -1,
        var qValue: Float = 0f, var nVisits: Int = 0,
        var forceEatActive: Boolean = false, var forceEatSafe: Boolean = false,
        var safeFollowMode: Boolean = false
    )

    private data class Sim(val body: ArrayDeque<P>, val ate: Boolean)
    private data class Particle(var x: Float, var y: Float, var vx: Float, var vy: Float, var life: Float, val color: Int)
    private data class FloatText(var x: Float, var y: Float, var life: Float, val text: String)

    private data class BeamNode(
        val body: ArrayDeque<P>,
        val dir: P,
        val food: P,
        val score: Float,
        val steps: Int,
        val ateFood: Boolean,
        val dead: Boolean,
        val loopPenalty: Float,
        val firstAction: P,
        val recentHeadCells: IntArray
    )

    private val snake = ArrayDeque<P>()
    private val queue = ArrayDeque<P>()
    private val dirs = listOf(P(0, -1), P(0, 1), P(-1, 0), P(1, 0))

    private var dir = P(1, 0)
    private var food = P(5, 5)
    private var score = 0
    private var highScore = 0
    private var money = 0
    private var gameOver = false
    private var running = false
    private var aiMode = 1
    private var forcedStrategy = -1

    private var gameSpeed = 220L
    private val gameSpeedMin = 45L
    private val gameSpeedStart = 220L
    private var accumulator = 0L
    private var lastFrame = 0L
    private var combo = 0
    private var hunger = 0
    private var lastFreeRegion = 0f
    private var deathCause = "无"
    private var lastDeathInfo = ""
    private var ai = Snapshot(chosen = dir)

    private val sharedLock = Any()
    private val evolveLock = Any()

    private val POPULATION_SIZE = 50
    @Volatile private var generation = 0
    private val population = MutableList(POPULATION_SIZE) { TinyBrain() }
    @Volatile private var currentAgentIndex = 0
    private var completedAgents = 0
    private val currentScores = FloatArray(POPULATION_SIZE)
    @Volatile private var qWeight = 1.0f
    @Volatile private var nnWeight = 0.0f
    @Volatile private var bestScoreThisGen = 0f
    @Volatile private var bestScoreAllTime = 0f
    @Volatile private var deadEndPredicted = false
    @Volatile private var rolloutActive = false
    @Volatile private var rolloutSteps = 0
    @Volatile private var foodSpaceRatio = 1f
    @Volatile private var evolving = false
    @Volatile private var generationTransitioning = false

    @Volatile private var beamCalls = 0L
    @Volatile private var beamSuccess = 0L
    @Volatile private var beamSelected = 0L
    @Volatile private var beamTotalNodes = 0L
    @Volatile private var beamBestScore = 0f

    private val visitedStates = java.util.Collections.newSetFromMap(
        java.util.concurrent.ConcurrentHashMap<Int, Boolean>()
    )

    private class ThreadStatus {
        @Volatile var alive = false
        @Volatile var agentId = -1
        @Volatile var score = 0
        @Volatile var steps = 0
        @Volatile var phase = "空闲"
    }
    private val threadStatus = Array(8) { ThreadStatus() }

    private class EvoRecord(
        val gen: Int, val bestScore: Float,
        val eliteN: Int, val crossN: Int, val breedN: Int,
        val personality: String, val deaths: IntArray, val timestamp: Long
    )
    private val evoHistory = java.util.concurrent.ConcurrentLinkedDeque<EvoRecord>()

    private val completedAgentIds = HashSet<Int>()
    private val agentCompleted = BooleanArray(POPULATION_SIZE)
    @Volatile private var generationToken = 0L
    @Volatile private var uniqueCompletedAgents = 0

    private enum class V3Goal(val label: String, val short: String, val color: Int) {
        GET_FOOD("获取食物", "食", Color.rgb(46, 204, 113)),
        PRESERVE_SPACE("保持空间", "空", Color.rgb(52, 152, 219)),
        REACH_TAIL("追踪尾巴", "尾", Color.rgb(155, 89, 182)),
        ESCAPE_DANGER("逃离危险", "危", Color.rgb(231, 76, 60)),
        BREAK_LOOP("打破循环", "循", Color.rgb(241, 196, 15)),
        SURVIVE("极限求生", "生", Color.rgb(230, 126, 34))
    }

    private data class V3Lesson(
        var badAction: Int, var cause: String, var penalty: Float,
        var confidence: Float, var occurrences: Int, var altAction: Int
    )

    private class V3FailureMemory(private val capacity: Int = 8000) {
        private val memory = LinkedHashMap<Long, V3Lesson>()

        @Synchronized
        fun remember(ctx: Long, action: Int, cause: String, penalty: Float, alt: Int): V3Lesson {
            val old = memory[ctx]
            return if (old == null) {
                val l = V3Lesson(action, cause, penalty, 0.30f, 1, alt)
                memory[ctx] = l
                if (memory.size > capacity) memory.remove(memory.keys.first())
                l
            } else {
                old.occurrences++
                old.cause = cause
                old.penalty = max(old.penalty, penalty)
                old.confidence = min(0.95f, 0.40f + old.occurrences * 0.18f)
                if (alt >= 0) old.altAction = alt
                old
            }
        }

        @Synchronized
        fun penaltyFor(ctx: Long, action: Int): Float {
            val l = memory[ctx] ?: return 0f
            if (l.badAction != action) return 0f
            return l.penalty * l.confidence
        }

        @Synchronized
        fun hardLesson(ctx: Long, action: Int): Boolean {
            val l = memory[ctx] ?: return false
            return l.badAction == action && l.occurrences >= 3 && l.confidence >= 0.70f
        }

        @Synchronized
        fun worstLessonText(): String {
            var best: V3Lesson? = null
            for (l in memory.values) if (best == null || l.occurrences > best!!.occurrences) best = l
            val b = best ?: return "暂无教训"
            return "死因=${b.cause} 重复${b.occurrences}次 置信=${"%.2f".format(b.confidence)}"
        }

        @Synchronized fun size(): Int = memory.size
        @Synchronized fun clear() = memory.clear()
    }

    private class V3StrategyGenome {
        var foodPriority = 1.00f
        var spacePriority = 1.25f
        var tailPriority = 0.90f
        var dangerAversion = 1.40f
        var loopAversion = 0.80f
        var hungerUrgency = 0.80f
        private var backup = floatArrayOf(1.00f, 1.25f, 0.90f, 1.40f, 0.80f, 0.80f)

        fun snapshot() { backup = floatArrayOf(foodPriority, spacePriority, tailPriority, dangerAversion, loopAversion, hungerUrgency) }
        fun revert() {
            foodPriority = backup[0]; spacePriority = backup[1]; tailPriority = backup[2]
            dangerAversion = backup[3]; loopAversion = backup[4]; hungerUrgency = backup[5]
        }
        fun normalize() {
            foodPriority = foodPriority.coerceIn(0.4f, 2.2f)
            spacePriority = spacePriority.coerceIn(0.6f, 2.4f)
            tailPriority = tailPriority.coerceIn(0.4f, 2.0f)
            dangerAversion = dangerAversion.coerceIn(0.8f, 2.6f)
            loopAversion = loopAversion.coerceIn(0.3f, 2.2f)
            hungerUrgency = hungerUrgency.coerceIn(0.4f, 2.0f)
        }
        fun selfAdjust(cause: String) {
            when (cause) {
                "SELF" -> { spacePriority += 0.05f; dangerAversion += 0.04f; tailPriority += 0.02f }
                "TRAP" -> { dangerAversion += 0.05f; spacePriority += 0.03f }
                "WALL" -> { dangerAversion += 0.03f; tailPriority += 0.03f }
                "HUNGER" -> { hungerUrgency += 0.04f; foodPriority += 0.03f; spacePriority -= 0.02f }
            }
            normalize()
        }
        fun evolve() {
            val sigma = 0.06f
            fun noise() = Random.nextFloat() * 2f * sigma - sigma
            foodPriority += noise(); spacePriority += noise(); tailPriority += noise()
            dangerAversion += noise(); loopAversion += noise(); hungerUrgency += noise()
            normalize()
        }
        fun values(): FloatArray = floatArrayOf(foodPriority, spacePriority, tailPriority, dangerAversion, loopAversion, hungerUrgency)
    }

    @Volatile private var v3FusionEnabled = true
    @Volatile private var v3Goal: V3Goal = V3Goal.GET_FOOD
    @Volatile private var v3LayerActive: Int = 4
    @Volatile private var v3LayerWhy: String = "V4融合待命"
    @Volatile private var v3Regret: Float = 0f
    @Volatile private var v3LessonFires: Int = 0
    @Volatile private var v3LoopHits: Int = 0

    private val v3GoalCounter = IntArray(V3Goal.values().size)
    private val v3RecentHeads = ArrayDeque<Int>()
    private val v3Memory = V3FailureMemory(8000)
    private val v3Genome = V3StrategyGenome()
    private var v3GenomeBest = 0f
    private var v3LessonFlash = 0f
    private val v3CtxSalt = 0x5157L
    private val v3TrainCtxSalt = 0x5157L

    fun setV3FusionEnabled(on: Boolean) { v3FusionEnabled = on; v3LayerWhy = if (on) "V4融合已接管" else "V2基线模式" }
    fun isV3FusionEnabled(): Boolean = v3FusionEnabled

    private fun v3ActionIndexOf(d: P): Int = dirs.indexOfFirst { it == d }
    private fun v3DirLabel(d: P): String = when (d) {
        P(0, -1) -> "上"; P(0, 1) -> "下"; P(-1, 0) -> "左"; P(1, 0) -> "右"; else -> "?"
    }
    private fun v3RecordHead() {
        val h = snake.firstOrNull() ?: return
        v3RecentHeads.addLast(h.y * cols + h.x)
        while (v3RecentHeads.size > 24) v3RecentHeads.removeFirst()
    }
    private fun v3LoopRisk(): Boolean {
        if (v3RecentHeads.size < 8) return false
        val last8 = if (v3RecentHeads.size > 8) v3RecentHeads.drop(v3RecentHeads.size - 8) else v3RecentHeads
        return last8.toSet().size <= 5
    }
    private fun v3SelectGoal(): V3Goal {
        if (legalDirectionMask() == 0) return V3Goal.ESCAPE_DANGER
        if (v3LoopRisk()) { v3LoopHits++; return V3Goal.BREAK_LOOP }
        val region = freeRegion(snake)
        val ratio = region.toFloat() / max(1, snake.size)
        val danger = calculateDanger()
        if (danger >= 4) return V3Goal.ESCAPE_DANGER
        if (ratio < 1.05f) return V3Goal.PRESERVE_SPACE
        if (snake.size >= total * 0.45f && tailReachable(snake)) return V3Goal.REACH_TAIL
        if (snake.size >= total * 0.55f) return V3Goal.SURVIVE
        return V3Goal.GET_FOOD
    }
    private fun legalDirectionMask(): Int {
        var m = 0
        val head = snake.firstOrNull() ?: return 0
        dirs.forEachIndexed { i, d ->
            val nx = head.x + d.x; val ny = head.y + d.y
            if (nx in 0 until cols && ny in 0 until rows && !snake.contains(P(nx, ny))) m = m or (1 shl i)
        }
        return m
    }

    private fun v3ContextHash(): Long {
        val head = snake.firstOrNull() ?: return 0L
        val regionBucket = (freeRegion(snake) / 4).coerceIn(0, 60)
        val lenBucket = (snake.size / 8).coerceIn(0, 30)
        val foodDxBucket = ((food.x - head.x) / 3).coerceIn(-5, 5)
        val foodDyBucket = ((food.y - head.y) / 3).coerceIn(-5, 5)
        val headingBucket = directionIndex(dir)
        val dangerBucket = calculateDanger().coerceIn(1, 5)
        val tailBucket = if (tailReachable(snake)) 1 else 0
        var h = 1125899906842597L
        h = h * 31 + head.x; h = h * 31 + head.y
        h = h * 31 + foodDxBucket; h = h * 31 + foodDyBucket
        h = h * 31 + headingBucket; h = h * 31 + dangerBucket
        h = h * 31 + regionBucket; h = h * 31 + lenBucket; h = h * 31 + tailBucket
        return h xor v3CtxSalt
    }

    private fun v3PostCheck(originalDir: P, legal: List<Candidate>, state: Int): P {
        if (!v3FusionEnabled || legal.size <= 1) return originalDir
        val best = legal.firstOrNull { it.d == originalDir } ?: return originalDir
        val ctx = v3ContextHash()

        if (v3Memory.hardLesson(ctx, v3ActionIndexOf(originalDir))) {
            val alt = legal
                .filter { it.d != originalDir && v3ActionIndexOf(it.d) >= 0 && !v3Memory.hardLesson(ctx, v3ActionIndexOf(it.d)) }
                .maxByOrNull { it.region * v3Genome.spacePriority * 10f + (if (it.tailOk) v3Genome.tailPriority * 40f else 0f) }
            if (alt != null && alt.tailOk && alt.region >= best.region * 0.8f) {
                Log.d(LOG_TAG, "L5 TRIGGERED! Cause: 防止重蹈覆辙")
                v3LayerActive = 5; v3LayerWhy = "L5反事实：阻止重蹈覆辙"
                v3LessonFires++
                return alt.d
            }
        }

        if (v3LoopRisk()) {
            val alt = legal
                .filter { it.d != originalDir && it.tailOk }
                .maxByOrNull { it.region * v3Genome.spacePriority + v3Genome.loopAversion * 8f }
            if (alt != null && alt.tailOk && alt.region >= best.region * 0.8f) {
                Log.d(LOG_TAG, "L6 TRIGGERED! Cause: 打破循环")
                v3LayerActive = 6; v3LayerWhy = "L6基因：循环厌恶接管"
                v3LoopHits++
                return alt.d
            }
        }
        return originalDir
    }

    private fun v3AnalyzeDeath(cause: String) {
        if (!v3FusionEnabled) return
        val chosenAction = v3ActionIndexOf(ai.chosen)
        if (chosenAction < 0) return
        val ctx = v3ContextHash()
        val alt = ai.candidates
            .filter { it.legal && it.d != ai.chosen && v3ActionIndexOf(it.d) >= 0 }
            .maxByOrNull { it.region * 10f + (if (it.tailOk) 50f else 0f) }
        val severity = when (cause) {
            "SELF" -> 1.0f; "TRAP" -> 0.9f; "WALL" -> 0.85f; "HUNGER" -> 0.35f; else -> 0.5f
        }
        val lesson = v3Memory.remember(ctx, chosenAction, cause, severity, v3ActionIndexOf(alt?.d ?: ai.chosen))
        v3Regret = severity * lesson.confidence
        v3LessonFires++; v3LessonFlash = 1f
        v3Genome.selfAdjust(cause)
    }

    private fun v3TrainRecordLesson(cause: String, head: P, tailOk: Boolean, len: Int, action: Int) {
        if (!v3FusionEnabled || action < 0) return
        var h = 1125899906842597L
        h = h * 31 + head.x; h = h * 31 + head.y
        h = h * 31 + len; h = h * 31 + (if (tailOk) 1 else 0)
        val ctx = h xor v3TrainCtxSalt
        val severity = when (cause) {
            "SELF" -> 0.9f; "TRAP" -> 0.8f; "WALL" -> 0.7f; else -> 0.3f
        }
        v3Memory.remember(ctx, action, cause, severity, -1)
    }

    private fun v3EvolveGenome() {
        synchronized(v3Genome) {
            v3Genome.snapshot()
            val before = v3GenomeBest
            v3Genome.evolve()
            if (before > 0f && bestScoreAllTime < before) v3Genome.revert()
            else v3GenomeBest = bestScoreAllTime
        }
    }

    private var wRegion = 11f
    private var wMobility = 35f
    private var wTailGood = 180f
    private var wTailBad = -250f
    private var wFoodNear = 300f
    private var wFoodAte = 850f
    private var wEdge = 55f
    private var wSpace = 30f

    private val wRegion0 = 11f
    private val wMobility0 = 35f
    private val wTailGood0 = 180f
    private val wTailBad0 = -250f
    private val wFoodNear0 = 300f
    private val wFoodAte0 = 850f
    private val wEdge0 = 55f
    private val wSpace0 = 30f

    private var aggression = 1.15f
    private var safetyMargin = 1.08f
    private var shortcutBonus = 0.90f

    private var deathWall = 0
    private var deathSelf = 0
    private var deathTrap = 0
    private var totalGames = 0
    private var lastLearnAction = "初始化"
    private val recentScores = ArrayDeque<Int>()
    private var bestRecentScore = 0
    private var generationsWithoutImprovement = 0
    private var previousGenerationBest = Float.NEGATIVE_INFINITY

    private companion object {
        const val V2_FOOD_DIR = 4
        const val V2_DANGER = 16
        const val V2_MOBILITY = 5
        const val V2_SPACE = 4
        const val V2_HUNGER = 5
        const val V2_LENGTH = 4
        const val V2_TAIL = 2
        const val V2_HEADING = 1
        const val V2_STATE_COUNT = V2_FOOD_DIR * V2_DANGER * V2_MOBILITY * V2_SPACE * V2_HUNGER * V2_LENGTH * V2_TAIL * V2_HEADING
        const val V2_ACTIONS = 4
        const val V2_Q_SIZE = V2_STATE_COUNT * V2_ACTIONS
        const val V2_LOCKS = 64
        const val GAMMA = 0.94f
        const val ALPHA_FAST = 0.18f
        const val ALPHA_NORMAL = 0.055f
        const val EPS_START = 0.22f
        const val EPS_MIN = 0.015f
        const val REWARD_STEP = -0.05f
        const val REWARD_FOOD = 10.0f
        const val REWARD_TAIL = 0.55f
        const val REWARD_DANGER = -0.30f
        const val REWARD_SPACE_DELTA = 0.08f
        const val DEATH_WALL = -14.0f
        const val DEATH_SELF = -18.0f
        const val DEATH_TRAP = -20.0f
        const val DEATH_HUNGER = -12.0f
        const val LOG_TAG = "SnakeTrain"
        const val HEARTBEAT_TIMEOUT_MS = 7_200_000L

        const val BEAM_ENABLED = true
        const val BEAM_WIDTH = 3
        const val BEAM_DEPTH_SHORT = 5
        const val BEAM_DEPTH_LONG = 7
        const val BEAM_MIN_LENGTH = 10
        const val BEAM_MAX_NODES = 80
        const val BEAM_WEIGHT = 0.30f
        const val BEAM_FOOD_WEIGHT = 1.0f
        const val BEAM_SPACE_WEIGHT = 1.2f
        const val BEAM_TAIL_WEIGHT = 1.1f
        const val BEAM_SURVIVAL_WEIGHT = 2.0f
        const val BEAM_DANGER_WEIGHT = 1.5f
        const val BEAM_LOOP_WEIGHT = 0.8f
        const val BEAM_LONG_LENGTH = 35
        const val BEAM_DEPTH_MAX = 8
    }

    private val qV2 = FloatArray(V2_Q_SIZE)
    private val qTarget = FloatArray(V2_Q_SIZE)
    private val nV2 = IntArray(V2_Q_SIZE)
    @Volatile private var trainingRunId = 0L
    private val trainingLifecycleLock = Any()
    private val targetLock = Any()
    private val targetUpdateCounter = java.util.concurrent.atomic.AtomicInteger(0)

    private fun isTrainingRunActive(runId: Long): Boolean = trainActive && trainingRunId == runId

    private val qLocks = Array(V2_LOCKS) { Any() }
    @Volatile private var v2LearningSteps = 0L
    @Volatile private var v2Episodes = 0L
    @Volatile private var v2Epsilon = EPS_START
    private var lastV2State = -1
    private var lastV2Action = -1

    private fun qIndex(state: Int, action: Int): Int = state * V2_ACTIONS + action
    private fun qLock(index: Int): Any = qLocks[index and (V2_LOCKS - 1)]
    private fun qStateLock(state: Int): Any = qLocks[state and (V2_LOCKS - 1)]

    private fun qRead(state: Int, action: Int): Float {
        if (state !in 0 until V2_STATE_COUNT || action !in 0 until V2_ACTIONS) return 0f
        return synchronized(qLock(state)) { qV2[qIndex(state, action)] }
    }
    private fun qVisit(state: Int, action: Int): Int {
        if (state !in 0 until V2_STATE_COUNT || action !in 0 until V2_ACTIONS) return 0
        return synchronized(qLock(state)) { nV2[qIndex(state, action)] }
    }
    private fun qMax(state: Int, legalMask: Int = 15): Float {
        if (state !in 0 until V2_STATE_COUNT) return 0f
        var bestAction = -1; var bestQ = -Float.MAX_VALUE
        synchronized(qLock(state)) {
            for (a in 0 until 4) {
                if ((legalMask and (1 shl a)) == 0) continue
                val v = qV2[qIndex(state, a)]
                if (v > bestQ) { bestQ = v; bestAction = a }
            }
            if (bestAction < 0) return 0f
            synchronized(targetLock) { return qTarget[qIndex(state, bestAction)] }
        }
    }

    private data class Experience(
        val state: Int, val action: Int, val reward: Float,
        val nextState: Int, val nextMask: Int, val terminal: Boolean,
        val tdError: Float = 0f
    )
    private val replayBuffer = ArrayList<Experience>(5000)
    private val REPLAY_CAPACITY = 5000

    private fun qUpdate(state: Int, action: Int, reward: Float, nextState: Int, nextMask: Int, terminal: Boolean) {
        if (state !in 0 until V2_STATE_COUNT || action !in 0 until V2_ACTIONS) return
        visitedStates.add(state)
        val effectiveReward = reward
        val idx = qIndex(state, action)
        val nextBest = if (terminal) 0f else qMax(nextState, nextMask)
        val oldValue = synchronized(qStateLock(state)) { qV2[idx] }
        val tdErr = if (terminal) effectiveReward - oldValue else effectiveReward + GAMMA * nextBest - oldValue
        synchronized(replayBuffer) {
            replayBuffer.add(Experience(state, action, effectiveReward, nextState, nextMask, terminal, tdErr))
            if (replayBuffer.size > REPLAY_CAPACITY) replayBuffer.removeAt(0)
        }
        synchronized(qStateLock(state)) {
            val visits = nV2[idx]
            val alpha = if (visits < 12) ALPHA_FAST else ALPHA_NORMAL
            val target = if (terminal) effectiveReward else effectiveReward + GAMMA * nextBest
            val old = qV2[idx]
            val updated = old + alpha * (target - old)
            qV2[idx] = updated.coerceIn(-10f, 10f)
            nV2[idx] = if (visits < Int.MAX_VALUE) visits + 1 else visits
        }
        synchronized(replayBuffer) {
            if (replayBuffer.size > 10) repeat(2) {
                val e = replayBuffer[Random.nextInt(replayBuffer.size)]
                evoUpdate(e.state, e.action, e.reward, e.nextState, e.nextMask, e.terminal)
            }
        }
        v2LearningSteps++
        val cnt = targetUpdateCounter.incrementAndGet()
        if (cnt >= 50 && targetUpdateCounter.compareAndSet(cnt, 0)) {
            synchronized(targetLock) {
                for (i in qTarget.indices) qTarget[i] = qTarget[i] + 0.01f * (qV2[i] - qTarget[i])
            }
        }
    }

    private fun evoUpdate(state: Int, action: Int, reward: Float, nextState: Int, nextMask: Int, terminal: Boolean) {
        if (state !in 0 until V2_STATE_COUNT || action !in 0 until V2_ACTIONS) return
        val idx = qIndex(state, action)
        val nextBest = if (terminal) 0f else qMax(nextState, nextMask)
        synchronized(qStateLock(state)) {
            val visits = nV2[idx]
            val alpha = if (visits < 12) ALPHA_FAST else ALPHA_NORMAL
            val target = if (terminal) reward else reward + GAMMA * nextBest
            val old = qV2[idx]
            val updated = old + alpha * (target - old)
            qV2[idx] = updated.coerceIn(-10f, 10f)
            nV2[idx] = if (visits < Int.MAX_VALUE) visits + 1 else visits
        }
    }

    private fun currentEpsilon(): Float {
        if (!trainingMode && !reinforceTraining) return 0f
        val e = v2Epsilon
        if (v2LearningSteps > 0L && v2LearningSteps % 4096L == 0L) v2Epsilon = max(EPS_MIN, v2Epsilon * 0.985f)
        return e
    }

    private inner class TinyBrain {
        var w1 = FloatArray(8 * 32) { Random.nextFloat() * 2f - 1f }
        var w2 = FloatArray(32 * 16) { Random.nextFloat() * 2f - 1f }
        var w3 = FloatArray(16 * 4) { Random.nextFloat() * 2f - 1f }

        fun think(inputs: FloatArray): FloatArray {
            val h1 = FloatArray(32)
            for (i in 0 until 32) { var s = 0f; for (j in 0 until 8) s += inputs[j] * w1[j * 32 + i]; h1[i] = max(0f, s) }
            val h2 = FloatArray(16)
            for (i in 0 until 16) { var s = 0f; for (j in 0 until 32) s += h1[j] * w2[j * 16 + i]; h2[i] = max(0f, s) }
            val outputs = FloatArray(4)
            for (i in 0 until 4) { var s = 0f; for (j in 0 until 16) s += h2[j] * w3[j * 4 + i]; outputs[i] = s }
            return outputs
        }

        fun copyFrom(src: TinyBrain) {
            System.arraycopy(src.w1, 0, w1, 0, w1.size)
            System.arraycopy(src.w2, 0, w2, 0, w2.size)
            System.arraycopy(src.w3, 0, w3, 0, w3.size)
        }
        fun breed(child: TinyBrain) {
            val mut = if (generation < 10) 0.18f else if (generation < 30) 0.10f else 0.05f
            for (i in w1.indices) child.w1[i] = w1[i] + (Random.nextFloat() - 0.5f) * mut
            for (i in w2.indices) child.w2[i] = w2[i] + (Random.nextFloat() - 0.5f) * mut
            for (i in w3.indices) child.w3[i] = w3[i] + (Random.nextFloat() - 0.5f) * mut
        }
        fun crossover(other: TinyBrain, child: TinyBrain, dynamicMut: Float) {
            val s1 = w1.size / 2; val s2 = w2.size / 2; val s3 = w3.size / 2
            System.arraycopy(w1, 0, child.w1, 0, s1)
            System.arraycopy(other.w1, s1, child.w1, s1, w1.size - s1)
            System.arraycopy(w2, 0, child.w2, 0, s2)
            System.arraycopy(other.w2, s2, child.w2, s2, w2.size - s2)
            System.arraycopy(w3, 0, child.w3, 0, s3)
            System.arraycopy(other.w3, s3, child.w3, s3, w3.size - s3)
            val baseMut = if (generation < 10) 0.12f else 0.06f
            val mut = max(baseMut, dynamicMut.coerceIn(0.06f, 0.30f))
            for (i in child.w1.indices) child.w1[i] += (Random.nextFloat() - 0.5f) * mut
            for (i in child.w2.indices) child.w2[i] += (Random.nextFloat() - 0.5f) * mut
            for (i in child.w3.indices) child.w3[i] += (Random.nextFloat() - 0.5f) * mut
        }
    }

    private fun evolveNextGeneration() {
        evolving = true
        try {
            v3EvolveGenome()
            generation++
            val scoresCopy = synchronized(sharedLock) { currentScores.copyOf() }
            val sortedIndices = (0 until POPULATION_SIZE).filter { !scoresCopy[it].isNaN() }.sortedByDescending { scoresCopy[it] }
            val bestBrains = if (sortedIndices.isNotEmpty()) {
                sortedIndices.take(minOf(10, sortedIndices.size)).map { TinyBrain().also { c -> c.copyFrom(population[it]) } }
            } else {
                (0 until minOf(10, POPULATION_SIZE)).map { TinyBrain().also { c -> c.copyFrom(population[it]) } }
            }
            if (bestBrains.isEmpty()) return

            val generationBest = if (sortedIndices.isNotEmpty()) scoresCopy[sortedIndices[0]] else 0f
            if (generationBest > previousGenerationBest + 0.001f) generationsWithoutImprovement = 0
            else generationsWithoutImprovement++
            previousGenerationBest = max(previousGenerationBest, generationBest)
            if (generationBest > bestScoreThisGen) bestScoreThisGen = generationBest
            if (generationBest > bestScoreAllTime) bestScoreAllTime = generationBest

            val dynamicMut = when {
                generationsWithoutImprovement >= 20 -> 0.30f
                generationsWithoutImprovement >= 10 -> 0.22f
                generationsWithoutImprovement >= 5 -> 0.16f
                else -> 0.12f
            }

            val eliteCount = 10
            val crossoverCount = 25
            val mutatedEliteCount = 10
            val immigrantCount = 5

            for (i in 0 until POPULATION_SIZE) {
                try {
                    when {
                        i < eliteCount -> population[i] = TinyBrain().also { it.copyFrom(bestBrains[i % bestBrains.size]) }
                        i < eliteCount + crossoverCount -> {
                            val p1 = bestBrains[Random.nextInt(bestBrains.size)]
                            var p2 = bestBrains[Random.nextInt(bestBrains.size)]
                            if (bestBrains.size > 1) while (p2 === p1) p2 = bestBrains[Random.nextInt(bestBrains.size)]
                            val child = TinyBrain(); p1.crossover(p2, child, dynamicMut); population[i] = child
                        }
                        i < eliteCount + crossoverCount + mutatedEliteCount -> {
                            val parent = bestBrains[Random.nextInt(bestBrains.size)]
                            val child = TinyBrain(); parent.breed(child); population[i] = child
                        }
                        else -> population[i] = TinyBrain()
                    }
                } catch (t: Throwable) { Log.e(LOG_TAG, "breed agent=$i failed", t); population[i] = TinyBrain() }
            }

            synchronized(sharedLock) { for (i in 0 until POPULATION_SIZE) currentScores[i] = 0f }

            val personality = when {
                v3Genome.dangerAversion > 1.8f && v3Genome.spacePriority > 1.6f -> "稳健保守型"
                v3Genome.foodPriority > 1.6f && v3Genome.hungerUrgency > 1.4f -> "激进捕食型"
                v3Genome.loopAversion > 1.6f -> "反循环型"
                v3Genome.tailPriority > 1.5f -> "追尾保命型"
                else -> "均衡探索型"
            }
            evoHistory.addLast(EvoRecord(generation, generationBest, eliteCount, crossoverCount,
                mutatedEliteCount + immigrantCount, personality,
                intArrayOf(deathWall, deathSelf, deathTrap), System.currentTimeMillis()))
            while (evoHistory.size > 24) evoHistory.pollFirst()

            val baseRatio = (generation / 30f).coerceIn(0f, 0.45f)
            val scoreBonus = (generationBest / 25000f).coerceIn(0f, 0.10f)
            nnWeight = (baseRatio + scoreBonus).coerceIn(0f, 0.50f)
            qWeight = (1.0f - nnWeight).coerceIn(0.50f, 1.0f)
            bestScoreThisGen = 0f

            Log.d(LOG_TAG, "EVOLVE gen=$generation best=$generationBest nnW=$nnWeight qW=$qWeight stall=$generationsWithoutImprovement")
            Thread { try { saveTrainingState() } catch (_: Exception) {} }.apply { isDaemon = true; start() }
        } catch (t: Throwable) { Log.e(LOG_TAG, "evolveNextGeneration failed", t) }
        finally { evolving = false }
    }

    private fun buildInputs(head: P, target: P, currentBody: ArrayDeque<P>): FloatArray {
        val inputs = FloatArray(8)
        inputs[0] = if (isSafeForBody(head.x, head.y - 1, currentBody)) 0f else 1f
        inputs[1] = if (isSafeForBody(head.x, head.y + 1, currentBody)) 0f else 1f
        inputs[2] = if (isSafeForBody(head.x - 1, head.y, currentBody)) 0f else 1f
        inputs[3] = if (isSafeForBody(head.x + 1, head.y, currentBody)) 0f else 1f
        inputs[4] = if (target.y < head.y) 1f else 0f
        inputs[5] = if (target.y > head.y) 1f else 0f
        inputs[6] = if (target.x < head.x) 1f else 0f
        inputs[7] = if (target.x > head.x) 1f else 0f
        return inputs
    }

    private fun isSafeForBody(nx: Int, ny: Int, body: ArrayDeque<P>): Boolean {
        val p = P(nx, ny)
        if (!inside(p)) return false
        if (body.contains(p) && p != body.last()) return false
        return true
    }

    var onScoreChanged: ((Int) -> Unit)? = null
    var onMoneyChanged: ((Int) -> Unit)? = null

    private val prefs = context.getSharedPreferences("snake_prefs", Context.MODE_PRIVATE)

    private val vibrator: Vibrator? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
        (context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as? VibratorManager)?.defaultVibrator
    } else {
        @Suppress("DEPRECATION") context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
    }

    private val toneGen: ToneGenerator? = try { ToneGenerator(AudioManager.STREAM_MUSIC, 85) } catch (_: Throwable) { null }

    private var bgm: BgmPlayer? = null
    private var bodyColor = Color.rgb(46, 204, 113)
    private var headColor = Color.rgb(39, 174, 96)
    private var bgColor = Color.BLACK
    private var gridColor = Color.CYAN
    private var rainbowSkin = false
    private val hsv = IntArray(360) { Color.HSVToColor(floatArrayOf(it.toFloat(), 1f, 1f)) }
    private val particles = mutableListOf<Particle>()
    private val floats = mutableListOf<FloatText>()

    private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val text = Paint(Paint.ANTI_ALIAS_FLAG)
    private val panel = Paint(Paint.ANTI_ALIAS_FLAG)
    private val border = Paint(Paint.ANTI_ALIAS_FLAG)
    private val gridPaint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val snakePaint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val headPaint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val foodPaint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val barPaint = Paint(Paint.ANTI_ALIAS_FLAG)

    private var flash = 0f
    private val hungerKillLimit = 500
    private val safeFollowLength = 32
    private var restartCountdown = 0L

    private var trainingMode = false
    private var reinforceTraining = false

    @Volatile private var lastHeartbeat = 0L
    @Volatile private var watchDogThread: Thread? = null
    @Volatile private var watchdogRestartCount = 0

    private fun heartbeat() { lastHeartbeat = System.currentTimeMillis() }

    private fun startWatchDog() {
        stopWatchDog()
        lastHeartbeat = System.currentTimeMillis()
        watchDogThread = Thread {
            while (true) {
                try { Thread.sleep(1000) } catch (_: Exception) {}
                if (!reinforceTraining) continue
                val now = System.currentTimeMillis()
                if (now - lastHeartbeat > HEARTBEAT_TIMEOUT_MS) {
                    watchdogRestartCount++
                    try { restartTrainingSafely() } catch (_: Exception) {}
                    try { Thread.sleep(3000) } catch (_: Exception) {}
                }
            }
        }.also { it.priority = Thread.MIN_PRIORITY; it.start() }
    }

    private fun stopWatchDog() { watchDogThread?.interrupt(); watchDogThread = null }

    override fun onSaveInstanceState(): Parcelable? {
        val superState = super.onSaveInstanceState()
        val bundle = Bundle()
        bundle.putParcelable("super", superState)
        bundle.putBoolean("reinforceTraining", reinforceTraining)
        bundle.putBoolean("trainingMode", trainingMode)
        return bundle
    }

    override fun onRestoreInstanceState(state: Parcelable?) {
        if (state is Bundle) {
            val wasReinforce = state.getBoolean("reinforceTraining", false)
            trainingMode = state.getBoolean("trainingMode", false)
            super.onRestoreInstanceState(state.getParcelable("super"))
            if (wasReinforce) { startParallelTraining(resetCounters = false); startWatchDog() }
        } else super.onRestoreInstanceState(state)
    }

    private var renderSkipCounter = 0
    private val reinforceButtonRect = RectF()
    private var lastReinforceTap = 0L
    @Volatile private var trainActive = false
    private val trainThreads: MutableList<Thread> = mutableListOf()
    private val TRAIN_THREADS = 8

    private val aiPool: ExecutorService = run {
        val cores = Runtime.getRuntime().availableProcessors().coerceIn(4, 8)
        Executors.newFixedThreadPool(cores) { r -> Thread(r, "snake-ai").apply { isDaemon = true; priority = Thread.NORM_PRIORITY } }
    }

    private val tlVisited: ThreadLocal<BooleanArray> = ThreadLocal.withInitial { BooleanArray(cols * rows) }
    private val tlQueue: ThreadLocal<IntArray> = ThreadLocal.withInitial { IntArray(cols * rows) }

    private var aiStepStartNs = 0L
    private var aiStepBudgetNs = 15_000_000L

    private fun budgetFor(speedMs: Long): Long = when {
        speedMs >= 150L -> 35_000_000L
        speedMs >= 80L -> 18_000_000L
        speedMs >= 55L -> 12_000_000L
        else -> 8_000_000L
    }

    private fun hungerForceEat(): Int = when {
        snake.size < 20 -> 50; snake.size < 35 -> 70; snake.size < 55 -> 100; snake.size < 80 -> 140; else -> 200
    }

    private fun vibrateEat() {
        if (reinforceTraining || trainingMode) return
        vibrator?.let { try { if (Build.VERSION.SDK_INT >= 26) it.vibrate(VibrationEffect.createOneShot(18, VibrationEffect.DEFAULT_AMPLITUDE)) else { @Suppress("DEPRECATION") it.vibrate(18) } } catch (_: Throwable) {} }
    }

    private fun vibrateDeath() {
        if (reinforceTraining || trainingMode) return
        vibrator?.let { try { if (Build.VERSION.SDK_INT >= 26) it.vibrate(VibrationEffect.createOneShot(120, VibrationEffect.DEFAULT_AMPLITUDE)) else { @Suppress("DEPRECATION") it.vibrate(120) } } catch (_: Throwable) {} }
    }

    private fun playEatSound() {
        if (reinforceTraining || trainingMode) return
        try { toneGen?.startTone(ToneGenerator.TONE_PROP_BEEP, 55) } catch (_: Throwable) {}
    }

    private val frame = object : Choreographer.FrameCallback {
        override fun doFrame(ns: Long) {
            if (!running) return
            if (lastFrame == 0L) lastFrame = ns
            val dt = ((ns - lastFrame) / 1_000_000L).coerceAtMost(100L)
            lastFrame = ns
            if (reinforceTraining) { if ((++renderSkipCounter % 2) == 0) invalidate(); Choreographer.getInstance().postFrameCallback(this); return }
            if (gameOver) restartCountdown = 0L
            else {
                accumulator += dt
                var stepCount = 0
                val maxSteps = if (trainingMode) 10 else Int.MAX_VALUE
                while (accumulator >= gameSpeed && stepCount < maxSteps) {
                    updateGame()
                    if (gameOver && !trainingMode) break
                    accumulator -= gameSpeed
                    stepCount++
                }
                if (stepCount >= maxSteps) accumulator = 0L
            }
            updateEffects(dt / 16f)
            val shouldRender = if (trainingMode) (++renderSkipCounter % 2) == 0 else true
            if (shouldRender) invalidate()
            Choreographer.getInstance().postFrameCallback(this)
        }
    }

    init {
        highScore = prefs.getInt("high_score", 0)
        money = prefs.getInt("money", 0)
        trainingMode = prefs.getBoolean("training_mode", false)
        aggression = prefs.getFloat("learn_aggression", 1.15f)
        safetyMargin = prefs.getFloat("learn_safety", 1.08f)
        shortcutBonus = prefs.getFloat("learn_shortcut", 0.90f)
        wRegion = prefs.getFloat("w_region", wRegion0)
        wMobility = prefs.getFloat("w_mobility", wMobility0)
        wTailGood = prefs.getFloat("w_tail_good", wTailGood0)
        wTailBad = prefs.getFloat("w_tail_bad", wTailBad0)
        wFoodNear = prefs.getFloat("w_food_near", wFoodNear0)
        wFoodAte = prefs.getFloat("w_food_ate", wFoodAte0)
        wEdge = prefs.getFloat("w_edge", wEdge0)
        wSpace = prefs.getFloat("w_space", wSpace0)

        fun fixW(v: Float, base: Float): Float = v.coerceIn(base * 0.85f, base * 1.15f)
        wRegion = fixW(wRegion, wRegion0); wMobility = fixW(wMobility, wMobility0)
        wTailGood = fixW(wTailGood, wTailGood0); wFoodNear = fixW(wFoodNear, wFoodNear0)
        wFoodAte = fixW(wFoodAte, wFoodAte0); wEdge = fixW(wEdge, wEdge0)
        wSpace = fixW(wSpace, wSpace0)
        wTailBad = wTailBad.coerceIn(wTailBad0 * 1.15f, wTailBad0 * 0.85f)
        aggression = aggression.coerceIn(0.95f, 1.35f)
        safetyMargin = safetyMargin.coerceIn(1.0f, 1.20f)

        lastLearnAction = prefs.getString("last_learn_action", "初始化") ?: "初始化"

        v3Genome.foodPriority = prefs.getFloat("v3_g_food", 1.00f)
        v3Genome.spacePriority = prefs.getFloat("v3_g_space", 1.25f)
        v3Genome.tailPriority = prefs.getFloat("v3_g_tail", 0.90f)
        v3Genome.dangerAversion = prefs.getFloat("v3_g_danger", 1.40f)
        v3Genome.loopAversion = prefs.getFloat("v3_g_loop", 0.80f)
        v3Genome.hungerUrgency = prefs.getFloat("v3_g_hunger", 0.80f)
        v3Genome.normalize()

        v3LessonFires = prefs.getInt("v3_lesson_fires", 0)
        v3LoopHits = prefs.getInt("v3_loop_hits", 0)
        deathWall = prefs.getInt("stat_wall", 0)
        deathSelf = prefs.getInt("stat_self", 0)
        deathTrap = prefs.getInt("stat_trap", 0)
        totalGames = prefs.getInt("stat_total", 0)

        bgm = BgmPlayer()
        updateCurrentSkin()
        updateCurrentBoard()
        loadTrainingState()
        reset()
    }

    fun getAIMode(): Int = aiMode
    fun setAIMode(m: Int) { aiMode = m; invalidate() }

    fun setTrainingMode(b: Boolean) {
        trainingMode = b
        if (b) { aiMode = 1; bgm?.stop(); reset() }
        else { stopParallelTraining(); if (running) bgm?.start(); reset() }
        invalidate()
    }

    fun setReinforceTraining(enable: Boolean) {
        if (enable) { startParallelTraining(); startWatchDog() }
        else { stopParallelTraining(); stopWatchDog() }
        invalidate()
    }

    fun isReinforceTraining(): Boolean = reinforceTraining
    fun isTrainingMode(): Boolean = trainingMode

    private fun restartTrainingSafely() {
        synchronized(sharedLock) { trainActive = false; reinforceTraining = false }
        val oldThreads = synchronized(trainThreads) { trainThreads.toList() }
        for (t in oldThreads) { try { t.interrupt() } catch (_: Throwable) {} }
        for (t in oldThreads) { try { t.join(500) } catch (_: InterruptedException) { break } }
        synchronized(trainThreads) { trainThreads.clear() }
        Thread.sleep(200)
        synchronized(sharedLock) { reinforceTraining = true }
        startParallelTraining(resetCounters = false)
        startWatchDog()
    }

    private fun startParallelTraining(resetCounters: Boolean = true) {
        synchronized(trainingLifecycleLock) {
            if (trainThreads.any { it.isAlive }) return
            if (trainActive) return

            trainingRunId++
            val myRunId = trainingRunId

            reinforceTraining = true
            trainingMode = true
            aiMode = 1
            bgm?.stop()
            gameOver = false
            trainActive = true
            trainThreads.clear()

            if (resetCounters) {
                currentAgentIndex = 0
                completedAgents = 0
                uniqueCompletedAgents = 0
                bestScoreThisGen = 0f
                completedAgentIds.clear()
                java.util.Arrays.fill(agentCompleted, false)
                synchronized(sharedLock) { for (i in 0 until POPULATION_SIZE) currentScores[i] = 0f }
            }

            generationToken++
            val myGenerationToken = generationToken
            generationTransitioning = false

            for (i in threadStatus.indices) {
                threadStatus[i].alive = false; threadStatus[i].agentId = -1
                threadStatus[i].score = 0; threadStatus[i].steps = 0; threadStatus[i].phase = "空闲"
            }

            Log.d(LOG_TAG, "GEN_START gen=$generation token=$myGenerationToken run=$myRunId pop=$POPULATION_SIZE th=$TRAIN_THREADS")

            for (i in 0 until TRAIN_THREADS) {
                val threadIdx = i
                val t = Thread({
                    val game = TrainGame(seed = System.nanoTime() + i * 999983L, runId = myRunId, statusIndex = threadIdx)
                    threadStatus[threadIdx].alive = true

                    while (isTrainingRunActive(myRunId) && !Thread.currentThread().isInterrupted) {
                        if (evolving || generationTransitioning || generationToken != myGenerationToken) {
                            threadStatus[threadIdx].phase = "进化"; Thread.yield(); continue
                        }

                        val agentId: Int
                        synchronized(sharedLock) {
                            if (currentAgentIndex >= POPULATION_SIZE) agentId = -1
                            else { agentId = currentAgentIndex; currentAgentIndex++ }
                        }

                        if (agentId < 0) { threadStatus[threadIdx].phase = "等待"; Thread.yield(); continue }

                        synchronized(sharedLock) {
                            if (agentId !in 0 until POPULATION_SIZE || agentCompleted[agentId]) {
                                Log.e(LOG_TAG, "INVALID_AGENT_ASSIGNMENT agent=$agentId gen=$generation")
                                continue
                            }
                        }

                        threadStatus[threadIdx].agentId = agentId
                        threadStatus[threadIdx].phase = "训练"
                        Log.d(LOG_TAG, "AGENT_START gen=$generation agent=$agentId thread=$threadIdx")

                        var episodeCompleted = false
                        try {
                            episodeCompleted = game.playOneGame(agentId = agentId, expectedGenerationToken = myGenerationToken)
                        } catch (t: Throwable) { Log.e(LOG_TAG, "Agent $agentId crashed outside playOneGame", t) }

                        if (!episodeCompleted) { threadStatus[threadIdx].phase = "等待"; continue }

                        var shouldEvolve = false
                        synchronized(sharedLock) {
                            if (generationToken != myGenerationToken) {
                                Log.w(LOG_TAG, "STALE_AGENT_RESULT agent=$agentId expected=$myGenerationToken actual=$generationToken")
                            } else if (agentId in 0 until POPULATION_SIZE && !agentCompleted[agentId]) {
                                agentCompleted[agentId] = true
                                completedAgentIds.add(agentId)
                                completedAgents++
                                uniqueCompletedAgents++
                                Log.d(LOG_TAG, "AGENT_COMPLETE gen=$generation agent=$agentId done=$completedAgents/$POPULATION_SIZE")
                                if (completedAgents == POPULATION_SIZE && currentAgentIndex == POPULATION_SIZE && !generationTransitioning) {
                                    generationTransitioning = true
                                    shouldEvolve = true
                                    Log.d(LOG_TAG, "GEN_COMPLETE gen=$generation done=$completedAgents/$POPULATION_SIZE")
                                }
                            }
                        }

                        if (shouldEvolve) {
                            synchronized(evolveLock) {
                                if (isTrainingRunActive(myRunId) && generationToken == myGenerationToken) {
                                    try { evolveNextGeneration() } catch (t: Throwable) { Log.e(LOG_TAG, "evolveNextGeneration failed", t) }
                                    finally {
                                        synchronized(sharedLock) {
                                            currentAgentIndex = 0; completedAgents = 0; uniqueCompletedAgents = 0
                                            completedAgentIds.clear(); java.util.Arrays.fill(agentCompleted, false)
                                            generationToken++; generationTransitioning = false
                                        }
                                        Log.d(LOG_TAG, "GEN_NEXT_READY gen=$generation")
                                    }
                                } else synchronized(sharedLock) { generationTransitioning = false }
                            }
                        }
                    }
                    threadStatus[threadIdx].alive = false; threadStatus[threadIdx].phase = "空闲"; threadStatus[threadIdx].agentId = -1
                }, "snake-train-$i")
                t.isDaemon = true
                t.priority = Thread.NORM_PRIORITY
                t.start()
                trainThreads.add(t)
            }
        }
    }

    private fun stopParallelTraining() {
        val threadsToJoin: List<Thread>
        synchronized(trainingLifecycleLock) {
            if (!trainActive && trainThreads.none { it.isAlive }) { reinforceTraining = false; trainingMode = false; return }
            trainingRunId++; trainActive = false; reinforceTraining = false; trainingMode = false
            threadsToJoin = trainThreads.toList()
        }
        for (t in threadsToJoin) { try { t.interrupt() } catch (_: Throwable) {} }
        for (t in threadsToJoin) { try { t.join(5000L) } catch (_: Throwable) {} }
        synchronized(trainingLifecycleLock) { trainThreads.removeAll { !it.isAlive } }
        saveLearning(); saveTrainingState()
        if (running) bgm?.start()
        reset()
    }

    fun setForcedStrategy(s: Int) { forcedStrategy = s; invalidate() }

    fun updateCurrentSkin(id: String? = null) {
        when (prefs.getString("equipped_skin", "green")) {
            "blue" -> setSnakeColors(Color.rgb(52, 152, 219), Color.rgb(41, 128, 185), false)
            "red" -> setSnakeColors(Color.rgb(46, 204, 113), Color.rgb(192, 57, 43), false)
            "purple" -> setSnakeColors(Color.rgb(155, 89, 182), Color.rgb(142, 68, 173), false)
            "gold" -> setSnakeColors(Color.rgb(241, 196, 15), Color.rgb(243, 156, 18), false)
            "rainbow" -> setSnakeColors(Color.WHITE, Color.WHITE, true)
            else -> setSnakeColors(Color.rgb(46, 204, 113), Color.rgb(39, 174, 96), false)
        }
        invalidate()
    }

    private fun setSnakeColors(body: Int, head: Int, rainbow: Boolean) {
        bodyColor = body; headColor = head; rainbowSkin = rainbow
        snakePaint.color = body
        snakePaint.style = Paint.Style.STROKE
        snakePaint.strokeCap = Paint.Cap.ROUND
        snakePaint.strokeJoin = Paint.Join.ROUND
        snakePaint.strokeWidth = 0f
        headPaint.color = head
    }

    fun updateCurrentBoard(id: String? = null) {
        when (prefs.getString("equipped_board", "dark")) {
            "light" -> { bgColor = Color.rgb(240, 240, 240); gridColor = Color.rgb(200, 200, 200) }
            "neon" -> { bgColor = Color.rgb(10, 25, 47); gridColor = Color.CYAN }
            "forest" -> { bgColor = Color.rgb(27, 46, 26); gridColor = Color.rgb(46, 74, 45) }
            "cyberpunk" -> { bgColor = Color.rgb(43, 15, 59); gridColor = Color.MAGENTA }
            "rainbow_board" -> { bgColor = Color.BLACK; gridColor = Color.WHITE }
            else -> { bgColor = Color.BLACK; gridColor = Color.CYAN }
        }
        invalidate()
    }

    fun reset() {
        snake.clear(); queue.clear()
        if (aiMode == 2) { snake.add(P(0, 0)); dir = P(0, 1) }
        else { snake.add(P(cols / 2, rows / 2)); dir = P(1, 0) }
        score = 0; combo = 0; hunger = 0
        gameOver = false; deathCause = "无"; lastDeathInfo = ""
        gameSpeed = if (trainingMode && !reinforceTraining) 2L else gameSpeedStart
        accumulator = 0L; lastFrame = 0L
        particles.clear(); floats.clear()
        flash = 0f; restartCountdown = 0L
        lastV2State = -1; lastV2Action = -1
        ai = Snapshot(chosen = dir)
        placeFood()
        lastFreeRegion = freeRegion(snake).toFloat()
        onScoreChanged?.invoke(score)
        invalidate()
    }

    fun resume() {
        if (running) return
        running = true; lastFrame = 0L
        if (!trainingMode) bgm?.start()
        Choreographer.getInstance().postFrameCallback(frame)
    }

    fun pause() {
        running = false; bgm?.stop()
        Choreographer.getInstance().removeFrameCallback(frame)
    }

    private fun updateGame() {
        if (gameOver) return
        heartbeat()
        if (hunger >= hungerKillLimit) { die("HUNGER"); return }
        if (aiMode != 0) { queue.clear(); queue.add(chooseMove()) }
        if (queue.isNotEmpty()) {
            val requested = queue.removeFirst()
            if (!isReverse(requested, dir) && legalDirection(requested)) dir = requested
        }
        if (dir == P(0, 0)) return
        val oldState = buildState(snake, dir, food, hunger)
        val oldAction = dirs.indexOfFirst { it == dir }.coerceAtLeast(0)
        val nh = P(snake.first().x + dir.x, snake.first().y + dir.y)
        if (!inside(nh)) { qTerminalFromMove(oldState, oldAction, DEATH_WALL); die("WALL"); return }
        val ate = nh == food
        val body = snake.toList()
        val hitIndex = body.indexOf(nh)
        val tail = snake.last()
        if (hitIndex >= 0 && !(nh == tail && !ate)) {
            val sim = simulateOn(ArrayDeque(snake), dir)
            val region = freeRegion(sim.body)
            val cause = if (region < max(2, (snake.size * safetyMargin).toInt())) "TRAP" else "SELF"
            val reward = if (cause == "TRAP") DEATH_TRAP else DEATH_SELF
            qTerminalFromMove(oldState, oldAction, reward); die(cause); return
        }
        snake.addFirst(nh); v3RecordHead()
        var reward = REWARD_STEP
        if (ate) {
            val comboBonus = min(combo, 30) * 3
            val gain = 10 + comboBonus + snake.size
            score += gain; combo++; hunger = 0
            money += gain * 3 + 30
            if (score > highScore) highScore = score
            onScoreChanged?.invoke(score); onMoneyChanged?.invoke(money)
            prefs.edit().putInt("money", money).putInt("high_score", highScore).apply()
            gameSpeed = max(gameSpeedMin, gameSpeedStart - snake.size * 2L)
            vibrateEat(); playEatSound(); spawnFoodEffect(nh); placeFood()
            reward += REWARD_FOOD + combo * 0.06f
        } else {
            snake.removeLast(); hunger++; combo = max(0, combo - 1)
            val curFree = freeRegion(snake).toFloat()
            val spaceDelta = curFree - lastFreeRegion
            lastFreeRegion = curFree
            reward += spaceDelta * REWARD_SPACE_DELTA
            if (tailReachable(snake)) reward += REWARD_TAIL
            if (calculateDanger() >= 4) reward += REWARD_DANGER
            val hungerPenalty = -(hunger * hunger * 0.001f).coerceAtMost(0.15f)
            reward += hungerPenalty
        }
        val nextState = buildState(snake, dir, food, hunger)
        val nextMask = legalActionMask(snake, dir, food)
        qUpdate(oldState, oldAction, reward, nextState, nextMask, false)
        lastV2State = nextState; lastV2Action = oldAction
    }

    private fun directionIndex(d: P): Int = when (d) { P(0, -1) -> 0; P(0, 1) -> 1; P(-1, 0) -> 2; else -> 3 }

    private fun foodDirection(head: P, target: P): Int {
        val dx = target.x - head.x; val dy = target.y - head.y
        return if (abs(dx) >= abs(dy)) { if (dx >= 0) 3 else 2 } else { if (dy >= 0) 1 else 0 }
    }

    private fun dangerMask(body: ArrayDeque<P>, heading: P, target: P): Int {
        if (body.isEmpty()) return 15
        val h = body.first(); var mask = 0
        for (i in dirs.indices) {
            val d = dirs[i]
            if (isReverse(d, heading)) { mask = mask or (1 shl i); continue }
            val np = P(h.x + d.x, h.y + d.y)
            if (!inside(np)) { mask = mask or (1 shl i); continue }
            val ate = np == target
            if (body.contains(np) && !(np == body.last() && !ate)) { mask = mask or (1 shl i); continue }
            val sim = simulateForBody(body, d, target)
            if (sim.body.isEmpty()) { mask = mask or (1 shl i); continue }
            val region = freeRegion(sim.body)
            val tail = tailReachable(sim.body)
            val ratio = region.toFloat() / max(1, sim.body.size)
            if (!tail && sim.body.size > 8) mask = mask or (1 shl i)
            else if (ratio < 0.55f && sim.body.size > 12) mask = mask or (1 shl i)
        }
        return mask and 15
    }

    private fun buildState(body: ArrayDeque<P>, heading: P, target: P, hungerValue: Int): Int {
        if (body.isEmpty()) return 0
        val h = body.first()
        val foodD = foodDirection(h, target)
        val danger = dangerMask(body, heading, target)
        val mobility = countSafeMovesFor(body, heading, target).coerceIn(0, 4)
        val region = freeRegion(body)
        val ratio = region.toFloat() / max(1, body.size)
        val spaceBucket = when { ratio < 0.8f -> 0; ratio < 1.3f -> 1; ratio < 2.0f -> 2; else -> 3 }
        val hungerBucket = when { hungerValue < 10 -> 0; hungerValue < 25 -> 1; hungerValue < 50 -> 2; hungerValue < 100 -> 3; else -> 4 }
        val lengthBucket = when { body.size < 12 -> 0; body.size < 30 -> 1; body.size < 60 -> 2; else -> 3 }
        val tail = if (tailReachable(body)) 1 else 0
        val headingIndex = directionIndex(heading)
        var s = foodD
        s = s * V2_DANGER + danger
        s = s * V2_MOBILITY + mobility
        s = s * V2_SPACE + spaceBucket
        s = s * V2_HUNGER + hungerBucket
        s = s * V2_LENGTH + lengthBucket
        s = s * V2_TAIL + tail
        s = s * V2_HEADING + headingIndex
        return s.coerceIn(0, V2_STATE_COUNT - 1)
    }

    private fun legalActionMask(body: ArrayDeque<P>, heading: P, target: P): Int {
        if (body.isEmpty()) return 0
        val h = body.first(); var mask = 0
        for (i in dirs.indices) {
            val d = dirs[i]
            if (isReverse(d, heading)) continue
            val np = P(h.x + d.x, h.y + d.y)
            if (!inside(np)) continue
            val ate = np == target
            if (body.contains(np) && !(np == body.last() && !ate)) continue
            mask = mask or (1 shl i)
        }
        return mask
    }

    private fun qTerminalFromMove(state: Int, action: Int, reward: Float) { qUpdate(state, action, reward, state, 0, true) }

    private fun selectV2Action(state: Int, legal: List<Candidate>, training: Boolean): Candidate {
        if (legal.isEmpty()) return Candidate(dir, -1e9f, "无合法动作", false)
        if (forcedStrategy >= 0) return bestSurvivalStep(legal)
        val epsilon = if (training) currentEpsilon() else 0f
        if (training && Random.nextFloat() < epsilon) {
            val safe = legal.filter { it.tailOk || it.region >= max(5, snake.size / 2) }
            return if (safe.isNotEmpty()) safe[Random.nextInt(safe.size)] else legal[Random.nextInt(legal.size)]
        }
        var best = legal.first(); var bestValue = -Float.MAX_VALUE
        for (candidate in legal) {
            val action = dirs.indexOfFirst { it == candidate.d }
            if (action < 0) continue
            val q = qRead(state, action); val visits = qVisit(state, action)
            val safetyBonus = when {
                candidate.tailOk && candidate.region >= snake.size * 1.5f -> 2.2f
                candidate.tailOk -> 1.2f
                candidate.region >= snake.size -> 0.35f
                else -> -1.5f
            }
            val foodBonus = if (candidate.ate) 4.0f else if (candidate.foodDist >= 0) 0.7f / (candidate.foodDist + 1) else 0f
            val visitBonus = 0.12f / kotlin.math.sqrt((visits + 1).toFloat())
            val value = q + safetyBonus + foodBonus + visitBonus
            if (value > bestValue) { bestValue = value; best = candidate.copy(qValue = q) }
        }
        return best
    }

    private fun chooseMove(): P {
        aiStepStartNs = System.nanoTime(); aiStepBudgetNs = budgetFor(gameSpeed)
        if (v3FusionEnabled) { val v3g = v3SelectGoal(); v3Goal = v3g; v3GoalCounter[v3g.ordinal]++ }
        val futures: List<Future<Candidate>> = dirs.map { d -> aiPool.submit(Callable { evaluate(d) }) }
        val candidates = futures.map { try { it.get() } catch (_: Throwable) { Candidate(P(0, 0), -1e9f, "AI异常", false) } }
        val legal = candidates.filter { it.legal }
        if (legal.isEmpty()) { ai = Snapshot(strategy = "NO MOVE", reason = "四个方向都无法前进", danger = 5, chosen = dir, candidates = candidates); return dir }
        val danger = calculateDanger()
        val regionNow = freeRegion(snake)
        val foodDistNow = distance(snake.first(), food, snake, true)
        val state = buildState(snake, dir, food, hunger)

        val safeFood = findSafeFoodStep()
        if (safeFood != null) {
            val action = dirs.indexOfFirst { it == safeFood }.coerceAtLeast(0)
            val q = qRead(state, action)
            lastV2State = state; lastV2Action = action
            v3LayerActive = 1; v3LayerWhy = "L1安全食物层(硬安全)"
            ai = Snapshot(strategy = "V2 SAFE FOOD", reason = "安全路径可吃食物，吃后尾巴仍可达",
                danger = danger, region = regionNow, spaceRatio = regionNow.toFloat() / max(1, snake.size),
                tailReachable = tailReachable(snake), foodReachable = true, foodDistance = foodDistNow,
                hunger = hunger, chosen = safeFood, candidates = candidates, depth = 2, nodes = legal.size,
                hungerFactor = hungerFactorValue(), regionWeight = wRegion, strategyId = 10,
                qValue = q, nVisits = qVisit(state, action), forceEatActive = false, forceEatSafe = true, safeFollowMode = false)
            return v3PostCheck(safeFood, legal, state)
        }

        val tailStep = followTailStep(legal)
        if (tailStep != null && hunger < hungerForceEat()) {
            val action = dirs.indexOfFirst { it == tailStep }.coerceAtLeast(0)
            val q = qRead(state, action)
            lastV2State = state; lastV2Action = action
            v3LayerActive = 2; v3LayerWhy = "L2尾巴追踪层(空间循环)"
            ai = Snapshot(strategy = "V2 TAIL", reason = "食物路线风险较高，沿尾巴保持循环空间",
                danger = danger, region = regionNow, spaceRatio = regionNow.toFloat() / max(1, snake.size),
                tailReachable = true, foodReachable = foodDistNow >= 0, foodDistance = foodDistNow,
                hunger = hunger, chosen = tailStep, candidates = candidates, depth = 1, nodes = legal.size,
                hungerFactor = hungerFactorValue(), regionWeight = wRegion, strategyId = 11,
                qValue = q, nVisits = qVisit(state, action), forceEatActive = false, forceEatSafe = false, safeFollowMode = true)
            return v3PostCheck(tailStep, legal, state)
        }

        val forceThreshold = hungerForceEat()
        if (hunger >= forceThreshold && foodDistNow >= 0) {
            val safeFoodCandidates = legal.filter { it.tailOk && it.foodDist >= 0 }
            if (safeFoodCandidates.isNotEmpty()) {
                val selected = selectV2Action(state, safeFoodCandidates, training = trainingMode || reinforceTraining)
                val action = dirs.indexOfFirst { it == selected.d }.coerceAtLeast(0)
                lastV2State = state; lastV2Action = action
                v3LayerActive = 3; v3LayerWhy = "L3饥饿压制层(强制进食)"
                ai = Snapshot(strategy = "V2 HUNGER", reason = "饥饿压力提高食物收益，但仍受安全屏蔽",
                    danger = max(danger, 3), region = regionNow, spaceRatio = regionNow.toFloat() / max(1, snake.size),
                    tailReachable = selected.tailOk, foodReachable = true, foodDistance = selected.foodDist,
                    hunger = hunger, chosen = selected.d,
                    candidates = candidates.map { if (it.d == selected.d) it.copy(qValue = qRead(state, action)) else it },
                    depth = 1, nodes = legal.size, hungerFactor = hungerFactorValue(), regionWeight = wRegion,
                    strategyId = 12, qValue = qRead(state, action), nVisits = qVisit(state, action),
                    forceEatActive = true, forceEatSafe = true, safeFollowMode = false)
                return v3PostCheck(selected.d, legal, state)
            }
        }

        val shielded = legal.filter { val ratio = it.region.toFloat() / max(1, snake.size); it.tailOk || ratio >= 1.0f || (snake.size < 15 && ratio >= 0.75f) }
        val pool = if (shielded.isNotEmpty()) shielded else legal
        val brain = if (trainingMode || reinforceTraining) population[currentAgentIndex.coerceAtLeast(0) % POPULATION_SIZE] else population[0]
        val nnInputs = buildInputs(snake.first(), food, snake)
        val nnVals = brain.think(nnInputs)
        val de = checkFoodDeadEnd()
        deadEndPredicted = de.first; foodSpaceRatio = de.second
        var deadEndPenalty = 0f; if (de.first) deadEndPenalty = -5f
        val rSteps = when { snake.size > 60 -> 5; snake.size > 25 -> 3; else -> 0 }
        rolloutActive = rSteps > 0; rolloutSteps = rSteps

        var best = pool.first(); var bestValue = -Float.MAX_VALUE
        for (candidate in pool) {
            val action = dirs.indexOfFirst { it == candidate.d }; if (action < 0) continue
            val q = qRead(state, action); val nn = nnVals[action]; val rule = candidate.score
            val rolloutScore = if (rSteps > 0) rolloutN(candidate.d, rSteps) else 0f
            val mixed = qWeight * q + nnWeight * nn * 5f + rule * 0.001f + deadEndPenalty + rolloutScore * 0.5f
            if (mixed > bestValue) { bestValue = mixed; best = candidate.copy(qValue = q) }
        }

        val action = dirs.indexOfFirst { it == best.d }.coerceAtLeast(0)
        lastV2State = state; lastV2Action = action
        v3LayerActive = 4; v3LayerWhy = "L4混合决策(Q+NN+规则)"
        ai = Snapshot(strategy = "V4混合进化 (Q+NN+记忆)", reason = "规则过滤后，Q表与NN选出最优动作",
            danger = danger, region = regionNow, spaceRatio = regionNow.toFloat() / max(1, snake.size),
            tailReachable = tailReachable(snake), foodReachable = foodDistNow >= 0, foodDistance = foodDistNow,
            hunger = hunger, chosen = best.d, candidates = candidates.map { if (it.d == best.d) it.copy(qValue = qRead(state, action)) else it },
            depth = 1, nodes = pool.size, hungerFactor = hungerFactorValue(), regionWeight = wRegion,
            strategyId = 20, qValue = qRead(state, action), nVisits = qVisit(state, action),
            forceEatActive = false, forceEatSafe = false, safeFollowMode = false)
        return v3PostCheck(best.d, legal, state)
    }

    private fun hungerFactorValue(): Float = when { hunger >= 60 -> 4f; hunger >= 30 -> 2.5f; hunger >= 15 -> 1.6f; else -> 1f }

    private fun followTailStep(legal: List<Candidate>): P? {
        if (snake.size < 2) return null
        val path = shortestPath(snake.first(), snake.last(), snake, allowTail = true) ?: return null
        if (path.isEmpty()) return null
        val step = path.first(); if (legal.none { it.d == step }) return null
        val sim = simulate(snake.first(), step); if (sim.body.isEmpty()) return null
        if (!tailReachable(sim.body)) return null
        val r = freeRegion(sim.body)
        if (r < 3 && snake.size < total - 5) return null
        return step
    }

    private fun findSafeFoodStep(): P? {
        val path = shortestPath(snake.first(), food, snake, allowTail = true) ?: return null
        if (path.isEmpty()) return null
        val simBody = ArrayDeque(snake); var ate = false
        for (step in path) {
            val nh = P(simBody.first().x + step.x, simBody.first().y + step.y)
            if (!inside(nh)) return null
            val willEat = nh == food
            if (simBody.contains(nh) && !(nh == simBody.last() && !willEat)) return null
            simBody.addFirst(nh); if (!willEat) simBody.removeLast() else ate = true
        }
        if (!ate) return null
        if (!tailReachable(simBody)) return null
        val len = simBody.size; val freeLeft = total - len
        if (len > 180 && freeLeft < 4) return null
        if (len > 150 && freeLeft < 6) return null
        if (len > 120 && freeLeft < 10) return null
        if (len > 90 && freeLeft < 14) return null
        if (len > 60 && freeLeft < 20) return null
        if (len <= 60 && freeLeft >= 20) { val r = freeRegion(simBody); if (r < max(4, freeLeft / 3)) return null }
        return path.first()
    }

    private fun bestSurvivalStep(legal: List<Candidate>): Candidate {
        var best = legal.first(); var bestScore = -1e30f
        val len = snake.size; val tailPos = snake.last(); val bodySet = snake.toHashSet()
        val tailW = (wTailGood / wTailGood0).coerceIn(0.8f, 1.2f)
        val spaceW = (wSpace / wSpace0).coerceIn(0.8f, 1.2f)
        val foodW = (wFoodNear / wFoodNear0).coerceIn(0.8f, 1.2f)
        for (cand in legal) {
            val sim = simulate(snake.first(), cand.d); if (sim.body.isEmpty()) continue
            val nh = sim.body.first(); val r = freeRegion(sim.body)
            val t = tailReachable(sim.body); val mob = countSafeMoves(sim.body)
            val freeLeft = total - sim.body.size
            var sc = 0f
            if (t) sc += 50000f * tailW
            else { sc -= 200000f; if (sc > bestScore) { bestScore = sc; best = cand }; continue }
            sc += r * 250f * spaceW
            if (freeLeft > 0) sc += (r.toFloat() / freeLeft) * 15000f * spaceW
            sc += mob * 500f
            var bodyAdj = 0
            for (d in dirs) { val p = P(nh.x + d.x, nh.y + d.y); if (bodySet.contains(p) || sim.body.contains(p)) bodyAdj++ }
            sc += bodyAdj * 600f
            val dToTail = distance(nh, tailPos, sim.body, true)
            if (dToTail >= 0) { sc += 8000f / (dToTail + 1); if (dToTail > 6) sc -= (dToTail - 6) * 150f }
            val fd = distance(nh, food, sim.body, true)
            if (fd >= 0) sc += (500f * foodW) / (fd + 1)
            if (len >= 100) sc += r * 300f
            val nx = sim.body.first().x; val ny = sim.body.first().y
            val edge = min(min(nx, cols - 1 - nx), min(ny, rows - 1 - ny))
            sc -= max(0, 3 - edge) * 800f
            val hx0 = snake.first().x; val hy0 = snake.first().y
            val atEdgeNow = hx0 == 0 || hx0 == cols - 1 || hy0 == 0 || hy0 == rows - 1
            if (!atEdgeNow && edge == 0 && snake.size > 20) sc -= 6000f
            if (nx == 0 || nx == cols - 1 || ny == 0 || ny == rows - 1) sc -= 500f
            if (sim.ate) sc += 5000f
            if (sc > bestScore) { bestScore = sc; best = cand }
        }
        return best
    }

    private fun evaluate(d: P): Candidate {
        if (!legalDirection(d)) return Candidate(d, -1e9f, "撞墙/身体", false)
        val sim = simulate(snake.first(), d)
        val region = freeRegion(sim.body); val tail = tailReachable(sim.body)
        val foodDist = distance(sim.body.first(), food, sim.body, true)
        val ate = sim.ate; val mobility = countSafeMoves(sim.body)
        val hungerFactor = hungerFactorValue()
        val lenBoost = if (snake.size >= safeFollowLength) (snake.size.toFloat() / safeFollowLength).coerceIn(1f, 3f) else 1f
        val regionScoreVal = region * wRegion * lenBoost
        val mobilityScoreVal = mobility * wMobility
        val tailScoreVal = if (tail) wTailGood * lenBoost else wTailBad * lenBoost
        var foodScoreVal = if (foodDist >= 0) hungerFactor * aggression * (wFoodNear / (foodDist + 1)) else -450f * hungerFactor
        if (ate) foodScoreVal += wFoodAte * aggression
        var eatPenalty = 0f
        if (ate) {
            val afterSize = sim.body.size
            val needSpace = (afterSize * safetyMargin).toInt() + 2
            if (!tail || region < needSpace) eatPenalty = -7500f - snake.size * 100f
            else {
                val after = ArrayDeque(sim.body)
                val dx = after.last().x - after.first().x
                val dy = after.last().y - after.first().y
                val follow = when {
                    abs(dx) >= abs(dy) && dx != 0 -> P(if (dx > 0) 1 else -1, 0)
                    dy != 0 -> P(0, if (dy > 0) 1 else -1)
                    else -> null
                }
                if (follow != null && canSim(after, follow)) {
                    val next = simulateOn(after, follow)
                    val r2 = freeRegion(next.body); val t2 = tailReachable(next.body)
                    if (!t2 || r2 < (afterSize * 1.2f).toInt()) eatPenalty = -4500f - snake.size * 60f
                }
            }
        }
        val edge = min(min(sim.body.first().x, cols - 1 - sim.body.first().x), min(sim.body.first().y, rows - 1 - sim.body.first().y))
        val edgeScoreVal = -max(0, 2 - edge) * wEdge
        val spacePenalty = max(0f, snake.size * safetyMargin - region.toFloat())
        val spaceScoreVal = -spacePenalty * wSpace
        val totalScore = regionScoreVal + mobilityScoreVal + tailScoreVal + foodScoreVal + edgeScoreVal + spaceScoreVal + eatPenalty
        val reason = when {
            ate && eatPenalty < 0 -> "吃完会困死，避开"
            ate -> "马上吃到食物"
            tail -> "保持尾巴可达"
            else -> "扩大可用空间"
        }
        return Candidate(d = d, score = totalScore, reason = reason, legal = true,
            regionScore = regionScoreVal, mobilityScore = mobilityScoreVal, tailScore = tailScoreVal,
            foodScore = foodScoreVal, edgeScore = edgeScoreVal, spaceScore = spaceScoreVal,
            region = region, mobility = mobility, tailOk = tail, foodDist = foodDist, ate = ate)
    }

    private fun clampW(v: Float, lo: Float, hi: Float): Float = v.coerceIn(lo, hi)

    private fun adjustWeights(cause: String) {
        val beforeEdge = wEdge; val beforeTail = wTailGood; val beforeSpace = wSpace; val beforeFood = wFoodNear
        val beforeAgg = aggression; val beforeSafety = safetyMargin
        when (cause) {
            "WALL" -> { wEdge = clampW(wEdge * 1.03f, wEdge0 * 0.9f, wEdge0 * 1.1f); aggression = clampW(aggression * 0.99f, 0.95f, 1.35f) }
            "SELF" -> { wTailGood = clampW(wTailGood * 1.03f, wTailGood0 * 0.9f, wTailGood0 * 1.1f); wTailBad = clampW(wTailBad * 1.02f, wTailBad0 * 1.1f, wTailBad0 * 0.9f); safetyMargin = clampW(safetyMargin * 1.01f, 1.0f, 1.20f) }
            "TRAP" -> { wSpace = clampW(wSpace * 1.04f, wSpace0 * 0.9f, wSpace0 * 1.1f); wRegion = clampW(wRegion * 1.02f, wRegion0 * 0.9f, wRegion0 * 1.1f); safetyMargin = clampW(safetyMargin * 1.01f, 1.0f, 1.20f); aggression = clampW(aggression * 1.005f, 0.95f, 1.35f); wFoodAte = clampW(wFoodAte * 1.02f, wFoodAte0 * 0.9f, wFoodAte0 * 1.1f) }
            "HUNGER" -> { wFoodNear = clampW(wFoodNear * 1.04f, wFoodNear0 * 0.9f, wFoodNear0 * 1.1f); wFoodAte = clampW(wFoodAte * 1.03f, wFoodAte0 * 0.9f, wFoodAte0 * 1.1f); aggression = clampW(aggression * 1.02f, 0.95f, 1.35f); wSpace = clampW(wSpace * 0.98f, wSpace0 * 0.9f, wSpace0 * 1.1f); safetyMargin = clampW(safetyMargin * 0.99f, 1.0f, 1.20f) }
        }
        wRegion = wRegion * 0.95f + wRegion0 * 0.05f
        wMobility = wMobility * 0.95f + wMobility0 * 0.05f
        wEdge = wEdge * 0.95f + wEdge0 * 0.05f
        wSpace = wSpace * 0.95f + wSpace0 * 0.05f
        wFoodNear = wFoodNear * 0.95f + wFoodNear0 * 0.05f
        wTailGood = wTailGood * 0.95f + wTailGood0 * 0.05f
        wFoodAte = wFoodAte * 0.95f + wFoodAte0 * 0.05f
        lastLearnAction = when (cause) {
            "WALL" -> "边界${"%.0f→%.0f".format(beforeEdge, wEdge)} 攻${"%.2f→%.2f".format(beforeAgg, aggression)}"
            "SELF" -> "尾+${"%.0f→%.0f".format(beforeTail, wTailGood)} 安全${"%.2f→%.2f".format(beforeSafety, safetyMargin)}"
            "TRAP" -> "空间${"%.0f→%.0f".format(beforeSpace, wSpace)} 安全${"%.2f→%.2f".format(beforeSafety, safetyMargin)}"
            "HUNGER" -> "食近${"%.0f→%.0f".format(beforeFood, wFoodNear)} 攻${"%.2f→%.2f".format(beforeAgg, aggression)}"
            else -> "微调"
        }
    }

    private fun saveTrainingState() {
        try {
            val file = context.getFileStreamPath("snake_training.dat")
            val genCopy: Int; val scoreCopy: Float; val qCopy: FloatArray; val nCopy: IntArray; val popCopy: List<TinyBrain>
            synchronized(sharedLock) {
                genCopy = generation; scoreCopy = bestScoreAllTime
                qCopy = qV2.copyOf(); nCopy = nV2.copyOf()
                popCopy = population.map { b -> TinyBrain().apply {
                    System.arraycopy(b.w1, 0, w1, 0, b.w1.size)
                    System.arraycopy(b.w2, 0, w2, 0, b.w2.size)
                    System.arraycopy(b.w3, 0, w3, 0, b.w3.size)
                } }
            }
            DataOutputStream(BufferedOutputStream(FileOutputStream(file))).use { out ->
                out.writeInt(genCopy); out.writeFloat(scoreCopy)
                for (brain in popCopy) {
                    for (v in brain.w1) out.writeFloat(v)
                    for (v in brain.w2) out.writeFloat(v)
                    for (v in brain.w3) out.writeFloat(v)
                }
                for (q in qCopy) out.writeFloat(q)
                for (n in nCopy) out.writeInt(n)
            }
        } catch (e: Exception) { e.printStackTrace() }
    }

    private fun loadTrainingState() {
        try {
            val file = context.getFileStreamPath("snake_training.dat")
            if (!file.exists()) return
            DataInputStream(BufferedInputStream(FileInputStream(file))).use { input ->
                generation = input.readInt(); bestScoreAllTime = input.readFloat()
                for (i in 0 until POPULATION_SIZE) {
                    val brain = TinyBrain()
                    for (j in brain.w1.indices) brain.w1[j] = input.readFloat()
                    for (j in brain.w2.indices) brain.w2[j] = input.readFloat()
                    for (j in brain.w3.indices) brain.w3[j] = input.readFloat()
                    population[i] = brain
                }
                for (i in qV2.indices) qV2[i] = input.readFloat()
                for (i in nV2.indices) nV2[i] = input.readInt()
            }
        } catch (e: Exception) {
            e.printStackTrace(); generation = 0; bestScoreAllTime = 0f
            for (i in 0 until POPULATION_SIZE) population[i] = TinyBrain()
            java.util.Arrays.fill(qV2, 0f); java.util.Arrays.fill(nV2, 0)
        }
    }

    private fun saveLearning() {
        synchronized(sharedLock) {
            prefs.edit()
                .putFloat("learn_aggression", aggression).putFloat("learn_safety", safetyMargin)
                .putFloat("learn_shortcut", shortcutBonus)
                .putFloat("w_region", wRegion).putFloat("w_mobility", wMobility)
                .putFloat("w_tail_good", wTailGood).putFloat("w_tail_bad", wTailBad)
                .putFloat("w_food_near", wFoodNear).putFloat("w_food_ate", wFoodAte)
                .putFloat("w_edge", wEdge).putFloat("w_space", wSpace)
                .putString("last_learn_action", lastLearnAction)
                .putFloat("v3_g_food", v3Genome.foodPriority).putFloat("v3_g_space", v3Genome.spacePriority)
                .putFloat("v3_g_tail", v3Genome.tailPriority).putFloat("v3_g_danger", v3Genome.dangerAversion)
                .putFloat("v3_g_loop", v3Genome.loopAversion).putFloat("v3_g_hunger", v3Genome.hungerUrgency)
                .putInt("v3_lesson_fires", v3LessonFires).putInt("v3_loop_hits", v3LoopHits)
                .putInt("stat_wall", deathWall).putInt("stat_self", deathSelf)
                .putInt("stat_trap", deathTrap).putInt("stat_total", totalGames)
                .putInt("money", money).putInt("high_score", highScore)
                .apply()
        }
    }

    private fun die(cause: String) {
        gameOver = true; deathCause = cause
        v3AnalyzeDeath(cause)
        when (cause) { "WALL" -> deathWall++; "SELF" -> deathSelf++; "HUNGER" -> deathTrap++; else -> deathTrap++ }
        adjustWeights(cause); totalGames++; heartbeat()
        recentScores.addLast(score)
        while (recentScores.size > 50) recentScores.removeFirst()
        if (score > bestRecentScore) bestRecentScore = score
        aggression = when (cause) {
            "WALL" -> max(0.9f, aggression * 0.99f)
            "SELF" -> max(0.9f, aggression * 0.995f)
            "HUNGER" -> min(1.4f, aggression * 1.03f)
            else -> max(0.9f, aggression * 0.99f)
        }
        if (cause == "TRAP") safetyMargin = min(1.20f, safetyMargin * 1.01f)
        if (cause == "HUNGER") safetyMargin = max(1.0f, safetyMargin * 0.99f)
        safetyMargin = safetyMargin * 0.95f + 1.08f * 0.05f
        aggression = aggression * 0.95f + 1.15f * 0.05f
        safetyMargin = safetyMargin.coerceIn(1.0f, 1.20f)
        aggression = aggression.coerceIn(0.95f, 1.35f)
        lastDeathInfo = "死因=$cause 长度=${snake.size} 分=$score 空间=${ai.region} 需求=${(snake.size * safetyMargin).toInt()}"
        saveLearning()
        if (trainingMode) { reset(); return }
        flash = 1f; vibrateDeath(); restartCountdown = 0L; invalidate()
    }

    private fun simulate(head: P, d: P): Sim = simulateOn(ArrayDeque(snake), d)
    private fun simulateOn(src: ArrayDeque<P>, d: P): Sim {
        val b = ArrayDeque(src); if (b.isEmpty()) return Sim(b, false)
        val nh = P(b.first().x + d.x, b.first().y + d.y)
        if (!inside(nh)) return Sim(b, false)
        val ate = nh == food
        if (b.contains(nh) && !(nh == b.last() && !ate)) return Sim(b, false)
        b.addFirst(nh); if (!ate) b.removeLast(); return Sim(b, ate)
    }

    private fun rolloutN(startDir: P, maxSteps: Int): Float {
        var body = ArrayDeque(snake); var dir = startDir; var score = 0f
        for (step in 0 until maxSteps) {
            var bestNext: P? = null; var bestSpace = -1
            for (d in dirs) {
                val nh = P(body.first().x + d.x, body.first().y + d.y)
                if (!inside(nh)) continue
                val isTail = nh == body.last()
                if (body.contains(nh) && !isTail) continue
                var space = 0
                for (sd in dirs) {
                    val sx = nh.x + sd.x; val sy = nh.y + sd.y
                    if (sx in 0 until cols && sy in 0 until rows) { if (!body.any { it.x == sx && it.y == sy }) space++ }
                }
                if (space > bestSpace) { bestSpace = space; bestNext = d }
            }
            if (bestNext == null) return -50f + step * -10f
            val sim = simulateOn(body, bestNext)
            body = sim.body; score += 5f; if (sim.ate) score += 15f; dir = bestNext
        }
        return score
    }

    private fun simulateForBody(src: ArrayDeque<P>, d: P, target: P): Sim {
        val b = ArrayDeque(src); if (b.isEmpty()) return Sim(b, false)
        val nh = P(b.first().x + d.x, b.first().y + d.y)
        if (!inside(nh)) return Sim(b, false)
        val ate = nh == target
        if (b.contains(nh) && !(nh == b.last() && !ate)) return Sim(b, false)
        b.addFirst(nh); if (!ate) b.removeLast(); return Sim(b, ate)
    }

    private fun canSim(body: ArrayDeque<P>, d: P): Boolean {
        if (body.isEmpty()) return false
        val h = body.first()
        val nh = P(h.x + d.x, h.y + d.y)
        if (!inside(nh)) return false
        val ate = nh == food
        return !body.contains(nh) || (nh == body.last() && !ate)
    }

    private fun legalDirection(d: P): Boolean = d != P(0, 0) && !isReverse(d, dir) && canSim(snake, d)
    private fun isReverse(a: P, b: P): Boolean = a.x == -b.x && a.y == -b.y

    private fun directionOfFirst(body: ArrayDeque<P>): P {
        if (body.size < 2) return dir
        return P(body.elementAt(0).x - body.elementAt(1).x, body.elementAt(0).y - body.elementAt(1).y)
    }

    private fun inside(p: P): Boolean = p.x in 0 until cols && p.y in 0 until rows

    private fun shortestPath(start: P, target: P, body: Collection<P>, allowTail: Boolean): List<P>? {
        if (start == target) return emptyList()
        if (!inside(start) || !inside(target)) return null
        val visited = tlVisited.get(); val queue = tlQueue.get()
        val parent = IntArray(total) { -1 }; val parentDir = arrayOfNulls<P>(total)
        java.util.Arrays.fill(visited, 0, total, false)
        for (p in body) { if (!inside(p)) continue; visited[p.y * cols + p.x] = true }
        if (allowTail && body.isNotEmpty()) { val last = body.last(); if (inside(last)) visited[last.y * cols + last.x] = false }
        val startIndex = start.y * cols + start.x; val targetIndex = target.y * cols + target.x
        visited[startIndex] = true
        var head = 0; var tail = 0; queue[tail++] = startIndex; var found = false
        while (head < tail) {
            val curr = queue[head++]; if (curr == targetIndex) { found = true; break }
            val cx = curr % cols; val cy = curr / cols
            val candidates = arrayOf(
                P(0, -1) to if (cy > 0) curr - cols else -1,
                P(0, 1) to if (cy < rows - 1) curr + cols else -1,
                P(-1, 0) to if (cx > 0) curr - 1 else -1,
                P(1, 0) to if (cx < cols - 1) curr + 1 else -1
            )
            for ((d, ni) in candidates) {
                if (ni < 0 || ni >= total) continue
                if (visited[ni]) continue
                visited[ni] = true; parent[ni] = curr; parentDir[ni] = d
                if (tail < total) queue[tail++] = ni
            }
        }
        if (!found) return null
        val steps = ArrayList<P>(); var cur = targetIndex
        while (cur != startIndex) {
            val d = parentDir[cur] ?: return null
            steps.add(d); cur = parent[cur]; if (cur < 0) return null
        }
        steps.reverse(); return steps
    }

    private fun freeRegion(body: ArrayDeque<P>): Int {
        if (body.isEmpty()) return 0
        val visited = tlVisited.get(); val queue = tlQueue.get()
        java.util.Arrays.fill(visited, 0, total, false)
        for (p in body) { if (!inside(p)) continue; visited[p.y * cols + p.x] = true }
        val start = body.first(); if (!inside(start)) return 0
        val startIndex = start.y * cols + start.x; visited[startIndex] = true
        var head = 0; var tail = 0; queue[tail++] = startIndex; var count = 0
        while (head < tail) {
            val curr = queue[head++]; val cx = curr % cols; val cy = curr / cols; count++
            if (cx > 0) { val ni = curr - 1; if (!visited[ni]) { visited[ni] = true; if (tail < total) queue[tail++] = ni } }
            if (cx < cols - 1) { val ni = curr + 1; if (!visited[ni]) { visited[ni] = true; if (tail < total) queue[tail++] = ni } }
            if (cy > 0) { val ni = curr - cols; if (!visited[ni]) { visited[ni] = true; if (tail < total) queue[tail++] = ni } }
            if (cy < rows - 1) { val ni = curr + cols; if (!visited[ni]) { visited[ni] = true; if (tail < total) queue[tail++] = ni } }
        }
        return count
    }

    private fun distance(start: P, target: P, body: Collection<P>, allowTail: Boolean): Int {
        if (!inside(start) || !inside(target)) return -1
        if (start == target) return 0
        val visited = tlVisited.get(); val queue = tlQueue.get()
        java.util.Arrays.fill(visited, 0, total, false)
        for (p in body) { if (!inside(p)) continue; visited[p.y * cols + p.x] = true }
        if (allowTail && body.isNotEmpty()) { val last = body.last(); if (inside(last)) visited[last.y * cols + last.x] = false }
        val startIndex = start.y * cols + start.x; visited[startIndex] = true
        var head = 0; var tail = 0; queue[tail++] = startIndex; var dist = 0
        while (head < tail) {
            val layerSize = tail - head
            repeat(layerSize) {
                if (head >= tail) return@repeat
                val curr = queue[head++]; val cx = curr % cols; val cy = curr / cols
                if (cx == target.x && cy == target.y) return dist
                if (cx > 0) { val ni = curr - 1; if (!visited[ni]) { visited[ni] = true; if (tail < total) queue[tail++] = ni } }
                if (cx < cols - 1) { val ni = curr + 1; if (!visited[ni]) { visited[ni] = true; if (tail < total) queue[tail++] = ni } }
                if (cy > 0) { val ni = curr - cols; if (!visited[ni]) { visited[ni] = true; if (tail < total) queue[tail++] = ni } }
                if (cy < rows - 1) { val ni = curr + cols; if (!visited[ni]) { visited[ni] = true; if (tail < total) queue[tail++] = ni } }
            }
            dist++
        }
        return -1
    }

    private fun countSafeMoves(body: ArrayDeque<P>): Int = countSafeMovesFor(body, directionOfFirst(body), food)

    private fun countSafeMovesFor(body: ArrayDeque<P>, heading: P, target: P): Int {
        if (body.isEmpty()) return 0
        val h = body.first()
        return dirs.count { d ->
            if (isReverse(d, heading)) return@count false
            val nh = P(h.x + d.x, h.y + d.y)
            if (!inside(nh)) return@count false
            val ate = nh == target
            !body.contains(nh) || (nh == body.last() && !ate)
        }
    }

    private fun tailReachable(body: ArrayDeque<P>): Boolean = if (body.isEmpty()) false else distance(body.first(), body.last(), body, true) >= 0

    private fun checkFoodDeadEnd(): Pair<Boolean, Float> {
        if (snake.isEmpty()) return Pair(false, 10f)
        val visited = Array(cols) { BooleanArray(rows) }
        val queue = ArrayDeque<P>(); queue.addLast(food); visited[food.x][food.y] = true
        var space = 0
        while (!queue.isEmpty()) {
            val cur = queue.removeFirst(); space++
            for (d in dirs) {
                val nx = cur.x + d.x; val ny = cur.y + d.y
                if (nx in 0 until cols && ny in 0 until rows && !visited[nx][ny]) {
                    val isBody = snake.any { it.x == nx && it.y == ny }
                    if (!isBody) { visited[nx][ny] = true; queue.addLast(P(nx, ny)) }
                }
            }
        }
        val ratio = space.toFloat() / snake.size
        return Pair(ratio < 1.2f, ratio)
    }

    private fun calculateDanger(): Int {
        val region = freeRegion(snake)
        val ratio = region.toFloat() / max(1, snake.size)
        val mobility = countSafeMoves(snake)
        return when {
            mobility <= 0 -> 5; ratio < 1.5f -> 5; ratio < 2.2f -> 4
            ratio < 3.5f -> 3; ratio < 5f -> 2; else -> 1
        }
    }

    private fun placeFood() {
        val free = ArrayList<P>()
        for (x in 0 until cols) for (y in 0 until rows) { val p = P(x, y); if (!snake.contains(p)) free.add(p) }
        if (free.isNotEmpty()) food = free[Random.nextInt(free.size)]
    }

    private fun spawnFoodEffect(p: P) {
        repeat(14) { particles.add(Particle(p.x.toFloat(), p.y.toFloat(), Random.nextFloat() - 0.5f, Random.nextFloat() - 0.5f, 1f, Color.YELLOW)) }
        floats.add(FloatText(p.x.toFloat(), p.y.toFloat(), 1f, "+10"))
    }

    private fun updateEffects(dt: Float) {
        flash = max(0f, flash - dt * 0.035f)
        v3LessonFlash = max(0f, v3LessonFlash - dt * 0.8f)
        particles.forEach { it.x += it.vx * dt; it.y += it.vy * dt; it.life -= dt * 0.035f }
        particles.removeAll { it.life <= 0f }
        floats.forEach { it.y -= dt * 0.04f; it.life -= dt * 0.025f }
        floats.removeAll { it.life <= 0f }
    }

    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        val hudReserve = 760f + 292f; val availTop = 12f
        val availBottom = (h - hudReserve).coerceAtLeast(availTop + h * 0.30f)
        val availH = availBottom - availTop
        cell = min(w.toFloat() / cols, availH / rows)
        ox = (w - cols * cell) / 2f
        val baseOy = availTop + (availH - rows * cell) / 2f
        val moveDown = cell * 2.5f; val maxOy = availBottom - rows * cell
        oy = (baseOy + moveDown).coerceAtMost(maxOy)
    }

    override fun onDraw(c: Canvas) {
        super.onDraw(c)
        if (reinforceTraining) { c.drawColor(Color.BLACK); text.textAlign = Paint.Align.LEFT; drawTrainingDashboard(c); return }
        if (trainingMode) { c.drawColor(Color.BLACK); text.textAlign = Paint.Align.LEFT; drawDebug(c); return }
        c.drawColor(bgColor)
        gridPaint.color = gridColor; gridPaint.style = Paint.Style.STROKE; gridPaint.strokeWidth = 1f
        for (i in 0..cols) c.drawLine(ox + i * cell, oy, ox + i * cell, oy + rows * cell, gridPaint)
        for (i in 0..rows) c.drawLine(ox, oy + i * cell, ox + cols * cell, oy + i * cell, gridPaint)
        drawFood(c); drawSnake(c); drawParticles(c); drawDebug(c)
        if (gameOver) drawGameOver(c)
    }

    private fun drawFood(c: Canvas) {
        val cx = ox + (food.x + 0.5f) * cell; val cy = oy + (food.y + 0.5f) * cell
        foodPaint.color = Color.argb(90, 255, 80, 80); c.drawCircle(cx, cy, cell * 0.38f, foodPaint)
        foodPaint.color = Color.RED; c.drawCircle(cx, cy, cell * 0.22f, foodPaint)
        foodPaint.color = Color.WHITE; c.drawCircle(cx, cy, cell * 0.07f, foodPaint)
    }

    private fun drawSnake(c: Canvas) {
        if (snake.isEmpty()) return
        snakePaint.strokeWidth = max(8f, cell * 0.62f)
        val list = snake.toList()
        for (i in 0 until list.size - 1) {
            val a = list[i]; val b = list[i + 1]
            snakePaint.color = if (rainbowSkin) hsv[(i * 23 + score) % 360] else bodyColor
            c.drawLine(ox + (a.x + 0.5f) * cell, oy + (a.y + 0.5f) * cell, ox + (b.x + 0.5f) * cell, oy + (b.y + 0.5f) * cell, snakePaint)
        }
        val h = snake.first()
        headPaint.color = headColor
        c.drawCircle(ox + (h.x + 0.5f) * cell, oy + (h.y + 0.5f) * cell, cell * 0.36f, headPaint)
        val ex = when { dir.x > 0 -> 0.12f; dir.x < 0 -> -0.12f; else -> 0f }
        val ey = when { dir.y > 0 -> 0.12f; dir.y < 0 -> -0.12f; else -> 0f }
        paint.color = Color.WHITE
        c.drawCircle(ox + (h.x + 0.5f) * cell + cell * (0.13f + ex), oy + (h.y + 0.5f) * cell + cell * (0.13f + ey), cell * 0.075f, paint)
        c.drawCircle(ox + (h.x + 0.5f) * cell - cell * (0.13f - ex), oy + (h.y + 0.5f) * cell - cell * (0.13f - ey), cell * 0.075f, paint)
    }

    private fun drawParticles(c: Canvas) {
        particles.forEach {
            paint.color = Color.argb((it.life * 255).toInt().coerceIn(0, 255), Color.red(it.color), Color.green(it.color), Color.blue(it.color))
            c.drawCircle(ox + (it.x + 0.5f) * cell, oy + (it.y + 0.5f) * cell, max(2f, cell * 0.05f), paint)
        }
        text.textAlign = Paint.Align.CENTER; text.textSize = cell * 0.3f
        floats.forEach {
            text.color = Color.argb((it.life * 255).toInt().coerceIn(0, 255), 255, 215, 0)
            c.drawText(it.text, ox + (it.x + 0.5f) * cell, oy + (it.y + 0.3f) * cell, text)
        }
    }

    private fun drawDangerGauge(c: Canvas, cx: Float, cy: Float, r: Float, danger: Int) {
        val arcPaint = Paint(Paint.ANTI_ALIAS_FLAG)
        arcPaint.style = Paint.Style.STROKE; arcPaint.strokeWidth = 13f; arcPaint.strokeCap = Paint.Cap.ROUND
        val oval = RectF(cx - r, cy - r, cx + r, cy + r)
        arcPaint.color = Color.rgb(50, 50, 50); c.drawArc(oval, -90f, 360f, false, arcPaint)
        arcPaint.color = when (danger) {
            1 -> Color.GREEN; 2 -> Color.rgb(150, 255, 80); 3 -> Color.YELLOW
            4 -> Color.rgb(255, 150, 0); else -> Color.RED
        }
        c.drawArc(oval, -90f, 360f * (danger.coerceIn(1, 5) / 5f), false, arcPaint)
    }

    private val prevWeights = FloatArray(8) { 1f }

    private fun drawWeightBars(c: Canvas, left: Float, top: Float, w: Float, h: Float) {
        val names = listOf("区域", "机动", "尾+", "尾-", "食近", "食吃", "边界", "空间")
        val values = floatArrayOf(
            wRegion / wRegion0, wMobility / wMobility0, wTailGood / wTailGood0, wTailBad / wTailBad0,
            wFoodNear / wFoodNear0, wFoodAte / wFoodAte0, wEdge / wEdge0, wSpace / wSpace0
        )
        val barW = w / names.size; val maxRatio = 2.0f
        names.forEachIndexed { i, name ->
            val x = left + i * barW; val ratio = values[i].coerceIn(0f, maxRatio)
            val barH = h * (ratio / maxRatio)
            barPaint.style = Paint.Style.FILL; barPaint.color = Color.rgb(40, 40, 40)
            c.drawRect(x + 3f, top, x + barW - 8f, top + h, barPaint)
            barPaint.color = Color.rgb(100, 100, 100)
            val baseY = top + h - h * (1f / maxRatio)
            c.drawLine(x + 3f, baseY, x + barW - 8f, baseY, barPaint)
            val prevRatio = prevWeights.getOrElse(i) { 1f }
            val delta = ratio - prevRatio; prevWeights[i] = ratio
            barPaint.color = when {
                delta > 0.05f -> Color.rgb(46, 204, 113)
                delta < -0.05f -> Color.rgb(46, 204, 113)
                ratio > 1.3f -> Color.rgb(46, 204, 113)
                ratio > 1.1f -> Color.rgb(241, 196, 15)
                ratio < 0.8f -> Color.rgb(52, 152, 219)
                else -> Color.rgb(46, 204, 113)
            }
            c.drawRect(x + 3f, top + h - barH, x + barW - 8f, top + h, barPaint)
            text.textAlign = Paint.Align.CENTER; text.textSize = 12f; text.color = Color.LTGRAY
            c.drawText(name, x + (barW - 5f) / 2f, top + h + 15f, text)
            text.color = Color.WHITE
            c.drawText("${(values[i] * 100f).toInt()}%", x + (barW - 5f) / 2f, top + h + 30f, text)
        }
        text.textAlign = Paint.Align.LEFT
    }

    private fun drawLearningCurve(c: Canvas, left: Float, top: Float, w: Float, h: Float) {
        barPaint.style = Paint.Style.FILL; barPaint.color = Color.rgb(25, 25, 25)
        c.drawRect(left, top, left + w, top + h, barPaint)
        if (recentScores.size < 2) {
            text.textAlign = Paint.Align.CENTER; text.textSize = 13f; text.color = Color.GRAY
            c.drawText("数据不足", left + w / 2f, top + h / 2f, text)
            text.textAlign = Paint.Align.LEFT; return
        }
        val scores = recentScores.toList(); val maxScore = scores.max().coerceAtLeast(1)
        val stepX = w / (scores.size - 1).coerceAtLeast(1)
        val areaPath = Path(); areaPath.moveTo(left, top + h)
        scores.forEachIndexed { i, s -> areaPath.lineTo(left + i * stepX, top + h - h * (s.toFloat() / maxScore)) }
        areaPath.lineTo(left + w, top + h); areaPath.close()
        barPaint.color = Color.argb(60, 120, 255, 180); c.drawPath(areaPath, barPaint)
        val linePath = Path()
        scores.forEachIndexed { i, s ->
            val x = left + i * stepX; val y = top + h - h * (s.toFloat() / maxScore)
            if (i == 0) linePath.moveTo(x, y) else linePath.lineTo(x, y)
        }
        val curvePaint = Paint(Paint.ANTI_ALIAS_FLAG)
        curvePaint.style = Paint.Style.STROKE; curvePaint.strokeWidth = 3f
        curvePaint.color = Color.rgb(120, 255, 180); c.drawPath(linePath, curvePaint)
        text.textSize = 12f; text.color = Color.LTGRAY
        c.drawText("max $maxScore", left + 5f, top + 14f, text)
    }

    private fun drawDeathPie(c: Canvas, cx: Float, cy: Float, r: Float) {
        val totalD = deathWall + deathSelf + deathTrap
        barPaint.style = Paint.Style.FILL
        if (totalD == 0) { barPaint.color = Color.rgb(60, 60, 60); c.drawCircle(cx, cy, r, barPaint); return }
        val oval = RectF(cx - r, cy - r, cx + r, cy + r); var start = -90f
        val sweepW = 360f * deathWall / totalD
        if (sweepW > 0f) { barPaint.color = Color.rgb(255, 100, 100); c.drawArc(oval, start, sweepW, true, barPaint); start += sweepW }
        val sweepS = 360f * deathSelf / totalD
        if (sweepS > 0f) { barPaint.color = Color.rgb(100, 150, 255); c.drawArc(oval, start, sweepS, true, barPaint); start += sweepS }
        val sweepT = 360f * deathTrap / totalD
        if (sweepT > 0f) { barPaint.color = Color.rgb(255, 200, 100); c.drawArc(oval, start, sweepT, true, barPaint) }
    }

    private fun drawQHeatmap(c: Canvas, left: Float, top: Float, w: Float, h: Float) {
        val grid = 10; val cellW = w / grid; val cellH = h / grid
        barPaint.style = Paint.Style.FILL; barPaint.color = Color.rgb(35, 35, 35)
        c.drawRect(left, top, left + w, top + h, barPaint)
        val sampleList = visitedStates.take(100); var maxAbs = 0.001f
        for (s in sampleList) for (a in 0 until 4) { val qv = qRead(s, a); if (abs(qv) > maxAbs) maxAbs = abs(qv) }
        for (i in 0 until 100) {
            val px = left + (i % grid) * cellW; val py = top + (i / grid) * cellH
            if (i >= sampleList.size) barPaint.color = Color.rgb(30, 30, 35)
            else {
                val s = sampleList[i]; var bestQ = -Float.MAX_VALUE
                for (a in 0 until 4) { val qv = qRead(s, a); if (qv > bestQ) bestQ = qv }
                val t = (bestQ / maxAbs).coerceIn(-1f, 1f)
                barPaint.color = if (t >= 0f) Color.rgb((60 * (1f - t)).toInt(), (60 + 195 * t).toInt(), 60)
                else { val nt = -t; Color.rgb((60 + 195 * nt).toInt(), (60 * (1f - nt)).toInt(), (60 * (1f - nt)).toInt()) }
            }
            c.drawRect(px, py, px + cellW - 1f, py + cellH - 1f, barPaint)
        }
    }

    private fun drawV3Panel(c: Canvas, w: Float, mainTop: Float) {
        if (mainTop < 290f) return
        val panelH = 272f; val left = (width - w) / 2f; val top = mainTop - 14f - panelH
        panel.color = Color.argb(232, 0, 0, 0)
        c.drawRoundRect(left, top, left + w, top + panelH, 22f, 22f, panel)
        val pulse = 0.55f + 0.45f * kotlin.math.sin(System.currentTimeMillis() / 160f)
        text.isFakeBoldText = true; text.textSize = 15f; text.color = Color.rgb(255, 200, 100)
        text.textAlign = Paint.Align.LEFT
        c.drawText("【V4融合 · AI层级链】", left + 16f, top + 24f, text)
        text.isFakeBoldText = true; text.textSize = 14f; val goalColor = v3Goal.color
        text.color = Color.argb((90 + 165 * pulse).toInt().coerceIn(0, 255), (goalColor shr 16) and 0xFF, (goalColor shr 8) and 0xFF, goalColor and 0xFF)
        c.drawText("目标: ${v3Goal.label}", left + w - 210f, top + 24f, text)
        text.textSize = 12f
        text.color = if (v3FusionEnabled) Color.rgb(46, 204, 113) else Color.rgb(120, 120, 120)
        c.drawText(if (v3FusionEnabled) "融合:开" else "融合:关", left + w - 70f, top + 24f, text)
        val layerNames = arrayOf("L1安全食物", "L2尾巴", "L3饥饿", "L4混合", "L5反事实", "L6基因")
        val layerColors = intArrayOf(
            Color.rgb(46, 204, 113), Color.rgb(155, 89, 182), Color.rgb(230, 126, 34),
            Color.rgb(52, 152, 219), Color.rgb(231, 76, 60), Color.rgb(241, 196, 15)
        )
        val chipGap = 6f; val chipW = (w - 32f - chipGap * 5f) / 6f
        val chipY = top + 34f; val chipH = 24f
        for (i in 0 until 6) {
            val cx = left + 16f + i * (chipW + chipGap)
            val active = (v3LayerActive == i + 1) && v3FusionEnabled
            panel.color = if (active) Color.argb((120 + 135 * pulse).toInt().coerceIn(0, 255), (layerColors[i] shr 16) and 0xFF, (layerColors[i] shr 8) and 0xFF, layerColors[i] and 0xFF)
            else Color.rgb(30, 30, 40)
            c.drawRoundRect(cx, chipY, cx + chipW, chipY + chipH, 8f, 8f, panel)
            text.isFakeBoldText = active; text.textSize = 10f
            text.color = if (active) Color.WHITE else Color.rgb(140, 140, 150)
            text.textAlign = Paint.Align.CENTER
            c.drawText(layerNames[i], cx + chipW / 2f, chipY + chipH / 2f + 4f, text)
        }
        text.textAlign = Paint.Align.LEFT
        text.isFakeBoldText = false; text.textSize = 12f; text.color = Color.rgb(180, 190, 205)
        val whyLine = if (v3FusionEnabled) { if (v3Regret > 0.01f) "$v3LayerWhy  遗憾=${"%.2f".format(v3Regret)}" else v3LayerWhy } else "V3层级已关闭，运行V2基线决策"
        c.drawText(whyLine, left + 16f, top + 76f, text)
        text.isFakeBoldText = true; text.textSize = 13f; text.color = Color.rgb(255, 150, 255)
        c.drawText("【V3基因柱状图】", left + 16f, top + 98f, text)
        val geneNames = arrayOf("食", "空", "尾", "危", "循", "饿")
        val gv = v3Genome.values()
        val geneColors = intArrayOf(
            Color.rgb(46, 204, 113), Color.rgb(52, 152, 219), Color.rgb(155, 89, 182),
            Color.rgb(231, 76, 60), Color.rgb(241, 196, 15), Color.rgb(230, 126, 34)
        )
        val geneAreaLeft = left + 16f; val geneAreaW = w * 0.52f
        val barGap = 5f; val geneBarW = (geneAreaW - barGap * 5f) / 6f
        val geneBaseY = top + 158f; val geneMaxH = 44f
        for (i in 0 until 6) {
            val bx = geneAreaLeft + i * (geneBarW + barGap)
            val frac = (gv[i] / 2.6f).coerceIn(0.05f, 1f); val bh = geneMaxH * frac
            panel.color = Color.rgb(30, 30, 40)
            c.drawRoundRect(bx, geneBaseY - geneMaxH, bx + geneBarW, geneBaseY, 4f, 4f, panel)
            panel.color = geneColors[i]
            c.drawRoundRect(bx, geneBaseY - bh, bx + geneBarW, geneBaseY, 4f, 4f, panel)
            text.isFakeBoldText = false; text.textSize = 11f; text.color = Color.rgb(160, 165, 175)
            text.textAlign = Paint.Align.CENTER
            c.drawText(geneNames[i], bx + geneBarW / 2f, geneBaseY + 12f, text)
            text.textSize = 9f; text.color = Color.rgb(210, 210, 220)
            c.drawText(String.format("%.2f", gv[i]), bx + geneBarW / 2f, geneBaseY - bh - 3f, text)
        }
        text.textAlign = Paint.Align.LEFT
        val infoX = left + w * 0.60f
        text.isFakeBoldText = false; text.textSize = 12f; text.color = Color.rgb(180, 190, 205)
        c.drawText("失败记忆: ${v3Memory.size()} 条", infoX, top + 118f, text)
        c.drawText("教训触发: ${v3LessonFires} 次", infoX, top + 136f, text)
        c.drawText("循环打断: ${v3LoopHits} 次", infoX, top + 154f, text)
        c.drawText("Beam 命中: $beamSelected/$beamCalls", infoX, top + 172f, text)
        text.textSize = 12f
        if (v3LessonFlash > 0.01f) {
            val a = (v3LessonFlash * 255f).toInt().coerceIn(0, 255)
            text.isFakeBoldText = true
            text.color = Color.argb(a, 255, 90 + ((60 * pulse).toInt()), 40)
            c.drawText("⚠ 新教训已写入: ${v3Memory.worstLessonText()}", left + 16f, top + 196f, text)
        } else {
            text.isFakeBoldText = false; text.color = Color.rgb(130, 135, 145)
            c.drawText("最近教训: ${v3Memory.worstLessonText()}", left + 16f, top + 196f, text)
        }
        text.isFakeBoldText = true; text.textSize = 13f; text.color = Color.rgb(255, 150, 255)
        c.drawText("【V3目标分布饼图】", left + 16f, top + 224f, text)
        val pieCx = left + w - 64f; val pieCy = top + 206f; val pieR = 42f
        val totalCnt = v3GoalCounter.sum()
        if (totalCnt <= 0) { panel.color = Color.rgb(30, 30, 40); c.drawCircle(pieCx, pieCy, pieR, panel) }
        else {
            var startAngle = -90f
            for (g in V3Goal.values()) {
                val cnt = v3GoalCounter[g.ordinal]; if (cnt <= 0) continue
                val sweep = cnt * 360f / totalCnt
                panel.color = g.color
                c.drawArc(pieCx - pieR, pieCy - pieR, pieCx + pieR, pieCy + pieR, startAngle, sweep, true, panel)
                startAngle += sweep
            }
            panel.color = Color.argb(232, 0, 0, 0); c.drawCircle(pieCx, pieCy, pieR * 0.45f, panel)
        }
        text.isFakeBoldText = false; text.textSize = 11f; var ly = top + 242f
        for (g in V3Goal.values()) {
            val cnt = v3GoalCounter[g.ordinal]
            val pct = if (totalCnt > 0) cnt * 100 / totalCnt else 0
            text.color = g.color; c.drawText("■", left + 18f, ly, text)
            text.color = Color.rgb(170, 175, 185)
            c.drawText("${g.label} $pct%", left + 34f, ly, text)
            ly += 14f; if (ly > top + panelH - 6f) break
        }
        text.isFakeBoldText = false; text.textSize = 14f; text.color = Color.WHITE
    }

    private fun drawTrainingDashboard(c: Canvas) {
        val W = width.toFloat(); val pad = W * 0.022f; var y = pad
        panel.color = Color.rgb(28, 24, 48)
        c.drawRoundRect(pad, y, W - pad, y + W * 0.155f, pad * 0.7f, pad * 0.7f, panel)
        text.textAlign = Paint.Align.LEFT; text.isFakeBoldText = true
        text.textSize = W * 0.062f; text.color = Color.rgb(150, 230, 255)
        c.drawText("🧬 第 $generation 代", pad * 1.6f, y + W * 0.068f, text)
        text.textSize = W * 0.034f
        text.color = if (evolving || generationTransitioning) Color.rgb(255, 180, 80) else Color.rgb(120, 230, 150)
        val headState = if (evolving || generationTransitioning) "⚙ 进化繁殖中..." else "▶ 训练运行中"
        text.textAlign = Paint.Align.RIGHT
        c.drawText(headState, W - pad * 1.6f, y + W * 0.06f, text)
        text.textAlign = Paint.Align.LEFT; text.textSize = W * 0.032f; text.color = Color.rgb(200, 200, 220)
        c.drawText("已分配 $currentAgentIndex/$POPULATION_SIZE   已完成 $completedAgents/$POPULATION_SIZE   总局数 $totalGames",
            pad * 1.6f, y + W * 0.118f, text)
        y += W * 0.155f + pad * 0.6f
        val barH = W * 0.022f
        panel.color = Color.rgb(50, 48, 66)
        c.drawRoundRect(pad, y, W - pad, y + barH, barH / 2, barH / 2, panel)
        val frac = (completedAgents.toFloat() / POPULATION_SIZE).coerceIn(0f, 1f)
        panel.color = Color.rgb(80, 220, 150)
        if (frac > 0.01f) c.drawRoundRect(pad, y, pad + (W - 2 * pad) * frac, y + barH, barH / 2, barH / 2, panel)
        y += barH + pad
        val cardW = (W - 3 * pad) / 2f; val cardH = W * 0.118f
        val phaseColor = mapOf(
            "捕食" to Color.rgb(255, 170, 60), "避险" to Color.rgb(255, 90, 90),
            "搜索" to Color.rgb(90, 170, 255), "进化" to Color.rgb(200, 130, 255),
            "等待" to Color.rgb(130, 130, 140), "空闲" to Color.rgb(100, 100, 110),
            "训练" to Color.rgb(120, 220, 150)
        )
        for (ti in 0 until 8) {
            val col = ti % 2; val row = ti / 2
            val x0 = pad + col * (cardW + pad); val y0 = y + row * (cardH + pad * 0.55f)
            val st = threadStatus[ti]
            panel.color = Color.rgb(24, 26, 38)
            c.drawRoundRect(x0, y0, x0 + cardW, y0 + cardH, pad * 0.5f, pad * 0.5f, panel)
            paint.color = phaseColor[st.phase] ?: Color.GRAY
            c.drawCircle(x0 + pad * 0.8f, y0 + pad * 0.9f, pad * 0.32f, paint)
            text.textSize = W * 0.029f; text.isFakeBoldText = true; text.color = Color.WHITE
            c.drawText("线程$ti · Agent ${if (st.agentId >= 0) st.agentId else "-"}", x0 + pad * 1.5f, y0 + pad * 1.15f, text)
            text.textAlign = Paint.Align.RIGHT; text.color = paint.color
            c.drawText(st.phase, x0 + cardW - pad * 0.7f, y0 + pad * 1.15f, text)
            text.textAlign = Paint.Align.LEFT; text.textSize = W * 0.045f; text.color = Color.rgb(150, 235, 170)
            c.drawText("${st.score}", x0 + pad * 0.9f, y0 + cardH - pad * 0.55f, text)
            text.textSize = W * 0.026f; text.color = Color.rgb(160, 165, 185); text.textAlign = Paint.Align.RIGHT
            c.drawText("步 ${st.steps}", x0 + cardW - pad * 0.7f, y0 + cardH - pad * 0.6f, text)
            text.textAlign = Paint.Align.LEFT
        }
        y += 4 * cardH + 3 * pad * 0.55f + pad * 0.4f
        val metrics = arrayOf(
            "本代最佳" to "%.0f".format(bestScoreThisGen), "历史最佳" to "%.0f".format(bestScoreAllTime),
            "Q权重" to "%.2f".format(qWeight), "NN权重" to "%.2f".format(nnWeight),
            "回放" to "${replayBuffer.size}", "ε" to "%.3f".format(v2Epsilon),
            "学习步" to "$v2LearningSteps", "Beam" to "$beamSelected/$beamCalls"
        )
        val mW = (W - 5 * pad) / 4f; val mH = W * 0.105f
        for (mi in metrics.indices) {
            val col = mi % 4; val row = mi / 4
            val x0 = pad + col * (mW + pad); val y0 = y + row * (mH + pad * 0.5f)
            panel.color = Color.rgb(30, 30, 44)
            c.drawRoundRect(x0, y0, x0 + mW, y0 + mH, pad * 0.4f, pad * 0.4f, panel)
            text.textSize = W * 0.024f; text.isFakeBoldText = false; text.color = Color.rgb(150, 155, 175)
            c.drawText(metrics[mi].first, x0 + pad * 0.5f, y0 + pad * 0.95f, text)
            text.textSize = W * 0.040f; text.isFakeBoldText = true; text.color = Color.WHITE
            c.drawText(metrics[mi].second, x0 + pad * 0.5f, y0 + mH - pad * 0.5f, text)
        }
        y += 2 * mH + pad * 0.5f + pad
        text.textSize = W * 0.034f; text.isFakeBoldText = true; text.color = Color.rgb(200, 170, 255)
        c.drawText("🧪 进化繁殖历程", pad * 0.4f, y, text); y += pad * 0.7f
        val fullHistory = evoHistory.toList()
        val history = if (fullHistory.size > 10) fullHistory.drop(fullHistory.size - 10) else fullHistory
        val rowH = W * 0.052f
        if (history.isEmpty()) {
            text.textSize = W * 0.028f; text.isFakeBoldText = false; text.color = Color.rgb(140, 140, 155)
            c.drawText("（等待第一代50只完成后开始进化…）", pad * 0.6f, y + rowH * 0.6f, text)
            y += rowH
        }
        for (rec in history) {
            text.textSize = W * 0.026f; text.isFakeBoldText = true; text.color = Color.WHITE
            c.drawText("G${rec.gen}", pad * 0.5f, y + rowH * 0.62f, text)
            val barX = pad * 2.6f; val barW = W * 0.46f; val bh2 = rowH * 0.42f
            val total = (rec.eliteN + rec.crossN + rec.breedN).coerceAtLeast(1)
            var bx = barX
            val seg = arrayOf(rec.eliteN to Color.rgb(70, 220, 130), rec.crossN to Color.rgb(80, 150, 255), rec.breedN to Color.rgb(255, 160, 70))
            for ((cnt, col) in seg) {
                val wseg = barW * (cnt.toFloat() / total)
                if (wseg > 0.5f) { panel.color = col; c.drawRect(bx, y, bx + wseg, y + bh2, panel) }
                bx += wseg
            }
            text.textSize = W * 0.025f; text.isFakeBoldText = false; text.color = Color.rgb(180, 240, 190)
            c.drawText("最佳%.0f".format(rec.bestScore), barX + barW + pad * 0.5f, y + rowH * 0.55f, text)
            text.color = Color.rgb(230, 200, 140); text.textAlign = Paint.Align.RIGHT
            c.drawText(rec.personality, W - pad * 0.5f, y + rowH * 0.55f, text)
            text.textAlign = Paint.Align.LEFT; y += rowH + pad * 0.18f
        }
        y += pad * 0.4f
        text.textSize = W * 0.032f; text.isFakeBoldText = true; text.color = Color.rgb(255, 150, 150)
        c.drawText("☠ 死因分布", pad * 0.4f, y, text); y += pad * 0.7f
        val deaths = arrayOf("撞墙" to deathWall, "撞自己" to deathSelf, "被困" to deathTrap)
        val maxDeath = max(1, max(deathWall, max(deathSelf, deathTrap)))
        val dRowH = W * 0.05f
        for ((name, cnt) in deaths) {
            text.textSize = W * 0.027f; text.isFakeBoldText = false; text.color = Color.WHITE
            c.drawText(name, pad * 0.6f, y + dRowH * 0.6f, text)
            val dx0 = pad * 2.4f; val dW = W * 0.55f
            panel.color = Color.rgb(60, 50, 60)
            c.drawRect(dx0, y + dRowH * 0.18f, dx0 + dW, y + dRowH * 0.62f, panel)
            panel.color = Color.rgb(235, 90, 90)
            val wf = dW * (cnt.toFloat() / maxDeath)
            if (wf > 0.5f) c.drawRect(dx0, y + dRowH * 0.18f, dx0 + wf, y + dRowH * 0.62f, panel)
            text.color = Color.rgb(220, 220, 230)
            c.drawText("$cnt", dx0 + dW + pad * 0.5f, y + dRowH * 0.6f, text)
            y += dRowH + pad * 0.15f
        }
        y += pad * 0.3f
        val bottom0 = y
        panel.color = Color.rgb(20, 30, 34)
        c.drawRoundRect(pad, bottom0, W - pad, height - pad, pad * 0.6f, pad * 0.6f, panel)
        text.textSize = W * 0.033f; text.isFakeBoldText = true; text.color = Color.rgb(120, 230, 200)
        val nowDoing = when {
            evolving || generationTransitioning -> "🧬 正在繁殖下一代：精英保留 + 交叉 + 变异"
            completedAgents >= POPULATION_SIZE - 2 -> "⏳ 本代即将完成，准备进化"
            else -> "🐍 8只小蛇并行训练，吃满CPU搜索+学习"
        }
        c.drawText(nowDoing, pad * 1.4f, bottom0 + pad * 1.4f, text)
        text.textSize = W * 0.026f; text.isFakeBoldText = false; text.color = Color.rgb(170, 200, 210)
        val why = v3LayerWhy
        c.drawText(why.take(46), pad * 1.4f, bottom0 + pad * 2.6f, text)
        if (why.length > 46) c.drawText(why.substring(46), pad * 1.4f, bottom0 + pad * 3.6f, text)
        text.color = Color.rgb(150, 180, 200)
        c.drawText("目标: $v3Goal   循环命中$v3LoopHits  教训触发$v3LessonFires   已分配$currentAgentIndex 已完成$completedAgents",
            pad * 1.4f, bottom0 + pad * 4.8f, text)
    }

    private fun drawDebug(c: Canvas) {
        if (aiMode == 0 && !reinforceTraining) return
        val w = min(width * 0.97f, 720f); val h = 760f
        val left = (width - w) / 2f; val top = max(12f, height - h - 12f)
        drawV3Panel(c, w, top)
        panel.color = Color.argb(232, 0, 0, 0)
        c.drawRoundRect(left, top, left + w, top + h, 22f, 22f, panel)
        border.color = Color.argb(60, 46, 204, 113); border.style = Paint.Style.STROKE; border.strokeWidth = 1.5f
        c.drawRoundRect(left, top, left + w, top + h, 22f, 22f, border)
        text.textAlign = Paint.Align.LEFT; text.isFakeBoldText = true; text.textSize = 26f; text.color = Color.WHITE
        c.drawText(if (reinforceTraining) "混合进化中 · 世代 $generation" else ai.strategy, left + 16f, top + 36f, text)
        text.isFakeBoldText = false; text.textSize = 14f; text.color = Color.YELLOW
        c.drawText(if (reinforceTraining) "规则过滤 + Q表 + 神经网络 自我迭代" else ai.reason, left + 16f, top + 58f, text)
        val gaugeCX = left + 58f; val gaugeCY = top + 116f
        if (reinforceTraining) {
            val progRatio = completedAgents.toFloat() / POPULATION_SIZE
            val arcPaint = Paint(Paint.ANTI_ALIAS_FLAG)
            arcPaint.style = Paint.Style.STROKE; arcPaint.strokeWidth = 13f; arcPaint.strokeCap = Paint.Cap.ROUND
            val oval = RectF(gaugeCX - 42f, gaugeCY - 42f, gaugeCX + 42f, gaugeCY + 42f)
            arcPaint.color = Color.rgb(50, 50, 50); c.drawArc(oval, -90f, 360f, false, arcPaint)
            arcPaint.color = Color.rgb(46, 204, 113); c.drawArc(oval, -90f, 360f * progRatio, false, arcPaint)
            text.textAlign = Paint.Align.CENTER; text.isFakeBoldText = true; text.textSize = 22f; text.color = Color.WHITE
            c.drawText("$generation", gaugeCX, gaugeCY + 8f, text)
            text.isFakeBoldText = false; text.textSize = 11f; text.color = Color.LTGRAY
            c.drawText("世代", gaugeCX, gaugeCY + 28f, text)
        } else {
            drawDangerGauge(c, gaugeCX, gaugeCY, 42f, ai.danger)
            text.textAlign = Paint.Align.CENTER; text.isFakeBoldText = true; text.textSize = 26f; text.color = Color.WHITE
            c.drawText("${ai.danger}", gaugeCX, gaugeCY + 9f, text)
            text.isFakeBoldText = false; text.textSize = 12f; text.color = Color.LTGRAY
            c.drawText("危险", gaugeCX, gaugeCY + 28f, text)
        }
        text.textAlign = Paint.Align.LEFT; text.textSize = 16f; text.color = Color.WHITE
        c.drawText("局数 $totalGames", left + 118f, top + 86f, text)
        val avg = if (recentScores.isEmpty()) 0f else recentScores.average().toFloat()
        c.drawText("近50均分 ${"%.0f".format(avg)}   最佳 $bestRecentScore", left + 118f, top + 110f, text)
        val threadInfo = if (reinforceTraining) "${trainThreads.size} 线程" else "单局"
        c.drawText("模式 $threadInfo   主蛇长 ${snake.size}   Q覆盖${visitedStates.size}", left + 118f, top + 134f, text)
        if (reinforceTraining) {
            barPaint.style = Paint.Style.FILL; var meterY = top + 155f; val meterW = w - 32f
            text.textSize = 9f; text.color = Color.rgb(200, 180, 255)
            c.drawText("Q覆盖 ${visitedStates.size}/$V2_STATE_COUNT", left + 16f, meterY + 8f, text)
            barPaint.color = Color.rgb(30, 30, 40)
            c.drawRoundRect(left + 16f, meterY + 12f, left + 16f + meterW, meterY + 19f, 3f, 3f, barPaint)
            barPaint.color = Color.rgb(200, 150, 255)
            val qCovR = (visitedStates.size.toFloat() / V2_STATE_COUNT).coerceIn(0f, 1f)
            c.drawRoundRect(left + 16f, meterY + 12f, left + 16f + meterW * qCovR, meterY + 19f, 3f, 3f, barPaint)
            meterY += 24f
            text.color = Color.rgb(100, 220, 255)
            c.drawText("回放 ${replayBuffer.size}/$REPLAY_CAPACITY", left + 16f, meterY + 8f, text)
            barPaint.color = Color.rgb(30, 30, 40)
            c.drawRoundRect(left + 16f, meterY + 12f, left + 16f + meterW, meterY + 19f, 3f, 3f, barPaint)
            barPaint.color = Color.rgb(100, 200, 255)
            val rpR = replayBuffer.size.toFloat() / REPLAY_CAPACITY
            c.drawRoundRect(left + 16f, meterY + 12f, left + 16f + meterW * rpR, meterY + 19f, 3f, 3f, barPaint)
            meterY += 24f
            text.color = Color.rgb(241, 196, 15)
            c.drawText("ε ${"%.2f".format(v2Epsilon)}", left + 16f, meterY + 8f, text)
            barPaint.color = Color.rgb(30, 30, 40)
            c.drawRoundRect(left + 16f, meterY + 12f, left + 16f + meterW, meterY + 19f, 3f, 3f, barPaint)
            barPaint.color = Color.rgb(241, 196, 15)
            c.drawRoundRect(left + 16f, meterY + 12f, left + 16f + meterW * v2Epsilon, meterY + 19f, 3f, 3f, barPaint)
            meterY += 24f
            text.color = Color.rgb(200, 200, 200)
            c.drawText("Q ${"%.2f".format(qWeight)} / NN ${"%.2f".format(nnWeight)}", left + 16f, meterY + 8f, text)
            barPaint.color = Color.rgb(30, 30, 40)
            c.drawRoundRect(left + 16f, meterY + 12f, left + 16f + meterW, meterY + 19f, 3f, 3f, barPaint)
            barPaint.color = Color.rgb(231, 76, 60)
            c.drawRoundRect(left + 16f, meterY + 12f, left + 16f + meterW * qWeight, meterY + 19f, 3f, 3f, barPaint)
            barPaint.color = Color.rgb(46, 204, 113)
            c.drawRoundRect(left + 16f + meterW * qWeight, meterY + 12f, left + 16f + meterW, meterY + 19f, 3f, 3f, barPaint)
        }
        val wbY = top + 250f
        text.isFakeBoldText = true; text.textSize = 14f; text.color = Color.rgb(255, 200, 100)
        c.drawText("【权重柱状图】", left + 16f, wbY, text)
        text.isFakeBoldText = false
        drawWeightBars(c, left + 16f, wbY + 8f, w - 32f, 66f)
        val learnY = top + 290f
        text.isFakeBoldText = true; text.textSize = 14f; text.color = Color.rgb(255, 150, 255)
        c.drawText("【V2学习】", left + 16f, learnY, text)
        text.isFakeBoldText = false; text.color = Color.WHITE
        c.drawText("训练中", left + 118f, learnY, text)
        val barStartX = left + 118f; val barEndX = left + w - 16f; val barW = barEndX - barStartX
        var barY = top + 318f
        if (!reinforceTraining) {
            text.isFakeBoldText = true; text.textSize = 14f; text.color = Color.rgb(255, 200, 100)
            c.drawText("【四方向安全 / Q】", left + 16f, barY, text)
            text.isFakeBoldText = false; barY += 10f
            val dirNames = listOf("UP", "DN", "LF", "RT")
            ai.candidates.forEachIndexed { idx, cand ->
                text.textSize = 18f
                text.color = if (!cand.legal) Color.GRAY else if (cand.d == ai.chosen) Color.CYAN else Color.WHITE
                c.drawText(dirNames[idx], left + 16f, barY + 19f, text)
                if (!cand.legal) {
                    text.textSize = 14f; text.color = Color.GRAY
                    c.drawText("非法", barStartX, barY + 19f, text)
                } else {
                    val regionRatio = if (snake.isNotEmpty()) cand.region.toFloat() / snake.size else 0f
                    val safeScore = when {
                        cand.tailOk && regionRatio >= 1.5f -> 1.0f
                        cand.tailOk && regionRatio >= 1.0f -> 0.75f
                        regionRatio >= 1.0f -> 0.5f
                        regionRatio >= 0.6f -> 0.3f
                        else -> 0.15f
                    }
                    barPaint.color = Color.rgb(40, 40, 40); barPaint.style = Paint.Style.FILL
                    c.drawRoundRect(barStartX, barY, barEndX, barY + 24f, 4f, 4f, barPaint)
                    val barColor = when {
                        safeScore >= 0.9f -> Color.rgb(46, 204, 113)
                        safeScore >= 0.7f -> Color.rgb(241, 196, 15)
                        safeScore >= 0.5f -> Color.rgb(230, 126, 34)
                        else -> Color.rgb(231, 76, 60)
                    }
                    barPaint.color = barColor
                    c.drawRoundRect(barStartX, barY, barStartX + barW * safeScore, barY + 24f, 4f, 4f, barPaint)
                    text.textSize = 13f; text.color = Color.WHITE
                    c.drawText("空间${cand.region} 尾${if (cand.tailOk) "Y" else "N"} 食${if (cand.foodDist < 0) "∞" else cand.foodDist} Q${"%.2f".format(cand.qValue)}",
                        barStartX + 8f, barY + 18f, text)
                }
                barY += 28f
            }
        } else barY = top + 318f
        val chartY = barY + 20f; val chartH = 72f
        val curveX = left + 16f; val curveW = (w - 32f) * 0.55f
        text.isFakeBoldText = true; text.textSize = 14f; text.color = Color.rgb(120, 255, 180)
        c.drawText("【历史分数】", curveX, chartY, text)
        text.isFakeBoldText = false
        drawLearningCurve(c, curveX, chartY + 8f, curveW, chartH)
        val pieCX = left + w - 130f; val pieCY = chartY + chartH / 2f + 14f; val pieR = 34f
        text.isFakeBoldText = true; text.textSize = 14f; text.color = Color.rgb(255, 150, 150)
        c.drawText("【死亡统计】", pieCX - 52f, chartY, text)
        text.isFakeBoldText = false
        drawDeathPie(c, pieCX, pieCY, pieR)
        text.textSize = 13f; text.color = Color.rgb(255, 100, 100)
        c.drawText("W $deathWall", pieCX + 42f, pieCY - 16f, text)
        text.color = Color.rgb(100, 150, 255); c.drawText("S $deathSelf", pieCX + 42f, pieCY + 4f, text)
        text.color = Color.rgb(255, 200, 100); c.drawText("T $deathTrap", pieCX + 42f, pieCY + 24f, text)
        val heatY = chartY + chartH + 30f
        text.textAlign = Paint.Align.LEFT; text.isFakeBoldText = true; text.textSize = 14f; text.color = Color.rgb(200, 180, 255)
        c.drawText("【V2 Q表热度】", left + 16f, heatY, text)
        text.isFakeBoldText = false
        drawQHeatmap(c, left + 16f, heatY + 8f, w - 32f, 66f)
        val infoY = heatY + 8f + 66f + 22f
        var visited = 0; var sumQ = 0f; var cntQ = 0
        val sampleStep = max(1, V2_STATE_COUNT / 400)
        for (s in 0 until V2_STATE_COUNT step sampleStep) for (a in 0 until 4) {
            val idx = qIndex(s, a); if (nV2[idx] > 0) { visited++; sumQ += qV2[idx]; cntQ++ }
        }
        val avgQ = if (cntQ > 0) sumQ / cntQ else 0f
        text.textSize = 14f; text.color = Color.WHITE; text.textAlign = Paint.Align.LEFT
        if (reinforceTraining) {
            c.drawText("世代 $generation   已分配 $currentAgentIndex/$POPULATION_SIZE   已完成 $completedAgents/$POPULATION_SIZE   Q覆盖${visitedStates.size}",
                left + 16f, infoY, text)
            c.drawText("本代最佳 ${"%.0f".format(bestScoreThisGen)}   历史最佳 ${"%.0f".format(bestScoreAllTime)}",
                left + 16f, infoY + 18f, text)
            c.drawText("Q表权重 ${"%.2f".format(qWeight)}   神经网络权重 ${"%.2f".format(nnWeight)}",
                left + 16f, infoY + 36f, text)
            c.drawText("回放${replayBuffer.size}/$REPLAY_CAPACITY   ε${"%.2f".format(v2Epsilon)}   步${v2LearningSteps}",
                left + 16f, infoY + 54f, text)
            val avgBeamNodes = if (beamCalls > 0) beamTotalNodes.toFloat() / beamCalls else 0f
            c.drawText("Beam 命中$beamSelected 调用$beamCalls 成功$beamSuccess 节点$beamTotalNodes 均$avgBeamNodes",
                left + 16f, infoY + 72f, text)
            val learnStatus = when {
                generation < 3 -> "🧬 初始化种群，随机试错中..."
                v2Epsilon > 0.15f -> "🔍 探索阶段：尝试新策略"
                v2Epsilon < 0.05f && nnWeight >= 0.45f -> "🧠 收敛阶段：神经网络主导"
                bestScoreThisGen > bestScoreAllTime * 0.95f && bestScoreAllTime > 0 -> "🚀 突破中！分数上升"
                bestScoreThisGen < bestScoreAllTime * 0.3f && bestScoreAllTime > 1000 -> "⚡ 瓶颈期，等待变异突破"
                else -> "📊 正常进化中..."
            }
            text.textSize = 13f; text.isFakeBoldText = true; text.color = Color.rgb(100, 220, 255)
            c.drawText(learnStatus, left + 16f, infoY + 92f, text)
            if (deadEndPredicted) {
                text.color = Color.rgb(255, 80, 80)
                c.drawText("⚠️ 死局预判！食物周围空间仅 ${"%.1f".format(foodSpaceRatio)}x 蛇长", left + 16f, infoY + 112f, text)
            } else {
                text.color = Color.rgb(80, 200, 120)
                c.drawText("✅ 食物空间 ${"%.1f".format(foodSpaceRatio)}x 蛇长", left + 16f, infoY + 112f, text)
            }
            text.color = if (rolloutActive) Color.rgb(180, 180, 255) else Color.rgb(100, 100, 120)
            c.drawText(if (rolloutActive) "🔮 前瞻模拟${rolloutSteps}步（蛇长${snake.size}）" else "🔮 前瞻模拟：蛇短不启用",
                left + 16f, infoY + 130f, text)
            text.isFakeBoldText = false; text.color = Color.WHITE; text.textSize = 14f
        } else {
            c.drawText("局数 $totalGames   近50均分 ${"%.0f".format(avg)}   最佳 $bestRecentScore", left + 16f, infoY, text)
            c.drawText("V2覆盖 $visited   平均Q ${"%.2f".format(avgQ)}   学习步 $v2LearningSteps", left + 16f, infoY + 18f, text)
            c.drawText("ε ${"%.3f".format(v2Epsilon)}   攻击x${"%.2f".format(aggression)}   安全x${"%.2f".format(safetyMargin)}", left + 16f, infoY + 36f, text)
        }
        if (gameOver && !reinforceTraining) {
            text.color = Color.RED; text.isFakeBoldText = true; text.textSize = 16f
            c.drawText("死亡原因：$deathCause", left + 16f, infoY + 62f, text)
            text.isFakeBoldText = false
        }
        val btnW = 160f; val btnH = 42f
        val btnLeft = left + w - btnW - 16f; val btnTop = infoY + 48f
        reinforceButtonRect.set(btnLeft, btnTop, btnLeft + btnW, btnTop + btnH)
        val btnColor = if (reinforceTraining) Color.rgb(231, 76, 60) else Color.rgb(46, 204, 113)
        panel.color = btnColor; c.drawRoundRect(reinforceButtonRect, 12f, 12f, panel)
        text.textAlign = Paint.Align.CENTER; text.isFakeBoldText = true; text.textSize = 18f; text.color = Color.WHITE
        c.drawText(if (reinforceTraining) "停止进化" else "神经进化", reinforceButtonRect.centerX(), reinforceButtonRect.centerY() + 7f, text)
        text.isFakeBoldText = false; text.textAlign = Paint.Align.LEFT
    }

    private fun drawGameOver(c: Canvas) {
        paint.color = Color.argb(150, 0, 0, 0)
        c.drawRect(0f, 0f, width.toFloat(), height.toFloat(), paint)
        text.textAlign = Paint.Align.CENTER; text.isFakeBoldText = true
        text.textSize = 30f; text.color = Color.WHITE
        c.drawText("GAME OVER", width / 2f, height / 2f - 45, text)
        text.textSize = 15f; text.isFakeBoldText = false
        c.drawText("分数 $score   最高 $highScore   长度 ${snake.size}", width / 2f, height / 2f - 15, text)
        text.color = Color.YELLOW
        c.drawText("点击屏幕重新开始", width / 2f, height / 2f + 20, text)
        text.color = Color.LTGRAY; text.textSize = 11f
        c.drawText(lastDeathInfo, width / 2f, height / 2f + 48, text)
    }

    private var touchStartX = 0f
    private var touchStartY = 0f

    override fun onTouchEvent(e: MotionEvent): Boolean {
        when (e.action) {
            MotionEvent.ACTION_DOWN -> { touchStartX = e.x; touchStartY = e.y; return true }
            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
                if (reinforceButtonRect.contains(e.x, e.y)) {
                    val now = System.currentTimeMillis()
                    if (now - lastReinforceTap > 400L) { lastReinforceTap = now; setReinforceTraining(!reinforceTraining) }
                    return true
                }
                if (reinforceTraining) return true
                if (gameOver) { reset(); return true }
                if (aiMode != 0) return true
                if (snake.isEmpty()) return true
                val dx = e.x - touchStartX; val dy = e.y - touchStartY
                val useSwipe = abs(dx) > 24f || abs(dy) > 24f
                val d = if (useSwipe) {
                    if (abs(dx) > abs(dy)) P(if (dx > 0) 1 else -1, 0) else P(0, if (dy > 0) 1 else -1)
                } else {
                    val hx = ox + (snake.first().x + 0.5f) * cell
                    val hy = oy + (snake.first().y + 0.5f) * cell
                    val rdx = e.x - hx; val rdy = e.y - hy
                    if (abs(rdx) > abs(rdy)) P(if (rdx > 0) 1 else -1, 0) else P(0, if (rdy > 0) 1 else -1)
                }
                if (!isReverse(d, dir)) { queue.clear(); queue.add(d) }
                return true
            }
            else -> return true
        }
    }

    override fun onDetachedFromWindow() {
        stopParallelTraining(); stopWatchDog()
        super.onDetachedFromWindow()
        bgm?.stop()
        try { toneGen?.release() } catch (_: Throwable) {}
        try { aiPool.shutdownNow() } catch (_: Throwable) {}
        saveTrainingState()
    }

    private inner class TrainGame(
        seed: Long,
        private val runId: Long,
        private val statusIndex: Int = 0
    ) {
        val rng = Random(seed)
        val gSnake = ArrayDeque<P>()
        var gDir = P(1, 0)
        var gFood = P(7, 7)
        var gScore = 0
        var gHunger = 0
        var gLastFreeRegion = 0f
        var gCombo = 0
        var gSteps = 0
        var gOver = false
        var lastDeathCause = "UNKNOWN"

        val vis = BooleanArray(total)
        val que = IntArray(total + 4)
        val par = IntArray(total)
        val parDir = arrayOfNulls<P>(total)

        private var currentAgentId = -1
        var gLastAction = -1

        fun playOneGame(agentId: Int, expectedGenerationToken: Long): Boolean {
            currentAgentId = agentId
            if (agentId !in 0 until POPULATION_SIZE) { Log.e(LOG_TAG, "INVALID_AGENT_ID=$agentId"); return false }
            if (generationToken != expectedGenerationToken) {
                Log.w(LOG_TAG, "STALE_GAME_START agent=$agentId expected=$expectedGenerationToken actual=$generationToken")
                return false
            }
            gSnake.clear(); gSnake.add(P(7, 7)); gSnake.add(P(6, 7)); gSnake.add(P(5, 7))
            gDir = P(1, 0); gScore = 0; gHunger = 0; gCombo = 0; gSteps = 0; gOver = false; gLastAction = -1
            lastDeathCause = "UNKNOWN"
            gLastFreeRegion = gFreeRegion(gSnake).toFloat(); gPlaceFood()
            val maxIterations = 8000; var iter = 0
            try {
                while (!gOver && isTrainingRunActive(runId) && generationToken == expectedGenerationToken && !Thread.currentThread().isInterrupted && iter < maxIterations) { gStep(); iter++ }
            } catch (t: Throwable) {
                Log.e(LOG_TAG, "TrainGame agent=$agentId crashed", t)
                if (isTrainingRunActive(runId) && generationToken == expectedGenerationToken) {
                    lastDeathCause = "EXCEPTION"; gOver = true
                    try { gDie(lastDeathCause) } catch (inner: Throwable) { Log.e(LOG_TAG, "gDie exception failed", inner) }
                    return true
                }
                return false
            }
            if (!isTrainingRunActive(runId) || generationToken != expectedGenerationToken || Thread.currentThread().isInterrupted) return false
            if (!gOver) {
                lastDeathCause = "TIMEOUT"; gOver = true
                gScore = max(0, gScore - 500)
                try { gDie(lastDeathCause) } catch (inner: Throwable) { Log.e(LOG_TAG, "gDie timeout failed", inner) }
                return true
            }
            try { gDie(lastDeathCause) } catch (inner: Throwable) { Log.e(LOG_TAG, "gDie normal failed", inner) }
            return true
        }

        fun gPlaceFood() {
            val free = ArrayList<P>(total)
            for (x in 0 until cols) for (y in 0 until rows) { val p = P(x, y); if (!gSnake.contains(p)) free.add(p) }
            if (free.isNotEmpty()) gFood = free[rng.nextInt(free.size)]
        }

        fun gStep() {
            heartbeat()
            val state = gBuildState()
            val mv = gChooseMove(state)
            val action = dirs.indexOfFirst { it == mv }.coerceAtLeast(0)
            gLastAction = action
            if (!gIsReverse(mv, gDir)) gDir = mv
            val nh = P(gSnake.first().x + gDir.x, gSnake.first().y + gDir.y)
            if (!gInside(nh)) { gTerminal(state, action, DEATH_WALL); lastDeathCause = "WALL"; gOver = true; return }
            val ate = nh == gFood; val tail = gSnake.last()
            if (gSnake.contains(nh) && !(nh == tail && !ate)) {
                val testSnake = ArrayDeque(gSnake); testSnake.addFirst(nh); if (!ate) testSnake.removeLast()
                val reg = gFreeRegion(testSnake)
                val cause = if (reg < max(2, (gSnake.size * safetyMargin).toInt())) "TRAP" else "SELF"
                gTerminal(state, action, if (cause == "TRAP") DEATH_TRAP else DEATH_SELF)
                lastDeathCause = cause; gOver = true; return
            }
            gSnake.addFirst(nh); var reward = REWARD_STEP
            if (ate) {
                gScore += 10 + min(gCombo, 30) * 3 + gSnake.size; gCombo++; gHunger = 0; gPlaceFood()
                reward += REWARD_FOOD + gCombo * 0.06f
            } else {
                gSnake.removeLast(); gHunger++; gCombo = max(0, gCombo - 1)
                val gCurFree = gFreeRegion(gSnake).toFloat(); val gSpaceDelta = gCurFree - gLastFreeRegion
                gLastFreeRegion = gCurFree; reward += gSpaceDelta * REWARD_SPACE_DELTA
                if (gTailReachable(gSnake)) reward += REWARD_TAIL
                if (gCalculateDanger() >= 4) reward += REWARD_DANGER
                reward += -(gHunger * gHunger * 0.001f).coerceAtMost(0.15f)
            }
            gSteps++
            if (statusIndex in threadStatus.indices) {
                val st = threadStatus[statusIndex]
                st.score = gScore; st.steps = gSteps
                st.phase = if (ate) "捕食" else if (gCalculateDanger() >= 3) "避险" else "搜索"
            }
            if (gHunger >= hungerKillLimit) { gTerminal(state, action, DEATH_HUNGER); lastDeathCause = "HUNGER"; gOver = true; return }
            val nextState = gBuildState(); val nextMask = gLegalMask()
            qUpdate(state, action, reward, nextState, nextMask, false)
        }

        private fun gTerminal(state: Int, action: Int, reward: Float) { qUpdate(state, action, reward, state, 0, true) }

        private fun beamSearchBestMove(): Pair<P, Float>? {
            if (!BEAM_ENABLED) return null
            if (gSnake.isEmpty()) return null
            if (gSnake.size < BEAM_MIN_LENGTH) return null

            beamCalls++

            try {
                val depth = when {
                    gSnake.size >= 50 -> BEAM_DEPTH_MAX
                    gSnake.size >= BEAM_LONG_LENGTH -> BEAM_DEPTH_LONG
                    else -> BEAM_DEPTH_SHORT
                }.coerceAtMost(BEAM_DEPTH_MAX)

                val width = if (gSnake.size >= BEAM_LONG_LENGTH) 4 else BEAM_WIDTH

                val initialMoves = dirs
                    .map { d -> gEvaluate(d) }
                    .filter { it.legal }
                    .sortedByDescending { it.score }
                    .take(width)

                if (initialMoves.isEmpty()) return null

                var beam = ArrayList<BeamNode>()
                var nodesExpanded = 0
                val startHeads = IntArray(4) { -1 }

                for (candidate in initialMoves) {
                    val node = simulateBeamMove(gSnake, gDir, gFood, candidate.d, candidate.d, startHeads)
                    if (node != null) {
                        beam.add(node)
                        nodesExpanded++
                    }
                }

                if (beam.isEmpty()) return null

                var depthStep = 0
                while (depthStep < depth - 1 && beam.isNotEmpty()) {
                    val next = ArrayList<BeamNode>()
                    var limitReached = false

                    for (node in beam) {
                        if (node.dead || limitReached) continue
                        val validMoves = dirs.filter { !gIsReverse(it, node.dir) }
                        val moves = ArrayList<BeamNode>()
                        for (mv in validMoves) {
                            val simulated = simulateBeamMove(node.body, node.dir, node.food, mv, node.firstAction, node.recentHeadCells)
                            if (simulated != null) {
                                moves.add(simulated)
                            }
                        }
                        val topMoves = moves.sortedByDescending { it.score }.take(width)
                        next.addAll(topMoves)
                        nodesExpanded += topMoves.size
                        if (nodesExpanded >= BEAM_MAX_NODES) {
                            limitReached = true
                        }
                    }
                    if (next.isEmpty()) {
                        beam = ArrayList()
                        break
                    }
                    beam = ArrayList(next.sortedByDescending { it.score }.take(width))
                    depthStep++
                }

                if (beam.isEmpty()) return null
                val best = beam.filter { !it.dead }.maxByOrNull { it.score }
                    ?: beam.maxByOrNull { it.score }
                    ?: return null

                beamSuccess++
                beamTotalNodes += nodesExpanded
                beamBestScore = best.score

                return Pair(best.firstAction, best.score)
            } catch (t: Throwable) {
                Log.e(LOG_TAG, "Beam search failed", t)
                return null
            }
        }

        private fun simulateBeamMove(
            sourceBody: ArrayDeque<P>,
            sourceDir: P,
            targetFood: P,
            move: P,
            firstAction: P,
            prevHeads: IntArray
        ): BeamNode? {
            if (sourceBody.isEmpty()) return null
            if (gIsReverse(move, sourceDir)) return null

            val body = ArrayDeque<P>()
            for (p in sourceBody) body.addLast(p)

            val head = body.first()
            val nextHead = P(head.x + move.x, head.y + move.y)

            if (!gInside(nextHead)) {
                return BeamNode(body, move, targetFood, -100f, 1, false, true, 0f, firstAction, prevHeads)
            }

            val ate = nextHead == targetFood
            val hitBody = body.contains(nextHead)

            if (hitBody && !(nextHead == body.last() && !ate)) {
                return BeamNode(body, move, targetFood, -100f, 1, false, true, 0f, firstAction, prevHeads)
            }

            body.addFirst(nextHead)
            if (!ate) body.removeLast()

            val region = gFreeRegion(body)
            val ratio = region.toFloat() / max(1, body.size)
            val tailOk = gTailReachable(body)
            val safeMoves = gCountSafeMoves(body)
            val foodDistance = gDistance(body.first(), targetFood, body, true).let { if (it < 0) 999 else it }
            val danger = calculateBeamDanger(body, move, targetFood)

            var score = 0f
            score += BEAM_SURVIVAL_WEIGHT
            score += ratio * BEAM_SPACE_WEIGHT

            if (tailOk) {
                score += BEAM_TAIL_WEIGHT
            } else if (body.size > 8) {
                score -= BEAM_TAIL_WEIGHT * 1.5f
            }

            if (ate) {
                score += 12f * BEAM_FOOD_WEIGHT
                val afterRegion = gFreeRegion(body)
                val afterTail = gTailReachable(body)
                val afterSafe = gCountSafeMoves(body)
                if (afterRegion < body.size * 0.8f) score -= 15f
                if (!afterTail && body.size > 12) score -= 12f
                if (afterSafe <= 1) score -= 8f
            } else {
                val foodProgress = 1f / (foodDistance + 1f)
                score += foodProgress * 8f * BEAM_FOOD_WEIGHT
            }

            score += safeMoves * 0.5f
            score -= danger * BEAM_DANGER_WEIGHT

            if (ratio < 0.7f && body.size > 8) {
                score -= 8f
            }
            if (!tailOk && body.size > 12) {
                score -= 7f
            }

            val nextCell = nextHead.y * cols + nextHead.x
            var loopHits = 0
            for (h in prevHeads) if (h == nextCell) loopHits++
            if (loopHits > 0) {
                score -= BEAM_LOOP_WEIGHT * loopHits
                if (loopHits >= 2) score -= BEAM_LOOP_WEIGHT
            }

            val newHeads = IntArray(4) { -1 }
            newHeads[0] = nextCell
            for (i in 1..3) newHeads[i] = prevHeads[i - 1]

            return BeamNode(body, move, targetFood, score, 1, ate, false, loopHits.toFloat(), firstAction, newHeads)
        }

        private fun calculateBeamDanger(body: ArrayDeque<P>, heading: P, target: P): Float {
            if (body.isEmpty()) return 5f
            val head = body.first()
            var danger = 0f
            for (d in dirs) {
                if (gIsReverse(d, heading)) continue
                val np = P(head.x + d.x, head.y + d.y)
                if (!gInside(np)) { danger += 1f; continue }
                val ate = np == target
                if (body.contains(np) && !(np == body.last() && !ate)) danger += 1f
            }
            val safeMoves = gCountSafeMoves(body)
            if (safeMoves <= 1) danger += 2f
            if (safeMoves == 0) danger += 5f
            return danger.coerceIn(0f, 5f)
        }

        fun gChooseMove(state: Int): P {
            val cands = dirs.map { gEvaluate(it) }
            val legal = cands.filter { it.legal }
            if (legal.isEmpty()) return gDir
            if (legal.size == 1) return legal.first().d

            val safeFood = gFindSafeFoodStep()
            val tailStep = if (gHunger < gHungerForceEat()) gFollowTailStep(legal) else null
            val threshold = gHungerForceEat()

            val candidatePool = when {
                gHunger >= threshold -> {
                    val safeFoodCandidates = legal.filter { it.tailOk && it.foodDist >= 0 }
                    if (safeFoodCandidates.isNotEmpty()) safeFoodCandidates else legal
                }
                else -> {
                    val shielded = legal.filter {
                        val ratio = it.region.toFloat() / max(1, gSnake.size)
                        it.tailOk || ratio >= 1.0f || (gSnake.size < 15 && ratio >= 0.75f)
                    }
                    if (shielded.isNotEmpty()) shielded else legal
                }
            }

            val boosted = candidatePool.map { c ->
                var extra = 0f
                if (safeFood != null && c.d == safeFood) extra += 3.0f
                if (tailStep != null && c.d == tailStep) extra += 1.5f
                c.copy(score = c.score + extra)
            }

            return gSelectAction(state, boosted).d
        }

        private fun gSelectAction(state: Int, legal: List<Candidate>): Candidate {
            if (legal.size == 1) return legal.first()
            if (rng.nextFloat() < currentEpsilon()) {
                val safe = legal.filter { it.tailOk || it.region >= max(5, gSnake.size / 2) }
                return if (safe.isNotEmpty()) safe[rng.nextInt(safe.size)] else legal[rng.nextInt(legal.size)]
            }
            if (currentAgentId !in 0 until POPULATION_SIZE) {
                Log.e(LOG_TAG, "Invalid currentAgentId=$currentAgentId")
                return legal.first()
            }
            val brain = population[currentAgentId]
            val nnInputs = buildInputs(gSnake.first(), gFood, gSnake)
            val nnVals = brain.think(nnInputs)

            val v3TrainCtx: Long = run {
                val h0 = gSnake.first()
                val foodDxBucket = ((gFood.x - h0.x) / 3).coerceIn(-5, 5)
                val foodDyBucket = ((gFood.y - h0.y) / 3).coerceIn(-5, 5)
                val regionBucket = (gFreeRegion(gSnake) / 4).coerceIn(0, 60)
                val lenBucket = (gSnake.size / 8).coerceIn(0, 30)
                val headingBucket = when (gDir) { P(0, -1) -> 0; P(0, 1) -> 1; P(-1, 0) -> 2; else -> 3 }
                val dangerBucket = gCalculateDanger().coerceIn(1, 5)
                val tailBucket = if (gTailReachable(gSnake)) 1 else 0
                var hh = 1125899906842597L
                hh = hh * 31 + h0.x; hh = hh * 31 + h0.y
                hh = hh * 31 + foodDxBucket; hh = hh * 31 + foodDyBucket
                hh = hh * 31 + headingBucket; hh = hh * 31 + dangerBucket
                hh = hh * 31 + regionBucket; hh = hh * 31 + lenBucket; hh = hh * 31 + tailBucket
                hh xor v3TrainCtxSalt
            }
            val de = gCheckFoodDeadEnd()
            deadEndPredicted = de.first; foodSpaceRatio = de.second
            var deadEndPenalty = 0f; if (de.first) deadEndPenalty = -5f
            val rSteps = when { gSnake.size > 60 -> 5; gSnake.size > 25 -> 3; else -> 0 }
            rolloutActive = rSteps > 0; rolloutSteps = rSteps

            val beamResult = if (BEAM_ENABLED && gSnake.size >= BEAM_MIN_LENGTH) beamSearchBestMove() else null
            val beamMove = beamResult?.first
            val beamValid = beamMove != null && legal.any { it.d == beamMove }

            var best = legal.first(); var bestValue = -Float.MAX_VALUE
            for (candidate in legal) {
                val a = dirs.indexOfFirst { it == candidate.d }; if (a < 0) continue
                val q = qRead(state, a); val nn = nnVals[a]; val rule = candidate.score
                val rolloutScore = if (rSteps > 0) gRolloutN(candidate.d, rSteps) else 0f
                val v3TrainPenalty = v3Memory.penaltyFor(v3TrainCtx, a) * (if (v3FusionEnabled) 45f else 0f)
                val qNorm = (q / 10f).coerceIn(-1f, 1f)
                val nnNorm = kotlin.math.tanh(nn * 0.25f).coerceIn(-1f, 1f)
                val ruleNorm = kotlin.math.tanh(rule / 1000f).coerceIn(-1f, 1f)
                val rolloutNorm = kotlin.math.tanh(rolloutScore / 30f).coerceIn(-1f, 1f)
                val memoryNorm = kotlin.math.tanh(v3TrainPenalty / 10f).coerceIn(-1f, 1f)
                val deadNorm = deadEndPenalty.coerceIn(-1f, 0f)
                val beamNorm = if (beamValid && candidate.d == beamMove) {
                    kotlin.math.tanh(beamResult!!.second / 20f).coerceIn(-1f, 1f)
                } else 0f
                val mixed = qWeight * qNorm + nnWeight * nnNorm +
                            0.30f * ruleNorm + 0.20f * rolloutNorm +
                            0.25f * memoryNorm + 0.20f * deadNorm +
                            BEAM_WEIGHT * beamNorm
                if (mixed > bestValue) { bestValue = mixed; best = candidate.copy(qValue = q) }
            }

            if (beamValid && best.d == beamMove) beamSelected++

            if (beamCalls > 0L && beamCalls % 100L == 0L && currentAgentId == 0) {
                Log.d(LOG_TAG, "Beam: calls=$beamCalls success=$beamSuccess selected=$beamSelected nodes=$beamTotalNodes best=$beamBestScore")
            }

            return best
        }

        private fun gCheckFoodDeadEnd(): Pair<Boolean, Float> {
            if (gSnake.isEmpty()) return Pair(false, 10f)
            val gVisited = BooleanArray(total); val queue = ArrayDeque<Int>()
            val start = gFood.y * cols + gFood.x; if (start !in gVisited.indices) return Pair(true, 0f)
            gVisited[start] = true; queue.addLast(start); var space = 0
            while (queue.isNotEmpty()) {
                val curr = queue.removeFirst(); space++
                val x = curr % cols; val y = curr / cols
                for (d in dirs) {
                    val nx = x + d.x; val ny = y + d.y
                    if (nx !in 0 until cols || ny !in 0 until rows) continue
                    val index = ny * cols + nx; if (gVisited[index]) continue
                    val p = P(nx, ny); if (gSnake.contains(p)) continue
                    gVisited[index] = true; queue.addLast(index)
                }
            }
            val ratio = space.toFloat() / max(1, gSnake.size)
            return Pair(ratio < 1.2f, ratio)
        }

        private fun gRolloutN(startDir: P, maxSteps: Int): Float {
            var body = ArrayDeque(gSnake); var dir = startDir; var score = 0f
            for (step in 0 until maxSteps) {
                if (body.isEmpty()) return score - 50f
                var bestNext: P? = null; var bestSpace = -1
                for (d in dirs) {
                    val nh = P(body.first().x + d.x, body.first().y + d.y)
                    if (!gInside(nh)) continue
                    val isTail = nh == body.last(); if (body.contains(nh) && !isTail) continue
                    var space = 0
                    for (sd in dirs) {
                        val sx = nh.x + sd.x; val sy = nh.y + sd.y
                        if (sx in 0 until cols && sy in 0 until rows) if (!body.any { it.x == sx && it.y == sy }) space++
                    }
                    if (space > bestSpace) { bestSpace = space; bestNext = d }
                }
                if (bestNext == null) return score - 50f
                val sim = gSimulateOn(body, bestNext); body = sim.body
                val region = gFreeRegion(body); val tailOk = gTailReachable(body); val mobility = gCountSafeMoves(body)
                val spaceRatio = region.toFloat() / max(1, body.size)
                score += spaceRatio.coerceIn(0f, 6f) * 0.8f
                score += mobility * 0.5f
                if (tailOk) score += 1.5f else if (body.size > 10) score -= 3.0f
                if (sim.ate) score += 8f
                val fd = gDistance(body.first(), gFood, body, true)
                if (fd >= 0) score += 3.0f / (fd + 1)
                score *= 0.92f
                dir = bestNext
            }
            return score
        }

        private fun gBuildState(): Int = buildState(gSnake, gDir, gFood, gHunger)
        private fun gLegalMask(): Int = legalActionMask(gSnake, gDir, gFood)

        fun gHungerForceEat(): Int = when { gSnake.size < 20 -> 50; gSnake.size < 35 -> 70; gSnake.size < 55 -> 100; gSnake.size < 80 -> 140; else -> 200 }

        fun gFollowTailStep(legal: List<Candidate>): P? {
            if (gSnake.size < 2) return null
            val path = gShortestPath(gSnake.first(), gSnake.last(), gSnake, true) ?: return null
            if (path.isEmpty()) return null
            val step = path.first(); if (legal.none { it.d == step }) return null
            val sim = gSimulate(step); if (sim.body.isEmpty()) return null
            if (!gTailReachable(sim.body)) return null
            return step
        }

        fun gFindSafeFoodStep(): P? {
            val path = gShortestPath(gSnake.first(), gFood, gSnake, true) ?: return null
            if (path.isEmpty()) return null
            val simBody = ArrayDeque(gSnake); var ate = false
            for (step in path) {
                val nh = P(simBody.first().x + step.x, simBody.first().y + step.y)
                if (!gInside(nh)) return null
                val willEat = nh == gFood
                if (simBody.contains(nh) && !(nh == simBody.last() && !willEat)) return null
                simBody.addFirst(nh); if (!willEat) simBody.removeLast() else ate = true
            }
            if (!ate) return null; if (!gTailReachable(simBody)) return null
            val len = simBody.size; val freeLeft = total - len
            if (len > 180 && freeLeft < 4) return null
            if (len > 150 && freeLeft < 6) return null
            if (len > 120 && freeLeft < 10) return null
            if (len > 90 && freeLeft < 14) return null
            if (len > 60 && freeLeft < 20) return null
            return path.first()
        }

        fun gEvaluate(d: P): Candidate {
            if (!gLegalDirection(d)) return Candidate(d, -1e9f, "非法", false)
            val sim = gSimulate(d); if (sim.body.isEmpty()) return Candidate(d, -1e9f, "非法", false)
            val region = gFreeRegion(sim.body); val tail = gTailReachable(sim.body)
            val foodDist = gDistance(sim.body.first(), gFood, sim.body, true)
            val ate = sim.ate; val mobility = gCountSafeMoves(sim.body)
            val hungerFactor = when { gHunger >= 60 -> 4f; gHunger >= 30 -> 2.5f; gHunger >= 15 -> 1.6f; else -> 1f }
            val regionScore = region * wRegion; val mobilityScore = mobility * wMobility
            val tailScore = if (tail) wTailGood else wTailBad
            var foodScore = if (foodDist >= 0) hungerFactor * aggression * (wFoodNear / (foodDist + 1)) else -450f * hungerFactor
            if (ate) foodScore += wFoodAte * aggression
            var eatPenalty = 0f
            if (ate) {
                val afterSize = sim.body.size; val needSpace = (afterSize * safetyMargin).toInt() + 2
                if (!tail || region < needSpace) eatPenalty = -7500f - gSnake.size * 100f
                else {
                    val after = ArrayDeque(sim.body)
                    val dx = after.last().x - after.first().x; val dy = after.last().y - after.first().y
                    val follow = when { abs(dx) >= abs(dy) && dx != 0 -> P(if (dx > 0) 1 else -1, 0); dy != 0 -> P(0, if (dy > 0) 1 else -1); else -> null }
                    if (follow != null && canSim(after, follow)) {
                        val next = simulateOn(after, follow)
                        val r2 = freeRegion(next.body); val t2 = tailReachable(next.body)
                        if (!t2 || r2 < (afterSize * 1.2f).toInt()) eatPenalty = -4500f - gSnake.size * 60f
                    }
                }
            }
            val edge = min(min(sim.body.first().x, cols - 1 - sim.body.first().x), min(sim.body.first().y, rows - 1 - sim.body.first().y))
            val edgeScore = -max(0, 2 - edge) * wEdge
            val spacePenalty = max(0f, gSnake.size * safetyMargin - region.toFloat())
            val spaceScore = -spacePenalty * wSpace
            val totalScore = regionScore + mobilityScore + tailScore + foodScore + edgeScore + spaceScore + eatPenalty
            return Candidate(d, totalScore, "", true, regionScore = regionScore, mobilityScore = mobilityScore,
                tailScore = tailScore, foodScore = foodScore, edgeScore = edgeScore, spaceScore = spaceScore,
                region = region, mobility = mobility, tailOk = tail, foodDist = foodDist, ate = ate)
        }

        fun gSimulate(d: P): Sim = gSimulateOn(ArrayDeque(gSnake), d)
        fun gSimulateOn(src: ArrayDeque<P>, d: P): Sim {
            val b = ArrayDeque(src); if (b.isEmpty()) return Sim(b, false)
            val nh = P(b.first().x + d.x, b.first().y + d.y)
            if (!gInside(nh)) return Sim(b, false)
            val ate = nh == gFood
            if (b.contains(nh) && !(nh == b.last() && !ate)) return Sim(b, false)
            b.addFirst(nh); if (!ate) b.removeLast(); return Sim(b, ate)
        }

        fun gLegalDirection(d: P): Boolean {
            if (d == P(0, 0)) return false
            if (gIsReverse(d, gDir)) return false
            if (gSnake.isEmpty()) return false
            val nh = P(gSnake.first().x + d.x, gSnake.first().y + d.y)
            if (!gInside(nh)) return false
            val ate = nh == gFood
            return !gSnake.contains(nh) || (nh == gSnake.last() && !ate)
        }

        fun gIsReverse(a: P, b: P): Boolean = a.x == -b.x && a.y == -b.y
        fun gInside(p: P): Boolean = p.x in 0 until cols && p.y in 0 until rows

        fun gFreeRegion(body: ArrayDeque<P>): Int {
            if (body.isEmpty()) return 0
            java.util.Arrays.fill(vis, 0, total, false)
            for (p in body) { if (!gInside(p)) continue; vis[p.y * cols + p.x] = true }
            val start = body.first(); if (!gInside(start)) return 0
            val si = start.y * cols + start.x; vis[si] = true
            var head = 0; var tail = 0; que[tail++] = si; var count = 0
            while (head < tail) {
                val curr = que[head++]; val cx = curr % cols; val cy = curr / cols; count++
                if (cx > 0) { val ni = curr - 1; if (!vis[ni]) { vis[ni] = true; if (tail < total) que[tail++] = ni } }
                if (cx < cols - 1) { val ni = curr + 1; if (!vis[ni]) { vis[ni] = true; if (tail < total) que[tail++] = ni } }
                if (cy > 0) { val ni = curr - cols; if (!vis[ni]) { vis[ni] = true; if (tail < total) que[tail++] = ni } }
                if (cy < rows - 1) { val ni = curr + cols; if (!vis[ni]) { vis[ni] = true; if (tail < total) que[tail++] = ni } }
            }
            return count
        }

        fun gDistance(start: P, target: P, body: Collection<P>, allowTail: Boolean): Int {
            if (!gInside(start) || !gInside(target)) return -1
            if (start == target) return 0
            java.util.Arrays.fill(vis, 0, total, false)
            for (p in body) { if (!gInside(p)) continue; vis[p.y * cols + p.x] = true }
            if (allowTail && body.isNotEmpty()) { val last = body.last(); if (gInside(last)) vis[last.y * cols + last.x] = false }
            val si = start.y * cols + start.x; vis[si] = true
            var head = 0; var tail = 0; que[tail++] = si; var dist = 0
            while (head < tail) {
                val layer = tail - head
                repeat(layer) {
                    if (head >= tail) return@repeat
                    val curr = que[head++]; val cx = curr % cols; val cy = curr / cols
                    if (cx == target.x && cy == target.y) return dist
                    if (cx > 0) { val ni = curr - 1; if (!vis[ni]) { vis[ni] = true; if (tail < total) que[tail++] = ni } }
                    if (cx < cols - 1) { val ni = curr + 1; if (!vis[ni]) { vis[ni] = true; if (tail < total) que[tail++] = ni } }
                    if (cy > 0) { val ni = curr - cols; if (!vis[ni]) { vis[ni] = true; if (tail < total) que[tail++] = ni } }
                    if (cy < rows - 1) { val ni = curr + cols; if (!vis[ni]) { vis[ni] = true; if (tail < total) que[tail++] = ni } }
                }
                dist++
            }
            return -1
        }

        fun gCountSafeMoves(body: ArrayDeque<P>): Int {
            if (body.isEmpty()) return 0
            val h = body.first()
            val prevDir = if (body.size < 2) gDir else P(body.elementAt(0).x - body.elementAt(1).x, body.elementAt(0).y - body.elementAt(1).y)
            return dirs.count { d ->
                val nh = P(h.x + d.x, h.y + d.y)
                gInside(nh) && (!body.contains(nh) || (nh == body.last() && nh != gFood)) && !gIsReverse(d, prevDir)
            }
        }

        fun gTailReachable(body: ArrayDeque<P>): Boolean = if (body.isEmpty()) false else gDistance(body.first(), body.last(), body, true) >= 0

        fun gShortestPath(start: P, target: P, body: Collection<P>, allowTail: Boolean): List<P>? {
            if (start == target) return emptyList()
            if (!gInside(start) || !gInside(target)) return null
            java.util.Arrays.fill(vis, 0, total, false)
            for (p in body) { if (!gInside(p)) continue; val idx = p.y * cols + p.x; vis[idx] = true }
            if (allowTail && body.isNotEmpty()) { val last = body.last(); if (gInside(last)) { val li = last.y * cols + last.x; vis[li] = false } }
            val si = start.y * cols + start.x; val ti = target.y * cols + target.x; vis[si] = true
            java.util.Arrays.fill(par, 0, total, -1)
            for (i in 0 until total) parDir[i] = null
            var head = 0; var tail = 0; que[tail++] = si; var found = false
            while (head < tail) {
                val curr = que[head++]; val cx = curr % cols; val cy = curr / cols
                if (cy > 0) { val ni = curr - cols; if (!vis[ni]) { vis[ni] = true; par[ni] = curr; parDir[ni] = P(0, -1); if (tail < total) que[tail++] = ni } }
                if (cy < rows - 1) { val ni = curr + cols; if (!vis[ni]) { vis[ni] = true; par[ni] = curr; parDir[ni] = P(0, 1); if (tail < total) que[tail++] = ni } }
                if (cx > 0) { val ni = curr - 1; if (!vis[ni]) { vis[ni] = true; par[ni] = curr; parDir[ni] = P(-1, 0); if (tail < total) que[tail++] = ni } }
                if (cx < cols - 1) { val ni = curr + 1; if (!vis[ni]) { vis[ni] = true; par[ni] = curr; parDir[ni] = P(1, 0); if (tail < total) que[tail++] = ni } }
            }
            if (!found) return null
            val steps = ArrayList<P>(); var cur = ti
            while (cur != si) { val d = parDir[cur] ?: return null; steps.add(d); cur = par[cur]; if (cur < 0) return null }
            steps.reverse(); return steps
        }

        fun gCalculateDanger(): Int {
            val region = gFreeRegion(gSnake); val ratio = region.toFloat() / max(1, gSnake.size)
            val mobility = gCountSafeMoves(gSnake)
            return when {
                mobility <= 0 -> 5; ratio < 1.5f -> 5; ratio < 2.2f -> 4
                ratio < 3.5f -> 3; ratio < 5f -> 2; else -> 1
            }
        }

        fun gDie(cause: String) {
            var shouldSave = false
            synchronized(sharedLock) {
                when (cause) { "WALL" -> deathWall++; "SELF" -> deathSelf++; else -> deathTrap++ }
                totalGames++; recentScores.addLast(gScore)
                while (recentScores.size > 50) recentScores.removeFirst()
                if (gScore > bestRecentScore) bestRecentScore = gScore
                val index = currentAgentId
                if (index in 0 until POPULATION_SIZE) {
                    currentScores[index] = gScore.toFloat()
                    if (gScore.toFloat() > bestScoreThisGen) bestScoreThisGen = gScore.toFloat()
                    if (gScore.toFloat() > bestScoreAllTime) bestScoreAllTime = gScore.toFloat()
                } else {
                    Log.e(LOG_TAG, "gDie invalid agent index=$index")
                }
                v2Episodes++; shouldSave = totalGames % 200 == 0
            }
            try { if (v3FusionEnabled && gSnake.isNotEmpty()) v3TrainRecordLesson(cause, gSnake.first(), gTailReachable(gSnake), gSnake.size, gLastAction) }
            catch (t: Throwable) { Log.e(LOG_TAG, "v3TrainRecordLesson failed", t) }
            adjustWeights(cause)
            safetyMargin = (safetyMargin * 0.95f + 1.08f * 0.05f).coerceIn(1.0f, 1.20f)
            aggression = (aggression * 0.95f + 1.15f * 0.05f).coerceIn(0.95f, 1.35f)
            if (shouldSave) { try { saveLearning() } catch (_: Throwable) {} }
        }
    }

    private class BgmPlayer {
        private var audioTrack: AudioTrack? = null
        @Volatile private var playing = false
        private var thread: Thread? = null

        fun start() {
            if (playing) return
            playing = true
            thread = Thread {
                try {
                    val sr = 22050; val pcm = generateMelody(sr)
                    val track = AudioTrack.Builder()
                        .setAudioAttributes(AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_GAME).setContentType(AudioAttributes.CONTENT_TYPE_MUSIC).build())
                        .setAudioFormat(AudioFormat.Builder().setEncoding(AudioFormat.ENCODING_PCM_16BIT).setSampleRate(sr).setChannelMask(AudioFormat.CHANNEL_OUT_MONO).build())
                        .setBufferSizeInBytes(pcm.size * 2).setTransferMode(AudioTrack.MODE_STATIC).build()
                    track.write(pcm, 0, pcm.size)
                    if (Build.VERSION.SDK_INT >= 23) track.setLoopPoints(0, pcm.size, -1)
                    audioTrack = track
                    if (playing) track.play()
                } catch (_: Throwable) {}
            }.also { it.start() }
        }

        fun stop() {
            playing = false
            try { audioTrack?.pause() } catch (_: Throwable) {}
            try { audioTrack?.flush() } catch (_: Throwable) {}
            try { audioTrack?.release() } catch (_: Throwable) {}
            audioTrack = null; thread = null
        }

        private fun generateMelody(sampleRate: Int): ShortArray {
            val N = 0f; val E5 = 659.25f; val G5 = 783.99f; val C6 = 1046.50f
            val D5 = 587.33f; val F5 = 698.46f; val A5 = 880.00f
            val C5 = 523.25f; val E4 = 329.63f; val G4 = 392.00f
            val B4 = 493.88f; val A4 = 440.00f
            val notes = listOf(
                E5 to 180, G5 to 180, C6 to 180, G5 to 180, E5 to 180, G5 to 180, C6 to 260, N to 100,
                D5 to 180, F5 to 180, A5 to 180, F5 to 180, D5 to 180, F5 to 180, A5 to 260, N to 100,
                E5 to 180, G5 to 180, C6 to 180, G5 to 180, E5 to 180, G5 to 180, C6 to 180, E4 to 180,
                F5 to 180, A5 to 180, C6 to 180, A5 to 180, G5 to 260, D5 to 260, C5 to 420, N to 260,
                C5 to 180, E5 to 180, G5 to 180, E5 to 180, A4 to 180, C5 to 180, E5 to 180, C5 to 180,
                G4 to 180, B4 to 180, D5 to 180, G5 to 180, E5 to 220, D5 to 220, C5 to 420, N to 260,
                E5 to 180, D5 to 180, C5 to 180, D5 to 180, E5 to 260, G5 to 260, C6 to 400, N to 200
            )
            val out = ArrayList<Short>()
            for ((freq, durMs) in notes) {
                val n = durMs * sampleRate / 1000
                if (freq == N || freq <= 0f) repeat(n) { out.add(0) }
                else {
                    val period = (sampleRate / freq).toInt().coerceAtLeast(1)
                    for (i in 0 until n) {
                        val phase = (i % period) / period.toFloat()
                        val t = i.toFloat() / n
                        val env = when { t < 0.05f -> t / 0.05f; t > 0.70f -> (1f - t) / 0.30f; else -> 1f }.coerceIn(0f, 1f)
                        val v = (if (phase < 0.5f) 1f else -1f) * env * 0.06f
                        out.add((v * Short.MAX_VALUE).toInt().coerceIn(Short.MIN_VALUE.toInt(), Short.MAX_VALUE.toInt()).toShort())
                    }
                }
            }
            return out.toShortArray()
        }
    }
}