bingo 项目提交

Assets/BingoBrain/System/Game.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 77c9a25febe54dffbb6afade123b3a42
+timeCreated: 1692267362

Assets/BingoBrain/System/Game/BingoDataSystem.cs

@@ -0,0 +1,661 @@
+using System;
+using BingoBrain.Core;
+using UnityEngine;
+using BingoBrain.HotFix;
+using System.Text;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace BingoBrain
+{
+    public class BingoDataSystem : BaseSystem
+    {
+        private Action onChangeDollar;
+
+        private Action onChangeGiftSwitch;
+
+        public BingoDataSystem(bool isAutoInit = true)
+        {
+            if (isAutoInit)
+            {
+                Init();
+            }
+        }
+
+        public sealed override void Init()
+        {
+            base.Init();
+
+            AddListener();
+        }
+
+        private void AddListener()
+        {
+            CtrlDispatcher.Instance.AddPriorityListener(CtrlMsg.Game_StartBefore, InitPreferences);
+            PreferencesDispatcher<int>.Instance.AddListener(PreferencesMsg.currency101, Add101);
+            PreferencesDispatcher<decimal>.Instance.AddListener(PreferencesMsg.currency102, Add102);
+            PreferencesDispatcher<bool>.Instance.AddListener(PreferencesMsg.isShowRewardFly101, OnChangeRewardFly101);
+            PreferencesDispatcher<bool>.Instance.AddListener(PreferencesMsg.isShowRewardFly102, OnChangeRewardFly102);
+            CtrlDispatcher.Instance.AddListener(CtrlMsg.ResetDailyTaskActive, ResetDailyTaskActive);
+            CtrlDispatcher.Instance.AddListener(CtrlMsg.GameNewDays, NewDay);
+            CtrlDispatcher.Instance.AddListener(CtrlMsg.Module_GiftSwitchChange, OnChangeGiftSwitch);
+            CtrlDispatcher.Instance.AddListener(CtrlMsg.WatchVideoFinish, AddWatchVideo);
+            GameDispatcher.Instance.AddListener(BingoInfo.ProcessReward, OnGetReward);
+            GameDispatcher.Instance.AddListener(BingoInfo.RefreshMakeupData, AddMakeupTaskData);
+            GameDispatcher.Instance.AddListener(BingoInfo.RefreshMakeupData, CheckCoinMakeupTaskData);
+        }
+        public static void AddMakeupTaskData(object a = null)
+        {
+            var makeupVOModel = ConfigSystem.GetConfig<MakeupModel>();
+            if (makeupVOModel == null || makeupVOModel.dataList == null || makeupVOModel.dataList.Count <= 0)
+            {
+                return;
+            }
+
+Debug.Log("????????????????????????3");
+            var lastId = -1;
+
+            var isRepeat = PreferencesMgr.Instance.MakeupTaskHistory.Count >= makeupVOModel.dataList.Count;
+            if (PreferencesMgr.Instance.MakeupTaskHistory.Count > 0)
+            {
+                var makeupTaskData = PreferencesMgr.Instance.MakeupTaskHistory.Last();
+
+                if (makeupTaskData.status != MakeupTaskStatus.Inline)
+                {
+                    return;
+                }
+
+                lastId = makeupTaskData.tableId;
+            }
+
+
+            if (lastId == makeupVOModel.dataList.Last().id)
+            {
+                lastId = -1;
+            }
+
+            foreach (var makeupVo in makeupVOModel.dataList)
+            {
+                if (makeupVo.id > lastId)
+                {
+                    if ((isRepeat && !makeupVo.is_onetime) || !isRepeat)
+                    {
+                        var makeupTaskData = new MakeupTaskData();
+                        makeupTaskData.tableId = makeupVo.id;
+                        makeupTaskData.id = PreferencesMgr.Instance.MakeupTaskHistory.Count + 1;
+                        makeupTaskData.amountStr = $"{makeupVo.item_need}";
+                        makeupTaskData.amount = makeupVo.item_need;
+                        makeupTaskData.orderID = GetRandomNum(8);
+
+                        PreferencesMgr.Instance.MakeupTaskHistory.Add(makeupTaskData);
+                        makeupTaskData.SetStatus(MakeupTaskStatus.None);
+                        PreferencesMgr.Instance.SaveMakeupTaskHistory();
+
+                        PreferencesMgr.Instance.MakeupTaskH5Time = 0;
+                        break;
+                    }
+                }
+            }
+        }
+        public static void CheckMakeupTaskData()
+        {
+            Debug.Log("????????????????????????1");
+            if (!GameHelper.IsGiftSwitch())
+            {
+                return;
+            }
+
+
+            if (PreferencesMgr.Instance.MakeupTaskHistory.Count == 0)
+            {
+                AddMakeupTaskData();
+            }
+            else
+            {
+                Debug.Log("????????????????????????2");
+                var common = ConfigSystem.GetConfig<CommonModel>();
+                var userId = GameHelper.GetLoginModel().uid;
+                foreach (var makeuptaskData in PreferencesMgr.Instance.MakeupTaskHistory)
+                {
+                    if (makeuptaskData.status == MakeupTaskStatus.Inline
+                        && makeuptaskData.inlineNum > common.inlineMin)
+                    {
+                        var redeemVOModel = ConfigSystem.GetConfig<MakeupModel>().dataList
+                   .FirstOrDefault(redeem => redeem.id == makeuptaskData.tableId);
+
+                        var days = PlayerPrefs.GetInt($"days_{userId}_{makeuptaskData.tableId}", 0);
+                        Debug.Log("------------------" + days);
+                        Debug.Log("------------------" + DateTime.Today.Day);
+                        if (days == DateTime.Today.Day)
+                        {
+                            continue;
+                        }
+
+                        PlayerPrefs.SetInt($"days_{userId}_{makeuptaskData.tableId}", DateTime.Today.Day);
+                        var loginNum = UnityEngine.Random.Range(common.inlineLoginDown[0],
+                            common.inlineLoginDown[1]);
+                        makeuptaskData.loginSpeedNum += loginNum;
+                        //如果登录减少人数大于配置的阈值，则不能减少排名了
+                        Debug.Log($"登录累计增加的排名为：{makeuptaskData.loginSpeedNum} 阈值为：{redeemVOModel.Login_Limit_times}");
+                        if (makeuptaskData.loginSpeedNum > redeemVOModel.Login_Limit_times)
+                        {
+                            makeuptaskData.loginSpeedNum = redeemVOModel.Login_Limit_times;
+                            continue;
+                        }
+
+                        Debug.Log($"订单为： {makeuptaskData.tableId} 通过登录减少的排名为：{loginNum}");
+                        makeuptaskData.inlineNum -= loginNum;
+                        if (makeuptaskData.inlineNum < common.inlineMin)
+                        {
+                            makeuptaskData.inlineNum = common.inlineMin;
+                        }
+                    }
+                }
+
+                PreferencesMgr.Instance.SaveMakeupTaskHistory();
+            }
+            if (SaveData.GetSaveobject().saveingpot_history.Count == 0)
+            {
+                // Debug.Log("tianjialishiiiiiiiiiiiiii");
+                // AddMakeupTaskData();
+            }
+            else
+            {
+                var common = ConfigSystem.GetConfig<CommonModel>();
+                foreach (var makeuptaskData in SaveData.GetSaveobject().saveingpot_history)
+                {
+                    if (makeuptaskData.status == SaveingPotTaskStatus.Inline
+                        && makeuptaskData.inlineNum > common.inlineMin)
+                    {
+
+
+
+                        var redeemVOModel = ConfigSystem.GetConfig<MakeupModel_2>().dataList
+                  .FirstOrDefault(redeem => redeem.id == makeuptaskData.tableId);
+
+                        var days = PlayerPrefs.GetInt($"days__{makeuptaskData.tableId}_pot", 0);
+                        if (days == DateTime.Today.Day)
+                        {
+                            continue;
+                        }
+
+                        PlayerPrefs.SetInt($"days__{makeuptaskData.tableId}_pot", DateTime.Today.Day);
+                        var loginNum = UnityEngine.Random.Range(common.inlineLoginDown[0],
+                            common.inlineLoginDown[1]);
+                        makeuptaskData.loginSpeedNum += loginNum;
+                        //如果登录减少人数大于配置的阈值，则不能减少排名了
+                        // Debug.Log($"登录累计增加的排名为：{makeuptaskData.loginSpeedNum} 阈值为：{redeemVOModel.Login_Limit_times}");
+                        if (makeuptaskData.loginSpeedNum > redeemVOModel.Login_Limit_times)
+                        {
+                            makeuptaskData.loginSpeedNum = redeemVOModel.Login_Limit_times;
+                            continue;
+                        }
+
+                        //Debug.Log($"订单为： {makeuptaskData.tableId} 通过登录减少的排名为：{loginNum}");
+                        makeuptaskData.inlineNum -= loginNum;
+                        if (makeuptaskData.inlineNum < common.inlineMin)
+                        {
+                            makeuptaskData.inlineNum = common.inlineMin;
+                        }
+                    }
+                }
+            }
+            SaveData.saveDataFunc();
+        }
+        public static string GetRandomNum(int count)
+        {
+            var resultStr = new StringBuilder();
+            for (int i = 0; i < count; i++)
+            {
+                resultStr.Append(UnityEngine.Random.Range(0, 10));
+            }
+
+            return resultStr.ToString();
+        }
+        public void AddChangeGiftSwitch(Action action)
+        {
+            onChangeGiftSwitch += action;
+        }
+
+        public void RemoveChangeGiftSwitch(Action action)
+        {
+            onChangeGiftSwitch -= action;
+        }
+
+        private void OnChangeGiftSwitch(object obj)
+        {
+            onChangeGiftSwitch?.Invoke();
+        }
+
+
+        private void InitPreferences(object obj)
+        {
+
+            if (PreferencesMgr.Instance.Currency101 == -1)
+            {
+                PreferencesMgr.Instance.Currency101 = GameHelper.GetCommonModel().Initial101;
+                GameDispatcher.Instance.Dispatch(BingoInfo.Update101Completed);
+            }
+
+            if (PreferencesMgr.Instance.CardBoardSum == -1 ||
+                (PreferencesMgr.Instance.CardBoardSum == 0 && PlayerPrefs.GetInt("First", 0) == 0))
+            {
+                PreferencesMgr.Instance.CardBoardSum = GameHelper.GetCommonModel().Fisrtcard[0];
+                Debug.Log("777777777777777777777777777");
+                //PlayerPrefs.SetInt("First", 1);
+            }
+
+            if (PreferencesMgr.Instance.Currency102 == -1)
+            {
+                PreferencesMgr.Instance.Currency102 = 0;
+            }
+
+
+            if (PreferencesMgr.Instance.DailyTaskState.Count == 0)
+            {
+                ResetDailyTaskActive();
+            }
+
+
+            if (PreferencesMgr.Instance.DailyTaskActiveState.Count == 0)
+            {
+                ResetDailyTaskActive();
+            }
+
+
+
+
+            if (PreferencesMgr.Instance.IsResetGuide)
+            {
+                PreferencesMgr.Instance.IsResetGuide = false;
+                PreferencesMgr.Instance.CompleteGuideList.Clear();
+                PreferencesMgr.Instance.SaveCompleteGuideList();
+            }
+
+            PreferencesMgr.Instance.IsShowRewardFly101 = false;
+            PreferencesMgr.Instance.IsShowRewardFly102 = false;
+            PreferencesMgr.Instance.IsShowRewardFly105 = false;
+            PreferencesMgr.Instance.IsShowRewardFly106 = false;
+
+            CheckCoinMakeupTaskData();
+            CheckMakeupTaskData();
+            PreferencesMgr.Instance.IsShowOpenReward = true;
+        }
+
+        private void Add101(ExiteValue<int> obj)
+        {
+            var val = obj.newValue - obj.oldValue;
+            if (val > 0)
+            {
+                PreferencesMgr.Instance.Max101 += val;
+            }
+
+            if (!PreferencesMgr.Instance.IsShowRewardFly101)
+            {
+                GameDispatcher.Instance.Dispatch(BingoInfo.Update101Completed);
+            }
+        }
+
+
+        private void Add102(ExiteValue<decimal> obj)
+        {
+            var val = obj.newValue - obj.oldValue;
+            if (val > 0)
+            {
+                PreferencesMgr.Instance.Max102 += val;
+            }
+
+            if (!PreferencesMgr.Instance.IsShowRewardFly102)
+            {
+                GameDispatcher.Instance.Dispatch(BingoInfo.Update102Completed);
+            }
+
+            onChangeDollar?.Invoke();
+        }
+
+        private void ResetDailyTaskActive(object obj = null)
+        {
+            PreferencesMgr.Instance.DailyTaskActiveState.Clear();
+            for (int i = 0; i < 2; i++)
+            {
+                PreferencesMgr.Instance.DailyTaskActiveState.Add(false);
+            }
+
+            PreferencesMgr.Instance.SaveDailyTaskActiveState();
+            PreferencesMgr.Instance.Active = 0;
+        }
+
+        private void NewDay(object obj)
+        {
+            PreferencesMgr.Instance.ToDayMaxScore = 0;
+            ResetDailyTaskActive();
+        }
+
+        private void AddWatchVideo(object obj = null)
+        {
+            if (PreferencesMgr.Instance.IsRealProcessing)
+            {
+                PreferencesMgr.Instance.RealWatchVideo++;
+            }
+            if (PreferencesMgr.Instance.MakeupTaskHistory.Count > 0)
+            {
+
+                CheckSpeedUpTaskData();
+
+                var taskData = PreferencesMgr.Instance.MakeupTaskHistory.Last();
+                if (taskData.status == MakeupTaskStatus.Task)
+                {
+                    var makeupVo = ConfigSystem.GetConfig<MakeupModel>().dataList.FirstOrDefault(card => card.id == taskData.tableId);
+                    if (makeupVo != null && taskData.videoCount < makeupVo.ad_need)
+                    {
+                        taskData.videoCount++;
+                        NetworkKit.BuriedPoint(BuriedPointEvent.ad_task, BuriedPointEvent.watch_ad_number, 1);
+                        PreferencesMgr.Instance.SaveMakeupTaskHistory();
+                        PlayerPrefs.SetInt("finish_ad_number", 0);
+                    }
+                    else
+                    {
+                        if (PlayerPrefs.GetInt("finish_ad_number", 0) == 0)
+                        {
+                            NetworkKit.BuriedPoint(BuriedPointEvent.ad_task, BuriedPointEvent.finish_ad_number, 1);
+                            PlayerPrefs.SetInt("finish_ad_number", 1);
+                        }
+
+                    }
+                }
+
+            }
+            if (PreferencesMgr.Instance.CoinMakeupTaskHistory.Count > 0)
+            {
+                var taskData = PreferencesMgr.Instance.CoinMakeupTaskHistory.Last();
+                if (taskData.status == MakeupTaskStatus.Task)
+                {
+                    var cardRedeemNewModel = ConfigSystem.GetConfig<CardRedeemNewModel>();
+                    var makeupVo = cardRedeemNewModel.dataList.FirstOrDefault(card => card.id == taskData.tableId);
+                    if (makeupVo != null && taskData.videoCount < makeupVo.fee_need)
+                    {
+                        taskData.videoCount++;
+                        PreferencesMgr.Instance.SaveCoinMakeupTaskHistory();
+                    }
+                }
+            }
+                       if (SaveData.GetSaveobject().saveingpot_history.Count > 0)
+            {
+                SaveingPotHelper.TestingClearTime();
+                CheckSpeedUpTaskData(2);
+                SaveingPotClass taskData = SaveData.GetSaveobject().saveingpot_history.Last();
+                makeup_2 makeupVo = ConfigSystem.GetConfig<MakeupModel_2>().GetData(taskData.tableId);
+                SaveData.GetSaveobject().saveingpot_cash += makeupVo.ADIncrease;
+                GameDispatcher.Instance.Dispatch(GameMsg.RefreshSaveingPot);
+                if (ConfigSystem.GetConfig<CommonModel>().PiggyBankSwitch == 1 && GameHelper.IsGiftSwitch())
+                {
+                    if ((SaveData.GetSaveobject().saveingpot_cash > taskData.amount) && (!taskData.auto_show) && !UI.Instance.IsExistUI(UIConst.H5UI))
+                    {
+
+                        UICtrlDispatcher.Instance.Dispatch(UICtrlMsg.SaveingPotUI_Open);
+                        taskData.auto_show = true;
+                    }
+                }
+
+                if (taskData.status == SaveingPotTaskStatus.Task)
+                {
+                    ;
+                    if (makeupVo != null && taskData.videoCount < makeupVo.ad_need)
+                    {
+                        taskData.videoCount++;
+                        //NetworkKit.BuriedPoint(BuriedPointEvent.ad_task, BuriedPointEvent.watch_ad_number, 1);
+                        PlayerPrefs.SetInt("fin_ad_num_saveingpot", 0);
+                    }
+                    else
+                    {
+                        if (PlayerPrefs.GetInt("fin_ad_num_saveingpot", 0) == 0)
+                        {
+                            //NetworkKit.BuriedPoint(BuriedPointEvent.ad_task, BuriedPointEvent.finish_ad_number, 1);
+                            PlayerPrefs.SetInt("fin_ad_num_saveingpot", 1);
+                        }
+
+                    }
+                }
+
+            }
+        }
+        public static void CheckCoinMakeupTaskData(object a = null)
+        {
+            if (!GameHelper.IsGiftSwitch())
+            {
+                return;
+            }
+            //if (PreferencesMgr.Instance.CoinMakeupTaskHistory == null) PreferencesMgr.Instance.CoinMakeupTaskHistory = new List<MakeupTaskData>();
+            MakeupTaskData taskData = null;
+            if (PreferencesMgr.Instance.CoinMakeupTaskHistory.Count != 0) taskData = PreferencesMgr.Instance.CoinMakeupTaskHistory.Last();
+            if (PreferencesMgr.Instance.CoinMakeupTaskHistory.Count == 0 || taskData.status == MakeupTaskStatus.Inline)
+            {
+                AddCoinMakeupTaskData();
+            }
+            else
+            {
+                foreach (var makeuptaskData in PreferencesMgr.Instance.CoinMakeupTaskHistory)
+                {
+                    if (makeuptaskData.status == MakeupTaskStatus.Inline
+                        && makeuptaskData.inlineNum > GameHelper.GetCommonModel().inlineMin)
+                    {
+                        makeuptaskData.inlineNum -= UnityEngine.Random.Range(
+                            GameHelper.GetCommonModel().inlineLoginDown[0],
+                            GameHelper.GetCommonModel().inlineLoginDown[1]);
+                        if (makeuptaskData.inlineNum < GameHelper.GetCommonModel().inlineMin)
+                        {
+                            makeuptaskData.inlineNum = GameHelper.GetCommonModel().inlineMin;
+                        }
+                    }
+                }
+
+                PreferencesMgr.Instance.SaveCoinMakeupTaskHistory();
+            }
+        }
+        public static void AddCoinMakeupTaskData()
+        {
+            var cardRedeemNewVOModel = ConfigSystem.GetConfig<CardRedeemNewModel>();
+
+            if (cardRedeemNewVOModel.dataList.Count <= 0)
+            {
+                return;
+            }
+
+
+            var lastId = -1;
+            if (PreferencesMgr.Instance.CoinMakeupTaskHistory.Count > 0)
+            {
+                var makeupTaskData = PreferencesMgr.Instance.CoinMakeupTaskHistory.Last();
+
+                if (makeupTaskData.status == MakeupTaskStatus.None
+                    || makeupTaskData.status == MakeupTaskStatus.Task)
+                {
+                    return;
+                }
+
+                lastId = makeupTaskData.tableId;
+            }
+
+
+            var lastVoId = cardRedeemNewVOModel.dataList.Last().id;
+            if (lastId == lastVoId)
+            {
+                lastId = lastVoId - 1;
+            }
+
+            foreach (var makeupVo in cardRedeemNewVOModel.dataList)
+            {
+                if (makeupVo.id > lastId)
+                {
+                    var makeupTaskData = new MakeupTaskData();
+                    //makeupTaskData.makeupTaskType = MakeupTaskType.Coin;
+                    makeupTaskData.tableId = makeupVo.id;
+                    makeupTaskData.id = PreferencesMgr.Instance.CoinMakeupTaskHistory.Count + 1;
+                    makeupTaskData.is_gold = true;
+                    // makeupTaskData.amountStr = GameHelper.GetMoneyStr(makeupVo);
+                    //makeupTaskData.orderID = GameHelper.GetRandomNum(8);
+
+                    PreferencesMgr.Instance.CoinMakeupTaskHistory.Add(makeupTaskData);
+                    makeupTaskData.SetStatus(MakeupTaskStatus.None);
+                    PreferencesMgr.Instance.SaveCoinMakeupTaskHistory();
+
+                    PreferencesMgr.Instance.CoinMakeupTaskH5Time = 0;
+                    break;
+                }
+            }
+        }
+        private void CheckSpeedUpTaskData(int type = 1)
+        {
+            if (!GameHelper.IsGiftSwitch())
+            {
+                return;
+            }
+
+            var common = ConfigSystem.GetConfig<CommonModel>();
+
+            if (type == 1 && PreferencesMgr.Instance.MakeupTaskHistory.Count > 0)
+            {
+                foreach (var makeuptaskData in PreferencesMgr.Instance.MakeupTaskHistory)
+                {
+                    if (makeuptaskData.status == MakeupTaskStatus.Inline
+                       && makeuptaskData.inlineNum > common.inlineMin)
+                    {
+                        var redeemVOModel = ConfigSystem.GetConfig<MakeupModel>().dataList
+                       .FirstOrDefault(redeem => redeem.id == makeuptaskData.tableId);
+
+                        var dowmNum = redeemVOModel.AD_Down;
+                        Debug.Log($"CheckSpeedUpTaskData dowmNum=== {dowmNum} makeuptaskData.WatchVideoSpeedNum ==== {makeuptaskData.WatchVideoSpeedNum}");
+
+                        makeuptaskData.WatchVideoSpeedNum += dowmNum;
+                        //如果看广告的减少人数大于配置的阈值，则不能减少排名了
+                        if (makeuptaskData.WatchVideoSpeedNum > redeemVOModel.AD_Limit_times)
+                        {
+                            makeuptaskData.WatchVideoSpeedNum = redeemVOModel.AD_Limit_times;
+                            continue;
+                        }
+
+                        Debug.Log($"订单为： {makeuptaskData.tableId} 通过看广告减少的排名为：{dowmNum}");
+                        makeuptaskData.inlineNum -= dowmNum;
+                        Debug.Log($"订单为： {makeuptaskData.tableId} 减少后的排名：{makeuptaskData.inlineNum}");
+                        if (makeuptaskData.inlineNum < common.inlineMin)
+                        {
+                            makeuptaskData.inlineNum = common.inlineMin;
+                        }
+                    }
+                }
+            }
+            if (type == 2 && SaveData.GetSaveobject().saveingpot_history.Count > 0)
+            {
+                foreach (var makeuptaskData in SaveData.GetSaveobject().saveingpot_history)
+                {
+                    if (makeuptaskData.status == SaveingPotTaskStatus.Inline
+                       && makeuptaskData.inlineNum > common.inlineMin)
+                    {
+                        var redeemVOModel = ConfigSystem.GetConfig<MakeupModel_2>().dataList
+                       .FirstOrDefault(redeem => redeem.id == makeuptaskData.tableId);
+
+                        var dowmNum = redeemVOModel.AD_Down;
+                        // Debug.Log($"CheckSpeedUpTaskData dowmNum=== {dowmNum} makeuptaskData.WatchVideoSpeedNum ==== {makeuptaskData.WatchVideoSpeedNum}");
+
+                        makeuptaskData.WatchVideoSpeedNum += dowmNum;
+                        //如果看广告的减少人数大于配置的阈值，则不能减少排名了
+                        if (makeuptaskData.WatchVideoSpeedNum > redeemVOModel.AD_Limit_times)
+                        {
+                            makeuptaskData.WatchVideoSpeedNum = redeemVOModel.AD_Limit_times;
+                            continue;
+                        }
+
+                        //Debug.Log($"订单为： {makeuptaskData.tableId} 通过看广告减少的排名为：{dowmNum}");
+                        makeuptaskData.inlineNum -= dowmNum;
+                        //Debug.Log($"订单为： {makeuptaskData.tableId} 减少后的排名：{makeuptaskData.inlineNum}");
+                        if (makeuptaskData.inlineNum < common.inlineMin)
+                        {
+                            makeuptaskData.inlineNum = common.inlineMin;
+                        }
+                    }
+                }
+            }
+        }
+        private void OnGetReward(object obj)
+        {
+            if (obj is RewardData rewardModel)
+            {
+                foreach (var rewardData in rewardModel.GetRewardDataList())
+                {
+                    ProcessData(rewardData);
+                }
+            }
+        }
+
+        private void ProcessData(Goda goda)
+        {
+            if (goda.origin == RewardOrigin.None)
+            {
+                return;
+            }
+
+            switch (goda.id)
+            {
+                case 101:
+                    {
+                        var roomTicket = PreferencesMgr.Instance.Currency101;
+                        roomTicket += (int)goda.GetTotalValue();
+
+                        PreferencesMgr.Instance.Currency101 = roomTicket;
+                    }
+                    break;
+                case 102:
+                    {
+                        var dollar = PreferencesMgr.Instance.Currency102;
+                        dollar += goda.GetTotalValue();
+
+                        PreferencesMgr.Instance.Currency102 = dollar;
+                    }
+                    break;
+                case 104:
+                    PreferencesMgr.Instance.CardBoardSum += (int)goda.GetTotalValue();
+                    break;
+                case 106:
+                    PreferencesMgr.Instance.Sum777 += (int)goda.GetTotalValue();
+                    break;
+                case 110:
+                    BingoCell.AddKeyCardSum((int)goda.GetTotalValue());
+                    break;
+            }
+        }
+
+        private void OnChangeRewardFly101(ExiteValue<bool> obj)
+        {
+            var oldValue = obj.oldValue;
+            var newValue = obj.newValue;
+
+            InitChangeRewardFly(101, oldValue, newValue);
+        }
+
+        private void OnChangeRewardFly102(ExiteValue<bool> obj)
+        {
+            var oldValue = obj.oldValue;
+            var newValue = obj.newValue;
+
+            InitChangeRewardFly(102, oldValue, newValue);
+        }
+
+        private void InitChangeRewardFly(int id, bool oldValue, bool newValue)
+        {
+            if (oldValue && !newValue)
+            {
+                switch (id)
+                {
+                    case 101:
+                        GameDispatcher.Instance.Dispatch(BingoInfo.Update101Completed);
+                        break;
+                    case 102:
+                        GameDispatcher.Instance.Dispatch(BingoInfo.Update102Completed);
+                        break;
+                }
+            }
+        }
+    }
+}

Assets/BingoBrain/System/Game/BingoDataSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b33f1a409b61479e9b014ab951bbff47
+timeCreated: 1692256149

Assets/BingoBrain/System/Game/BingoSystem.cs

@@ -0,0 +1,185 @@
+using System.Collections.Generic;
+using DG.Tweening;
+using BingoBrain.Core;
+using BingoBrain.HotFix;
+using UnityEngine;
+
+namespace BingoBrain
+{
+    public class BingoSystem : BaseSystem
+    {
+        public BingoSystem(bool isAutoInit = true)
+        {
+            if (isAutoInit)
+            {
+                Init();
+            }
+        }
+
+        public override void Init()
+        {
+            base.Init();
+
+            GameDispatcher.Instance.AddPriorityListener(BingoInfo.StartBingoGame, OnStartBingoGame);
+            GameDispatcher.Instance.AddListener(BingoInfo.EndBingoGame, OnReset);
+            GameDispatcher.Instance.AddPriorityListener(BingoInfo.ShowGameOver, OnShowGameOver);
+        }
+
+        public override void Dispose()
+        {
+            base.Dispose();
+
+            GameDispatcher.Instance.RemovePriorityListener(BingoInfo.StartBingoGame, OnStartBingoGame);
+            GameDispatcher.Instance.RemoveListener(BingoInfo.EndBingoGame, OnReset);
+            GameDispatcher.Instance.RemovePriorityListener(BingoInfo.ShowGameOver, OnShowGameOver);
+        }
+
+        private void OnShowGameOver(object obj)
+        {
+            BingoCell.isGameOver = true;
+        }
+
+        private void InitTestCallList()
+        {
+            for (int i = 1; i <= 70; i++)
+            {
+                BingoCell.calledList.Add(i);
+            }
+        }
+
+        private void OnStartBingoGame(object obj)
+        {
+            if (BingoCell.IsInGame)
+            {
+                return;
+            }
+
+            OnReset();
+
+            BingoCell.isFirstGame = PlayerPrefs.GetInt("FirstGame", 0) == 0;
+            InitBingoList();
+            UICtrlDispatcher.Instance.Dispatch(SkinInfo.GodPleAcUI_Close);
+            UICtrlDispatcher.Instance.Dispatch(SkinInfo.BingoStartUI_Open);
+            UICtrlDispatcher.Instance.Dispatch(SkinInfo.BingoHallUI_Close);
+            UICtrlDispatcher.Instance.Dispatch(SkinInfo.BottomUI_Close);
+            UICtrlDispatcher.Instance.Dispatch(SkinInfo.BingoHalldUI_Close);
+            BingoCell.isGameOver = false;
+
+            BingoCell.IsInGame = true;
+
+            var isFirst = PlayerPrefs.GetInt("FirstGame", 0) == 1;
+            if (!isFirst)
+            {
+                PlayerPrefs.SetInt("FirstGame", 1);
+            }
+        }
+
+        #region 流程
+
+        void InitBingoList()
+        {
+            for (var i = 0; i < BingoCell.bingoCount; i++)
+            {
+                var bingoRow = new List<int>();
+                var bingoColumn = new List<int>();
+                for (var j = 0; j < BingoCell.bingoCount * BingoCell.bingoCount; j++)
+                {
+                    if (GetRow(j) == i)
+                    {
+                        bingoRow.Add(j);
+                    }
+
+                    if (GetColumn(j) == i)
+                    {
+                        bingoColumn.Add(j);
+                    }
+                }
+
+                BingoCell.bingoDic.Add(i, bingoColumn);
+                BingoCell.bingoDic.Add(i + 5, bingoRow);
+            }
+
+            var list = new List<int>();
+            for (var i = 0; i < 5; i++)
+            {
+                list.Add(i * (BingoCell.bingoCount + 1));
+            }
+
+            BingoCell.bingoDic.Add(10, list);
+            var list2 = new List<int>();
+
+            for (var i = 0; i < 5; i++)
+            {
+                list2.Add(i * (BingoCell.bingoCount - 1) + 4);
+            }
+
+            BingoCell.bingoDic.Add(11, list2);
+
+            var list3 = new List<int>
+            {
+                0,
+                4,
+                BingoCell.FixedNum,
+                24,
+                20
+            };
+
+            BingoCell.bingoDic.Add(12, list3);
+        }
+
+        void OnReset(object o = null)
+        {
+            var backToMain = false;
+            if (o != null)
+            {
+                backToMain = (bool)o;
+            }
+
+            BingoCell.KeyCardSum = 0;
+            BingoCell.bingoDic.Clear();
+            foreach (var tween in BingoCell.tweens)
+            {
+                tween?.Kill();
+            }
+
+            BingoCell.tweens.Clear();
+            BingoCell.isProcedure = false;
+            BingoCell.isPropRewarding = false;
+            BingoCell.IsInGame = false;
+            BingoCell.PauseSum = 0;
+            UICtrlDispatcher.Instance.Dispatch(SkinInfo.BingoStartUI_Close);
+            if (backToMain)
+            {
+                DOVirtual.DelayedCall(UIMgrConst.OpenUIAnimEffectTime, delegate
+                {
+                    UICtrlDispatcher.Instance.Dispatch(SkinInfo.BingoHallUI_Open);
+                    UICtrlDispatcher.Instance.Dispatch(SkinInfo.BingoHalldUI_Open);
+                    if (GameHelper.IsGiftSwitch() && Random.Range(0, 100) < ConfigSystem.GetConfig<CommonModel>().backhallrate)
+                    {
+                        BingoHalldUI.Instance.OnClickHall();
+                    }
+                    else
+                    {
+                        BingoHalldUI.Instance.OnClickMainTab();
+                    }
+                });
+            }
+        }
+
+        #endregion
+
+        #region 封装
+
+        public int GetColumn(int index)
+        {
+            return index / BingoCell.bingoCount;
+        }
+
+        public int GetRow(int index)
+        {
+            return index % BingoCell.bingoCount;
+        }
+
+        #endregion
+    }
+}

Assets/BingoBrain/System/Game/BingoSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 15be730bc874467790b29fb1840c7e28
+timeCreated: 1699946581

Assets/BingoBrain/System/Game/CallSystem.cs

@@ -0,0 +1,318 @@
+using System;
+using System.Linq;
+using BingoBrain.Core;
+using UnityEngine;
+using BingoBrain.HotFix;
+using System.Collections.Generic;
+
+namespace BingoBrain
+{
+    public class CallSystem : BaseSystem
+    {
+        private bool isDeBug = false;
+
+        private System.Random random;
+
+        public CallSystem(bool isAutoInit = true)
+        {
+            if (isAutoInit)
+            {
+                Init();
+            }
+        }
+
+        public override void Init()
+        {
+            base.Init();
+            validNumPool = new List<int>();
+            invalidNumPool = new List<int>();
+            AddListener();
+        }
+
+        private void AddListener()
+        {
+            GameDispatcher.Instance.AddListener(BingoInfo.StartCallNum, StartCall);
+            GameDispatcher.Instance.AddListener(BingoInfo.EndBingoGame, EndCallNumber);
+            GameDispatcher.Instance.AddListener(BingoInfo.ShowGameOver, EndCallNumber);
+            GameDispatcher.Instance.AddListener(BingoInfo.StartBingoGame, OnStartBingoGame);
+        }
+
+        private void OnStartBingoGame(object obj)
+        {
+            BingoCell.AddCallSum = 0;
+            BingoCell.calledList.Clear();
+            BingoCell.MaxAddCallSum = GameHelper.GetCommonModel().MaxAddCallSum;
+
+            callIntervalTime = GameHelper.GetCommonModel().NumCD[0];
+            updataTime = callIntervalTime;
+            BingoCell.MaxCallSum = GameHelper.GetCommonModel().NumCD[1];
+            callSum = 0;
+        }
+
+        #region 叫号
+
+        #region updata
+
+        private bool isStartCall;
+        private float updataTime;
+
+        public override void Update()
+        {
+            if (!isStartCall)
+            {
+                return;
+            }
+
+
+            if (BingoCell.IsPauseGame)
+            {
+                return;
+            }
+
+
+            if (UI.Instance.HasUIInLayer(UILayerType.Popup))
+            {
+                return;
+            }
+
+            updataTime += Time.deltaTime * BingoCell.CallSpeed;
+            if (updataTime >= callIntervalTime)
+            {
+                updataTime = 0;
+                if (callSum >= BingoCell.MaxCallSum && !BingoCell.isPropRewarding && !BingoCell.isVictory)
+                {
+                    GameDispatcher.Instance.Dispatch(BingoInfo.CallNumFinish);
+                    return;
+                }
+
+                if (BingoCell.isVictory)
+                {
+                    return;
+                }
+
+                CallNumber();
+            }
+        }
+
+        #endregion
+
+
+        private int callIntervalTime;
+
+
+        private int callSum;
+
+
+        private List<int> validNumPool;
+
+
+        private List<int> invalidNumPool;
+
+
+        private void SetNumPool()
+        {
+            invalidNumPool.Clear();
+            validNumPool.Clear();
+            foreach (var num in BingoCell.cardBoardList.SelectMany(item =>
+                         item.data.cardNumList.Where(num => !validNumPool.Contains(num))))
+            {
+                validNumPool.Add(num);
+            }
+
+            for (var i = 1; i <= 75; i++)
+            {
+                if (!validNumPool.Contains(i))
+                {
+                    invalidNumPool.Add(i);
+                }
+            }
+        }
+
+
+        private void StartCall(object o)
+        {
+            random = isDeBug
+                ? new System.Random(123456789)
+                : new System.Random((int)DateTimeBoardk.Instance.GetServerCurrTimestamp());
+
+            SetNumPool();
+
+            if (BingoCell.IsInGame)
+            {
+                isStartCall = true;
+            }
+        }
+
+
+        private void CallNumber()
+        {
+            if (callSum >= BingoCell.MaxCallSum)
+            {
+                return;
+            }
+
+            callSum++;
+            var num = GetCallNumber();
+            if (BingoCell.calledList.Contains(num))
+            {
+            }
+
+            BingoCell.calledList.Add(num);
+            Audio.Instance.PlayDynamicEffect("Call." + num);
+            GameDispatcher.Instance.Dispatch(BingoInfo.CallNum, num);
+        }
+
+
+        private void EndCallNumber(object o)
+        {
+            if (isStartCall)
+            {
+                validNumPool.Clear();
+                invalidNumPool.Clear();
+                isStartCall = false;
+            }
+        }
+
+
+        public int GetDaubCountInBingoList(List<int> bingoList, CardBoardEntity cardBoardEntity)
+        {
+            return (from index in bingoList
+                let cardEntity = cardBoardEntity.cardList[index]
+                where cardBoardEntity.data.selectList.Contains(index) ||
+                      BingoCell.calledList.Contains(cardEntity.data.num)
+                select index).Count();
+        }
+
+
+        public int GetCallNumber()
+        {
+            if (BingoCell.isFirstGame)
+            {
+                if (BingoCell.FixedCallIndexList.Count != 0)
+                {
+                    var index = BingoCell.FixedCallIndexList[0];
+                    var num = BingoCell.cardBoardList[0].data.cardNumList[index];
+                    BingoCell.FixedCallIndexList.RemoveAt(0);
+                    return num;
+                }
+            }
+
+            var vo = GameHelper.GetConfig<BingoProbModel>().GetData(PreferencesMgr.Instance.CardBoardIndex + 1);
+            var daubCount = BingoCell.cardBoardList.Sum(cardBoard => cardBoard.data.selectList.Count);
+
+            float chance = vo.probability;
+            var isNeedAdvance = false;
+            for (var i = 0; i < vo.daubNum.Length; i++)
+            {
+                if (daubCount >= vo.daubNum[i])
+                {
+                    chance = vo.bingoprob[i];
+                    isNeedAdvance = true;
+                }
+            }
+
+            var isSucceed = GlobalHarmony.IsChance(chance / 100f);
+
+            if (isNeedAdvance)
+            {
+                if (isSucceed)
+                {
+                    var maxMatchCount = 1;
+                    var bingoIndexAndCardBoardList = new List<Tuple<CardBoardEntity, int>>();
+                    foreach (var bingoKv in BingoCell.bingoDic)
+                    {
+                        foreach (var cardBoard in BingoCell.cardBoardList)
+                        {
+                            if (cardBoard.isFinish)
+                            {
+                                continue;
+                            }
+
+                            var count = GetDaubCountInBingoList(bingoKv.Value, cardBoard);
+                            if (count == 5)
+                            {
+                                continue;
+                            }
+
+                            if (count > maxMatchCount)
+                            {
+                                maxMatchCount = count;
+                                bingoIndexAndCardBoardList.Clear();
+                                bingoIndexAndCardBoardList.Add(new Tuple<CardBoardEntity, int>(cardBoard, bingoKv.Key));
+                            }
+                            else if (count == maxMatchCount)
+                            {
+                                bingoIndexAndCardBoardList.Add(new Tuple<CardBoardEntity, int>(cardBoard, bingoKv.Key));
+                            }
+                        }
+                    }
+
+                    var finalCardNum = GlobalHarmony.GetRandomList(bingoIndexAndCardBoardList);
+                    if (finalCardNum != null)
+                    {
+                        foreach (var num in from index in BingoCell.bingoDic[finalCardNum.Item2]
+                                 let num = finalCardNum.Item1.data.cardNumList[index]
+                                 where !finalCardNum.Item1.data.selectList.Contains(index) &&
+                                       !BingoCell.calledList.Contains(num)
+                                 select num)
+                        {
+                            return num;
+                        }
+                    }
+                    else
+                    {
+                    }
+                }
+            }
+
+
+            var sum = 0;
+            List<int> list;
+
+            if (isSucceed)
+            {
+                if (validNumPool.Count > 0)
+                {
+                    list = validNumPool;
+                }
+                else
+                {
+                    list = invalidNumPool;
+                }
+            }
+            else
+            {
+                list = invalidNumPool.Count > 0 ? invalidNumPool : validNumPool;
+            }
+
+
+            if (list.Count > 0)
+            {
+                var index = random.Next(0, list.Count);
+                sum = list[index];
+                list.RemoveAt(index);
+            }
+
+            if (sum == 0)
+            {
+                while (true)
+                {
+                    sum = random.Next(0, 76);
+                    if (!BingoCell.calledList.Contains(sum))
+                    {
+                        break;
+                    }
+
+                    if (BingoCell.calledList.Count >= 75)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            return sum;
+        }
+
+        #endregion
+    }
+}

Assets/BingoBrain/System/Game/CallSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 96fcc8dd516b4a78881b86137648e9fd
+timeCreated: 1699948308

Assets/BingoBrain/System/Game/CardBoardSystem.cs

@@ -0,0 +1,247 @@
+using System.Linq;
+using DG.Tweening;
+using BingoBrain.Core;
+using UnityEngine;
+using BingoBrain.HotFix;
+using System.Collections.Generic;
+
+namespace BingoBrain
+{
+    public class CardBoardSystem : BaseSystem
+    {
+        public CardBoardSystem(bool isAutoInit = true)
+        {
+            if (isAutoInit)
+            {
+                Init();
+            }
+        }
+
+        public override void Init()
+        {
+            base.Init();
+
+            GameDispatcher.Instance.AddListener(BingoInfo.FinishOneCardBoard, OnFinishOneCardBoard);
+            GameDispatcher.Instance.AddListener(BingoInfo.StartBingoGame, OnStartBingoGame);
+            GameDispatcher.Instance.AddListener(BingoInfo.EndBingoGame, OnEndBingoGame);
+            GameDispatcher.Instance.AddListener(BingoInfo.AddPropRewardFinish, OnAddPropRewardFinish);
+            GameDispatcher.Instance.AddListener(BingoInfo.CallNum, OnCallNum);
+            GameDispatcher.Instance.AddListener(BingoInfo.CheckBingo, OnCheckBingo);
+
+            cardBoardPool = new Jcna<CardBoardEntity>(OnGet, OnRelease);
+        }
+
+        private void OnCheckBingo(object obj)
+        {
+            var index = (int)obj;
+            for (var i = 0; i < BingoCell.cardBoardList.Count; i++)
+            {
+                var cardBoard = BingoCell.cardBoardList[i];
+                if (cardBoard.data.index == index || cardBoard.isFinish)
+                {
+                    continue;
+                }
+
+
+                cardBoard.CheckBingo();
+            }
+        }
+
+        private void OnAddPropRewardFinish(object obj)
+        {
+        }
+
+        private void OnCallNum(object obj)
+        {
+            var num = (int)obj;
+            foreach (var card in BingoCell.cardBoardList.SelectMany(cardBoard =>
+                         cardBoard.cardList.Where(card => !card.data.isSelect && !card.data.isCoin)
+                             .Where(card => card.data.num == num)))
+            {
+                card.TweenAlphaNum();
+            }
+        }
+
+        private void OnEndBingoGame(object obj)
+        {
+            ResetCardBoard();
+        }
+
+        private void OnStartBingoGame(object obj)
+        {
+            PreferencesMgr.Instance.GameSum++;
+            InitCardBoardData();
+        }
+
+        private void OnRelease(CardBoardEntity obj)
+        {
+            if (obj.GoCell.gameObject != null)
+            {
+                obj.GoCell.gameObject.SetActive(false);
+            }
+        }
+
+        private void OnGet(CardBoardEntity obj)
+        {
+            if (obj.GoCell.gameObject != null)
+            {
+                obj.GoCell.gameObject.SetActive(true);
+            }
+        }
+
+        #region 变量
+
+        Jcna<CardBoardEntity> cardBoardPool;
+
+        #endregion
+
+        #region 流程
+
+        void InitCardBoardData()
+        {
+            for (var i = 0; i < BingoCell.CardBoardCount; i++)
+            {
+                var entity = cardBoardPool.Get();
+                var cardBoardData = entity.data;
+                cardBoardData.index = i;
+                for (var j = 0; j < BingoCell.bingoCount; j++)
+                {
+                    var startNum = 1 + 15 * j;
+                    var endNum = 15 + 15 * j;
+                    for (var k = 0; k < BingoCell.bingoCount; k++)
+                    {
+                        var num = Random.Range(startNum, endNum + 1);
+                        while (cardBoardData.cardNumList.Contains(num))
+                        {
+                            if (BingoCell.bingoCount >= 15)
+                            {
+                                return;
+                            }
+
+                            num = Random.Range(startNum, endNum + 1);
+                        }
+
+                        cardBoardData.cardNumList.Add(num);
+                    }
+                }
+
+                entity.data.selectList.Add(BingoCell.FixedNum);
+                entity.SetData();
+                BingoCell.cardBoardList.Add(entity);
+            }
+
+
+            var finalList = new List<CardEntity>();
+            foreach (var card in BingoCell.cardBoardList.Where(cardBoard => !cardBoard.isFinish)
+                         .SelectMany(cardBoard => cardBoard.cardList.Where(GameHelper.IsCommonCard)))
+            {
+                if (card.data.isSelect)
+                {
+                    Debug.Log(card.data.index);
+                }
+
+                finalList.Add(card);
+            }
+
+            finalList = GlobalHarmony.GetRandomList(finalList,
+                ConfigSystem.GetConfig<CommonModel>().Initialcardprop);
+            if (finalList.Count != 0)
+            {
+                foreach (var card in finalList)
+                {
+                    card.data.type = CardPropType.fanpai;
+                    card.SetReward();
+                }
+            }
+
+            switch (BingoCell.CardBoardCount)
+            {
+                case 1:
+                    BingoCell.cardBoardList[0].GoCell.gameObject.SetActive(true);
+                    BingoCell.cardBoardList[0].GoCell.transform.localScale = Vector3.one;
+                    BingoCell.cardBoardList[0].GoCell.transform.localPosition = new Vector3(0, -1);
+                    break;
+                case 2:
+                {
+                    IsfvKit.DelayedAction(0.1f, () =>
+                    {
+                        for (var i = 0; i < 2; i++)
+                        {
+                            BingoCell.cardBoardList[i].GoCell.gameObject.SetActive(true);
+                            BingoCell.cardBoardList[i].GoCell.transform.localScale = Vector3.one * 0.63f;
+                            var symbol = i == 0 ? -1 : 1;
+                            BingoCell.cardBoardList[i].GoCell.transform.localPosition = Vector3.zero;
+                            BingoCell.cardBoardList[i].GoCell.transform
+                                .DOLocalMove(new Vector3(0, symbol * 3.3f - 2f), 0.2f).SetEase(Ease.Linear);
+                            BingoCell.cardBoardList[i].bingGoSke.transform.localScale = Vector3.one;
+                        }
+                    });
+
+                    break;
+                }
+                case 4:
+                {
+                    IsfvKit.DelayedAction(0.1f, () =>
+                    {
+                        for (var i = 0; i < 4; i++)
+                        {
+                            BingoCell.cardBoardList[i].GoCell.transform.localScale = Vector3.one * 0.58f;
+                            var symbolX = i % 2 == 0 ? -1 : 1;
+                            var symbolY = i / 2 == 0 ? -1 : 1;
+                            BingoCell.cardBoardList[i].GoCell.transform.localPosition = Vector3.zero;
+                            BingoCell.cardBoardList[i].GoCell.transform
+                                .DOLocalMove(new Vector3(symbolX * 2.57f, symbolY * 3 - 1.5f), 0.2f)
+                                .SetEase(Ease.Linear);
+                            BingoCell.cardBoardList[i].bingGoSke.transform.localScale = Vector3.one;
+                        }
+                    });
+
+                    break;
+                }
+            }
+        }
+
+        private void OnFinishOneCardBoard(object obj)
+        {
+            if (BingoCell.IsPauseGame)
+            {
+                return;
+            }
+
+
+            if (BingoCell.isVictory)
+            {
+                return;
+            }
+
+            var isFinish = BingoCell.cardBoardList.All(cardBoard => cardBoard.isFinish);
+
+            if (isFinish)
+            {
+                if (!BingoCell.IsInGame)
+                {
+                    return;
+                }
+
+                BingoCell.isVictory = true;
+                DOVirtual.DelayedCall(1, delegate { GameDispatcher.Instance.Dispatch(BingoInfo.ShowGameOver); });
+            }
+        }
+
+        void ResetCardBoard()
+        {
+            foreach (var cardBoard in BingoCell.cardBoardList)
+            {
+                cardBoard.OnReset();
+                cardBoardPool.Release(cardBoard);
+            }
+
+            BingoCell.cardBoardList.Clear();
+            BingoCell.bingoCardboardIndex = -1;
+            BingoCell.isVictory = false;
+            BingoCell.PauseSum = 0;
+        }
+
+        #endregion
+    }
+}

Assets/BingoBrain/System/Game/CardBoardSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2faab4f65f2942ffa42088efb196fd12
+timeCreated: 1699946624

Assets/BingoBrain/System/Game/DialogSystem.cs

@@ -0,0 +1,95 @@
+using BingoBrain.Core;
+using BingoBrain.HotFix;
+
+namespace BingoBrain
+{
+    public class DialogSystem : BaseSystem
+    {
+        public DialogSystem(bool isAutoInit = true)
+        {
+            if (isAutoInit)
+            {
+                Init();
+            }
+        }
+
+        Gsss startGameSequence = new Gsss();
+        Gsss backMainSequence = new Gsss();
+
+        public sealed override void Init()
+        {
+            base.Init();
+
+            AddListener();
+        }
+
+        private void AddListener()
+        {
+            CtrlDispatcher.Instance.AddOnceListener(CtrlMsg.Game_Start, StartGame);
+            GameDispatcher.Instance.AddFinallyListener(BingoInfo.EndBingoGame, OnEndBingoGame);
+        }
+
+        private void StartGame(object obj)
+        {
+            startGameSequence.Clear();
+
+            if (GameHelper.IsOpenGuide())
+            {
+                AddOpenReward(startGameSequence);
+            }
+
+            if (startGameSequence.Count == 0)
+            {
+                // End();
+            }
+            else
+            {
+                startGameSequence.Run();
+            }
+        }
+
+        private void OnEndBingoGame(object obj)
+        {
+            var isBackMain = (bool)obj;
+            if (isBackMain)
+            {
+                BackMain();
+            }
+        }
+
+        private void BackMain()
+        {
+            backMainSequence.Clear();
+
+            AddOpenReward(backMainSequence);
+
+            if (backMainSequence.Count == 0)
+            {
+            }
+            else
+            {
+                backMainSequence.Run();
+            }
+        }
+
+        private bool isFinishNaive;
+
+        private void AddOpenReward(Gsss gsss)
+        {
+            if (!GameHelper.IsGiftSwitch())
+            {
+                return;
+            }
+
+            if (PreferencesMgr.Instance.IsShowOpenReward)
+            {
+                gsss.Add(true, (procedure) =>
+                {
+                    UICtrlDispatcher.Instance.Dispatch(SkinInfo.OpenRewardUI_Open);
+                    UICtrlDispatcher.Instance.AddOnceListener(SkinInfo.OpenRewardUI_Close,
+                        e => { procedure.InvokeComplete(); });
+                });
+            }
+        }
+    }
+}

Assets/BingoBrain/System/Game/DialogSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1b4c0d23d2744f868b80f5ea89b2bddf
+timeCreated: 1692848262

Assets/BingoBrain/System/Game/JsonSystem.cs

@@ -0,0 +1,351 @@
+using System;
+using System.IO;
+using BingoBrain.Core;
+using UnityEngine;
+using BingoBrain.Asset;
+using BingoBrain.HotFix;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using BingoBrain;
+using System.Linq;
+
+namespace BingoBrain
+{
+    public class ConfigSystem : BaseSystem
+    {
+        private static Dictionary<Type, object> configData = new();
+
+        public ConfigSystem(bool isAutoInit = true)
+        {
+            if (isAutoInit)
+            {
+                Init();
+            }
+        }
+
+        public sealed override void Init()
+        {
+            base.Init();
+            AddListener();
+        }
+
+        private void AddListener()
+        {
+            NetworkDispatcher.Instance.AddListener(ExternalInfo.GetConfig, OnRequestGetConfig);
+        }
+
+        private void RemoveListener()
+        {
+            NetworkDispatcher.Instance.RemoveListener(ExternalInfo.GetConfig, OnRequestGetConfig);
+        }
+
+        private void OnRequestGetConfig(object obj)
+        {
+            // var configFileName = "BingoJson";
+            // var configFileSavePath = $"{Application.streamingAssetsPath}/Config/";
+            // var assetHotFixFilePath = $"{configFileSavePath}{configFileName}.txt";
+            // if (File.Exists(assetHotFixFilePath))
+            // {
+            //     ParseConfig(File.ReadAllText(assetHotFixFilePath));
+            //     UICtrlDispatcher.Instance.Dispatch(SkinInfo.CheckReadyUI_Close);
+            //     AppDispatcher.Instance.Dispatch(CsjInfoC.LoginInit);
+            // }
+            // else
+            // {
+            //     IsfvKit.StartCoroutine(CachKit.GetTextFromUrl($"{Application.streamingAssetsPath + "/Config/BingoJson.txt"}", configFileName,
+            //         content =>
+            //         {
+            //             ParseConfig(content);
+            //             UICtrlDispatcher.Instance.Dispatch(SkinInfo.CheckReadyUI_Close);
+            //             AppDispatcher.Instance.Dispatch(CsjInfoC.LoginInit);
+            //             CtrlDispatcher.Instance.Dispatch(CtrlMsg.Game_StartBefore);
+            //         }, configFileSavePath));
+            // }
+
+
+            GameHelper.PostFunnelLogin("loadBegin");
+            var loginData = GameHelper.GetLoginModel();
+
+            var configFileName = "BingoJson";
+            var configFileSavePath = $"{Application.persistentDataPath}/Config/";
+            var assetHotFixFilePath = $"{configFileSavePath}{configFileName}.txt";
+            var configFileNameKey = "configFileName";
+
+            var CDNConfigFileName = loginData.setting;
+            string savedCfgName = PlayerPrefs.GetString(configFileNameKey);
+            bool needDownloadConfigFile = false;
+
+            if (!string.IsNullOrEmpty(CDNConfigFileName))
+            {
+                //如果本地Player Prefs里没有保存配置文件名
+                if (string.IsNullOrEmpty(savedCfgName))
+                {
+                    // Debug.Log("[UNITY] No config file name saved.");
+                    needDownloadConfigFile = true;
+                }
+                else
+                {
+                    // Debug.Log($"[UNITY] Saved config name: {savedCfgName}, CDN config name: {CDNConfigFileName}");
+                    //与CDN上的对比名称
+                    if (!savedCfgName.Equals(CDNConfigFileName))
+                    {
+                        needDownloadConfigFile = true;
+                    }
+                }
+            }
+            //Debug.Log($"[UNITY] needDownloadConfigFile: {needDownloadConfigFile}");
+            //默默地拉去新配置
+            // Debug.Log("kkkkkkkkkkkkkkkkkkkkkk" + needDownloadConfigFile);
+            // Debug.Log("kkkkkkkkkkkkkkkkkkkkkk" + savedCfgName);
+
+            if (needDownloadConfigFile)
+            {
+                IsfvKit.StartCoroutine(CachKit.GetTextFromUrl($"{NetworkKit.CDNUrl}config/{CDNConfigFileName}",
+                    configFileName, (content) =>
+                    {
+                        PlayerPrefs.SetString(configFileNameKey, CDNConfigFileName);
+                        ParseConfig(content);
+                        //CtrlDispatcher.Instance.Dispatch(CtrlMsg.NewConfigRead);
+                    }, configFileSavePath));
+            }
+            //检查设备本地是否有配置文件
+            if (File.Exists(assetHotFixFilePath))
+            {
+                //  Debug.Log($"[UNITY] Load config from datapath: {assetHotFixFilePath}");
+                ParseConfig(File.ReadAllText(assetHotFixFilePath));
+                // UICtrlDispatcher.Instance.Dispatch(UICtrlMsg.NetLoadingUI_Close);
+                AppDispatcher.Instance.Dispatch(CsjInfoC.LoginInit);
+                GameHelper.PostFunnelLogin("loadFinish");
+
+            }
+            else  //没有就从StreamingAssets读取
+            {
+                var path = $"{Application.streamingAssetsPath}/Config/{configFileName}.txt";
+#if UNITY_IOS
+                path = "file://" + path;
+#endif
+                // Debug.Log($"[UNITY] Load config from streaming asset: {path}");
+                IsfvKit.StartCoroutine(CachKit.GetTextFromUrl(path, configFileName, content =>
+                {
+                    ParseConfig(content);
+                    // UICtrlDispatcher.Instance.Dispatch(UICtrlMsg.NetLoadingUI_Close);
+                    AppDispatcher.Instance.Dispatch(CsjInfoC.LoginInit);
+                    GameHelper.PostFunnelLogin("loadFinish");
+                }, configFileSavePath));
+            }
+        }
+
+        private void ParseConfig(string json)
+        {
+            if (json == null)
+            {
+                return;
+            }
+
+            if (!json.StartsWith("{"))
+            {
+                json = Base64Kit.Decode(json, NetworkMsg.Identifier);
+            }
+
+            var dictionary = Havva.ToObject<Dictionary<string, object>>(json);
+            ParseGameConfig(dictionary);
+            ModuleBoardk.Instance.AllModuleReadData();
+        }
+
+        #region 游戏配置
+        public static List<GameUrls> light_weblist = new List<GameUrls>();
+        public static List<GameUrls> dark_weblist = new List<GameUrls>();
+        private List<GameUrls> data_new;
+        public static string web_through_str;
+        private void GetGameConfig<T, TK>(IReadOnlyDictionary<string, object> dictionary)
+        {
+            if (dictionary.TryGetValue(typeof(TK).Name.ToString(), out var config))
+            {
+                // Debug.Log(typeof(T));
+                // Debug.Log(config);
+                if (typeof(T) == typeof(CommonModel))
+                {
+                    Debug.Log(config);
+                }
+                var data = Havva.ToObject<List<TK>>(config.ToString());
+                object[] para = { data };
+                var o = (T)Activator.CreateInstance(typeof(T));
+                typeof(T).GetMethod("SetDataList")?.Invoke(o, para);
+                configData[typeof(T)] = o;
+
+                if (typeof(T) == typeof(GameUrlsModel))
+                {
+
+                    light_weblist.Clear();
+                    dark_weblist.Clear();
+                    web_through_str = "";
+                    data_new = Havva.ToObject<List<GameUrls>>(config.ToString());
+                    List<int> type_list = new List<int>();
+                    for (int i = 0; i < data_new.Count; i++)
+                    {
+
+                        if (data_new[i].webType == 2)
+                        {
+                            if (GameHelper.IsGiftSwitch() && (data_new[i].isMagic == 1)) light_weblist.Add(data_new[i]);
+                            else if (!GameHelper.IsGiftSwitch() && (data_new[i].isMagic == 0)) light_weblist.Add(data_new[i]);
+                        }
+                        else
+                        {
+                            dark_weblist.Add(data_new[i]);
+                            if (!type_list.Contains(data_new[i].wvType))
+                            {
+                                web_through_str += data_new[i].wvthrough;
+                                web_through_str += "|";
+                                type_list.Add(data_new[i].wvType);
+                            }
+                        }
+
+                    }
+
+                    web_through_str.Remove(web_through_str.Length - 1);
+
+                    Debug.Log(light_weblist.Count);
+                    Debug.Log(dark_weblist.Count);
+                }
+
+            }
+        }
+
+        private void GetGameConfData(IReadOnlyDictionary<string, object> dictionary)
+        {
+            var GameConfigModel = new GameConfigModel();
+
+            foreach (var item in dictionary)
+            {
+                if (item.Key.StartsWith("GameBoard"))
+                {
+                    string[] parts = item.Key.Split('_');
+
+                    int boardIndex;
+                    if (parts.Length > 1 && int.TryParse(parts[1], out boardIndex))
+                    {
+                        // 成功解析出数字
+                        // Debug.Log($"boardIndex==== {boardIndex}");
+                    }
+                    else
+                    {
+                        boardIndex = 1;
+                    }
+
+                    if (dictionary.TryGetValue(item.Key, out var gameboard))
+                    {
+
+                        if (!GameConfigModel.game_conf.ContainsKey(boardIndex))
+                        {
+                            GameConfigModel.game_conf.Add(boardIndex, null);
+                        }
+
+                        GameConfigModel.game_conf[boardIndex] = SerializeUtil.ToObject<List<GameBoard>>(gameboard.ToString());
+
+                    }
+                }
+            }
+            configData[typeof(GameConfigModel)] = GameConfigModel;
+        }
+
+
+        private void GetSingleConfig<T>(IReadOnlyDictionary<string, object> dictionary, string configName)
+        {
+            if (dictionary.TryGetValue(configName, out var config))
+            {
+                var model = Havva.ToObject<T>(config.ToString());
+                configData[typeof(T)] = model;
+            }
+        }
+
+        private void ParseGameConfig(IReadOnlyDictionary<string, object> dictionary)
+        {
+            GetSingleConfig<CommonModel>(dictionary, "Common");
+
+            GetGameConfig<AdRewardModel, AdReward>(dictionary);
+            GetGameConfig<TaskListModel, TaskList>(dictionary);
+            GetGameConfig<Out101Model, Out101>(dictionary);
+            GetGameConfig<Out102Model, Out102>(dictionary);
+            GetGameConfig<FlopModel, Flop>(dictionary);
+            GetGameConfig<QBLOXModel, QBLOX>(dictionary);
+            GetGameConfig<PropModel, Prop>(dictionary);
+            GetGameConfig<TurntableModel, Turntable>(dictionary);
+            GetGameConfig<SignDailyModel, SignDaily>(dictionary);
+            GetGameConfig<BingoProbModel, BingoProb>(dictionary);
+            GetGameConfig<MakeupModel, makeup>(dictionary);
+            GetGameConfig<CardRedeemNewModel, cardRedeemNew>(dictionary);
+            GetGameConfig<GameUrlsModel, GameUrls>(dictionary);
+            GetGameConfig<exBrPoolModel, exBrPool>(dictionary);
+
+            GetGameConfig<PaidcoinsModel, Paidcoins>(dictionary);
+            GetGameConfData(dictionary);
+            GetGameConfig<PassingTaskModel, PassingTasks>(dictionary);
+            GetGameConfig<DurationtasksModel, Durationtasks>(dictionary);
+            GetGameConfig<PassportrewardsModel, Passportrewards>(dictionary);
+            GetGameConfig<RewardNumModel, rewardNum>(dictionary);
+            GetGameConfig<SmallrewardNumModel, SmallrewardNum>(dictionary);
+            GetGameConfig<LargerewardNumModel, LargerewardNum>(dictionary);
+            GetGameConfig<PaidgiftModel, Paidgift>(dictionary);
+            GetGameConfig<exBrPoolModel_2, exBrPool_2>(dictionary);
+            GetGameConfig<MakeupModel_2, makeup_2>(dictionary);
+            GetGameConfig<MultigiftModel, Multigift>(dictionary);
+            exBrPoolModel.config_name_list = ConfigSystem.GetConfig<exBrPoolModel>().dataList[0].user_name.Split(",").ToList();
+            exBrPoolModel.config_money_list = ConfigSystem.GetConfig<exBrPoolModel>().dataList[0].amount.Split(",").ToList();
+            exBrPoolModel_2.config_name_list = ConfigSystem.GetConfig<exBrPoolModel_2>().dataList[0].user_name.Split(",").ToList();
+            exBrPoolModel_2.config_money_list = ConfigSystem.GetConfig<exBrPoolModel_2>().dataList[0].amount.Split(",").ToList();
+            //   exBrPoolModel.getFaqData();
+            if (PreferencesMgr.Instance.ActiveMissions != null)
+            {
+                for (int i = 0; i < PreferencesMgr.Instance.ActiveMissions.Count; i++)
+                {
+                    // Debug.Log(JsonConvert.SerializeObject(PreferencesMgr.Instance.ActiveMissions[i]));
+                    // Debug.Log(JsonConvert.SerializeObject(GameHelper.GetConfig<TaskListModel>().GetData(i + 1)));
+                    TaskList config = GameHelper.GetConfig<TaskListModel>().GetData(i + 1);
+                    PreferencesMgr.Instance.ActiveMissions[i].MaxProgress = config.taskNum;
+                    PreferencesMgr.Instance.ActiveMissions[i].RewardId = config.rewardID;
+                    PreferencesMgr.Instance.ActiveMissions[i].IsMulti = config.isMulti;
+                    if (!PreferencesMgr.Instance.FinishTaskList.Contains(i + 1))
+                    {
+                        PreferencesMgr.Instance.ActiveMissions[i].RewardSum = config.rewardFirst;
+                    }
+                    else
+                    {
+                        PreferencesMgr.Instance.ActiveMissions[i].RewardSum = config.reward[GameHelper.GetDynamicIndex(i + 1)];
+                    }
+                }
+
+            }
+            if (PreferencesMgr.Instance.DailyBonusItemLst != null)
+            {
+                for (int i = 0; i < PreferencesMgr.Instance.DailyBonusItemLst.Count; i++)
+                {
+                    // Debug.Log(JsonConvert.SerializeObject(PreferencesMgr.Instance.DailyBonusItemLst[i]));
+                    // Debug.Log(JsonConvert.SerializeObject(GameHelper.GetConfig<SignDailyModel>().GetData(i + 1)));
+                    SignDaily config = GameHelper.GetConfig<SignDailyModel>().GetData(i + 1);
+                    PreferencesMgr.Instance.DailyBonusItemLst[i].id = config.item1;
+                    PreferencesMgr.Instance.DailyBonusItemLst[i].quantity = config.quantity[0];
+                    PreferencesMgr.Instance.DailyBonusItemLst[i].isDouble = config.isMulti;
+                    PreferencesMgr.Instance.DailyBonusItemLst[i].cont_index = config.cont_index;
+                }
+
+            }
+
+            // Debug.Log("888888888888888888");
+        }
+
+        #endregion
+
+        public static T GetConfig<T>()
+        {
+            return configData.TryGetValue(typeof(T), out var value) ? (T)value : default;
+        }
+
+        public override void Dispose()
+        {
+            base.Dispose();
+            RemoveListener();
+        }
+    }
+
+
+}

Assets/BingoBrain/System/Game/JsonSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3a3bd721f95842948573aea8599cd364
+timeCreated: 1692603665

Assets/BingoBrain/System/Game/PropSystem.cs

@@ -0,0 +1,311 @@
+using System.Collections.Generic;
+using System.Linq;
+using DG.Tweening;
+using FairyGUI;
+using BingoBrain.Core;
+using BingoBrain.HotFix;
+using UnityEngine;
+
+namespace BingoBrain
+{
+    public class PropSystem : BaseSystem
+    {
+        public PropSystem(bool isAutoInit = true)
+        {
+            if (isAutoInit)
+            {
+                Init();
+            }
+        }
+
+        public override void Init()
+        {
+            base.Init();
+            GameDispatcher.Instance.AddPriorityListener(BingoInfo.SelectOneNum, OnSelectOneCard);
+            GameDispatcher.Instance.AddListener(BingoInfo.EndBingoGame, OnEndBingoGame);
+            GameDispatcher.Instance.AddListener(BingoInfo.AddMoneyCell, OnAddMoneyCell);
+        }
+
+        private void OnAddMoneyCell(object obj)
+        {
+            var count = (int)obj;
+
+            var finalList = new List<CardEntity>();
+            foreach (var list in from cardBoard in BingoCell.cardBoardList
+                     where !cardBoard.isFinish
+                     select GlobalHarmony.GetRandomList(cardBoard.cardList.FindAll(GameHelper.IsCommonCard),
+                         count))
+            {
+                if (list.Count != 0)
+                {
+                    foreach (var card in list)
+                    {
+                        card.data.type = CardPropType.cash;
+                    }
+                }
+
+                finalList.AddRange(list);
+            }
+
+            var path = "Prefab.Game.PropItem";
+            var time = 0.5f;
+
+            if (finalList.Count != 0)
+            {
+                foreach (var card in finalList)
+                {
+                    var reward = Battle.Instance.ShungTik.Get(path, "reward3");
+                    var finalPos = card.Game.transform.position;
+                    reward.transform.SetParent(BingoCell.root, false);
+
+                    var originPos =
+                        CameraBoardk.Instance.FGUIPosToWorldPos(new Vector3(GRoot.inst.width / 2,
+                            GRoot.inst.height / 2));
+
+                    reward.transform.position = originPos;
+                    reward.transform.localScale = Vector3.one * 0.5f;
+
+                    reward.transform.DOScale(1, time);
+                    reward.transform.DOMove(finalPos, time).OnComplete(delegate
+                    {
+                        var rainbow = Battle.Instance.ShungTik.Get("Effect.spark", "fx_skill_enter");
+                        rainbow.transform.SetParent(card.Game.transform, false);
+                        DOVirtual.DelayedCall(1, () => { Battle.Instance.ShungTik.Release(rainbow); });
+                        card.SetReward();
+
+                        Battle.Instance.ShungTik.Release(reward);
+                    });
+                }
+            }
+        }
+
+        private void OnEndBingoGame(object obj)
+        {
+            BingoCell.curEnergy = 0;
+        }
+
+        private void OnSelectOneCard(object obj)
+        {
+            if (BingoCell.isFirstGame)
+            {
+                return;
+            }
+
+            if (BingoCell.isPropRewarding)
+            {
+                return;
+            }
+
+            BingoCell.curEnergy++;
+            if (BingoCell.IsFullEnergy)
+            {
+                DOVirtual.DelayedCall(Time.deltaTime, delegate
+                {
+                    BingoCell.isPropRewarding = true;
+
+                    RandomReward();
+                });
+            }
+        }
+
+        private int rewardType;
+        int coinType = 1;
+        int x3Type = 2;
+        int daubType = 0;
+
+
+        List<int> typeIdList = new List<int>
+        {
+            108, 107, 109
+        };
+
+        private void RandomReward()
+        {
+            rewardType = Random.Range(0, 3);
+
+            GameDispatcher.Instance.Dispatch(BingoInfo.StartFullEnergy, rewardType);
+
+            if (PreferencesMgr.Instance.IsFirstPropFull)
+            {
+                PreferencesMgr.Instance.IsFirstPropFull = false;
+                UICtrlDispatcher.Instance.Dispatch(SkinInfo.PropInfoUI_Open);
+                UICtrlDispatcher.Instance.AddOnceListener(SkinInfo.PropInfoUI_Close, a => { DoProp(); });
+            }
+            else
+            {
+                DoProp();
+            }
+        }
+
+        int GetCountByType()
+        {
+            var id = typeIdList[rewardType];
+            var vo = ConfigSystem.GetConfig<PropModel>().dataList.FirstOrDefault(prop => prop.id == id);
+            return vo.quantity[PreferencesMgr.Instance.CardBoardIndex];
+        }
+
+        void DoProp()
+        {
+            var count = GetCountByType();
+            var finalList = new List<CardEntity>();
+
+
+            if (rewardType == coinType)
+            {
+                foreach (var list in from cardBoard in BingoCell.cardBoardList
+                         where !cardBoard.isFinish
+                         select GlobalHarmony.GetRandomList(cardBoard.cardList.FindAll(GameHelper.IsCommonCard),
+                             count))
+                {
+                    if (list.Count != 0)
+                    {
+                        foreach (var card in list)
+                        {
+                            card.data.type = CardPropType.coin;
+                        }
+                    }
+
+                    finalList.AddRange(list);
+                }
+            }
+
+            else if (rewardType == x3Type)
+            {
+                foreach (var list in from cardBoard in BingoCell.cardBoardList
+                         where !cardBoard.isFinish
+                         select GlobalHarmony.GetRandomList(cardBoard.cardList.FindAll(tmp =>
+                             tmp.data.type is CardPropType.cash or CardPropType.coin && !tmp.data.isSelect &&
+                             !tmp.data.isDelaySelect), count))
+                {
+                    if (list.Count != 0)
+                    {
+                        foreach (var card in list)
+                        {
+                            card.data.type = card.data.type == CardPropType.cash
+                                ? CardPropType.cashx3
+                                : CardPropType.coinx3;
+                        }
+                    }
+
+                    finalList.AddRange(list);
+                }
+            }
+
+            else if (rewardType == daubType)
+            {
+                foreach (var card in BingoCell.cardBoardList.Where(cardBoard => !cardBoard.isFinish).SelectMany(
+                             cardBoard => cardBoard.cardList.Where(GameHelper.IsCommonCard)
+                                 .Where(card => !BingoCell.calledList.Contains(card.data.num))))
+                {
+                    if (card.data.isSelect)
+                    {
+                        Debug.Log(card.data.index);
+                    }
+
+                    finalList.Add(card);
+                }
+
+                finalList = GlobalHarmony.GetRandomList(finalList, count);
+
+                foreach (var card in finalList)
+                {
+                    card.AddToSelectedList();
+                }
+            }
+
+            var path = "Prefab.Game.PropItem";
+            var time = 0.5f;
+            Audio.Instance.PlayDynamicEffect("prop_ready");
+            if (finalList.Count != 0)
+            {
+                DOVirtual.DelayedCall(1.5f, () =>
+                {
+                    var cardBoardList = new List<CardBoardEntity>();
+                    Audio.Instance.PlayDynamicEffect("prop_fly");
+
+                    foreach (var card in finalList)
+                    {
+                        var reward = Battle.Instance.ShungTik.Get(path, $"reward{rewardType}");
+                        var finalPos = card.Game.transform.position;
+                        reward.transform.SetParent(BingoCell.root.transform, false);
+                        var originPos = BingoCell.propOriginPos;
+                        reward.transform.position = originPos;
+                        reward.transform.localScale = Vector3.one * 0.5f;
+                        if (rewardType == daubType)
+                        {
+                            if (!cardBoardList.Contains(card.data.cardBoard))
+                            {
+                                cardBoardList.Add(card.data.cardBoard);
+                            }
+                        }
+
+                        reward.transform.DOScale(1, time);
+                        reward.transform.DOMove(finalPos, time).OnComplete(delegate
+                        {
+                            if (rewardType == daubType)
+                            {
+                                card.SetByData();
+                                var boom = Battle.Instance.ShungTik.Get("Effect.spark.fx_skill_boom",
+                                    "fx_skill_boom");
+                                boom.transform.SetParent(card.Game.transform, false);
+                                DOVirtual.DelayedCall(1, () => { Battle.Instance.ShungTik.Release(boom); });
+                            }
+                            else
+                            {
+                                var rainbow = Battle.Instance.ShungTik.Get("Effect.spark.fx_skill_enter",
+                                    "fx_skill_enter");
+                                rainbow.transform.SetParent(card.Game.transform, false);
+                                DOVirtual.DelayedCall(1,
+                                    () => { Battle.Instance.ShungTik.Release(rainbow); });
+                                card.SetReward();
+                            }
+
+                            Battle.Instance.ShungTik.Release(reward);
+                        });
+                    }
+
+                    if (cardBoardList.Count != 0)
+                        DOVirtual.DelayedCall(time, delegate
+                        {
+                            var effectName = "";
+                            if (rewardType == coinType)
+                            {
+                                effectName = "prop_coin";
+                            }
+                            else if (rewardType == x3Type)
+                            {
+                                effectName = "propx3";
+                            }
+                            else
+                            {
+                                effectName = "prop_daub";
+                            }
+
+                            Audio.Instance.PlayDynamicEffect(effectName);
+
+
+                            foreach (var cardBoard in cardBoardList)
+                            {
+                                cardBoard.DelayCheckBingo();
+                            }
+                        });
+                });
+                DOVirtual.DelayedCall(3.5f, () =>
+                {
+                    BingoCell.curEnergy = 0;
+                    BingoCell.isPropRewarding = false;
+                    GameDispatcher.Instance.Dispatch(BingoInfo.AddPropRewardFinish);
+                });
+            }
+            else
+            {
+                DOVirtual.DelayedCall(1.5f, () =>
+                {
+                    BingoCell.curEnergy = 0;
+                    BingoCell.isPropRewarding = false;
+                    GameDispatcher.Instance.Dispatch(BingoInfo.AddPropRewardFinish);
+                });
+            }
+        }
+    }
+}

Assets/BingoBrain/System/Game/PropSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 50ac908e0a924267a828484ebef77c29
+timeCreated: 1699946782

Assets/BingoBrain/System/Game/TomorrowSystem.cs

@@ -0,0 +1,46 @@
+using System;
+using BingoBrain;
+using BingoBrain.Core;
+using UnityEngine;
+
+public class TomorrowSystem : BaseSystem
+{
+    public TomorrowSystem(bool isAutoInit = true)
+    {
+        if (isAutoInit)
+        {
+            Init();
+        }
+    }
+    public override void Init()
+    {
+        base.Init();
+        AddListener();
+    }
+
+    private void AddListener()
+    {
+        CtrlDispatcher.Instance.AddPriorityListener(CtrlMsg.Game_Start, GameStart);
+    }
+
+    private void GameStart(object o)
+    {
+        Hall.Instance.UpdateSecondEvent += CheckNewDay;
+        CheckNewDay();
+    }
+
+
+    private void CheckNewDay()
+    {
+        if (GameHelper.GetNowTime() > PreferencesMgr.Instance.NextNewDayTime)
+        {
+            DateTime dateTime = DateTimeBoardk.Instance.GetDateTime(DateTimeBoardk.Instance.GetServerCurrTimestamp());
+            dateTime = dateTime.AddDays(1);
+            dateTime = new DateTime(dateTime.Year, dateTime.Month, dateTime.Day);
+            PreferencesMgr.Instance.NextNewDayTime = (long)DateTimeBoardk.Instance.GetTimestamp(dateTime);
+            CtrlDispatcher.Instance.Dispatch(CtrlMsg.GameNewDays);
+            Debug.Log("NewDay");
+        }
+
+    }
+}

Assets/BingoBrain/System/Game/TomorrowSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f6d6f86aade744beb9b911d6c035c2fe
+timeCreated: 1699955312

Assets/BingoBrain/System/Game/TuSystem.cs

@@ -0,0 +1,236 @@
+using System;
+using BingoBrain.Core;
+using System.Collections.Generic;
+
+namespace BingoBrain
+{
+    public class TuSystem : BaseSystem
+    {
+        public TuSystem(bool isAutoInit = true)
+        {
+            if (isAutoInit)
+            {
+                Init();
+            }
+        }
+
+        public sealed override void Init()
+        {
+            base.Init();
+
+            AddListener();
+        }
+
+        private void AddListener()
+        {
+            CtrlDispatcher.Instance.AddListener(CtrlMsg.ConsumeResources, OnConsumeResources);
+        }
+
+        private void OnConsumeResources(object obj)
+        {
+            var consumeVal = (ConsumeVal)obj;
+
+            var consumeSuccessCount = 0;
+            for (var index = 0; index < consumeVal.ItemId.Count; index++)
+            {
+                var item = consumeVal.ItemId[index];
+                var itemValue = consumeVal.ItemVal[index];
+                switch (item)
+                {
+                    case 101:
+                        if (itemValue <= PreferencesMgr.Instance.Currency101)
+                        {
+                            consumeSuccessCount++;
+                        }
+                        else
+                        {
+                            GameHelper.Toast("outTicket", true);
+                        }
+
+                        break;
+                    case 102:
+                        if (itemValue <= PreferencesMgr.Instance.Currency102)
+                        {
+                            consumeSuccessCount++;
+                        }
+
+                        break;
+                    case 103:
+                        if (itemValue <= PreferencesMgr.Instance.Active)
+                        {
+                            consumeSuccessCount++;
+                        }
+
+                        break;
+                }
+            }
+
+            if (consumeVal.isConsume)
+            {
+                if (consumeSuccessCount == consumeVal.ItemId.Count)
+                {
+                    for (var index = 0; index < consumeVal.ItemId.Count; index++)
+                    {
+                        var item = consumeVal.ItemId[index];
+                        var itemValue = consumeVal.ItemVal[index];
+                        switch (item)
+                        {
+                            case 101:
+                                if (itemValue <= PreferencesMgr.Instance.Currency101)
+                                {
+                                    PreferencesMgr.Instance.Currency101 -= (int)itemValue;
+                                }
+
+                                break;
+                            case 102:
+                                if (itemValue <= PreferencesMgr.Instance.Currency102)
+                                {
+                                    PreferencesMgr.Instance.Currency102 -= itemValue;
+                                }
+
+                                break;
+                            case 103:
+                                if (itemValue <= PreferencesMgr.Instance.Active)
+                                {
+                                    PreferencesMgr.Instance.Active -= (int)itemValue;
+                                }
+
+                                break;
+                        }
+                    }
+
+                    consumeVal.onfinish?.Invoke(true);
+                }
+                else
+                {
+                    consumeVal.onfinish?.Invoke(false);
+                }
+            }
+            else
+            {
+                consumeVal.onfinish?.Invoke(consumeSuccessCount == consumeVal.ItemId.Count);
+            }
+
+            consumeVal.Release();
+        }
+
+        #region 消耗资源
+
+        public static void Consume(int itemId, int itemNum, Action<bool> onCompleted = null, bool isConsume = true)
+        {
+            var consumeVal = ConsumeVal.Get(itemId, itemNum, onCompleted);
+            consumeVal.isConsume = isConsume;
+            CtrlDispatcher.Instance.Dispatch(CtrlMsg.ConsumeResources, consumeVal);
+        }
+
+        public static void Consume(int itemId, decimal itemNum, Action<bool> onCompleted = null, bool isConsume = true)
+        {
+            var consumeVal = ConsumeVal.Get(itemId, itemNum, onCompleted);
+            consumeVal.isConsume = isConsume;
+            CtrlDispatcher.Instance.Dispatch(CtrlMsg.ConsumeResources, consumeVal);
+        }
+
+
+        public static void Consume(int[] itemIds, int[] itemNums, Action<bool> onCompleted = null,
+            bool isConsume = true)
+        {
+            var consumeVal = ConsumeVal.Get();
+            consumeVal.onfinish = onCompleted;
+            for (var i = 0; i < itemIds.Length; i++)
+            {
+                consumeVal.AddConsume(itemIds[i], itemNums[i]);
+            }
+
+            consumeVal.isConsume = isConsume;
+            CtrlDispatcher.Instance.Dispatch(CtrlMsg.ConsumeResources, consumeVal);
+        }
+
+        public static void Consume(int[] itemIds, decimal[] itemNums, Action<bool> onCompleted = null,
+            bool isConsume = true)
+        {
+            var consumeVal = ConsumeVal.Get();
+            consumeVal.onfinish = onCompleted;
+            for (var i = 0; i < itemIds.Length; i++)
+            {
+                consumeVal.AddConsume(itemIds[i], itemNums[i]);
+            }
+
+            consumeVal.isConsume = isConsume;
+            CtrlDispatcher.Instance.Dispatch(CtrlMsg.ConsumeResources, consumeVal);
+        }
+
+        #endregion
+
+        public static void CheckItem(int itemId, int itemNum, Action<bool> onCompleted = null)
+        {
+            Consume(itemId, itemNum, onCompleted, false);
+        }
+
+        public static void CheckItem(int itemId, decimal itemNum, Action<bool> onCompleted = null)
+        {
+            Consume(itemId, itemNum, onCompleted, false);
+        }
+
+        public static void CheckItem(int[] itemId, int[] itemNum, Action<bool> onCompleted = null)
+        {
+            Consume(itemId, itemNum, onCompleted, false);
+        }
+
+        public static void CheckItem(int[] itemId, decimal[] itemNum, Action<bool> onCompleted = null)
+        {
+            Consume(itemId, itemNum, onCompleted, false);
+        }
+    }
+
+
+    public class ConsumeVal
+    {
+        private static Jcna<ConsumeVal> _pool = new Jcna<ConsumeVal>();
+
+        public static ConsumeVal Get()
+        {
+            ConsumeVal val = _pool.Get();
+            return val;
+        }
+
+        public static ConsumeVal Get(int id, float sum)
+        {
+            return Get(id, sum);
+        }
+
+        public static ConsumeVal Get(int id, decimal sum, Action<bool> finish = null)
+        {
+            ConsumeVal val = _pool.Get();
+            val.AddConsume(id, sum);
+            val.onfinish = finish;
+            return val;
+        }
+
+
+        public void Release()
+        {
+            ItemId.Clear();
+            ItemVal.Clear();
+            isConsume = true;
+            onfinish = null;
+            _pool.Release(this);
+        }
+
+        public ConsumeVal()
+        {
+        }
+
+        public Action<bool> onfinish;
+
+        public List<int> ItemId = new List<int>();
+        public List<decimal> ItemVal = new List<decimal>();
+
+        public bool isConsume = true;
+
+        public void AddConsume(int id, decimal sum)
+        {
+            ItemId.Add(id);
+            ItemVal.Add(sum);
+        }
+    }
+}

Assets/BingoBrain/System/Game/TuSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fcd01defe47f4c65b155e8edb148d1cc
+timeCreated: 1692785015

Assets/BingoBrain/System/Game/UsaSystem.cs

@@ -0,0 +1,231 @@
+using DG.Tweening;
+using BingoBrain;
+using BingoBrain.Core;
+using BingoBrain.HotFix;
+using UnityEngine;
+
+public class UsaSystem : BaseSystem
+{
+    private static Tween _tween;
+
+    public UsaSystem(bool isAutoInit = true)
+    {
+        if (isAutoInit)
+        {
+            Init();
+        }
+    }
+
+    public override void Init()
+    {
+        base.Init();
+        AddListener();
+    }
+
+    private void AddListener()
+    {
+        GameDispatcher.Instance.AddListener(BingoInfo.GetReward, OnGetReward);
+    }
+
+
+    private void OnGetReward(object obj)
+    {
+        if (obj is not RewardData rewardData)
+        {
+            return;
+        }
+
+
+        if (IsRewardDialog(rewardData))
+        {
+            if (!GameHelper.IsGiftSwitch()) UICtrlDispatcher.Instance.Dispatch(SkinInfo.GodPleUI_Open, rewardData);
+            else
+            {
+                var temp = new SuccessData();
+                temp.IsWin = true;
+                temp.cash_number = (float)rewardData.rewardDataList[0].value;
+                temp.rate =  (int)GameHelper.GetRewardValue(2)[1];
+                temp.IsLevelSuccess = false;
+                temp.IsH5Reward = true;
+                UICtrlDispatcher.Instance.Dispatch(UICtrlMsg.LevelSuccessUI_Open, temp);
+            }
+        }
+        else
+        {
+            if (IsRewardNumber(rewardData))
+            {
+                rewardData.OnCompleted(true);
+                GameDispatcher.Instance.Dispatch(BingoInfo.ProcessReward, rewardData);
+            }
+            else
+            {
+                GetReward(rewardData);
+            }
+        }
+    }
+
+
+    public static bool IsRewardFly(RewardData rewardData)
+    {
+        return (RewardDisplayType.RewardFly & rewardData.displayType) == RewardDisplayType.RewardFly;
+    }
+
+
+    public static bool IsRewardValueChange(RewardData rewardData)
+    {
+        return (RewardDisplayType.ValueChange & rewardData.displayType) == RewardDisplayType.ValueChange;
+    }
+
+
+    public static bool IsRewardNumber(RewardData rewardData)
+    {
+        return (RewardDisplayType.Number & rewardData.displayType) == RewardDisplayType.Number;
+    }
+
+
+    public static bool IsRewardDialog(RewardData rewardData)
+    {
+        return (RewardDisplayType.Dialog & rewardData.displayType) == RewardDisplayType.Dialog;
+    }
+
+
+    public static void GetReward(RewardData rewardData)
+    {
+        PlayReward(rewardData);
+        GameDispatcher.Instance.Dispatch(BingoInfo.ProcessReward, rewardData);
+    }
+
+
+    private static void PlayReward(RewardData rewardData)
+    {
+        if (rewardData == null) return;
+        var completed = 0;
+
+        foreach (var rewardSingleData in rewardData.GetRewardDataList())
+        {
+            var id = rewardSingleData.id;
+            var sum = rewardSingleData.value;
+
+            if (sum <= 0)
+            {
+                continue;
+            }
+
+            switch (rewardSingleData.origin)
+            {
+                case RewardOrigin.Play:
+                case RewardOrigin.Slot:
+                case RewardOrigin.PickBox:
+                case RewardOrigin.PlayCard:
+                case RewardOrigin.MoreCard:
+                case RewardOrigin.PlayBallon:
+                    BingoCell.AddReadSum(id, sum);
+                    break;
+            }
+
+
+            var isValueChange = IsRewardValueChange(rewardData);
+            if (isValueChange)
+            {
+                if (rewardSingleData.endPosition == Vector2.zero && id is 101 or 102)
+                {
+                    if (!UI.Instance.IsExistUI(UIConst.SmailUI))
+                    {
+                        if (_tween is { active: true })
+                        {
+                            _tween?.Kill();
+                        }
+                    }
+                }
+                else if (id == 111)
+                {
+                    if (_tween is { active: true })
+                    {
+                        _tween?.Kill();
+                    }
+                }
+
+
+                SetRewardValueChangeState(id, true);
+            }
+
+
+            if (!rewardSingleData.IsCanFly())
+            {
+                continue;
+            }
+
+
+            var isNeedFly = IsRewardFly(rewardData);
+
+            rewardSingleData.InitFlyPosition();
+
+            var rewardDisplayModel = new GodDa(rewardSingleData)
+            {
+                isSingle = rewardData.isSingle,
+                isPlayAudio = true,
+                isNeedFly = isNeedFly,
+                isNeedValueChange = isValueChange,
+                audioName = DoConst.CoinFly
+            };
+
+            rewardDisplayModel.SetUpdate(changeValue => { OnChangeValue(id, changeValue); });
+            rewardDisplayModel.SetUpdateComplete(() =>
+            {
+                completed++;
+                if (isValueChange)
+                {
+                    SetRewardValueChangeState(id, false);
+                    if (id is 101 or 102)
+                    {
+                        if (!UI.Instance.IsExistUI(UIConst.SmailUI))
+                        {
+                            _tween = DOVirtual.DelayedCall(0.5f, () => { });
+                        }
+                    }
+                }
+
+                if (completed >= rewardData.GetRewardFlyCount())
+                {
+                    rewardData.OnCompleted(true);
+                }
+            });
+
+            UICtrlDispatcher.Instance.Dispatch(SkinInfo.GodPleAcUI_Open, rewardDisplayModel);
+        }
+    }
+
+
+    private static void SetRewardValueChangeState(int id, bool isShow)
+    {
+        switch (id)
+        {
+            case 101:
+                PreferencesMgr.Instance.IsShowRewardFly101 = isShow;
+                break;
+            case 102:
+                PreferencesMgr.Instance.IsShowRewardFly102 = isShow;
+                break;
+            case 105:
+                PreferencesMgr.Instance.IsShowRewardFly105 = isShow;
+                break;
+            case 106:
+                PreferencesMgr.Instance.IsShowRewardFly106 = isShow;
+                break;
+        }
+    }
+
+
+    private static void OnChangeValue(int id, decimal changeValue)
+    {
+        switch (id)
+        {
+            case 101:
+                GameDispatcher.Instance.Dispatch(BingoInfo.Update101, changeValue);
+                break;
+            case 102:
+                GameDispatcher.Instance.Dispatch(BingoInfo.Update102, changeValue);
+                break;
+        }
+    }
+}

Assets/BingoBrain/System/Game/UsaSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b41a4be29284494880840871bb69070a
+timeCreated: 1692696618