AI로 게임 개발하기 14일차 — 로그라이크 런과 시드 맵 생성 구현

// RunManager.cs 실제 코드
public class RunManager : IDisposable
{
    private readonly ReactiveProperty<RunState> _reactiveState = new(RunState.NotStarted);
    private RunProgressData _progress;

    private readonly Subject<(RunState Previous, RunState Current)> _onRunStateChanged = new();
    private readonly Subject<int> _onStageCompleted = new();
    private readonly Subject<bool> _onRunEnded = new();

    // 상태 전이 규칙을 Dictionary로 정적 정의
    private static readonly Dictionary<RunState, HashSet<RunState>> ValidTransitions = new()
    {
        { RunState.NotStarted, new HashSet<RunState> { RunState.MapSelect } },
        { RunState.MapSelect, new HashSet<RunState> { RunState.StageIntro } },
        { RunState.StageIntro, new HashSet<RunState> { RunState.Combat, RunState.MapSelect } },
        { RunState.Combat, new HashSet<RunState> { RunState.CombatResult } },
        { RunState.CombatResult, new HashSet<RunState> { RunState.RewardSelect } },
        { RunState.RewardSelect, new HashSet<RunState> { RunState.MapSelect, RunState.StageTransition } },
        { RunState.StageTransition, new HashSet<RunState> { RunState.StageIntro, RunState.WorldClear } },
        { RunState.WorldClear, new HashSet<RunState> { RunState.MapSelect, RunState.RunComplete } },
        { RunState.RunComplete, new HashSet<RunState>() },
        { RunState.RunFailed, new HashSet<RunState>() },
    };

    public ReadOnlyReactiveProperty<RunState> ReactiveState => _reactiveState;
    public Observable<(RunState Previous, RunState Current)> OnRunStateChanged => _onRunStateChanged;
    public Observable<bool> OnRunEnded => _onRunEnded;
}

// RunMapGenerator.cs 실제 코드
public class RunMapGenerator
{
    private const int LAYERS_PER_WORLD = 6;
    private const int START_NODES_MIN = 2;
    private const int START_NODES_MAX_EXCL = 4;   // 시작층 2~3개
    private const int ELITE_NODES_MIN = 1;
    private const int ELITE_NODES_MAX_EXCL = 3;   // 엘리트 1~2개
    private const int BOSS_NODE_COUNT = 1;         // 보스 항상 1개

    public List<List<StageNodeData>> GenerateMap(RunConfigSO config, int seed)
    {
        var random = new Random(seed);
        var allLayers = new List<List<StageNodeData>>();
        int nodeIdCounter = 0;

        for (int world = 0; world < config.WorldCount; world++)
        {
            var worldLayers = GenerateWorld(random, world, ref nodeIdCounter);
            allLayers.AddRange(worldLayers);
        }
        return allLayers;
    }
}

// RunMapGenerator.cs — BuildConnections
private Dictionary<int, List<int>> BuildConnections(Random random, int[][] layerNodeIds)
{
    var connections = new Dictionary<int, List<int>>();

    // 모든 노드에 빈 연결 리스트 초기화
    for (int layer = 0; layer < LAYERS_PER_WORLD; layer++)
        foreach (int nodeId in layerNodeIds[layer])
            connections[nodeId] = new List<int>();

    // 각 층 → 다음 층 1~2개 연결
    for (int layer = 0; layer < LAYERS_PER_WORLD - 1; layer++)
    {
        var currentIds = layerNodeIds[layer];
        var nextIds = layerNodeIds[layer + 1];

        foreach (int currentId in currentIds)
        {
            int maxConnections = Math.Min(
                random.Next(MIN_CONNECTIONS, MAX_CONNECTIONS_EXCL), nextIds.Length);
            var selectedIndices = PickRandomIndices(random, nextIds.Length, maxConnections);
            foreach (int idx in selectedIndices)
                connections[currentId].Add(nextIds[idx]);
        }

        // 고립 노드 방지
        EnsureNoIsolation(random, currentIds, nextIds, connections);
    }
    return connections;
}

private List<int> PickRandomIndices(Random random, int total, int count)
{
    var indices = new List<int>(total);
    for (int i = 0; i < total; i++) indices.Add(i);

    // Fisher-Yates 부분 셔플
    for (int i = 0; i < count; i++)
    {
        int j = random.Next(i, indices.Count);
        (indices[i], indices[j]) = (indices[j], indices[i]);
    }
    return indices.GetRange(0, count);
}

// FillInBerserkerAI.cs 실제 코드
public class FillInBerserkerAI : MonoBehaviour
{
    [SerializeField] private EnemyPatternSO _normalPattern;   // ● _ _ _ ● _ _ _
    [SerializeField] private EnemyPatternSO _burstPattern;    // ● _ _ _ ● ● ● ●
    [SerializeField] private int _normalMeasuresBeforeFillIn = 3;
    [SerializeField] private float _berserkHpThreshold = 0.5f;
    [SerializeField] private float _berserkSpeedMultiplier = 2.0f;
    [SerializeField] private float _berserkTelegraphMultiplier = 0.8f;

    [SerializeField] private EnemyPatternSequencer _sequencer;
    [SerializeField] private EnemyMovement _movement;
    [SerializeField] private EnemyRhythmAttack _rhythmAttack;
    [SerializeField] private HealthComponent _healthComponent;

    private bool _isBerserk;
    private int _normalLoopCount;
    private DisposableBag _disposables;

    public event Action OnBerserkActivated;
    public event Action<bool> OnPatternSwitched;  // true=필인, false=기본
}

// 광폭화 시 변경되는 수치
_movement.SetMoveSpeed(_baseSpeed * _berserkSpeedMultiplier);  // 3.0 → 6.0 m/s
_rhythmAttack.TelegraphMultiplier = _berserkTelegraphMultiplier; // 0.8배 (20% 감소)
// 광폭화 후에는 매 루프마다 필인 발동 (_normalMeasuresBeforeFillIn 무시)

// MetronomeKnightAI.cs 실제 코드
public class MetronomeKnightAI : MonoBehaviour
{
    private const float DEFAULT_P1_BPM = 120f;
    private const float DEFAULT_P2_BPM = 240f;
    private const float DEFAULT_PHASE_TRANSITION_PAUSE = 1.0f;
    private const int DEFAULT_BOSS_HP = 500;

    [SerializeField] private EnemyPatternSO _phase1Pattern;  // ● _ _ _ ● _ _ _ (Red)
    [SerializeField] private EnemyPatternSO _phase2Pattern;  // ● _ ● _ ● _ ● _ (Orange)
    [SerializeField] private float _phase1BPM = DEFAULT_P1_BPM;
    [SerializeField] private float _phase2BPM = DEFAULT_P2_BPM;
    [SerializeField] private float _bpmTransitionDuration = 1.0f;
    [SerializeField] private RhythmManager _rhythmManager;

    public event Action OnPhase2Activated;
    public event Action<float, float> OnBPMTransitionRequested;  // (targetBPM, duration)
    public event Action OnBGMTransitionRequested;
    public event Action<bool> OnPatternSwitched;  // true=P2
}

// GameLifetimeScope.cs — 실제 등록 구조
public class GameLifetimeScope : LifetimeScope
{
    [SerializeField] private CombatTimingConfigSO _combatTimingConfig;
    [SerializeField] private RunConfigSO _runConfig;  // null이면 로그라이크 비활성

    protected override void Configure(IContainerBuilder builder)
    {
        // 항상 등록: 전투 코어
        builder.RegisterInstance(_combatTimingConfig);
        builder.RegisterComponentInHierarchy<RhythmManager>();
        builder.RegisterComponentInHierarchy<BeatJudge>();
        builder.Register<DamageCalculator>(Lifetime.Singleton);

        // RunConfigSO가 있을 때만: 로그라이크 서비스
        if (_runConfig != null)
        {
            builder.RegisterInstance(_runConfig);
            builder.Register<RunManager>(Lifetime.Singleton);
            builder.Register<RunMapGenerator>(Lifetime.Singleton);
            builder.Register<RewardGenerator>(Lifetime.Singleton);
            builder.Register<DifficultyScaler>(Lifetime.Singleton);
            builder.Register<ArtifactManager>(Lifetime.Singleton);
            builder.Register<StageFlowController>(Lifetime.Singleton);
        }
    }
}