备份CatanBuilding瘦身独立工程

Assets/Scripts/MiniBP/UI/HomeBtnMiniBP.cs

@@ -0,0 +1,124 @@
+using asap.core;
+using GameCore;
+using System;
+using System.Collections.Generic;
+using TMPro;
+using UniRx;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class HomeBtnMiniBP : EventButtonResource, IUIRedPoint
+{
+    public const string redKey = "MiniBP";
+    public MiniBattlePassType Type = MiniBattlePassType.LuckMagic;
+    MiniBattlePassDataModel miniBP;
+    Image icon;
+    Button btn;
+    TMP_Text text_time;
+    GameObject redpoint;
+
+    IDisposable timerDisposable;
+    private void Awake()
+    {
+        miniBP = GContext.container.Resolve<MiniBattlePassDataProvider>().GetModel(Type);
+        icon = transform.Find("icon").GetComponent<Image>();
+        text_time = transform.Find("text_time").GetComponent<TMP_Text>();
+        btn = GetComponent<Button>();
+        redpoint = transform.Find("redpoint").gameObject;
+        if (!miniBP.IsShow() || miniBP.IsDone())
+        {
+            gameObject.SetActive(false);
+            return;
+        }
+
+        CheckResource(new List<string>() { miniBP.PanelName, miniBP.Icon });
+    }
+
+    private void Start()
+    {
+        btn.onClick.AddListener(OnClickIn);
+    }
+
+    private void OnEnable()
+    {
+        ShowTimer();
+        RedPointManager.Instance.AddRedPoint(redKey + Type, this);
+        SetRedPointState(RedPointManager.Instance.GetRedPointState(redKey + Type));
+    }
+
+
+    public void SetRedPointState(bool state)
+    {
+        redpoint.SetActive(state);
+
+    }
+
+    void OnClickIn()
+    {
+        UIManager.Instance.ShowUILoad(new UIType(miniBP.PanelName));
+    }
+
+    void ShowTimer()
+    {
+        //剩余时间
+        if (timerDisposable != null)
+        {
+            timerDisposable.Dispose();
+            timerDisposable = null;
+        }
+        TimeSpan duration = miniBP.endTime - ZZTimeHelper.UtcNow();
+        text_time.text = ConvertTools.ConvertTime2(duration);
+        timerDisposable = Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(UpdateTimer);
+    }
+    public void SetShow()
+    {
+        miniBP = GContext.container.Resolve<MiniBattlePassDataProvider>().GetModel(Type);
+        if (miniBP.IsShow() && !miniBP.IsDone())
+        {
+            ShowTimer();
+            gameObject.SetActive(true);
+            CheckResource(new List<string>() { miniBP.PanelName, miniBP.Icon });
+        }
+    }
+
+    private void UpdateTimer(long _ = 0L)
+    {
+        text_time.text = ConvertTools.ConvertTime2(miniBP.endTime - ZZTimeHelper.UtcNow());
+        if (!miniBP.IsShow())
+        {
+            Refresh();
+        }
+    }
+
+    protected void Refresh()
+    {
+        if (timerDisposable != null)
+        {
+            timerDisposable.Dispose();
+            timerDisposable = null;
+        }
+        gameObject.SetActive(false);
+    }
+
+    private void OnDisable()
+    {
+        RedPointManager.Instance.RemoveRedPoint(redKey + Type);
+
+        if (timerDisposable != null)
+        {
+            timerDisposable.Dispose();
+            timerDisposable = null;
+        }
+    }
+
+    protected override void OnLoadEventResource()
+    {
+        miniBP = GContext.container.Resolve<MiniBattlePassDataProvider>().GetModel(Type);
+        if (miniBP.IsShow() && !miniBP.IsDone())
+        {
+            gameObject.SetActive(true);
+            IUIService uIService = GContext.container.Resolve<IUIService>();
+            uIService.SetImageSprite(icon, miniBP.Icon);
+        }
+    }
+}

Assets/Scripts/MiniBP/UI/HomeBtnMiniBP.cs.meta

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

Assets/Scripts/MiniBP/UI/MapBtnMiniBP.cs

@@ -0,0 +1,324 @@
+using asap.core;
+using Coffee.UIExtensions;
+using DG.Tweening;
+using GameCore;
+using System;
+using TMPro;
+using UniRx;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class MapBtnMiniBP : MonoBehaviour, IUIRedPoint
+{
+    MiniBattlePassType Type = MiniBattlePassType.Fishcard;
+    MiniBattlePassDataModel miniBP;
+    public Button btn_questionmark;
+
+    Button btn;
+    Image icon;
+    TMP_Text text_time;
+    GameObject redpoint;
+    GameObject redpoint_big;
+    TMP_Text text_redpoint_big;
+    TMP_Text text_level;
+    Image bar;
+    TMP_Text text_num_bar;
+    int curExp;
+    int curAllExp;
+    int curMax = 1;
+    float _fillTime = 0.5f;
+    public GameObject fx;
+    public UIParticleAttractor uIParticleAttractor;
+    public CanvasGroup canvasGroup;
+    IDisposable timerDisposable;
+    private void Awake()
+    {
+        miniBP = GContext.container.Resolve<MiniBattlePassDataProvider>().GetModel(Type);
+        icon = transform.Find("icon").GetComponent<Image>();
+        text_time = transform.Find("text_time").GetComponent<TMP_Text>();
+        btn = GetComponent<Button>();
+        redpoint = transform.Find("redpoint").gameObject;
+        redpoint_big = transform.Find("redpoint_big").gameObject;
+        text_redpoint_big = redpoint_big.transform.Find("text_redpoint").GetComponent<TMP_Text>();
+        text_level = transform.Find("level/text_num").GetComponent<TMP_Text>();
+        bar = transform.Find("bg_bar/bar").GetComponent<Image>();
+        text_num_bar = transform.Find("bg_bar/text_num").GetComponent<TMP_Text>();
+        OnInit();
+    }
+
+    private void Start()
+    {
+        btn.onClick.AddListener(OnClickIn);
+    }
+
+    private void OnInit()
+    {
+        if (timerDisposable != null)
+        {
+            timerDisposable.Dispose();
+            timerDisposable = null;
+        }
+        if (!miniBP.IsShow())
+        {
+            gameObject.SetActive(false);
+            return;
+        }
+        else
+        {
+            gameObject.SetActive(true);
+        }
+        miniBP.SetOldLevel();
+        var progressList = miniBP.ProgressList;
+        int nextlv = miniBP.rewardIndex + 1;
+        if (nextlv < progressList.Count)
+        {
+            int startExp = 0;
+            if (nextlv > 0)
+            {
+                startExp = progressList[nextlv - 1];
+            }
+            curExp = miniBP.Data.Exp - startExp;
+
+            curMax = progressList[nextlv] - startExp;
+            text_num_bar.text = $"{curExp}/{curMax}";
+            bar.fillAmount = curExp / (float)curMax;
+            text_level.text = nextlv.ToString();
+        }
+        else
+        {
+            bar.fillAmount = 1f;
+            text_num_bar.text = LocalizationMgr.GetText("UI_FishingRodPanel_Advanced_18");
+            text_level.text = miniBP.rewardIndex.ToString();
+        }
+
+        curAllExp = miniBP.Data.Exp;
+        ShowTimer();
+    }
+    private void OnEnable()
+    {
+        RedPointManager.Instance.AddRedPoint(HomeBtnMiniBP.redKey + Type, this);
+        SetRedPointState(RedPointManager.Instance.GetRedPointState(HomeBtnMiniBP.redKey + Type));
+    }
+
+    /// <summary>
+    /// 资源飞入
+    /// </summary>
+    /// <param name="classification"></param>
+    /// <returns></returns>
+    public async System.Threading.Tasks.Task ParticleAttractor(int showCount)
+    {
+        ParticleSystem particleSystem = fx.transform.Find("Scale/quan03").GetComponent<ParticleSystem>();
+        if (particleSystem != null)
+        {
+            particleSystem.Clear();
+
+            var main = particleSystem.main;
+            int maxCount = main.maxParticles;
+            if (showCount < maxCount)
+            {
+                int addCount = (int)showCount;
+                main.maxParticles = addCount;
+            }
+            fx.SetActive(true);
+            uIParticleAttractor.enabled = true;
+            await Awaiters.Seconds(1.8f);
+            fx.SetActive(false);
+            uIParticleAttractor.enabled = false;
+        }
+    }
+
+    /// <summary>
+    /// 资源飞入之后
+    /// </summary>
+    public async void PlayUpBar()
+    {
+        int offset = miniBP.Data.Exp - curAllExp;
+        if (offset <= 0)
+        {
+            return;
+        }
+        curAllExp = miniBP.Data.Exp;
+        canvasGroup.blocksRaycasts = false;
+        await ParticleAttractor(offset);
+
+        int oldLv = miniBP.Data.showIndex;
+        int curLv = miniBP.rewardIndex;
+        if (curLv > oldLv)
+        {
+            miniBP.SetOldLevel();
+            for (int i = oldLv + 1; i < curLv; i++)
+            {
+                text_level.text = i.ToString();
+                bar.DOFillAmount(1f, _fillTime).OnUpdate(
+                     () =>
+                     {
+                         var curExp = bar.fillAmount * curMax;
+                         text_num_bar.text = $"{(int)curExp}/{curMax}";
+                     }
+                     );
+                await Awaiters.Seconds(_fillTime);
+                int startExp = 0;
+                if (i > 0)
+                {
+                    startExp = miniBP.ProgressList[i - 1];
+                }
+                curMax = miniBP.ProgressList[i] - startExp;
+                text_num_bar.text = $"{0}/{curMax}";
+                bar.fillAmount = 0;
+            }
+            text_level.text = curLv.ToString();
+            bar.DOFillAmount(1f, _fillTime).OnUpdate(
+                     () =>
+                     {
+                         var curExp = bar.fillAmount * curMax;
+                         text_num_bar.text = $"{(int)curExp}/{curMax}";
+                     }
+                     ).OnComplete(PlayUpBarEnd);
+        }
+        else if (curLv <= miniBP.ProgressList.Count - 1)
+        {
+            PlayBar(false);
+        }
+        else
+        {
+            canvasGroup.blocksRaycasts = true;
+        }
+    }
+    void PlayUpBarEnd()
+    {
+        bar.fillAmount = 0f;
+        curExp = 0;
+        PlayBar(true);
+    }
+    void PlayBar(bool openPanel)
+    {
+        var progressList = miniBP.ProgressList;
+        int nextlv = miniBP.rewardIndex + 1;
+
+        if (nextlv < progressList.Count)
+        {
+            text_num_bar.text = $"{curExp}/{curMax}";
+            bar.fillAmount = curExp / (float)curMax;
+            text_level.text = nextlv.ToString();
+            int startExp = 0;
+            if (nextlv > 0)
+            {
+                startExp = progressList[nextlv - 1];
+            }
+            curMax = progressList[nextlv] - startExp;
+            curExp = miniBP.Data.Exp - startExp;
+            if (curExp == 0)
+            {
+                if (openPanel)
+                {
+                    OnClickIn();
+                }
+                canvasGroup.blocksRaycasts = true;
+                return;
+            }
+            bar.DOFillAmount(curExp / (float)curMax, _fillTime)
+                .OnUpdate(
+                   () =>
+                   {
+                       var curExp = bar.fillAmount * curMax;
+                       text_num_bar.text = $"{(int)curExp}/{curMax}";
+                   }
+                   )
+                .OnComplete(
+                () =>
+                {
+                    text_num_bar.text = $"{curExp}/{curMax}";
+                    bar.fillAmount = curExp / (float)curMax;
+                    if (openPanel)
+                    {
+                        OnClickIn();
+                    }
+                    canvasGroup.blocksRaycasts = true;
+                });
+        }
+        else
+        {
+            bar.fillAmount = 1f;
+            text_num_bar.text = LocalizationMgr.GetText("UI_FishingRodPanel_Advanced_18");
+            text_level.text = miniBP.rewardIndex.ToString();
+            if (openPanel)
+            {
+                OnClickIn();
+            }
+            canvasGroup.blocksRaycasts = true;
+        }
+    }
+    public void SetRedPointState(bool state)
+    {
+        if (redpoint_big != null && text_redpoint_big != null)
+        {
+            if (!state)
+            {
+                redpoint_big.SetActive(false);
+            }
+            else
+            {
+                int count = RedPointManager.Instance.GetRedPointCount(HomeBtnMiniBP.redKey + Type);
+                if (count > 1)
+                {
+                    redpoint_big.SetActive(true);
+                    if (count > 99)
+                    {
+                        text_redpoint_big.text = "99+";
+                    }
+                    else
+                    {
+                        text_redpoint_big.text = count.ToString();
+                    }
+                    state = false;
+                }
+                else
+                {
+                    redpoint_big.SetActive(false);
+                }
+            }
+        }
+        redpoint.SetActive(state);
+    }
+
+    void OnClickIn()
+    {
+        UIManager.Instance.ShowUILoad(new UIType(miniBP.PanelName));
+    }
+
+    void ShowTimer()
+    {
+        //剩余时间
+        TimeSpan duration = miniBP.endTime - ZZTimeHelper.UtcNow();
+        text_time.text = ConvertTools.ConvertTime2(duration);
+        timerDisposable = Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(UpdateTimer);
+    }
+    private void UpdateTimer(long _ = 0L)
+    {
+        text_time.text = ConvertTools.ConvertTime2(miniBP.endTime - ZZTimeHelper.UtcNow());
+        if (!miniBP.IsShow())
+        {
+            Refresh();
+        }
+    }
+    protected void Refresh()
+    {
+        gameObject.SetActive(false);
+        GContext.container.Resolve<FishingEventData>().GetEventAndInit(9, 3);
+        OnInit();
+    }
+
+    private void OnDisable()
+    {
+        RedPointManager.Instance.RemoveRedPoint(HomeBtnMiniBP.redKey + Type);
+
+    }
+    private void OnDestroy()
+    {
+        if (timerDisposable != null)
+        {
+            timerDisposable.Dispose();
+            timerDisposable = null;
+        }
+    }
+}

Assets/Scripts/MiniBP/UI/MapBtnMiniBP.cs.meta

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

Assets/Scripts/MiniBP/UI/MiniBattlePassCardPanel.cs

@@ -0,0 +1,92 @@
+
+using asap.core;
+using cfg;
+using GameCore;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class MiniBattlePassCardPanel : MiniBattlePassFirstPanel
+{
+    protected override MiniBattlePassType Type => MiniBattlePassType.Fishcard;
+    protected override int showCount => 3;
+
+    Image bar;
+    TMP_Text text_num_bar;
+    TMP_Text text_num_level;
+    Button btn_questionmark;
+    GameObject info_tips;
+    Button btn_close_tips;
+    TMP_Text text_content;
+
+    TMP_Text exp_text_num;
+    TMP_Text source_text;
+    TMP_Text convert_text;
+    Image convert_icon;
+    protected override void Awake()
+    {
+        base.Awake();
+        bar = transform.Find("root/bar/bg_bar/bar").GetComponent<Image>();
+        text_num_bar = transform.Find("root/bar/bg_bar/text_num").GetComponent<TMP_Text>();
+        text_num_level = transform.Find("root/bar/level/text_num").GetComponent<TMP_Text>();
+        btn_questionmark = transform.Find("root/btn_questionmark").GetComponent<Button>();
+        info_tips = transform.Find("root/info_tips").gameObject;
+        btn_close_tips = info_tips.transform.Find("btn_close").GetComponent<Button>();
+        text_content = info_tips.transform.Find("item/text_content").GetComponent<TMP_Text>();
+        exp_text_num = transform.Find("root/ScrollView/Viewport/Content/panel_gift_final/money/position/money/text_num").GetComponent<TMP_Text>();
+        source_text = transform.Find("root/ScrollView/Viewport/Content/panel_gift_final/money/position/transform/icon_exp/text_num").GetComponent<TMP_Text>();
+        convert_text = transform.Find("root/ScrollView/Viewport/Content/panel_gift_final/money/position/transform/icon_money/text_num").GetComponent<TMP_Text>();
+        convert_icon = transform.Find("root/ScrollView/Viewport/Content/panel_gift_final/money/position/transform/icon_money").GetComponent<Image>();
+        timerFormat = "{0}";
+    }
+    protected override void Start()
+    {
+        base.Start();
+        if (miniBP.OverFlow.Count >= 3)
+        {
+            convert_text.text = miniBP.OverFlow[1].ToString();
+            source_text.text = miniBP.OverFlow[0].ToString();
+            Item item = GContext.container.Resolve<Tables>().TbItem.GetOrDefault(miniBP.OverFlow[2]);
+            GContext.container.Resolve<IUIService>().SetImageSprite(convert_icon, item.Icon);
+        }
+        else
+        {
+            Debug.LogError("MiniBattlePassCardPanel: OverFlow count is less than 3, check the data.");
+        }
+        var progressList = miniBP.ProgressList;
+        int nextlv = miniBP.rewardIndex + 1;
+        if (nextlv < progressList.Count)
+        {
+            int startExp = 0;
+            if (nextlv > 0)
+            {
+                startExp = progressList[nextlv - 1];
+            }
+            int curExp = miniBP.Data.Exp - startExp;
+            int curMax = progressList[nextlv] - startExp;
+            text_num_bar.text = $"{curExp}/{curMax}";
+            bar.fillAmount = curExp / (float)curMax;
+            text_num_level.text = nextlv.ToString();
+            exp_text_num.text = "0";
+        }
+        else
+        {
+            exp_text_num.text = $"{miniBP.Data.Exp - progressList[^1]}";
+            bar.fillAmount = 1f;
+            text_num_bar.text = LocalizationMgr.GetText("UI_FishingRodPanel_Advanced_18");
+            text_num_level.text = miniBP.rewardIndex.ToString();
+        }
+        btn_questionmark.onClick.AddListener(() =>
+        {
+            info_tips.SetActive(true);
+        });
+        info_tips.SetActive(false);
+        btn_close_tips.onClick.AddListener(() =>
+        {
+            info_tips.SetActive(false);
+        });
+        text_content.text = LocalizationMgr.GetFormatTextValue(miniBP.TaskDesc, miniBP.Param);
+        text_buy.text = LocalizationMgr.GetFormatTextValue("UI_MiniBattlePass_FishcardPanel_2", text_buy.text);
+    }
+}
+

Assets/Scripts/MiniBP/UI/MiniBattlePassCardPanel.cs.meta

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

Assets/Scripts/MiniBP/UI/MiniBattlePassFirstPanel.cs

@@ -0,0 +1,55 @@
+using DG.Tweening;
+using TMPro;
+using UnityEngine.UI;
+
+public class MiniBattlePassFirstPanel : MiniBattlePassPanel
+{
+    TMP_Text text_num;
+    protected Button btn_claim_n;
+    protected Button btn_claim_gray_n;
+    protected override int showCount => 4;
+
+    protected override void Awake()
+    {
+        base.Awake();
+
+        text_num = transform.Find("root/total_prize/reward/text_num").GetComponent<TMP_Text>();
+        btn_claim_n = transform.Find("root/bottom/buy/btn_claim/btn_green").GetComponent<Button>();
+        btn_claim_gray_n = transform.Find("root/bottom/buy/btn_claim_gray/btn_green").GetComponent<Button>();
+    }
+    protected override void Start()
+    {
+        btn_claim_n.onClick.AddListener(ClickClaimAll);
+        text_num.text = $"x{ConvertTools.GetNumberString(miniBP.ItemCountShow[0])}";
+        base.Start();
+    }
+
+    protected override void RefreshPanel()
+    {
+        base.RefreshPanel();
+        if (!miniBP.IsVip)
+        {
+            btn_claim_n.gameObject.SetActive(miniBP.Data.NRIndexs.Count <= miniBP.rewardIndex);
+            btn_claim_gray_n.gameObject.SetActive(miniBP.Data.NRIndexs.Count > miniBP.rewardIndex);
+        }
+
+    }
+
+    protected override void JumpToIndex()
+    {
+        int index = miniBP.Data.showIndex;
+        float startPos = 1 - (index * 1f / (miniBPItemDatas.Count - showCount));
+        if (startPos > 1f) startPos = 1f;
+        if (startPos < 0f) startPos = 0f;
+        scrollRect.verticalNormalizedPosition = startPos;
+        if (miniBP.rewardIndex > index)
+        {
+            miniBP.SetOldLevel();
+            float endPos = 1 - (miniBP.rewardIndex * 1f / (miniBPItemDatas.Count - showCount));
+            if (endPos > 1f) endPos = 1f;
+            if (endPos < 0f) endPos = 0f;
+            scrollRect.DOVerticalNormalizedPos(endPos, 0.5f);
+        }
+    }
+}
+

Assets/Scripts/MiniBP/UI/MiniBattlePassFirstPanel.cs.meta

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

Assets/Scripts/MiniBP/UI/MiniBattlePassItem.cs

@@ -0,0 +1,83 @@
+
+using asap.core;
+using GameCore;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public interface IMiniBattlePassItem
+{
+    void Init(MiniBPItemData bpItemFirstData, MiniBattlePassDataModel miniBP);
+    void Refresh();
+    void UnlockRefresh();
+}
+public class MiniBattlePassItem : MonoBehaviour, IMiniBattlePassItem
+{
+    public GameObject bg_normal;
+    public GameObject bg_done;
+    public RewardItemNew grandReward;
+    public GameObject grandClaimLocked;
+    public GameObject fx_unlocked;
+    public GameObject grandClaim;
+    public Button grandClaimBtn;
+    public TMP_Text text_task;
+    public Image bar;
+    public TMP_Text text_bar;
+    protected MiniBattlePassDataModel miniBP;
+    protected bool isClaim;
+
+    protected virtual void Start()
+    {
+        grandClaimBtn.onClick.AddListener(ClickGrandClaim);
+    }
+    private void ClickLock()
+    {
+        if (isClaim)
+        {
+            ToastPanel.Show(LocalizationMgr.GetText("UI_ToastPanel_106"));
+        }
+    }
+
+    public MiniBPItemData data;
+
+    public virtual void Init(MiniBPItemData bpItemFirstData, MiniBattlePassDataModel miniBP)
+    {
+        if (bpItemFirstData == null)
+        {
+            return;
+        }
+        this.miniBP = miniBP;
+        this.data = bpItemFirstData;
+        isClaim = bpItemFirstData.progress >= bpItemFirstData.maxProgress;
+        text_bar.text = $"{bpItemFirstData.progress}/{bpItemFirstData.maxProgress}";
+        bar.fillAmount = (float)bpItemFirstData.progress / bpItemFirstData.maxProgress;
+        grandReward.SetData(bpItemFirstData.grandReward);
+        text_task.text = bpItemFirstData.taskName;
+        bg_normal.SetActive(!isClaim);
+        Refresh();
+    }
+
+    public virtual void Refresh()
+    {
+        grandClaimLocked.gameObject.SetActive(!data.isGrandReward);
+    }
+    public void UnlockRefresh()
+    {
+        fx_unlocked.SetActive(true);
+    }
+    private void ClickGrandClaim()
+    {
+        if (data.isGrandReward)
+        {
+            //领取付费奖励的逻辑
+            miniBP.ReceiveReward(data.index, false);
+            //Refresh();
+            GContext.Publish(new RefreshPanelEvent());
+        }
+        else
+        {
+            ToastPanel.Show(LocalizationMgr.GetText("UI_ToastPanel_106"));
+        }
+    }
+}
+

Assets/Scripts/MiniBP/UI/MiniBattlePassItem.cs.meta

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

Assets/Scripts/MiniBP/UI/MiniBattlePassItemFirst.cs

@@ -0,0 +1,54 @@
+using asap.core;
+using GameCore;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class MiniBattlePassItemFirst : MiniBattlePassItem
+{
+    public GameObject grandClaimed;
+    public RewardItemNew freeReward;
+    public GameObject freeClaim;
+    public Button freeClaimBtn;
+    public GameObject freeClaimed;
+
+    protected override void Start()
+    {
+        base.Start();
+        freeClaimBtn.onClick.AddListener(() =>
+        {
+            miniBP.ReceiveReward(data.index, true);
+            //Refresh();
+            GContext.Publish(new RefreshPanelEvent());
+        });
+    }
+    public override void Init(MiniBPItemData bpItemFirstData, MiniBattlePassDataModel miniBP)
+    {
+        base.Init(bpItemFirstData, miniBP);
+        freeReward.SetData(bpItemFirstData.freeReward);
+        bg_done.SetActive(isClaim);
+    }
+    /// <summary>
+    /// 购买VIP 或 领奖之后刷新界面
+    /// </summary>
+    public override void Refresh()
+    {
+        base.Refresh();
+        freeClaim.SetActive(!data.isFreeClaimed && isClaim);
+        freeClaimed.SetActive(data.isFreeClaimed);
+        grandClaim.SetActive(data.isGrandReward && !data.isGrandClaimed && isClaim);
+        grandClaimed.SetActive(data.isGrandClaimed);
+    }
+}
+
+public class MiniBPItemData
+{
+    public int index;
+    public int progress;
+    public int maxProgress;
+    public string taskName;
+    public ItemData freeReward;
+    public ItemData grandReward;
+    public bool isGrandReward;
+    public bool isGrandClaimed;
+    public bool isFreeClaimed;
+}

Assets/Scripts/MiniBP/UI/MiniBattlePassItemFirst.cs.meta

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

Assets/Scripts/MiniBP/UI/MiniBattlePassItemFishCard.cs

@@ -0,0 +1,97 @@
+
+using asap.core;
+using GameCore;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class MiniBattlePassItemFishCard : MonoBehaviour, IMiniBattlePassItem
+{
+    public GameObject tag_normal_mask;
+    public TMP_Text text_num_normal;
+    public GameObject tag_current;
+    public TMP_Text text_num_current;
+    public GameObject tag_first;
+    public RewardItemNew freeReward;
+    public GameObject freeClaim;
+    public Button freeClaimBtn;
+    public RewardItemNew grandReward;
+    public GameObject grandClaimLocked;
+    public GameObject fx_unlocked;
+    public GameObject grandClaim;
+    public Button grandClaimBtn;
+    protected MiniBattlePassDataModel miniBP;
+    protected bool isClaim;
+    MiniBPItemData data;
+    protected void Start()
+    {
+        grandClaimBtn.onClick.AddListener(ClickGrandClaim);
+        freeClaimBtn.onClick.AddListener(() =>
+        {
+            miniBP.ReceiveReward(data.index, true);
+            //Refresh();
+            GContext.Publish(new RefreshPanelEvent());
+        });
+    }
+    private void ClickLock()
+    {
+        if (isClaim)
+        {
+            ToastPanel.Show(LocalizationMgr.GetText("UI_ToastPanel_106"));
+        }
+    }
+
+    public void Init(MiniBPItemData bpItemFirstData, MiniBattlePassDataModel miniBP)
+    {
+        if (bpItemFirstData == null)
+        {
+            return;
+        }
+        this.miniBP = miniBP;
+        this.data = bpItemFirstData;
+        isClaim = bpItemFirstData.progress >= bpItemFirstData.maxProgress;
+
+        grandReward.SetData(bpItemFirstData.grandReward);
+        //text_task.text = bpItemFirstData.taskName;
+        if (bpItemFirstData.freeReward != null)
+        {
+            freeReward.SetData(bpItemFirstData.freeReward);
+        }
+        tag_normal_mask.SetActive(!isClaim);
+        tag_first.SetActive(data.index == 0);
+        tag_current.SetActive(data.index == miniBP.rewardIndex);
+        text_num_current.text = text_num_normal.text = data.index.ToString();
+        Refresh();
+    }
+
+    public void Refresh()
+    {
+        grandClaimLocked.gameObject.SetActive(!data.isGrandReward);
+        grandClaim.SetActive(data.isGrandReward && !data.isGrandClaimed && isClaim);
+        grandClaimBtn.gameObject.SetActive(data.isGrandReward && !data.isGrandClaimed && isClaim);
+        freeClaim.SetActive(!data.isFreeClaimed && isClaim);
+        freeClaimBtn.gameObject.SetActive(!data.isFreeClaimed && isClaim);
+        grandReward.SetReceived(data.isGrandClaimed);
+        freeReward.SetReceived(data.isFreeClaimed);
+    }
+    public void UnlockRefresh()
+    {
+        fx_unlocked.SetActive(true);
+    }
+    private void ClickGrandClaim()
+    {
+        if (data.isGrandReward)
+        {
+            //领取付费奖励的逻辑
+            miniBP.ReceiveReward(data.index, false);
+            //Refresh();
+            GContext.Publish(new RefreshPanelEvent());
+        }
+        else
+        {
+            ToastPanel.Show(LocalizationMgr.GetText("UI_ToastPanel_106"));
+        }
+    }
+
+}
+

Assets/Scripts/MiniBP/UI/MiniBattlePassItemFishCard.cs.meta

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

Assets/Scripts/MiniBP/UI/MiniBattlePassItemSecond.cs

@@ -0,0 +1,26 @@
+using GameCore;
+using UnityEngine;
+
+public class MiniBattlePassItemSecond : MiniBattlePassItem
+{
+    public GameObject current;
+    public GameObject bg_cliam;
+
+    public override void Init(MiniBPItemData bpItemFirstData, MiniBattlePassDataModel miniBP)
+    {
+        base.Init(bpItemFirstData, miniBP);
+        bg_cliam.SetActive(isClaim);
+        current.SetActive(data.index == miniBP.rewardIndex + 1);
+    }
+    /// <summary>
+    /// 购买VIP 或 领奖之后刷新界面
+    /// </summary>
+    public override void Refresh()
+    {
+        base.Refresh();
+        grandClaim.SetActive(!data.isGrandClaimed && isClaim);
+        bg_done.SetActive(data.isGrandClaimed);
+    }
+
+}
+

Assets/Scripts/MiniBP/UI/MiniBattlePassItemSecond.cs.meta

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

Assets/Scripts/MiniBP/UI/MiniBattlePassPanel.cs

@@ -0,0 +1,202 @@
+using asap.core;
+using game;
+using GameCore;
+using System;
+using System.Collections.Generic;
+using TMPro;
+using UniRx;
+using UnityEngine;
+using UnityEngine.UI;
+public struct RefreshPanelEvent
+{
+}
+public class MiniBattlePassPanel : MonoBehaviour
+{
+    protected virtual MiniBattlePassType Type => MiniBattlePassType.LuckMagic;
+    protected MiniBattlePassDataModel miniBP;
+    Button btn_close;
+    TMP_Text text_time;
+    GameObject buy;
+    Button btn_buy;
+    Button btn_claim;
+    Button btn_claim_gray;
+    GameObject claim;
+    GameObject done;
+    protected TMP_Text text_buy;
+
+    protected GameObject item;
+    protected RectTransform contentRect;
+    protected Transform content;
+    protected ScrollRect scrollRect;
+    protected VerticalLayoutGroup layoutGroup;
+    int addSizeDelta;
+    int startAdd;
+    protected float itemHeight = 164f;
+    protected float allHeight = 0f;
+    protected virtual int showCount => 2;
+
+    protected List<MiniBPItemData> miniBPItemDatas;
+    List<IMiniBattlePassItem> miniBattlePassItems = new List<IMiniBattlePassItem>();
+    protected CompositeDisposable disposables = new CompositeDisposable();
+    protected string timerFormat;
+    protected virtual void Awake()
+    {
+        miniBP = GContext.container.Resolve<MiniBattlePassDataProvider>().GetModel(Type);
+
+        miniBP.SetPanelData();
+        item = transform.Find("root/ScrollView/Viewport/Content/item").gameObject;
+        item.SetActive(false);
+        scrollRect = transform.Find("root/ScrollView").GetComponent<ScrollRect>();
+        content = transform.Find("root/ScrollView/Viewport/Content");
+        contentRect = content.GetComponent<RectTransform>();
+        layoutGroup = content.GetComponent<VerticalLayoutGroup>();
+        float spacing = layoutGroup.spacing;
+        addSizeDelta = layoutGroup.padding.vertical;
+        startAdd = layoutGroup.padding.top;
+        itemHeight = item.GetComponent<RectTransform>().sizeDelta.y + spacing;
+
+        btn_close = transform.Find("root/btn_close").GetComponent<Button>();
+        text_time = transform.Find("root/bg_time/text_time").GetComponent<TMP_Text>();
+        buy = transform.Find("root/bottom/buy").gameObject;
+        btn_buy = transform.Find("root/bottom/buy/btn_buy/btn_green").GetComponent<Button>();
+        text_buy = transform.Find("root/bottom/buy/btn_buy/btn_green/Ani_Container/p_text").GetComponent<TMP_Text>();
+        claim = transform.Find("root/bottom/claim").gameObject;
+        btn_claim = transform.Find("root/bottom/claim/btn_claim/btn_green").GetComponent<Button>();
+        btn_claim_gray = transform.Find("root/bottom/claim/btn_claim_gray/btn_green").GetComponent<Button>();
+        done = transform.Find("root/bottom/done").gameObject;
+
+        timerFormat = LocalizationMgr.GetText("UI_COMMON_end");
+        GContext.OnEvent<RefreshPanelEvent>().Subscribe(_ =>
+        {
+            RefreshPanel();
+        }).AddTo(disposables);
+    }
+
+
+    protected virtual void Start()
+    {
+        btn_close.onClick.AddListener(OnClickClose);
+        btn_buy.onClick.AddListener(OnClickBuy);
+        btn_claim.onClick.AddListener(ClickClaimAll);
+        SetItem();
+        ShowTimer();
+        SetButtonShow();
+        RefreshPanel();
+        var _tables = GContext.container.Resolve<cfg.Tables>();
+        var _iapItem = miniBP.GetIAPItem();
+        SKUDetailDataEvent sKUDetailDataEvent = new SKUDetailDataEvent(_iapItem);
+        GContext.Publish(sKUDetailDataEvent);
+        text_buy.text = sKUDetailDataEvent.price;
+        miniBP.CheckIfGetLastBpRewards();
+    }
+
+
+    protected void SetButtonShow()
+    {
+        buy.SetActive(!miniBP.IsVip);
+        claim.SetActive(miniBP.IsVip && !miniBP.IsDone());
+        done.SetActive(miniBP.IsDone());
+    }
+
+    async void OnClickBuy()
+    {
+        if (miniBP.IsVip)
+        {
+            return;
+        }
+        bool Result = await miniBP.BuyBattlePass();
+        if (Result)
+        {
+            BuySuccess();
+        }
+    }
+
+    protected void BuySuccess()
+    {
+        buy.SetActive(false);
+        claim.SetActive(true);
+        done.SetActive(false);
+        RefreshPanel();
+
+        for (int i = 0; i < miniBattlePassItems.Count; i++)
+        {
+            miniBattlePassItems[i].UnlockRefresh();
+        }
+    }
+
+    protected void ClickClaimAll()
+    {
+        miniBP.ReceiveAllReward();
+        RefreshPanel();
+    }
+
+    void SetItem()
+    {
+        miniBPItemDatas = miniBP.miniBPItemDatas;
+        allHeight = miniBPItemDatas.Count * itemHeight + addSizeDelta;
+        contentRect.sizeDelta = new Vector2(contentRect.sizeDelta.x, allHeight);
+        for (int i = 0; i < miniBPItemDatas.Count; i++)
+        {
+            GameObject go = Instantiate(item, content);
+            go.SetActive(true);
+            IMiniBattlePassItem miniBattlePassItem = go.GetComponent<IMiniBattlePassItem>();
+            miniBattlePassItem.Init(miniBPItemDatas[i], miniBP);
+            miniBattlePassItems.Add(miniBattlePassItem);
+        }
+        JumpToIndex();
+    }
+
+    protected virtual void JumpToIndex()
+    {
+
+    }
+
+    protected virtual void RefreshPanel()
+    {
+        if (miniBP.IsVip)
+        {
+            bool isShowAllBtn = miniBP.Data.VRIndexs.Count <= miniBP.rewardIndex;
+            if (miniBP.FreeRewards.Count > 0)
+            {
+                isShowAllBtn |= miniBP.Data.NRIndexs.Count <= miniBP.rewardIndex;
+            }
+
+            btn_claim.gameObject.SetActive(isShowAllBtn);
+            btn_claim_gray.gameObject.SetActive(!isShowAllBtn);
+        }
+
+        for (int i = 0; i < miniBattlePassItems.Count; i++)
+        {
+            miniBattlePassItems[i].Refresh();
+        }
+    }
+
+    void ShowTimer()
+    {
+        //剩余时间
+        TimeSpan duration = miniBP.endTime - ZZTimeHelper.UtcNow();
+
+        text_time.text = string.Format(timerFormat, ConvertTools.ConvertTime2(duration));
+        var timer = Observable.Interval(TimeSpan.FromSeconds(1))
+                              .TakeWhile(seconds => seconds <= duration.TotalSeconds)
+                              .Subscribe(seconds => text_time.text =
+                                            string.Format(timerFormat, ConvertTools.ConvertTime2(duration.Subtract(TimeSpan.FromSeconds(seconds))))
+                                             , Refresh)
+                              .AddTo(disposables);
+    }
+
+    protected void Refresh()
+    {
+        OnClickClose();
+    }
+
+    void OnClickClose()
+    {
+        UIManager.Instance.DestroyUI(gameObject.name);
+    }
+    private void OnDestroy()
+    {
+        disposables?.Dispose();
+        disposables = null;
+    }
+}

Assets/Scripts/MiniBP/UI/MiniBattlePassPanel.cs.meta

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

Assets/Scripts/MiniBP/UI/MiniBattlePassSecondPanel.cs

@@ -0,0 +1,72 @@
+using DG.Tweening;
+using Spine.Unity;
+using TMPro;
+using UnityEngine;
+
+public class MiniBattlePassSecondPanel : MiniBattlePassPanel
+{
+    //TMP_Text text_num;
+    TMP_Text text_num1;
+    Transform spineRoot;
+    SkeletonGraphic spine;
+    RewardItemNew reward;
+    protected override MiniBattlePassType Type => MiniBattlePassType.Dive;
+
+    protected override int showCount => 5;
+    protected override void Awake()
+    {
+        base.Awake();
+        reward = transform.Find("root/total_prize/bg/reward").GetComponent<RewardItemNew>();
+        spineRoot = transform.Find("root/ScrollView/Viewport/Content/spineRoot");
+        spine = transform.Find("root/ScrollView/Viewport/Content/spineRoot/spine").GetComponent<SkeletonGraphic>();
+
+        //text_num = transform.Find("root/total_prize/bg/reward/text_num").GetComponent<TMP_Text>();
+        text_num1 = transform.Find("root/total_prize/reward/text_num").GetComponent<TMP_Text>();
+    }
+    protected override void Start()
+    {
+        reward.SetData(miniBP.ItemShow[0], $"x{ConvertTools.GetNumberString(miniBP.ItemCountShow[0])}", true);
+        //text_num.text = $"x{miniBP.ItemCountShow[0]}";
+        text_num1.text = $"x{ConvertTools.GetNumberString(miniBP.ItemCountShow[1])}";
+        base.Start();
+    }
+
+    protected override void JumpToIndex()
+    {
+        int index = miniBP.Data.showIndex;
+        float startPos = ((index - 2) * 1f / (miniBPItemDatas.Count - showCount));
+        if (startPos > 1f) startPos = 1f;
+        if (startPos < 0f) startPos = 0f;
+        scrollRect.verticalNormalizedPosition = startPos;
+        int spineIndex = miniBP.Data.showIndex;
+        if (spineIndex < miniBPItemDatas.Count - 1)
+        {
+            spineIndex++;
+        }
+        spineRoot.localPosition = new Vector3(spineRoot.localPosition.x, spineIndex * itemHeight, 0);
+        if (miniBP.rewardIndex > index)
+        {
+            miniBP.SetOldLevel();
+            float endPos = ((miniBP.rewardIndex - 2) * 1f / (miniBPItemDatas.Count - showCount));
+            if (endPos > 1f) endPos = 1f;
+            if (endPos < 0f) endPos = 0f;
+            spine.AnimationState.SetAnimation(0, "swimming_move", true);
+            scrollRect.DOVerticalNormalizedPos(endPos, 1).SetEase(Ease.Linear);
+            spineIndex = miniBP.rewardIndex;
+            if (spineIndex < miniBPItemDatas.Count - 1)
+            {
+                spineIndex++;
+            }
+            spineRoot.DOLocalMoveY(spineIndex * itemHeight, 1).OnComplete(() =>
+            {
+                spine.AnimationState.SetAnimation(0, "swimming_idle", true);
+            });
+        }
+        else
+        {
+            spine.AnimationState.SetAnimation(0, "swimming_idle", true);
+        }
+    }
+}
+
+

Assets/Scripts/MiniBP/UI/MiniBattlePassSecondPanel.cs.meta

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