Merge remote-tracking branch 'origin/main'

# Conflicts:
#	Assets/Data/Cards/CardDatabase.asset
#	Assets/Scenes/MainMenuScene.unity
#	Assets/Scripts/UI/MainMenuController.cs

Assets/Scripts/Combat.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 59b9870361cbdec4b9419c57a3ff71df
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Combat/CardInstance.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: c05e61a09404ee046a6771f8ac75803c

Assets/Scripts/Combat/CombatContext.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 2eed81ad20b42a447858691a49666804

Assets/Scripts/Combat/CombatManager.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 9f87432412de1ee46bf7d4c9c530d4c6

Assets/Scripts/Combat/CombatantState.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 93b1080022652b542903e204d36a64f8

Assets/Scripts/Combat/DeckController.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 6683933e853af334ba19e658b13c878d

Assets/Scripts/Combat/HandController.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: bece1c6fddc2c63489bf129bf6295a31

Assets/Scripts/Combat/ICardEffect.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 886be8d59396e5e488eea3ea58445fb4

Assets/Scripts/Combat/IResolutionTrack.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 5d296d1160df6d747adaeec9ef68c710

Assets/Scripts/Combat/InterpreterQueue.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 13c99cf765e7e8b48a58afbacc8a5440

Assets/Scripts/Combat/LazyStack.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 556859e6fac10a24bb4a60165fd82157

Assets/Scripts/Combat/NativeTrack.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: b662e4e1a38b1554084a063fd3d415e2

Assets/Scripts/Combat/StatusEffectController.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 5f91b8d9171889f4996bb3106d97f1f6

Assets/Scripts/Core.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: d51c41fa71b1068438855f64f946cc57
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Core/GameEvents.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: cf446c6fd7627294c9e2aa23c9b576e7

Assets/Scripts/Core/Language.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: c06078e18f184c84cab3579c0e562dbe

Assets/Scripts/Core/Rarity.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 542a3f97e8074ed428fd7019177f221b

Assets/Scripts/Core/ResolutionTrack.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 3b76dcac6b8cae447bb9079460692238

Assets/Scripts/Core/SceneLoader.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 0d860bbf8e7f4df2a91e2e1e9892d904
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Core/StatusType.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: cbdd46dffec613346ae6191f18a94225

Assets/Scripts/Core/TurnPhase.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: e1974726f936d0640943801549b4574e

Assets/Scripts/Data.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: e0a39b97df9ee0641b2bbadf5bca417c
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Data/CardDefinition.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 5178747fac4dbfc448ff15d8a687e03c

Assets/Scripts/Data/CardEffectDefinition.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: fdb3d58d94b76834598e408448e19d2a

Assets/Scripts/Data/DistroDatabase.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 5af93d291e7d4d51b312bdf1e47dc6ef
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Data/DistroDefinition.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: bd550368fd0c75d43a53aa4fb3b6541e

Assets/Scripts/Data/EnemyDefinition.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 8b5b43b43c697c142b33fbfc5160cf90

Assets/Scripts/Data/StatusEffectDefinition.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 1470a223647d6514f9439de7ded702c9

Assets/Scripts/KernelPanic.Runtime.asmdef.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 6aad857173769044f861a0c6b1318032
-AssemblyDefinitionImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Meta.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: ae19044bbccbb074da1d5e38b61e5657
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Meta/EntropyWallet.cs

@@ -7,6 +7,11 @@ namespace KernelPanic.Meta
     {
         public int Balance { get; private set; }
 
+        public void SetBalance(int amount)
+        {
+            Balance = amount < 0 ? 0 : amount;
+        }
+
         public void Add(int amount)
         {
             Balance += amount;

Assets/Scripts/Meta/EntropyWallet.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 8b77d0de67282ca4181a7c53feec4343

Assets/Scripts/Meta/GachaBannerState.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+
+namespace KernelPanic.Meta
+{
+    /// <summary>
+    /// Stores per-banner counters that must persist between sessions.
+    /// </summary>
+    [Serializable]
+    public sealed class GachaBannerState
+    {
+        public string bannerId;
+        public int totalPulls;
+        public int pityCounter;
+        public int fiveStarPityCounter;
+        public bool exhausted;
+        public bool featuredFiveStarGuaranteed;
+        public List<string> guaranteedDistroIds = new();
+
+        public GachaBannerState()
+        {
+        }
+
+        public GachaBannerState(string bannerId)
+        {
+            this.bannerId = bannerId;
+        }
+
+        public void EnsureLists()
+        {
+            guaranteedDistroIds ??= new List<string>();
+        }
+    }
+}

Assets/Scripts/Meta/GachaCurrencyType.cs

@@ -0,0 +1,11 @@
+namespace KernelPanic.Meta
+{
+    /// <summary>
+    /// Identifies currencies spent on banner pulls.
+    /// </summary>
+    public enum GachaCurrencyType
+    {
+        StandardPull,
+        LimitedPull
+    }
+}

Assets/Scripts/Meta/GachaRewardType.cs

@@ -0,0 +1,12 @@
+namespace KernelPanic.Meta
+{
+    /// <summary>
+    /// Describes the persistent reward category produced by a gacha pull.
+    /// </summary>
+    public enum GachaRewardType
+    {
+        Equipment,
+        Distro,
+        FutureStandardFiveStarDistro
+    }
+}

Assets/Scripts/Meta/GachaService.cs

@@ -5,16 +5,150 @@ using KernelPanic.Data;
 namespace KernelPanic.Meta
 {
     /// <summary>
-    /// Provides the contract for spending entropy on persistent unlock pulls.
+    /// Provides persistent banner pull logic and currency accounting.
     /// </summary>
     public sealed class GachaService
     {
-        private readonly List<DistroDefinition> bannerPool = new();
+        public const string BeginnerBannerId = "beginner";
+        public const string StandardBannerId = "standard";
+        public const string LimitedBannerId = "limited";
+        public const int BeginnerMaxPulls = 50;
+        public const int BeginnerSinglePullCost = 1;
+        public const int BeginnerTenPullCost = 8;
+        public const int FourStarHardPity = 10;
+        public const int FiveStarSoftPityStart = 66;
+        public const int FiveStarHardPity = 80;
+        public const int EntropyPerPullToken = 100;
 
-        public int PullTokens => 0; // TODO: Replace with the real pull-token wallet when that meta system exists.
+        private const double FourStarBaseChance = 0.12d;
+        private const double FiveStarBaseChance = 0.008d;
+        private const double FiveStarSoftPityStep = 0.07d;
+        private const double DistroChanceOnFeaturedTier = 0.5d;
+        private const double LimitedStandardFiveStarChance = 1d / 3d;
+
+        private readonly List<DistroDefinition> bannerPool = new();
+        private readonly Dictionary<GachaCurrencyType, int> currencyBalances = new();
+        private readonly Random random;
+        private GachaBannerState beginnerState = new(BeginnerBannerId);
+
+        public GachaService()
+            : this(new Random())
+        {
+        }
+
+        public GachaService(Random random)
+        {
+            this.random = random ?? new Random();
+            currencyBalances[GachaCurrencyType.StandardPull] = 0;
+            currencyBalances[GachaCurrencyType.LimitedPull] = 0;
+        }
+
+        public int PullTokens => GetCurrencyBalance(GachaCurrencyType.StandardPull);
+        public int LimitedPullTokens => GetCurrencyBalance(GachaCurrencyType.LimitedPull);
+        public int RootCredits { get; private set; }
         public IReadOnlyList<DistroDefinition> BannerPool => bannerPool;
+        public GachaBannerState BeginnerState => beginnerState;
+        public bool IsBeginnerBannerAvailable => !beginnerState.exhausted && beginnerState.totalPulls < BeginnerMaxPulls && bannerPool.Count > 0;
 
         public event Action BannerPoolChanged;
+        public event Action Changed;
+
+        public void LoadProgress(SaveData data)
+        {
+            if (data == null)
+            {
+                return;
+            }
+
+            data.EnsureLists();
+            RootCredits = Math.Max(0, data.rootCredits);
+            SetCurrencyBalanceSilently(GachaCurrencyType.StandardPull, data.standardPullCurrency);
+            SetCurrencyBalanceSilently(GachaCurrencyType.LimitedPull, data.limitedPullCurrency);
+            beginnerState = data.beginnerBannerState ?? new GachaBannerState(BeginnerBannerId);
+            beginnerState.bannerId = BeginnerBannerId;
+            beginnerState.EnsureLists();
+            if (beginnerState.totalPulls >= BeginnerMaxPulls)
+            {
+                beginnerState.exhausted = true;
+            }
+
+            beginnerState.fiveStarPityCounter = Math.Max(0, beginnerState.fiveStarPityCounter);
+
+            Changed?.Invoke();
+        }
+
+        public void WriteProgress(SaveData data)
+        {
+            if (data == null)
+            {
+                return;
+            }
+
+            data.EnsureLists();
+            data.rootCredits = RootCredits;
+            data.standardPullCurrency = GetCurrencyBalance(GachaCurrencyType.StandardPull);
+            data.limitedPullCurrency = GetCurrencyBalance(GachaCurrencyType.LimitedPull);
+            data.beginnerBannerState = CloneState(beginnerState);
+        }
+
+        public int GetCurrencyBalance(GachaCurrencyType currencyType)
+        {
+            return currencyBalances.TryGetValue(currencyType, out int balance) ? balance : 0;
+        }
+
+        public void SetCurrencyBalance(GachaCurrencyType currencyType, int amount)
+        {
+            SetCurrencyBalanceSilently(currencyType, amount);
+            Changed?.Invoke();
+        }
+
+        public void AddCurrency(GachaCurrencyType currencyType, int amount)
+        {
+            if (amount <= 0)
+            {
+                return;
+            }
+
+            SetCurrencyBalance(currencyType, GetCurrencyBalance(currencyType) + amount);
+        }
+
+        public void AddRootCredits(int amount)
+        {
+            if (amount <= 0)
+            {
+                return;
+            }
+
+            RootCredits += amount;
+            Changed?.Invoke();
+        }
+
+        public bool ConvertRootCreditsToEntropy(EntropyWallet wallet, int amount, out string failureReason)
+        {
+            if (wallet == null)
+            {
+                failureReason = "entropy wallet unavailable";
+                return false;
+            }
+
+            if (amount <= 0)
+            {
+                failureReason = "no root-credits selected";
+                return false;
+            }
+
+            if (RootCredits < amount)
+            {
+                failureReason = $"need {amount} root-credits";
+                return false;
+            }
+
+            RootCredits -= amount;
+            wallet.Add(amount);
+            failureReason = null;
+            Changed?.Invoke();
+            return true;
+        }
 
         public void AddToBannerPool(DistroDefinition distro)
         {
@@ -25,26 +159,446 @@ namespace KernelPanic.Meta
 
             bannerPool.Add(distro);
             BannerPoolChanged?.Invoke();
+            Changed?.Invoke();
+        }
+
+        public void SetBeginnerGuaranteedDistros(IReadOnlyList<DistroDefinition> distros)
+        {
+            beginnerState.guaranteedDistroIds.Clear();
+            if (distros != null)
+            {
+                for (int i = 0; i < distros.Count; i++)
+                {
+                    DistroDefinition distro = distros[i];
+                    if (distro != null && !string.IsNullOrWhiteSpace(distro.Id))
+                    {
+                        beginnerState.guaranteedDistroIds.Add(distro.Id);
+                    }
+                }
+            }
+
+            Changed?.Invoke();
+        }
+
+        public int GetBeginnerPullCost(int pullCount)
+        {
+            return pullCount == 10 ? BeginnerTenPullCost : BeginnerSinglePullCost;
+        }
+
+        public bool CanPullBeginner(int pullCount, out string failureReason)
+        {
+            if (pullCount != 1 && pullCount != 10)
+            {
+                failureReason = "only single and ten pulls are supported";
+                return false;
+            }
+
+            if (!IsBeginnerBannerAvailable)
+            {
+                failureReason = "beginner banner unavailable";
+                return false;
+            }
+
+            int remainingPulls = BeginnerMaxPulls - beginnerState.totalPulls;
+            if (pullCount > remainingPulls)
+            {
+                failureReason = $"only {remainingPulls} beginner pull(s) remain";
+                return false;
+            }
+
+            int cost = GetBeginnerPullCost(pullCount);
+            if (GetCurrencyBalance(GachaCurrencyType.StandardPull) < cost)
+            {
+                failureReason = $"need {cost} {FormatCurrencyName(GachaCurrencyType.StandardPull)}";
+                return false;
+            }
+
+            failureReason = null;
+            return true;
+        }
+
+        public int GetMissingPullTokens(GachaCurrencyType currencyType, int pullCost)
+        {
+            return Math.Max(0, pullCost - GetCurrencyBalance(currencyType));
+        }
+
+        public bool CanCoverMissingPullTokensWithEntropy(EntropyWallet wallet, int missingPullTokens)
+        {
+            return missingPullTokens <= 0 || (wallet != null && wallet.Balance >= missingPullTokens * EntropyPerPullToken);
+        }
+
+        public GachaPullResult PerformBeginnerPull(int pullCount)
+        {
+            return PerformBeginnerPull(pullCount, null, 0);
+        }
+
+        public GachaPullResult PerformBeginnerPull(int pullCount, EntropyWallet wallet, int entropyTokenCount)
+        {
+            if (!CanPullBeginnerWithEntropy(pullCount, wallet, entropyTokenCount, out string failureReason))
+            {
+                return GachaPullResult.Failed(BeginnerBannerId, failureReason);
+            }
+
+            int cost = GetBeginnerPullCost(pullCount);
+            int tokenSpend = cost - entropyTokenCount;
+            if (tokenSpend > 0)
+            {
+                SetCurrencyBalanceSilently(GachaCurrencyType.StandardPull, GetCurrencyBalance(GachaCurrencyType.StandardPull) - tokenSpend);
+            }
+
+            int entropySpent = entropyTokenCount * EntropyPerPullToken;
+            if (entropySpent > 0)
+            {
+                wallet.Spend(entropySpent);
+            }
+
+            List<GachaReward> rewards = new();
+            for (int i = 0; i < pullCount; i++)
+            {
+                beginnerState.totalPulls++;
+                rewards.Add(RollBeginnerReward(beginnerState.totalPulls));
+            }
+
+            if (beginnerState.totalPulls >= BeginnerMaxPulls)
+            {
+                beginnerState.exhausted = true;
+            }
+
+            Changed?.Invoke();
+            return new GachaPullResult(true, BeginnerBannerId, GachaCurrencyType.StandardPull, tokenSpend, entropySpent, rewards, null);
+        }
+
+        public static string FormatCurrencyName(GachaCurrencyType currencyType)
+        {
+            return currencyType switch
+            {
+                GachaCurrencyType.LimitedPull => "feature-pull-token",
+                _ => "stable-pull-token"
+            };
+        }
+
+        public static double GetFiveStarChance(GachaBannerState state)
+        {
+            return GetFiveStarChance(state == null ? 0 : state.fiveStarPityCounter);
+        }
+
+        public static double GetFiveStarChance(int fiveStarPityCounter)
+        {
+            int pityPullNumber = Math.Max(0, fiveStarPityCounter) + 1;
+            if (pityPullNumber >= FiveStarHardPity)
+            {
+                return 1d;
+            }
+
+            if (pityPullNumber < FiveStarSoftPityStart)
+            {
+                return FiveStarBaseChance;
+            }
+
+            int softPitySteps = pityPullNumber - FiveStarSoftPityStart + 1;
+            return Math.Min(1d, FiveStarBaseChance + softPitySteps * FiveStarSoftPityStep);
         }
 
         public GachaPullResult PerformPull(EntropyWallet wallet, int cost)
         {
-            throw new NotImplementedException();
+            return PerformBeginnerPull(1);
+        }
+
+        private GachaReward RollBeginnerReward(int pullNumber)
+        {
+            if (pullNumber == 20)
+            {
+                AdvanceFiveStarPityAfterNonFiveStar(beginnerState);
+                return RewardGuaranteedBeginnerDistro(0, "20-pull starter guarantee");
+            }
+
+            if (pullNumber == 40)
+            {
+                AdvanceFiveStarPityAfterNonFiveStar(beginnerState);
+                return RewardGuaranteedBeginnerDistro(1, "40-pull starter guarantee");
+            }
+
+            if (pullNumber == 50)
+            {
+                beginnerState.pityCounter = 0;
+                return GachaReward.FutureStandardFiveStar("future standard 5-star distro", "50-pull beginner capstone");
+            }
+
+            if (TryRollFiveStar(beginnerState, out bool fiveStarPityTriggered))
+            {
+                return RewardRandomFiveStar(fiveStarPityTriggered);
+            }
+
+            bool pityTriggered = beginnerState.pityCounter >= FourStarHardPity - 1;
+            bool hitFourStarOrCharacter = pityTriggered || random.NextDouble() < FourStarBaseChance;
+            if (!hitFourStarOrCharacter)
+            {
+                beginnerState.pityCounter++;
+                return GachaReward.Equipment(3, "3-star equipment", false, false);
+            }
+
+            beginnerState.pityCounter = 0;
+            if (bannerPool.Count > 0 && random.NextDouble() < DistroChanceOnFeaturedTier)
+            {
+                DistroDefinition distro = bannerPool[random.Next(bannerPool.Count)];
+                return GachaReward.DistroReward(distro, 4, pityTriggered, false);
+            }
+
+            return GachaReward.Equipment(4, "4-star equipment", pityTriggered, false);
+        }
+
+        private bool TryRollFiveStar(GachaBannerState state, out bool pityTriggered)
+        {
+            state ??= beginnerState;
+            int pityPullNumber = Math.Max(0, state.fiveStarPityCounter) + 1;
+            pityTriggered = pityPullNumber >= FiveStarSoftPityStart;
+
+            double chance = GetFiveStarChance(state);
+            bool hit = chance >= 1d || random.NextDouble() < chance;
+            if (!hit)
+            {
+                state.fiveStarPityCounter++;
+                return false;
+            }
+
+            state.fiveStarPityCounter = 0;
+            state.pityCounter = 0;
+            return true;
+        }
+
+        private static void AdvanceFiveStarPityAfterNonFiveStar(GachaBannerState state)
+        {
+            if (state != null)
+            {
+                state.fiveStarPityCounter++;
+            }
+        }
+
+        private GachaReward RewardRandomFiveStar(bool pityTriggered)
+        {
+            if (bannerPool.Count == 0 || random.NextDouble() >= DistroChanceOnFeaturedTier)
+            {
+                return GachaReward.Equipment(5, "5-star equipment", pityTriggered, false);
+            }
+
+            DistroDefinition distro = bannerPool.Count == 0 ? null : bannerPool[random.Next(bannerPool.Count)];
+            return GachaReward.DistroReward(distro, 5, pityTriggered, false);
+        }
+
+        public bool ResolveFeaturedTierIsDistro()
+        {
+            return random.NextDouble() < DistroChanceOnFeaturedTier;
+        }
+
+        public bool ResolveLimitedFiveStarUsesStandardPool(GachaBannerState limitedState)
+        {
+            if (limitedState == null)
+            {
+                return false;
+            }
+
+            if (limitedState.featuredFiveStarGuaranteed)
+            {
+                limitedState.featuredFiveStarGuaranteed = false;
+                return false;
+            }
+
+            bool useStandardPool = random.NextDouble() < LimitedStandardFiveStarChance;
+            limitedState.featuredFiveStarGuaranteed = useStandardPool;
+            return useStandardPool;
+        }
+
+        private GachaReward RewardGuaranteedBeginnerDistro(int guaranteeIndex, string reason)
+        {
+            beginnerState.pityCounter = 0;
+            DistroDefinition distro = null;
+            if (guaranteeIndex >= 0 && guaranteeIndex < beginnerState.guaranteedDistroIds.Count)
+            {
+                distro = FindBannerPoolDistro(beginnerState.guaranteedDistroIds[guaranteeIndex]);
+            }
+
+            distro ??= bannerPool.Count == 0 ? null : bannerPool[Math.Min(guaranteeIndex, bannerPool.Count - 1)];
+            return distro == null
+                ? GachaReward.Equipment(4, "4-star equipment", true, true)
+                : GachaReward.DistroReward(distro, 4, true, true, reason);
+        }
+
+        private DistroDefinition FindBannerPoolDistro(string id)
+        {
+            if (string.IsNullOrWhiteSpace(id))
+            {
+                return null;
+            }
+
+            for (int i = 0; i < bannerPool.Count; i++)
+            {
+                DistroDefinition distro = bannerPool[i];
+                if (distro != null && string.Equals(distro.Id, id, StringComparison.OrdinalIgnoreCase))
+                {
+                    return distro;
+                }
+            }
+
+            return null;
+        }
+
+        private void SetCurrencyBalanceSilently(GachaCurrencyType currencyType, int amount)
+        {
+            currencyBalances[currencyType] = Math.Max(0, amount);
+        }
+
+        private bool CanPullBeginnerWithEntropy(int pullCount, EntropyWallet wallet, int entropyTokenCount, out string failureReason)
+        {
+            if (pullCount != 1 && pullCount != 10)
+            {
+                failureReason = "only single and ten pulls are supported";
+                return false;
+            }
+
+            if (!IsBeginnerBannerAvailable)
+            {
+                failureReason = "beginner banner unavailable";
+                return false;
+            }
+
+            int remainingPulls = BeginnerMaxPulls - beginnerState.totalPulls;
+            if (pullCount > remainingPulls)
+            {
+                failureReason = $"only {remainingPulls} beginner pull(s) remain";
+                return false;
+            }
+
+            int cost = GetBeginnerPullCost(pullCount);
+            if (entropyTokenCount < 0 || entropyTokenCount > cost)
+            {
+                failureReason = "invalid entropy substitute amount";
+                return false;
+            }
+
+            int tokenSpend = cost - entropyTokenCount;
+            if (GetCurrencyBalance(GachaCurrencyType.StandardPull) < tokenSpend)
+            {
+                failureReason = $"need {tokenSpend} {FormatCurrencyName(GachaCurrencyType.StandardPull)}";
+                return false;
+            }
+
+            int entropySpend = entropyTokenCount * EntropyPerPullToken;
+            if (entropySpend > 0 && (wallet == null || wallet.Balance < entropySpend))
+            {
+                failureReason = $"need {entropySpend} entropy";
+                return false;
+            }
+
+            failureReason = null;
+            return true;
+        }
+
+        private static GachaBannerState CloneState(GachaBannerState state)
+        {
+            state ??= new GachaBannerState(BeginnerBannerId);
+            state.EnsureLists();
+            GachaBannerState clone = new(state.bannerId)
+            {
+                totalPulls = state.totalPulls,
+                pityCounter = state.pityCounter,
+                fiveStarPityCounter = state.fiveStarPityCounter,
+                exhausted = state.exhausted,
+                featuredFiveStarGuaranteed = state.featuredFiveStarGuaranteed
+            };
+            clone.guaranteedDistroIds.AddRange(state.guaranteedDistroIds);
+            return clone;
         }
     }
 
     /// <summary>
-    /// Represents the result of a persistent unlock pull.
+    /// Describes one reward entry from one pull.
+    /// </summary>
+    public readonly struct GachaReward
+    {
+        private GachaReward(
+            GachaRewardType rewardType,
+            int starRating,
+            string displayName,
+            DistroDefinition distro,
+            bool pityTriggered,
+            bool guaranteed,
+            string guaranteeReason)
+        {
+            RewardType = rewardType;
+            StarRating = starRating;
+            DisplayName = displayName;
+            Distro = distro;
+            PityTriggered = pityTriggered;
+            Guaranteed = guaranteed;
+            GuaranteeReason = guaranteeReason;
+        }
+
+        public GachaRewardType RewardType { get; }
+        public int StarRating { get; }
+        public string DisplayName { get; }
+        public DistroDefinition Distro { get; }
+        public bool PityTriggered { get; }
+        public bool Guaranteed { get; }
+        public string GuaranteeReason { get; }
+
+        public static GachaReward Equipment(int starRating, string displayName, bool pityTriggered, bool guaranteed)
+        {
+            return new GachaReward(GachaRewardType.Equipment, starRating, displayName, null, pityTriggered, guaranteed, null);
+        }
+
+        public static GachaReward DistroReward(DistroDefinition distro, int starRating, bool pityTriggered, bool guaranteed, string guaranteeReason = null)
+        {
+            string displayName = distro == null ? "unknown distro" : DistroDisplayName(distro);
+            return new GachaReward(GachaRewardType.Distro, starRating, displayName, distro, pityTriggered, guaranteed, guaranteeReason);
+        }
+
+        public static GachaReward FutureStandardFiveStar(string displayName, string guaranteeReason)
+        {
+            return new GachaReward(GachaRewardType.FutureStandardFiveStarDistro, 5, displayName, null, true, true, guaranteeReason);
+        }
+
+        private static string DistroDisplayName(DistroDefinition distro)
+        {
+            return string.IsNullOrWhiteSpace(distro.DisplayName) ? distro.name : distro.DisplayName;
+        }
+    }
+
+    /// <summary>
+    /// Represents the result of a banner pull request.
     /// </summary>
     public readonly struct GachaPullResult
     {
-        public GachaPullResult(bool success, string unlockId)
+        public GachaPullResult(
+            bool success,
+            string bannerId,
+            GachaCurrencyType currencyType,
+            int currencySpent,
+            int entropySpent,
+            IReadOnlyList<GachaReward> rewards,
+            string failureReason)
         {
             Success = success;
-            UnlockId = unlockId;
+            BannerId = bannerId;
+            CurrencyType = currencyType;
+            CurrencySpent = currencySpent;
+            EntropySpent = entropySpent;
+            Rewards = rewards ?? Array.Empty<GachaReward>();
+            FailureReason = failureReason;
+            UnlockId = Rewards.Count > 0 && Rewards[0].Distro != null ? Rewards[0].Distro.Id : null;
         }
 
         public bool Success { get; }
+        public string BannerId { get; }
+        public GachaCurrencyType CurrencyType { get; }
+        public int CurrencySpent { get; }
+        public int EntropySpent { get; }
+        public IReadOnlyList<GachaReward> Rewards { get; }
+        public string FailureReason { get; }
         public string UnlockId { get; }
+
+        public static GachaPullResult Failed(string bannerId, string reason)
+        {
+            return new GachaPullResult(false, bannerId, GachaCurrencyType.StandardPull, 0, 0, Array.Empty<GachaReward>(), reason);
+        }
     }
 }

Assets/Scripts/Meta/GachaService.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: f62e697e985a8a44ca26ccb8e853ee66

Assets/Scripts/Meta/IEventBannerSource.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 542dd3144a914ea5b1e0c0e21db5ec6b
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Meta/PlayerCollection.cs

@@ -13,7 +13,6 @@ namespace KernelPanic.Meta
         private int featuredIndex;
 
         // TODO: Populate owned units from SaveService during bootstrap.
-        // TODO: Add newly unlocked units from GachaService rewards when pulls exist.
         public IReadOnlyList<DistroDefinition> OwnedUnits => ownedUnits;
         public DistroDefinition FeaturedUnit => ownedUnits.Count == 0 ? null : ownedUnits[Math.Clamp(featuredIndex, 0, ownedUnits.Count - 1)];
 
@@ -21,7 +20,7 @@ namespace KernelPanic.Meta
 
         public void Add(DistroDefinition unit)
         {
-            if (unit == null || ownedUnits.Contains(unit))
+            if (unit == null)
             {
                 return;
             }
@@ -32,6 +31,26 @@ namespace KernelPanic.Meta
             Changed?.Invoke();
         }
 
+        public int GetOwnedCount(string unitId)
+        {
+            if (string.IsNullOrWhiteSpace(unitId))
+            {
+                return 0;
+            }
+
+            int count = 0;
+            for (int i = 0; i < ownedUnits.Count; i++)
+            {
+                DistroDefinition unit = ownedUnits[i];
+                if (unit != null && string.Equals(unit.Id, unitId, StringComparison.OrdinalIgnoreCase))
+                {
+                    count++;
+                }
+            }
+
+            return count;
+        }
+
         public void SelectNextFeatured()
         {
             if (ownedUnits.Count < 2)

Assets/Scripts/Meta/PlayerCollection.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 4a10ff65b6e9478d9fe638f8a39f8144

Assets/Scripts/Meta/SaveService.cs

@@ -58,8 +58,13 @@ namespace KernelPanic.Meta
     public sealed class SaveData
     {
         public bool starterChosen;
+        public int entropyBalance;
+        public int rootCredits;
+        public int standardPullCurrency;
+        public int limitedPullCurrency;
         public List<string> ownedUnitIds = new();
         public List<string> bannerPoolIds = new();
+        public GachaBannerState beginnerBannerState = new(GachaService.BeginnerBannerId);
         public LastRunLoadoutSaveEntry lastRunLoadout = new();
 
         public static SaveData CreateDefault()
@@ -71,6 +76,9 @@ namespace KernelPanic.Meta
         {
             ownedUnitIds ??= new List<string>();
             bannerPoolIds ??= new List<string>();
+            beginnerBannerState ??= new GachaBannerState(GachaService.BeginnerBannerId);
+            beginnerBannerState.bannerId = GachaService.BeginnerBannerId;
+            beginnerBannerState.EnsureLists();
             lastRunLoadout ??= new LastRunLoadoutSaveEntry();
             lastRunLoadout.EnsureLists();
         }

Assets/Scripts/Meta/SaveService.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 752a83f338afd024b8e728a1921e38ee

Assets/Scripts/Run.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 9ae21840b594d4147a8f5497c992b4fa
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Run/RewardService.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: a06eada6fbafd6e44ae1d21238a64750

Assets/Scripts/Run/RunConfig.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 0c3d34a2ce0e53b4b8f9a77feb60fb95

Assets/Scripts/Run/RunManager.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 234cc6c5ca577b64ea44020f5514cebe

Assets/Scripts/UI.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 84a74d1de7c84009a2cf84394e8a9fa2
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/UI/AsciiArtFitter.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 6f677d4ac6de4dca8e92a3efa687ff1b
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/UI/BackgroundLogRingBuffer.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 03ad9dd5bf1d46ee9cd2a6f54d17b5fa
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/UI/BootLogCopy.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: e05527a70e234c16af2f9089012721b8
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/UI/DistroArtPresenter.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 4bf334307f22465cad853cb6b3757468
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/UI/FeaturedUnitPanel.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: c7f7ef4e16694ed9bd746278b0ddc4d8
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/UI/GachaScreenController.cs

@@ -0,0 +1,487 @@
+using System;
+using System.Collections.Generic;
+using KernelPanic.Data;
+using KernelPanic.Meta;
+using UnityEngine;
+using UnityEngine.TextCore.Text;
+using UnityEngine.UIElements;
+
+namespace KernelPanic.UI
+{
+    /// <summary>
+    /// Renders banner selection and pull controls for the gacha screen.
+    /// </summary>
+    [Serializable]
+    public sealed class GachaScreenController
+    {
+        private const string SelectedClassName = "selected";
+
+        private readonly List<VisualElement> bannerRows = new();
+        private readonly string[] bannerIds =
+        {
+            GachaService.BeginnerBannerId,
+            GachaService.StandardBannerId,
+            GachaService.LimitedBannerId
+        };
+
+        private VisualElement bannerList;
+        private VisualElement bannerDetail;
+        private DistroDatabase distroDatabase;
+        private FontAsset monospaceFont;
+        private GachaService gachaService;
+        private PlayerCollection playerCollection;
+        private EntropyWallet wallet;
+        private Action onChanged;
+        private Action requestRootCreditExchange;
+        private int selectedBannerIndex;
+        private int pendingPullCount;
+        private int pendingMissingTokens;
+        private bool hasOpened;
+        private string resultBannerId;
+        private string resultText;
+
+        public void Bind(VisualElement root, DistroDatabase database, FontAsset artFont, GachaService service, PlayerCollection collection, EntropyWallet entropyWallet, Action changedCallback, Action rootCreditExchangeCallback)
+        {
+            distroDatabase = database;
+            monospaceFont = artFont;
+            gachaService = service;
+            playerCollection = collection;
+            wallet = entropyWallet;
+            onChanged = changedCallback;
+            requestRootCreditExchange = rootCreditExchangeCallback;
+            bannerList = root.Q<VisualElement>("GachaBannerList");
+            bannerDetail = root.Q<VisualElement>("GachaBannerDetail");
+        }
+
+        public void Open()
+        {
+            if (!hasOpened)
+            {
+                selectedBannerIndex = 0;
+                hasOpened = true;
+            }
+
+            Refresh();
+        }
+
+        public void Refresh()
+        {
+            if (bannerList == null || bannerDetail == null || gachaService == null)
+            {
+                return;
+            }
+
+            bannerRows.Clear();
+            bannerList.Clear();
+
+            for (int i = 0; i < bannerIds.Length; i++)
+            {
+                int index = i;
+                VisualElement row = BuildBannerRow(bannerIds[i]);
+                row.RegisterCallback<ClickEvent>(_ => SelectBanner(index));
+                bannerList.Add(row);
+                bannerRows.Add(row);
+            }
+
+            selectedBannerIndex = Mathf.Clamp(selectedBannerIndex, 0, bannerRows.Count - 1);
+            ApplySelectedBanner();
+        }
+
+        public void HandleKeyDown(KeyDownEvent evt)
+        {
+            // Pulls are deliberately click-only to avoid accidental currency spend.
+        }
+
+        private VisualElement BuildBannerRow(string bannerId)
+        {
+            VisualElement row = new();
+            row.AddToClassList("gacha-banner-row");
+
+            row.Add(new Label(">") { name = $"GachaBannerCursor_{bannerId}" });
+            row.ElementAt(0).AddToClassList("command-cursor");
+
+            row.Add(new Label(GetBannerTitle(bannerId)) { name = $"GachaBannerName_{bannerId}" });
+            row.ElementAt(1).AddToClassList("command-text");
+
+            row.Add(new Label(GetBannerStatus(bannerId)) { name = $"GachaBannerStatus_{bannerId}" });
+            row.ElementAt(2).AddToClassList("command-description");
+
+            return row;
+        }
+
+        private void SelectBanner(int index)
+        {
+            if (bannerRows.Count == 0)
+            {
+                return;
+            }
+
+            selectedBannerIndex = (index + bannerRows.Count) % bannerRows.Count;
+            ApplySelectedBanner();
+        }
+
+        private void ApplySelectedBanner()
+        {
+            for (int i = 0; i < bannerRows.Count; i++)
+            {
+                bool selected = i == selectedBannerIndex;
+                bannerRows[i].EnableInClassList(SelectedClassName, selected);
+                bannerRows[i].Q<Label>(className: "command-cursor").visible = selected;
+            }
+
+            RenderSelectedBanner();
+        }
+
+        private void RenderSelectedBanner()
+        {
+            bannerDetail.Clear();
+            string bannerId = bannerIds[selectedBannerIndex];
+            if (bannerId == GachaService.BeginnerBannerId)
+            {
+                RenderBeginnerBanner();
+                return;
+            }
+
+            RenderFutureBanner(bannerId);
+        }
+
+        private void RenderBeginnerBanner()
+        {
+            GachaBannerState state = gachaService.BeginnerState;
+            bannerDetail.Add(BuildBannerHero("beginner install media"));
+
+            Label title = new("beginner install media");
+            title.AddToClassList("gacha-detail-title");
+            bannerDetail.Add(title);
+
+            bannerDetail.Add(BuildInfoLine("entropy", wallet == null ? "--" : wallet.Balance.ToString()));
+            bannerDetail.Add(BuildInfoLine("pulls", $"{state.totalPulls}/{GachaService.BeginnerMaxPulls}"));
+            bannerDetail.Add(BuildInfoLine("4-star pity", $"{state.pityCounter}/{GachaService.FourStarHardPity}"));
+            bannerDetail.Add(BuildInfoLine("ten pull", $"{GachaService.BeginnerTenPullCost} stable-pull-tokens for 10 pulls"));
+            bannerDetail.Add(BuildInfoLine("guarantees", FormatBeginnerGuarantees()));
+
+            Label rules = new("Base result is a 3-star equipment cache. A 4-star equipment cache or starter distro can appear early, with one 4-star+ result guaranteed every 10 pulls.");
+            rules.AddToClassList("gacha-rules");
+            bannerDetail.Add(rules);
+
+            VisualElement actions = new();
+            actions.AddToClassList("gacha-actions");
+
+            Button singleButton = new(() => RequestPullSelectedBanner(1))
+            {
+                text = $"git pull --single\n1x {GachaService.FormatCurrencyName(GachaCurrencyType.StandardPull)}"
+            };
+            singleButton.AddToClassList("terminal-button");
+            singleButton.AddToClassList("gacha-action-button");
+            singleButton.SetEnabled(CanAttemptBeginnerPull(1));
+            actions.Add(singleButton);
+
+            Button tenButton = new(() => RequestPullSelectedBanner(10))
+            {
+                text = $"git pull --ten\n8x {GachaService.FormatCurrencyName(GachaCurrencyType.StandardPull)}"
+            };
+            tenButton.AddToClassList("terminal-button");
+            tenButton.AddToClassList("gacha-action-button");
+            tenButton.SetEnabled(CanAttemptBeginnerPull(10));
+            actions.Add(tenButton);
+
+            bannerDetail.Add(actions);
+
+            if (pendingPullCount > 0)
+            {
+                bannerDetail.Add(BuildEntropyPrompt());
+            }
+
+            if (resultBannerId == GachaService.BeginnerBannerId && !string.IsNullOrWhiteSpace(resultText))
+            {
+                Label result = new(resultText);
+                result.AddToClassList("gacha-result");
+                bannerDetail.Add(result);
+            }
+        }
+
+        private void RenderFutureBanner(string bannerId)
+        {
+            bannerDetail.Add(BuildBannerHero(GetBannerTitle(bannerId)));
+
+            Label title = new(GetBannerTitle(bannerId));
+            title.AddToClassList("gacha-detail-title");
+            bannerDetail.Add(title);
+
+            string currency = bannerId == GachaService.StandardBannerId
+                ? GachaService.FormatCurrencyName(GachaCurrencyType.StandardPull)
+                : GachaService.FormatCurrencyName(GachaCurrencyType.LimitedPull);
+            bannerDetail.Add(BuildInfoLine("pull currency", currency));
+            bannerDetail.Add(BuildInfoLine("status", "not implemented yet"));
+            bannerDetail.Add(BuildInfoLine("pity", "own counter, 10-pull 4-star+ guarantee"));
+            bannerDetail.Add(new Label("Use the beginner implementation as the template: define the banner pool, persist a separate GachaBannerState, then route single/ten pulls through GachaService.") { name = "FutureBannerHint" });
+            bannerDetail.ElementAt(bannerDetail.childCount - 1).AddToClassList("gacha-rules");
+
+            if (resultBannerId == bannerId && !string.IsNullOrWhiteSpace(resultText))
+            {
+                Label result = new(resultText);
+                result.AddToClassList("gacha-result");
+                bannerDetail.Add(result);
+            }
+        }
+
+        private void PullSelectedBanner(int pullCount, int entropyTokenCount)
+        {
+            string bannerId = bannerIds[selectedBannerIndex];
+            if (bannerId != GachaService.BeginnerBannerId)
+            {
+                resultBannerId = bannerId;
+                resultText = $"git pull origin {bannerId}: remote not implemented yet";
+                RenderSelectedBanner();
+                return;
+            }
+
+            GachaPullResult result = gachaService.PerformBeginnerPull(pullCount, wallet, entropyTokenCount);
+            if (!result.Success)
+            {
+                resultBannerId = bannerId;
+                resultText = $"git pull failed: {result.FailureReason}";
+                RenderSelectedBanner();
+                return;
+            }
+
+            List<string> lines = new();
+            lines.Add($"git pull complete: spent {result.CurrencySpent} {GachaService.FormatCurrencyName(result.CurrencyType)}");
+            if (result.EntropySpent > 0)
+            {
+                lines.Add($"entropy fallback: spent {result.EntropySpent} entropy");
+            }
+
+            for (int i = 0; i < result.Rewards.Count; i++)
+            {
+                GachaReward reward = result.Rewards[i];
+                bool duplicate = reward.Distro != null && playerCollection.GetOwnedCount(reward.Distro.Id) > 0;
+                if (reward.Distro != null)
+                {
+                    playerCollection.Add(reward.Distro);
+                }
+
+                string suffix = reward.Guaranteed ? " guaranteed" : reward.PityTriggered ? " pity" : string.Empty;
+                string duplicateText = duplicate ? " duplicate" : string.Empty;
+                lines.Add($"{i + 1:00}: {reward.StarRating}-star {reward.DisplayName}{suffix}{duplicateText}");
+            }
+
+            resultBannerId = bannerId;
+            resultText = string.Join("\n", lines);
+            onChanged?.Invoke();
+            Refresh();
+        }
+
+        private void RequestPullSelectedBanner(int pullCount)
+        {
+            string bannerId = bannerIds[selectedBannerIndex];
+            if (bannerId != GachaService.BeginnerBannerId)
+            {
+                PullSelectedBanner(pullCount, 0);
+                return;
+            }
+
+            int cost = gachaService.GetBeginnerPullCost(pullCount);
+            int missingTokens = gachaService.GetMissingPullTokens(GachaCurrencyType.StandardPull, cost);
+            if (missingTokens <= 0)
+            {
+                ClearEntropyPrompt();
+                PullSelectedBanner(pullCount, 0);
+                return;
+            }
+
+            if (!gachaService.CanCoverMissingPullTokensWithEntropy(wallet, missingTokens))
+            {
+                if (gachaService.RootCredits > 0)
+                {
+                    requestRootCreditExchange?.Invoke();
+                    return;
+                }
+
+                resultBannerId = bannerId;
+                resultText = $"git pull failed: need {missingTokens} {GachaService.FormatCurrencyName(GachaCurrencyType.StandardPull)} or {missingTokens * GachaService.EntropyPerPullToken} entropy";
+                RenderSelectedBanner();
+                return;
+            }
+
+            pendingPullCount = pullCount;
+            pendingMissingTokens = missingTokens;
+            resultBannerId = bannerId;
+            resultText = null;
+            RenderSelectedBanner();
+        }
+
+        private VisualElement BuildEntropyPrompt()
+        {
+            VisualElement prompt = new();
+            prompt.AddToClassList("gacha-entropy-prompt");
+
+            int entropyCost = pendingMissingTokens * GachaService.EntropyPerPullToken;
+            Label copy = new($"missing {pendingMissingTokens} stable-pull-token(s). spend {entropyCost} entropy to complete git pull?");
+            copy.AddToClassList("gacha-result");
+            prompt.Add(copy);
+
+            VisualElement actions = new();
+            actions.AddToClassList("gacha-actions");
+
+            Button cancel = new(() =>
+            {
+                ClearEntropyPrompt();
+                RenderSelectedBanner();
+            })
+            {
+                text = "git pull --abort"
+            };
+            cancel.AddToClassList("terminal-button");
+            cancel.AddToClassList("gacha-action-button");
+            actions.Add(cancel);
+
+            Button confirm = new(() =>
+            {
+                int pullCount = pendingPullCount;
+                int missingTokens = pendingMissingTokens;
+                ClearEntropyPrompt();
+                PullSelectedBanner(pullCount, missingTokens);
+            })
+            {
+                text = $"git pull --use-entropy={entropyCost}"
+            };
+            confirm.AddToClassList("terminal-button");
+            confirm.AddToClassList("gacha-action-button");
+            actions.Add(confirm);
+
+            prompt.Add(actions);
+            return prompt;
+        }
+
+        private bool CanAttemptBeginnerPull(int pullCount)
+        {
+            if (gachaService.CanPullBeginner(pullCount, out _))
+            {
+                return true;
+            }
+
+            if (!gachaService.IsBeginnerBannerAvailable || pullCount > GachaService.BeginnerMaxPulls - gachaService.BeginnerState.totalPulls)
+            {
+                return false;
+            }
+
+            int missingTokens = gachaService.GetMissingPullTokens(GachaCurrencyType.StandardPull, gachaService.GetBeginnerPullCost(pullCount));
+            return missingTokens > 0 &&
+                   (gachaService.CanCoverMissingPullTokensWithEntropy(wallet, missingTokens) ||
+                    gachaService.RootCredits > 0);
+        }
+
+        private void ClearEntropyPrompt()
+        {
+            pendingPullCount = 0;
+            pendingMissingTokens = 0;
+        }
+
+        private VisualElement BuildBannerHero(string bannerTitle)
+        {
+            VisualElement hero = new();
+            hero.AddToClassList("gacha-hero");
+
+            VisualElement artRow = new();
+            artRow.AddToClassList("gacha-hero-art-row");
+
+            IReadOnlyList<DistroDefinition> distros = distroDatabase == null ? Array.Empty<DistroDefinition>() : distroDatabase.AllDistros;
+            int artCount = Mathf.Min(3, distros.Count);
+            for (int i = 0; i < artCount; i++)
+            {
+                artRow.Add(BuildDistroArtCard(distros[i]));
+            }
+
+            if (artCount == 0)
+            {
+                Label empty = new("ascii art unavailable");
+                empty.AddToClassList("gacha-rules");
+                artRow.Add(empty);
+            }
+
+            Label title = new(bannerTitle);
+            title.AddToClassList("gacha-hero-title");
+
+            hero.Add(artRow);
+            hero.Add(title);
+            return hero;
+        }
+
+        private VisualElement BuildDistroArtCard(DistroDefinition distro)
+        {
+            VisualElement card = new();
+            card.AddToClassList("gacha-art-card");
+
+            VisualElement artShell = new();
+            artShell.AddToClassList("gacha-art-shell");
+
+            Label artLabel = new();
+            DistroArtPresenter.ConfigureArtLabel(artLabel, monospaceFont);
+            artLabel.AddToClassList("gacha-ascii-art");
+            VisualElement placeholder = DistroArtPresenter.CreatePlaceholder();
+            placeholder.AddToClassList("gacha-ascii-placeholder");
+            AsciiArtFitter artFitter = new(artLabel, monospaceFont);
+            artFitter.SetArt(DistroArtPresenter.Render(artLabel, placeholder, distro));
+            if (distro != null)
+            {
+                artLabel.style.color = new StyleColor(distro.AccentColor);
+            }
+
+            artShell.Add(placeholder);
+            artShell.Add(artLabel);
+            card.Add(artShell);
+
+            Label name = new(distro == null ? "--" : DistroPresentation.DisplayName(distro));
+            name.AddToClassList("gacha-art-name");
+            if (distro != null)
+            {
+                name.style.color = new StyleColor(distro.AccentColor);
+            }
+
+            card.Add(name);
+            return card;
+        }
+
+        private string FormatBeginnerGuarantees()
+        {
+            IReadOnlyList<string> ids = gachaService.BeginnerState.guaranteedDistroIds;
+            string first = ids.Count > 0 ? ids[0] : "--";
+            string second = ids.Count > 1 ? ids[1] : "--";
+            return $"20={first}, 40={second}, 50=future standard 5-star";
+        }
+
+        private static VisualElement BuildInfoLine(string key, string value)
+        {
+            VisualElement row = new();
+            row.AddToClassList("kv-row");
+            row.Add(new Label(key) { name = $"Gacha{key}Key" });
+            row.ElementAt(0).AddToClassList("kv-key");
+            row.Add(new Label(value) { name = $"Gacha{key}Value" });
+            row.ElementAt(1).AddToClassList("kv-value");
+            return row;
+        }
+
+        private string GetBannerStatus(string bannerId)
+        {
+            return bannerId switch
+            {
+                GachaService.BeginnerBannerId => gachaService.IsBeginnerBannerAvailable ? $"{gachaService.BeginnerState.totalPulls}/{GachaService.BeginnerMaxPulls}" : "closed",
+                GachaService.StandardBannerId => "soon",
+                GachaService.LimitedBannerId => "soon",
+                _ => "--"
+            };
+        }
+
+        private static string GetBannerTitle(string bannerId)
+        {
+            return bannerId switch
+            {
+                GachaService.BeginnerBannerId => "beginner install media",
+                GachaService.StandardBannerId => "stable branch",
+                GachaService.LimitedBannerId => "feature branch",
+                _ => bannerId
+            };
+        }
+    }
+}

Assets/Scripts/UI/MainMenuController.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 27a7f29e93cb4c55beac52f1e32a1bf5
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/UI/UIPreferences.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: a1efef5d7a1b485493c2f30d64644898
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: