Release/1.39.0

.Lib9c.Tests/Action/AdventureBoss/ExploreAdventureBossTest.cs

@@ -24,6 +24,9 @@ namespace Lib9c.Tests.Action.AdventureBoss
 
     public class ExploreAdventureBossTest
     {
+        // See UseBoostTestBoss.
+        private const int BoostTestAdventureBossId = 2;
+
         private static readonly Dictionary<string, string> Sheets =
             TableSheetsImporter.ImportSheets();
 
@@ -343,6 +346,287 @@ out var items
             }
         }
 
+        [Fact]
+        public void Execute_AppliesScheduledRewardBoost()
+        {
+            var (baseRewards, baseScore, adventureBossId) = ExploreWithBoostSchedule(null);
+            var firstClear = FirstClearRewards(adventureBossId, 1, 5);
+            var floorRewards = Combine(baseRewards, firstClear, -1);
+            Assert.NotEmpty(firstClear);
+            Assert.Contains(floorRewards, pair => pair.Value > 0);
+
+            var (floorBoosted, floorBoostedScore, _) = ExploreWithBoostSchedule(
+                BoostCsv(BoostScheduleSheet.Targets.AdventureBossFloorReward, "1~5", 0, 10));
+            var (firstBoosted, firstBoostedScore, _) = ExploreWithBoostSchedule(
+                BoostCsv(BoostScheduleSheet.Targets.AdventureBossFirstClearReward, "1~5", 0, 10));
+
+            // ×2 scales granted amounts only, so every draw — including the score drawn after
+            // each floor reward — stays where it was, and each target doubles only its own part.
+            Assert.Equal(baseScore, floorBoostedScore);
+            Assert.Equal(baseScore, firstBoostedScore);
+            Assert.Equal(Combine(baseRewards, floorRewards, 1), floorBoosted);
+            Assert.Equal(Combine(baseRewards, firstClear, 1), firstBoosted);
+        }
+
+        // Each target grants at most AdventureBossHelper.MaxAdventureBossRewardBoostFactor (5)
+        // times its own part, however large the value.
+        [Theory]
+        [InlineData("2", 2)]
+        [InlineData("100", 5)]
+        [InlineData("2147483647", 5)]
+        public void Execute_CapsScheduledRewardBoost(string value, int multiplier)
+        {
+            var (baseRewards, baseScore, adventureBossId) = ExploreWithBoostSchedule(null);
+            var firstClear = FirstClearRewards(adventureBossId, 1, 5);
+            var floorRewards = Combine(baseRewards, firstClear, -1);
+
+            var (floorBoosted, floorBoostedScore, _) = ExploreWithBoostSchedule(
+                BoostCsv(BoostScheduleSheet.Targets.AdventureBossFloorReward, "1~5", 0, 10, value));
+            var (firstBoosted, firstBoostedScore, _) = ExploreWithBoostSchedule(
+                BoostCsv(BoostScheduleSheet.Targets.AdventureBossFirstClearReward, "1~5", 0, 10, value));
+
+            Assert.Equal(baseScore, floorBoostedScore);
+            Assert.Equal(baseScore, firstBoostedScore);
+            Assert.Equal(Combine(baseRewards, Scale(floorRewards, multiplier - 1), 1), floorBoosted);
+            Assert.Equal(Combine(baseRewards, Scale(firstClear, multiplier - 1), 1), firstBoosted);
+        }
+
+        [Fact]
+        public void Execute_MatchesFloorRewardBoostByFloorNumber()
+        {
+            var (baseRewards, baseScore, adventureBossId) = ExploreWithBoostSchedule(null);
+            var floorRewards = Combine(baseRewards, FirstClearRewards(adventureBossId, 1, 5), -1);
+
+            // ×2 on a single floor grants exactly that floor's one reward entry once more.
+            var perFloor = new List<Dictionary<string, BigInteger>>();
+            for (var floor = 1; floor <= 5; floor++)
+            {
+                var (rewards, score, _) = ExploreWithBoostSchedule(
+                    BoostCsv(BoostScheduleSheet.Targets.AdventureBossFloorReward, $"{floor}", 0, 10));
+                Assert.Equal(baseScore, score);
+                var extra = Combine(rewards, baseRewards, -1);
+                Assert.Single(extra);
+                Assert.True(extra.Single().Value > 0, $"floor {floor}");
+                perFloor.Add(extra);
+            }
+
+            Assert.Equal(floorRewards, perFloor.Aggregate((a, b) => Combine(a, b, 1)));
+
+            // An inner range catches an off-by-one at either end.
+            var (inner, innerScore, _) = ExploreWithBoostSchedule(
+                BoostCsv(BoostScheduleSheet.Targets.AdventureBossFloorReward, "2~4", 0, 10));
+            Assert.Equal(baseScore, innerScore);
+            var expected = perFloor.Skip(1).Take(3).Aggregate(baseRewards, (a, b) => Combine(a, b, 1));
+            Assert.Equal(expected, inner);
+        }
+
+        [Fact]
+        public void Execute_MatchesFirstClearRewardBoostByFloorNumber()
+        {
+            var (baseRewards, baseScore, adventureBossId) = ExploreWithBoostSchedule(null);
+            var (inner, innerScore, _) = ExploreWithBoostSchedule(
+                BoostCsv(BoostScheduleSheet.Targets.AdventureBossFirstClearReward, "2~4", 0, 10));
+
+            Assert.Equal(baseScore, innerScore);
+            Assert.Equal(
+                Combine(baseRewards, FirstClearRewards(adventureBossId, 2, 4), 1),
+                inner);
+        }
+
+        [Theory]
+        [InlineData(2L, 10L)]
+        [InlineData(0L, 1L)]
+        public void Execute_IgnoresRewardBoostOutsideItsBlockRange(long start, long end)
+        {
+            var (baseRewards, baseScore, _) = ExploreWithBoostSchedule(null);
+            var csv =
+                BoostCsv(BoostScheduleSheet.Targets.AdventureBossFloorReward, "*", start, end) +
+                $"2,{BoostScheduleSheet.Targets.AdventureBossFirstClearReward},*,MUL,2,{start},{end}\n";
+            var (rewards, score, _) = ExploreWithBoostSchedule(csv);
+
+            Assert.Equal(baseScore, score);
+            Assert.Equal(baseRewards, rewards);
+        }
+
+        [Fact]
+        public void Execute_IsUnchangedWhenTheChainWasNeverPatchedWithBoostScheduleSheet()
+        {
+            var (neverPatched, neverPatchedScore, _) = ExploreWithBoostSchedule(null);
+            var (emptySheet, emptySheetScore, _) = ExploreWithBoostSchedule(
+                "id,target,target_id,op,value,start_block,end_block\n");
+
+            Assert.Contains(neverPatched, pair => pair.Value > 0);
+            Assert.Equal(neverPatchedScore, emptySheetScore);
+            Assert.Equal(neverPatched, emptySheet);
+        }
+
+        private static string BoostCsv(
+            string target,
+            string targetId,
+            long start,
+            long end,
+            string value = "2") =>
+            "id,target,target_id,op,value,start_block,end_block\n" +
+            $"1,{target},{targetId},MUL,{value},{start},{end}\n";
+
+        private static Dictionary<string, BigInteger> Scale(
+            Dictionary<string, BigInteger> rewards,
+            int factor) =>
+            rewards.ToDictionary(pair => pair.Key, pair => pair.Value * factor);
+
+        // Sums or subtracts per key, leaving out keys that end at zero.
+        private static Dictionary<string, BigInteger> Combine(
+            Dictionary<string, BigInteger> left,
+            Dictionary<string, BigInteger> right,
+            int sign) =>
+            left.Keys.Union(right.Keys)
+                .Select(key => (key, value: left.GetValueOrDefault(key) + (sign * right.GetValueOrDefault(key))))
+                .Where(pair => pair.value != 0)
+                .ToDictionary(pair => pair.key, pair => pair.value);
+
+        private static string RewardKey(string itemType, int itemId) =>
+            itemType switch
+            {
+                "Material" => $"item:{itemId}",
+                "Rune" => $"fav:{TableSheets.RuneSheet[itemId].Ticker}",
+                "Crystal" => "fav:CRYSTAL",
+                _ => throw new ArgumentException(itemType),
+            };
+
+        // First-clear rewards of floors fromFloor~toFloor (floor numbers) of the given boss.
+        private static Dictionary<string, BigInteger> FirstClearRewards(
+            int adventureBossId,
+            int fromFloor,
+            int toFloor)
+        {
+            var rewards = new Dictionary<string, BigInteger>();
+            foreach (var floorRow in TableSheets.AdventureBossFloorSheet.Values.Where(
+                         r => r.AdventureBossId == adventureBossId &&
+                              fromFloor <= r.Floor && r.Floor <= toFloor))
+            {
+                var firstReward = TableSheets.AdventureBossFloorFirstRewardSheet[floorRow.Id];
+                foreach (var reward in firstReward.Rewards)
+                {
+                    var key = RewardKey(reward.ItemType, reward.ItemId);
+                    rewards[key] = rewards.GetValueOrDefault(key) + reward.Amount;
+                }
+            }
+
+            return rewards;
+        }
+
+        // Makes season 1 fight AdventureBossSheet id 2, whose floor rows are numbered from 31, so
+        // that a boost matched against the floor row id instead of the floor number misses.
+        private static IWorld UseBoostTestBoss(IWorld state)
+        {
+            var floorOneRow = TableSheets.AdventureBossFloorSheet.Values
+                .First(row => row.AdventureBossId == BoostTestAdventureBossId && row.Floor == 1);
+            Assert.NotEqual(1, floorOneRow.Id);
+            var season = state.GetSeasonInfo(1);
+            season.BossId = TableSheets.AdventureBossSheet[BoostTestAdventureBossId].BossId;
+            return state.SetSeasonInfo(season).SetLatestAdventureBossSeason(season);
+        }
+
+        // Explores floors 1~5 at block 1 with a fixed seed, with the BoostScheduleSheet given as
+        // CSV or, for null, a chain that was never patched with it. Returns what was granted, by
+        // item id and currency ticker, the explorer's score and the season's AdventureBossSheet id.
+        private (Dictionary<string, BigInteger> Rewards, int Score, int AdventureBossId)
+            ExploreWithBoostSchedule(
+            string boostCsv)
+        {
+            var state = _initialState;
+            var gameConfigState = new GameConfigState(Sheets[nameof(GameConfigSheet)]);
+            state = state.SetLegacyState(gameConfigState.address, gameConfigState.Serialize());
+            foreach (var (key, value) in Sheets)
+            {
+                state = state.SetLegacyState(Addresses.TableSheet.Derive(key), value.Serialize());
+            }
+
+            state = state.SetLegacyState(
+                Addresses.GetSheetAddress<CollectionSheet>(),
+                CollectionSheetFixture.Default.Serialize());
+            state = state.SetLegacyState(
+                Addresses.TableSheet.Derive(nameof(BoostScheduleSheet)),
+                boostCsv is null ? Null.Value : boostCsv.Serialize());
+
+            state = Stake(state, WantedAddress);
+            var apPotionRow = TableSheets.MaterialItemSheet.OrderedList
+                .First(row => row.ItemSubType == ItemSubType.ApStone);
+            var inventory = state.GetInventoryV2(TesterAvatarAddress);
+            inventory.AddItem(ItemFactory.CreateMaterial(apPotionRow), 20);
+            state = state.SetInventory(TesterAvatarAddress, inventory);
+
+            var gameConfig = new GameConfigState(Sheets[nameof(GameConfigSheet)]);
+            state = new Wanted
+            {
+                Season = 1,
+                AvatarAddress = WantedAvatarAddress,
+                Bounty = gameConfig.AdventureBossMinBounty * NCG,
+            }.Execute(
+                new ActionContext
+                {
+                    PreviousState = state,
+                    Signer = WantedAddress,
+                    BlockIndex = 0L,
+                    RandomSeed = 1,
+                });
+            state = UseBoostTestBoss(state);
+            state = state.SetExplorer(
+                1,
+                new Explorer(TesterAvatarAddress, TesterAvatarState.name) { MaxFloor = 5, });
+            var before = Granted(state);
+
+            state = new ExploreAdventureBoss
+            {
+                Season = 1,
+                AvatarAddress = TesterAvatarAddress,
+                Costumes = new List<Guid>(),
+                Equipments = new List<Guid>(),
+                Foods = new List<Guid>(),
+                RuneInfos = new List<RuneSlotInfo>(),
+            }.Execute(
+                new ActionContext
+                {
+                    PreviousState = state,
+                    Signer = TesterAddress,
+                    BlockIndex = 1L,
+                    RandomSeed = 7,
+                });
+
+            var explorer = state.GetExplorer(1, TesterAvatarAddress);
+            Assert.Equal(5, explorer.Floor);
+            var bossId = state.GetLatestAdventureBossSeason().BossId;
+            var adventureBossId = TableSheets.AdventureBossSheet.Values
+                .First(row => row.BossId == bossId).Id;
+            Assert.Equal(BoostTestAdventureBossId, adventureBossId);
+            return (Combine(Granted(state), before, -1), explorer.Score, adventureBossId);
+        }
+
+        private Dictionary<string, BigInteger> Granted(IWorld state)
+        {
+            var granted = new Dictionary<string, BigInteger>();
+            foreach (var item in state.GetInventoryV2(TesterAvatarAddress).Items
+                         .Where(i => i.item.ItemSubType != ItemSubType.ApStone))
+            {
+                var key = $"item:{item.item.Id}";
+                granted[key] = granted.GetValueOrDefault(key) + item.count;
+            }
+
+            var currencies = TableSheets.RuneSheet.Values
+                .Select(row => Currencies.GetRune(row.Ticker))
+                .Append(Currencies.Crystal);
+            foreach (var currency in currencies)
+            {
+                var balance = state.GetBalance(TesterAvatarAddress, currency).MajorUnit;
+                if (balance != 0)
+                {
+                    granted[$"fav:{currency.Ticker}"] = balance;
+                }
+            }
+
+            return granted;
+        }
+
         private IWorld Stake(IWorld world, Address agentAddress)
         {
             var action = new Stake(new BigInteger(500_000), TesterAvatarAddress);