feat: Add dungeon detail subscription field

not-blond-beard · Mar 25, 2024 · 9a0405b · 9a0405b
1 parent 1a1d218
commit 9a0405b
Show file tree

Hide file tree

Showing 7 changed files with 202 additions and 5 deletions.
diff --git a/backend/app/Savor22b/Constants/Addresses.cs b/backend/app/Savor22b/Constants/Addresses.cs
@@ -4,6 +4,13 @@ namespace Savor22b.Constants;
 
 public static class Addresses
 {
-    public static readonly Address ShopVaultAddress = new Address("0000000000000000000000000000000000000000");
-    public static readonly Address UserHouseDataAddress = new Address("0000000000000000000000000000000000000001");
+    public static readonly Address ShopVaultAddress = new Address(
+        "0000000000000000000000000000000000000000"
+    );
+    public static readonly Address UserHouseDataAddress = new Address(
+        "0000000000000000000000000000000000000001"
+    );
+    public static readonly Address DungeonDataAddress = new Address(
+        "0000000000000000000000000000000000000002"
+    );
 }
diff --git a/backend/app/Savor22b/GraphTypes/Types/DungeonStateType.cs b/backend/app/Savor22b/GraphTypes/Types/DungeonStateType.cs
@@ -1,11 +1,14 @@
 namespace Savor22b.GraphTypes.Types;
 
 using GraphQL.Types;
+using Libplanet;
+using Libplanet.Blockchain;
+using Libplanet.Explorer.GraphTypes;
 using Savor22b.Model;
 
 public class DungeonStateType : ObjectGraphType<Dungeon>
 {
-    public DungeonStateType()
+    public DungeonStateType(BlockChain blockChain)
     {
         Field<NonNullGraphType<StringGraphType>>(
             "name",
@@ -49,5 +52,17 @@ public DungeonStateType()
                 return seeds;
             }
         );
+
+        Field<NonNullGraphType<BooleanGraphType>>(
+            "isConquest",
+            description: "현재 던전이 점령 되었는지의 여부입니다.",
+            resolve: context => context.Source.IsConquest(blockChain)
+        );
+
+        Field<AddressType>(
+            "conquestUserAddress",
+            description: "현재 던전을 점령하고 있는 유저의 Address입니다.",
+            resolve: context => context.Source.CurrentConquestUserAddress(blockChain)
+        );
     }
 }
diff --git a/backend/app/Savor22b/Model/Dungeon.cs b/backend/app/Savor22b/Model/Dungeon.cs
@@ -1,4 +1,9 @@
 using System.Collections.Immutable;
+using Bencodex.Types;
+using Libplanet;
+using Libplanet.Blockchain;
+using Savor22b.Constants;
+using Savor22b.States;
 
 namespace Savor22b.Model;
 
@@ -10,4 +15,30 @@ public class Dungeon
     public int ID { get; set; }
     public int VillageId { get; set; }
     public ImmutableList<int> RewardSeedIdList { get; set; }
+
+    private static GlobalDungeonState GetGlobalDungeonState(BlockChain blockChain)
+    {
+        GlobalDungeonState globalDungeonState = blockChain.GetState(Addresses.DungeonDataAddress)
+            is Dictionary stateEncoded
+            ? new GlobalDungeonState(stateEncoded)
+            : new GlobalDungeonState();
+
+        return globalDungeonState;
+    }
+
+    public bool IsConquest(BlockChain blockChain)
+    {
+        GlobalDungeonState globalDungeonState = GetGlobalDungeonState(blockChain);
+
+        return globalDungeonState.DungeonStatus.ContainsKey(ID.ToString());
+    }
+
+    public Address? CurrentConquestUserAddress(BlockChain blockChain)
+    {
+        GlobalDungeonState globalDungeonState = GetGlobalDungeonState(blockChain);
+
+        return globalDungeonState.DungeonStatus.TryGetValue(ID.ToString(), out Address address)
+            ? address
+            : default;
+    }
 }
diff --git a/backend/app/Savor22b/States/DungeonConquestHistoryState.cs b/backend/app/Savor22b/States/DungeonConquestHistoryState.cs
@@ -0,0 +1,53 @@
+namespace Savor22b.States;
+
+using Bencodex.Types;
+using Libplanet;
+using Libplanet.Headless.Extensions;
+
+public class DungeonConquestHistoryState : State
+{
+    public long BlockIndex { get; private set; }
+    public int DungeonId { get; private set; }
+    public Address TargetUserAddress { get; private set; }
+    public int DungeonConquestStatus { get; private set; }
+
+    public DungeonConquestHistoryState(
+        long blockIndex,
+        int dungeonId,
+        Address targetUserAddress,
+        int dungeonConquestStatus
+    )
+    {
+        BlockIndex = blockIndex;
+        DungeonId = dungeonId;
+        TargetUserAddress = targetUserAddress;
+        DungeonConquestStatus = dungeonConquestStatus;
+    }
+
+    public DungeonConquestHistoryState(Dictionary encoded)
+    {
+        BlockIndex = encoded[nameof(BlockIndex)].ToLong();
+        DungeonId = encoded[nameof(DungeonId)].ToInteger();
+        TargetUserAddress = encoded[nameof(TargetUserAddress)].ToAddress();
+        DungeonConquestStatus = encoded[nameof(DungeonConquestStatus)].ToInteger();
+    }
+
+    public IValue Serialize()
+    {
+        var pairs = new[]
+        {
+            new KeyValuePair<IKey, IValue>((Text)nameof(BlockIndex), BlockIndex.Serialize()),
+            new KeyValuePair<IKey, IValue>((Text)nameof(DungeonId), DungeonId.Serialize()),
+            new KeyValuePair<IKey, IValue>(
+                (Text)nameof(TargetUserAddress),
+                TargetUserAddress.ToBencodex()
+            ),
+            new KeyValuePair<IKey, IValue>(
+                (Text)nameof(DungeonConquestStatus),
+                DungeonConquestStatus.Serialize()
+            ),
+        };
+
+        return new Dictionary(pairs);
+    }
+}
diff --git a/backend/app/Savor22b/States/DungeonHistoryState.cs b/backend/app/Savor22b/States/DungeonHistoryState.cs
@@ -1,23 +1,39 @@
 namespace Savor22b.States;
 
+using System.Collections.Immutable;
 using Bencodex.Types;
 using Libplanet.Headless.Extensions;
 
 public class DungeonHistoryState : State
 {
     public long BlockIndex { get; private set; }
     public int DungeonId { get; private set; }
+    public int DungeonClearStatus { get; private set; }
+    public ImmutableList<int> DungeonClearRewardSeedIdList { get; private set; }
 
-    public DungeonHistoryState(long blockIndex, int dungeonId)
+    public DungeonHistoryState(
+        long blockIndex,
+        int dungeonId,
+        int dungeonClearStatus,
+        ImmutableList<int> dungeonClearRewardSeedIdList
+    )
     {
         BlockIndex = blockIndex;
         DungeonId = dungeonId;
+        DungeonClearStatus = dungeonClearStatus;
+        DungeonClearRewardSeedIdList = dungeonClearRewardSeedIdList;
     }
 
     public DungeonHistoryState(Dictionary encoded)
     {
         BlockIndex = encoded[nameof(BlockIndex)].ToLong();
         DungeonId = encoded[nameof(DungeonId)].ToInteger();
+        DungeonClearStatus = encoded[nameof(DungeonClearStatus)].ToInteger();
+        DungeonClearRewardSeedIdList = (
+            (Bencodex.Types.List)encoded[nameof(DungeonClearRewardSeedIdList)]
+        )
+            .Select(e => e.ToInteger())
+            .ToImmutableList();
     }
 
     public IValue Serialize()
@@ -26,6 +42,14 @@ public IValue Serialize()
         {
             new KeyValuePair<IKey, IValue>((Text)nameof(BlockIndex), BlockIndex.Serialize()),
             new KeyValuePair<IKey, IValue>((Text)nameof(DungeonId), DungeonId.Serialize()),
+            new KeyValuePair<IKey, IValue>(
+                (Text)nameof(DungeonClearStatus),
+                DungeonClearStatus.Serialize()
+            ),
+            new KeyValuePair<IKey, IValue>(
+                (Text)nameof(DungeonClearRewardSeedIdList),
+                new List(DungeonClearRewardSeedIdList.Select(e => e.Serialize()))
+            ),
         };
 
         return new Dictionary(pairs);

diff --git a/backend/app/Savor22b/States/GlobalDungeonState.cs b/backend/app/Savor22b/States/GlobalDungeonState.cs
@@ -0,0 +1,53 @@
+namespace Savor22b.States;
+
+using Libplanet.Headless.Extensions;
+
+using Bencodex.Types;
+using Libplanet;
+
+public class GlobalDungeonState : State
+{
+    public Dictionary<string, Address> DungeonStatus { get; private set; }
+
+    public GlobalDungeonState()
+    {
+        DungeonStatus = new Dictionary<string, Address>();
+    }
+
+    public GlobalDungeonState(Dictionary<string, Address> dungeonStatus)
+    {
+        DungeonStatus = dungeonStatus;
+    }
+
+    public GlobalDungeonState(Bencodex.Types.Dictionary encoded)
+    {
+        if (encoded.TryGetValue((Text)nameof(DungeonStatus), out var dungeonStatus))
+        {
+            DungeonStatus = ((Bencodex.Types.Dictionary)dungeonStatus).ToDictionary(
+                pair => ((Bencodex.Types.Text)pair.Key).Value,
+                pair => pair.Value.ToAddress()
+            );
+        }
+        else
+        {
+            DungeonStatus = new Dictionary<string, Address>();
+        }
+    }
+
+    public IValue Serialize()
+    {
+        var pairs = new[]
+        {
+            new KeyValuePair<IKey, IValue>(
+                (Text)nameof(DungeonStatus),
+                new Dictionary(
+                    DungeonStatus.Select(
+                        e => new KeyValuePair<IKey, IValue>((Text)e.Key, e.Value.ToBencodex())
+                    )
+                )
+            ),
+        };
+
+        return new Dictionary(pairs);
+    }
+}
diff --git a/backend/app/Savor22b/States/UserDungeonState.cs b/backend/app/Savor22b/States/UserDungeonState.cs
@@ -9,15 +9,21 @@ public class UserDungeonState : State
     public static readonly int DungeonKeyChargeIntervalBlock = 12;
 
     public ImmutableList<DungeonHistoryState> DungeonHistories { get; private set; }
+    public ImmutableList<DungeonConquestHistoryState> DungeonConquestHistories { get; private set; }
 
     public UserDungeonState()
     {
         DungeonHistories = ImmutableList<DungeonHistoryState>.Empty;
+        DungeonConquestHistories = ImmutableList<DungeonConquestHistoryState>.Empty;
     }
 
-    public UserDungeonState(ImmutableList<DungeonHistoryState> dungeonKeyHistories)
+    public UserDungeonState(
+        ImmutableList<DungeonHistoryState> dungeonKeyHistories,
+        ImmutableList<DungeonConquestHistoryState> dungeonConquestHistories
+    )
     {
         DungeonHistories = dungeonKeyHistories;
+        DungeonConquestHistories = dungeonConquestHistories;
     }
 
     public UserDungeonState(Dictionary encoded)
@@ -32,6 +38,10 @@ public UserDungeonState(Dictionary encoded)
         {
             DungeonHistories = ImmutableList<DungeonHistoryState>.Empty;
         }
+
+        DungeonConquestHistories = ((List)encoded[nameof(DungeonConquestHistories)])
+            .Select(element => new DungeonConquestHistoryState((Dictionary)element))
+            .ToImmutableList();
     }
 
     public IValue Serialize()
@@ -43,6 +53,10 @@ public IValue Serialize()
                     (Text)nameof(DungeonHistories),
                     new List(DungeonHistories.Select(element => element.Serialize()))
                 ),
+                new KeyValuePair<IKey, IValue>(
+                    (Text)nameof(DungeonConquestHistories),
+                    new List(DungeonConquestHistories.Select(element => element.Serialize()))
+                ),
             }
         );
     }