备份CatanBuilding瘦身独立工程

Assets/Scripts/UI/ShootingRange/ShootingRangeData.cs

@@ -0,0 +1,356 @@
+using System;
+using System.Collections.Generic;
+using asap.core;
+using cfg;
+using UnityEngine;
+using UnityEngine.Assertions;
+using GameCore;
+
+public class EventShootingRangeData : IChainPackData
+{
+    private RawData _data = new RawData();
+    private readonly Tables _tables = GContext.container.Resolve<Tables>();
+    private readonly TbPack _pack = GContext.container.Resolve<Tables>().TbPack;
+    private readonly TbEventPackManager _eventPackManager = GContext.container.Resolve<Tables>().TbEventPackManager;
+
+    private readonly TbEventShootingRangeMain _shootingRangeMainTable =
+        GContext.container.Resolve<Tables>().TbEventShootingRangeMain;
+
+    public const string Key = "EventShootingRangeData",
+        PackRedPointId = "EventShooting.Pack",
+        EntranceRedPointId = "EventShooting.Enter";
+
+    private const int SlotCount = 6;
+    public int EventId => _data.EventId;
+    public int RedirectId => _data.RedirectId;
+    public int AmmoCount => _data.AmmoCount;
+
+    public bool HasBeenOpened
+    {
+        get => _data.HasBeenOpened;
+        set => _data.HasBeenOpened = value;
+    }
+
+    public TimeSpan RemainingTime =>
+        DateTime.Parse((_tables.TbFishingEvent[_data.EventId].TimeDefinition as LimitedTime)?.EndTime) -
+        ZZTimeHelper.UtcNow();
+
+    public bool IsActive => _tables.TbFishingEvent.DataMap.ContainsKey(_data.EventId) &&
+                            _tables.TbFishingEventCycleItem2.DataMap.ContainsKey(_data.CycleId) &&
+                            _tables.TbEventShootingRangeMain.DataMap.ContainsKey(_data.RedirectId) &&
+                            _tables.TbEventPackManager.DataMap.ContainsKey(_tables
+                                .TbEventShootingRangeMain[_data.RedirectId].PackId) &&
+                            RemainingTime.TotalSeconds > 0 &&
+                            ZZTimeHelper.UtcNow() >=
+                            DateTime.Parse((_tables.TbFishingEvent[_data.EventId].TimeDefinition as LimitedTime)
+                                ?.StartTime);
+
+    public EventShootingRangeMain EventShootingRange =>
+        GContext.container.Resolve<Tables>().TbEventShootingRangeMain[RedirectId];
+
+    public EventShootingRangeStage CurrentStage =>
+        _tables.TbEventShootingRangeStage[EventShootingRange.StageList[CurrentStageIdx]];
+
+    public int CurrentStageIdx => _data.CurrentStageIdx % EventShootingRange.StageList.Count;
+    public int RoundCount => _data.CurrentStageIdx / EventShootingRange.StageList.Count;
+
+    // public bool IsGameDepleted =>
+    //     _data.CurrentStageIdx < 0 || _data.CurrentStageIdx >= EventShootingRange.StageList.Count;
+
+    public bool IsGrandPrizeAllowed => CurrentStageShootCount >= CurrentStage.MinAttempts - 1;
+    public bool IsFinalStage => CurrentStageIdx == EventShootingRange.StageList.Count - 1;
+
+    public int CurrentStageShootCount
+    {
+        get
+        {
+            int count = 0;
+            var flag = _data.RewardFlag;
+            while (flag > 0)
+            {
+                count += (int)(flag & 1);
+                flag >>= 1;
+            }
+
+            return count;
+        }
+    }
+
+    private List<int> ChainList => _tables.TbEventPackManager[_tables.TbEventShootingRangeMain[_data.RedirectId].PackId]
+        .VIPPackList[0];
+
+    public int ChainListCount => ChainList.Count;
+    public bool IsChainPackDepleted => _data.ChainProgress >= ChainListCount;
+    public bool IsEndGame => _data.ChainProgress > ChainList.Count - SlotCount;
+
+    public bool DoNeedPackRedPoint
+    {
+        get
+        {
+            if (!IsChainPackDepleted && ChainProgress < ChainListCount)
+                return _pack[_eventPackManager[EventShootingRange.PackId].VIPPackList[0][ChainProgress]].IAPID == 0;
+            return false;
+        }
+    }
+
+    public bool DoNeedEntranceRedPoint => !HasBeenOpened || _data.AmmoCount >= CycleItem.RedDot;
+
+    public int ChainProgress
+    {
+        get => _data.ChainProgress;
+        set => _data.ChainProgress = value;
+    }
+
+    public Pack[] NormalPacks
+    {
+        get
+        {
+            // return [_tables.TbPack[EventShootingRange.PackId2], _tables.TbPack[EventShootingRange.PackId2 + 1]
+            var normalPackIds = _tables.TbEventPackManager[EventShootingRange.PackId2].VIPPackList[0];
+            var packs = new Pack[normalPackIds.Count];
+            for (int i = 0; i < normalPackIds.Count; i++)
+            {
+                packs[i] = _tables.TbPack[normalPackIds[i]];
+            }
+
+            return packs;
+        }
+    }
+
+    public string AmmoIconUrl => GContext.container.Resolve<Tables>().TbItem[CycleItem.ID].Icon;
+    public string AmmoNameUrl => GContext.container.Resolve<Tables>().TbItem[CycleItem.ID].Name_l10n_key;
+
+    public List<int> GetTokenProgressRewardAfterAddingToken(int tokenAdded)
+    {
+        throw new NotImplementedException();
+    }
+
+    public FishingEventCycleItem2 CycleItem => _tables.TbFishingEventCycleItem2[_data.CycleId];
+
+    #region UI Resources
+    public string ChainPackPanelUrl => _shootingRangeMainTable[RedirectId].ChainPackPanel;
+    public string PackPanelUrl => _shootingRangeMainTable[RedirectId].PackPanel;
+    public string InfoPanelUrl => _shootingRangeMainTable[RedirectId].InfoPanel;
+    public string MainPanelUrl => _shootingRangeMainTable[RedirectId].EventPanel;
+    public string RewardPanelUrl => _shootingRangeMainTable[RedirectId].EventRewardPanel;
+    public string ShootingRangeAct => _shootingRangeMainTable[RedirectId].Scene;
+    public string EntranceIcon => _shootingRangeMainTable[RedirectId].IconEvent;
+    public string PackIcon => _shootingRangeMainTable[RedirectId].IconPackage;
+    public string TransitionPanelUrl => _shootingRangeMainTable[RedirectId].TransPanel;
+
+    #endregion
+    public int AmmoId => CycleItem.ItemId;
+
+    public string RedPointKey => throw new NotImplementedException();
+
+    public int GetChainProgressBySlotIdx(int slotIdx)
+    {
+        // Debug.Log($"<color=#f18c0a>Progress: {ChainProgress}</color>");
+        int res;
+        if (_data.ChainProgress > ChainList.Count - SlotCount)
+            res = ChainList.Count - SlotCount + slotIdx;
+        else
+            res = _data.ChainProgress + slotIdx;
+        Assert.IsTrue(res < ChainList.Count, $"Progress {res} out of range: {ChainListCount}");
+        return res;
+    }
+
+    public void UpdateData(FishingEvent e)
+    {
+        if (EventId == e.ID)
+            return;
+        _data = new RawData
+        {
+            EventId = e.ID,
+            CycleId = e.RedirectID,
+            RedirectId = _tables.TbFishingEventCycleItem2[e.RedirectID].RedirectID,
+            AmmoCount = _tables.TbFishingEventCycleItem2[e.RedirectID].WelcomeGift,
+            HasBeenOpened = false
+        };
+        UploadData();
+    }
+
+    public void LoadData(string s)
+    {
+        _data = Newtonsoft.Json.JsonConvert.DeserializeObject<RawData>(s);
+        // _data.EventId = 0;
+        // Debug.Log($"<color=#4d90fe>ShootingRangeDataLoaded: {s}</color>");
+    }
+
+    public void UploadData()
+    {
+        var message = Newtonsoft.Json.JsonConvert.SerializeObject(_data);
+        // Debug.Log($"<color=#4d90fe>ShootingRangeDataUploaded: {message}</color>");
+        PlayFabMgr.Instance.UpdateUserDataValue(Key, message);
+    }
+
+    public void AddAmmo(int count)
+    {
+        _data.AmmoCount += count;
+        GContext.container.Resolve<FishingEventData>().SaveTransitionData(_data.EventId, _data.AmmoCount);
+        UploadData();
+    }
+
+    public int PickRandomIndex(IList<int> weightList)
+    {
+        Assert.IsTrue(weightList is { Count: >= 1 }, "WeightList contains no weight.");
+        var acc = new List<int> { weightList[0] };
+        for (int i = 1; i < weightList.Count; i++)
+            acc.Add(weightList[i] + acc[i - 1]);
+        int random = UnityEngine.Random.Range(0, acc[^1]);
+        for (int i = 0; i < acc.Count; i++)
+        {
+            if (random < acc[i])
+            {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    /// <summary>
+    /// Checkout to next stage.
+    /// </summary>
+    /// <returns>False if next stage is out of range.</returns>
+    public void SwitchToNextStage()
+    {
+        _data.CurrentStageIdx++;
+        // _data.CurrentStageIdx %= EventShootingRange.StageList.Count;
+        ResetRewardFlag();
+        ResetTargetFlag();
+        // return _data.CurrentStageIdx < EventShootingRange.StageList.Count;
+    }
+
+    public void SwitchToStage(int n)
+    {
+        _data.CurrentStageIdx = n;
+        ResetRewardFlag();
+        ResetTargetFlag();
+    }
+
+    public Pack GetChainPackByChainProgress(int chainProgress)
+    {
+        return _tables.TbPack[ChainList[chainProgress]];
+    }
+
+    public void OnBuySuccess()
+    {
+        if (ChainProgress >= ChainListCount)
+        {
+            Debug.LogError($"Trying to buy pack no.{ChainProgress} while there are/is only {ChainListCount} packs.");
+            return;
+        }
+
+        _data.ChainProgress++;
+    }
+#if UNITY_EDITOR
+    public void ResetData()
+    {
+        _data.AmmoCount = 200;
+        ResetRewardFlag();
+        ResetTargetFlag();
+        _data.CurrentStageIdx = 11;
+        UploadData();
+        Debug.Log("<color=#4d90fe>Data reset.</color>");
+    }
+#endif
+
+    #region Flags
+
+    public void ResetRewardFlag()
+    {
+        _data.RewardFlag = 0;
+    }
+
+    /// <summary>
+    /// Check if reward No.idx in current stage is claimed.
+    /// </summary>
+    /// <param name="idx">Index of current reward. Starts with 0.</param>
+    /// <returns>True if this reward is collected.</returns>
+    public bool IsRewardCollected(int idx)
+    {
+        Assert.IsTrue(idx < CurrentStage.DropId.Count,
+            $"Attempting to get reward{idx} status, while we have only {CurrentStage.DropId.Count} rewards.");
+        long idxFlag = (long)1 << idx;
+        return (_data.RewardFlag & idxFlag) == idxFlag;
+    }
+
+    public void SetRewardCollected(int idx)
+    {
+        Assert.IsTrue(idx < CurrentStage.DropId.Count,
+            $"Attempting to set reward{idx} as got, while we have only {CurrentStage.DropId.Count} rewards.");
+        _data.RewardFlag |= (long)1 << idx;
+    }
+
+    public void ResetTargetFlag()
+    {
+        _data.TargetFlag = 0;
+    }
+
+    public bool IsTargetHit(int idx)
+    {
+        /*Assert.IsTrue(idx < CurrentStage.DropId.Count,
+            $"Attempting to get target{idx} status, while we have only {CurrentStage.DropId.Count} targets.");
+        Assert.IsTrue(false, "JP wins!");
+        Assert.IsTrue(false,
+            $"Attempting to get target{idx} status, while we have only {CurrentStage.DropId.Count} targets.");*/
+        if (idx >= CurrentStage.DropId.Count)
+            Debug.LogWarning($"尝试获取{idx}号靶子的状态，但是咱只有{CurrentStage.DropId.Count}个Drop。这很奇怪。");
+        long idxFlag = (long)1 << idx;
+        return (_data.TargetFlag & idxFlag) == idxFlag;
+    }
+
+    public void SetTargetHit(int idx)
+    {
+        // Assert.IsTrue(idx < CurrentStage.DropId.Count,
+        //     $"Attempting to get target{idx} status, while we have only {CurrentStage.DropId.Count} targets.");
+        if (idx >= CurrentStage.DropId.Count)
+            Debug.LogWarning($"尝试打击{idx}号靶子，但是咱只有{CurrentStage.DropId.Count}个Drop。这很奇怪。");
+        _data.TargetFlag |= ((long)1 << idx);
+    }
+
+    public int GetHitTargetCount()
+    {
+        int count = 0;
+        long num = _data.TargetFlag;
+        while (num != 0)
+        {
+            num &= num - 1;
+            count++;
+        }
+        return count;
+    }
+
+    public List<ItemData> GetItemsByPackDropId(int dropId)
+    {
+        throw new NotImplementedException();
+    }
+
+    #endregion
+
+    private struct RawData
+    {
+        public int EventId;
+        public int CycleId;
+        public int RedirectId;
+        public int AmmoCount;
+
+        /// <summary>
+        /// Used in flag fashion.
+        /// </summary>
+        public long RewardFlag;
+
+        /// <summary>
+        /// Used in flag fashion.
+        /// </summary>
+        public long TargetFlag;
+
+        /// <summary>
+        /// Stage index that starts from 0. May exceed total stage count, indicating how many rounds player has counted.
+        /// </summary>
+        public int CurrentStageIdx;
+        public int ChainProgress;
+        public bool HasBeenOpened;
+    }
+}