备份CatanBuilding瘦身独立工程

Assets/Scripts/Aquarium/DataCenter/AquariumManager.cs

@@ -0,0 +1,654 @@
+using asap.core;
+using cfg;
+using game;
+using GameCore;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using UnityEngine;
+
+public class AquariumManager
+{
+    public const string AquariumEventDataKey = "AquariumEventDataKey";
+    private cfg.Tables _tables;
+    private ICustomServerMgr customServerMgr;
+    public AquariumManagerData data { get; private set; }
+    public int MapId => data.mapId;
+    public int Slot => data.slot;
+    public List<string> eggNames;
+    public List<AquariumSlotData> sellList;
+    public AquariumManager()
+    {
+        _tables = GContext.container.Resolve<Tables>();
+        customServerMgr = GContext.container.Resolve<ICustomServerMgr>();
+    }
+    public async Task Synchrodata()
+    {
+        //从服务器拿数据
+        string dataStr = PlayFabMgr.Instance.GetLocalData(AquariumEventDataKey);
+        if (string.IsNullOrEmpty(dataStr))
+        {
+            //新数据
+            data = new AquariumManagerData();
+            data.startTime = ZZTimeHelper.UtcNow().AddDays(-2);
+            data.refreshCount = 0;
+            data.adCount = 0;
+            data.refreshDay = ZZTimeHelper.UtcNow().UtcNowOffset().Date.DayOfYear;
+
+            data.slot = GContext.container.Resolve<PlayerData>().benefitsAquariumLimit;
+        }
+        else
+        {
+            data = Newtonsoft.Json.JsonConvert.DeserializeObject<AquariumManagerData>(dataStr);
+            if (data.slotDatas == null || data.slotDatas.Count < data.slot)
+            {
+                return;
+            }
+            GetAquariumDataRequest request = new GetAquariumDataRequest();
+            request.playFabId = GContext.container.Resolve<IUserService>().UserId;
+            string result = await customServerMgr.CustomServerPost("aquarium/GetAquariumData", Newtonsoft.Json.JsonConvert.SerializeObject(request));
+            AquariumServerData serverData = null;
+            if (result != null)
+            {
+                var resp = JsonConvert.DeserializeObject<GetAquariumDataResp>(result);
+                if (resp.code == 0)
+                {
+                    serverData = resp.data;
+                }
+                else if (resp.code == 1)
+                {
+                    Debug.LogWarning("GetAquariumDataRequest Null");
+                }
+                else
+                {
+                    Debug.LogError("GetAquariumDataRequest Null");
+                }
+            }
+            if (serverData != null)
+            {
+                data.aquariumHurtDatas = serverData.aquariumHurtDatas ?? new List<AquariumHurtData>();
+                int count = data.slot - data.aquariumHurtDatas.Count;
+                if (count > 0)
+                {
+                    for (int i = 0; i < count; i++)
+                    {
+                        AquariumHurtData aquariumHurtData = new AquariumHurtData();
+                        data.aquariumHurtDatas.Add(aquariumHurtData);
+                    }
+                }
+                data.aquariumResultDatas = serverData.aquariumResultDatas ?? new List<AquariumResultData>();
+                count = data.slot - data.aquariumResultDatas.Count;
+                if (count > 0)
+                {
+                    for (int i = 0; i < count; i++)
+                    {
+                        AquariumResultData aquariumResultData = new AquariumResultData();
+                        data.aquariumResultDatas.Add(aquariumResultData);
+                    }
+                }
+                PlayFabMgr.Instance.UpdateUserDataValue(AquariumEventDataKey, Newtonsoft.Json.JsonConvert.SerializeObject(data));
+            }
+
+            //for (int i = 0; i < data.aquariumResultDatas.Count; i += 2)
+            //{
+            //    data.aquariumResultDatas[i].playerID = GContext.container.Resolve<IUserService>().UserId;
+            //    data.aquariumResultDatas[i].displayName = GContext.container.Resolve<IUserService>().DisplayName;
+            //}
+
+            SetJury();
+            //保存 数据
+            SaveData(serverData == null);
+        }
+    }
+    void SetJury()
+    {
+        var dateTime = ZZTimeHelper.UtcNow();
+        AquariumFish aquariumFish = null;
+        for (int i = 0; i < data.slot; i++)
+        {
+            AquariumSlotData slotData = data.slotDatas[i];
+            slotData.index = i;
+            AquariumHurtData aquariumHurtData = data.aquariumHurtDatas[i];
+            //没有受新伤
+            if (aquariumHurtData.injuryTime < slotData.allRecoveryTime + 0.0001f)
+            {
+                continue;
+            }
+
+            var HatchTime = slotData.FishHatchTime();
+            //还没孵化
+            if (HatchTime > dateTime)
+            {
+                continue;
+            }
+            //检查是否受伤
+            //正常的成长时间 自然时间+加速成长-总恢复时间
+            float normalH = (float)(dateTime - HatchTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+            //受伤时的成长时间 受伤时的时间+加速成长-受伤时的总恢复时间
+            float injuryH = slotData.injuryGrowthTime;
+
+            aquariumFish = _tables.TbAquariumFish.GetOrDefault(slotData.aquariumFishID);
+            //受伤时的成长进度大于正常的成长进度=还没恢复
+            if (injuryH > normalH)
+            {
+                var recoveryTime = UnityEngine.Random.Range(aquariumFish.RecoveryTime[0], aquariumFish.RecoveryTime[1]);
+                slotData.recoveryTime = recoveryTime;
+                recoveryTime -= injuryH - normalH;
+                //处于受伤状态刷新时间
+                if (recoveryTime > 0)
+                {
+                    slotData.allRecoveryTime += recoveryTime;
+                }
+            }
+            else
+            {
+                //不处于受伤状态添加受伤时间
+                //当前正常的成长进度 自然时间+加速成长 - 全部恢复时间
+                //受伤时的成长时间 受伤时的时间+加速成长-受伤时的总恢复时间
+
+                slotData.injuryGrowthTime = (float)(dateTime - HatchTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+                slotData.recoveryTime = UnityEngine.Random.Range(aquariumFish.RecoveryTime[0], aquariumFish.RecoveryTime[1]);
+                slotData.allRecoveryTime += slotData.recoveryTime;
+            }
+
+        }
+    }
+    public void GetRandmMap()
+    {
+        PlayerData playerData = GContext.container.Resolve<PlayerData>();
+        PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();
+
+        data.startTime = ZZTimeHelper.UtcNow();
+        data.slot = playerData.benefitsAquariumLimit;
+        List<AquariumInit> inits = _tables.TbAquariumInit.DataList;
+        if (data.startCount < inits.Count)
+        {
+            NewSlotInitData(inits[data.startCount]);
+        }
+        else
+        {
+            NewSlotData();
+        }
+        data.refreshCount++;
+        data.isHome = false;
+        data.startCount++;
+        //保存 数据
+        SaveData(true);
+        GContext.container.Resolve<TriggerPackData>().RefreshTriggerPackData(4000201, data.mapId);
+
+#if AGG
+        int fishcard_totallevel = playerFishData.GetFishLevelByMap(data.mapId);
+        string egg_quality_list = data.slotDatas[0].eggId.ToString();
+        for (int i = 1; i < data.slotDatas.Count; i++)
+        {
+            egg_quality_list = $"{egg_quality_list},{data.slotDatas[i].eggId}";
+        }
+        using (var e = GEvent.GameEvent("aquarium_start"))
+        {
+            e.AddContent("map_id", data.mapId)
+            .AddContent("total_eggpots", data.slot)
+            .AddContent("fishcard_totallevel", fishcard_totallevel)
+            .AddContent("egg_quality_list", egg_quality_list);
+        }
+#endif
+    }
+    void NewSlotInitData(AquariumInit init)
+    {
+        data.mapId = init.MapID;
+        List<AquariumSlotData> slotDatas = new List<AquariumSlotData>();
+        List<AquariumHurtData> aquariumHurtDatas = new List<AquariumHurtData>();
+        List<AquariumResultData> aquariumResultDatas = new List<AquariumResultData>();
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+
+        List<AquariumEgg> TankEggList = _tables.TbAquariumEgg.DataList;
+        eggNames = new List<string>();
+        for (int i = 0; i < TankEggList.Count; i++)
+        {
+            eggNames.Add(TankEggList[i].Icon);
+        }
+
+        List<int> Egglist = init.Egglist;
+        List<int> FishQualitylist = init.FishQualitylist;
+        List<int> FishList = init.Fishlist;
+        List<int> FishQuatitylist = init.FishQuatitylist;
+        List<int> FishMutantlist = init.FishMutantlist;
+
+
+        for (int i = 0; i < data.slot; i++)
+        {
+            AquariumSlotData aquariumSlotData = new AquariumSlotData();
+            aquariumSlotData.eggId = Egglist[i];
+            aquariumSlotData.aquariumFishID = FishQualitylist[i];
+            aquariumSlotData.fishMQ = FishQuatitylist[i];
+            aquariumSlotData.fishItemID = FishList[i];
+
+            var tankEgg = _tables.TbAquariumEgg.GetOrDefault(Egglist[i]);
+
+            aquariumSlotData.startTime = dateTime;
+            aquariumSlotData.hatchTime = UnityEngine.Random.Range(tankEgg.HatchTime[0], tankEgg.HatchTime[1]);
+
+            AquariumFish aquariumFish = _tables.TbAquariumFish.GetOrDefault(FishQualitylist[i]);
+
+            float allCash = SetRewardCount(aquariumFish.SoldReward);
+            float soldRewardRand = UnityEngine.Random.Range(0, aquariumFish.SoldRewardRand) - aquariumFish.SoldRewardRand * 0.5f;
+            aquariumSlotData.allCash = allCash * (1 + soldRewardRand);
+
+            aquariumSlotData.growthTime = UnityEngine.Random.Range(aquariumFish.GrowthTime[0], aquariumFish.GrowthTime[1]);
+            aquariumSlotData.mutants = FishMutantlist[i];
+            aquariumSlotData.index = i;
+            slotDatas.Add(aquariumSlotData);
+
+            AquariumHurtData aquariumHurtData = new AquariumHurtData();
+            aquariumHurtDatas.Add(aquariumHurtData);
+
+            AquariumResultData aquariumResultData = new AquariumResultData();
+            aquariumResultDatas.Add(aquariumResultData);
+        }
+        data.slotDatas = slotDatas;
+        data.aquariumHurtDatas = aquariumHurtDatas;
+        data.aquariumResultDatas = aquariumResultDatas;
+    }
+
+    void SetAquariumFish(MapData mapData, AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
+    {
+        List<FishItemList> fishList = mapData.DropFishList;
+
+        //权重取鱼
+        int allProb = tankEgg.HatchFishQualityProb.Sum();
+        int prob = UnityEngine.Random.Range(0, allProb);
+        int curProb = 0;
+        int fishQuality = tankEgg.HatchFishQuality[^1];
+        for (int k = 0; k < tankEgg.HatchFishQuality.Count; k++)
+        {
+            curProb += tankEgg.HatchFishQualityProb[k];
+            if (curProb > prob)
+            {
+                fishQuality = tankEgg.HatchFishQuality[k];
+                break;
+            }
+        }
+        //品质大于6？？？
+        if (6 > fishQuality)
+        {
+            List<int> FishIDList = fishList[fishQuality - 1].FishIDList;
+            aquariumSlotData.fishItemID = FishIDList[UnityEngine.Random.Range(0, FishIDList.Count)];
+        }
+        else
+        {
+            List<int> FishIDList = _tables.TbAquariumConfig.AquariumSpFishList;
+            aquariumSlotData.fishItemID = FishIDList[UnityEngine.Random.Range(0, FishIDList.Count)];
+        }
+        aquariumSlotData.aquariumFishID = fishQuality;
+        //取鱼的数量
+        allProb = tankEgg.HatchFishQuantityProb.Sum();
+        prob = UnityEngine.Random.Range(0, allProb);
+        curProb = 0;
+        int fishCount = tankEgg.HatchFishQuantity[0];
+        for (int k = 0; k < tankEgg.HatchFishQuantity.Count; k++)
+        {
+            curProb += tankEgg.HatchFishQuantityProb[k];
+            if (curProb > prob)
+            {
+                fishCount = tankEgg.HatchFishQuantity[k];
+                break;
+            }
+        }
+        aquariumSlotData.fishMQ = fishCount;
+    }
+
+    void SetTime(AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
+    {
+        aquariumSlotData.hatchTime = UnityEngine.Random.Range(tankEgg.HatchTime[0], tankEgg.HatchTime[1]);
+
+        AquariumFish aquariumFish = _tables.TbAquariumFish.GetOrDefault(aquariumSlotData.aquariumFishID);
+
+        float allCash = SetRewardCount(aquariumFish.SoldReward);
+        float soldRewardRand = UnityEngine.Random.Range(0, aquariumFish.SoldRewardRand) - aquariumFish.SoldRewardRand * 0.5f;
+        aquariumSlotData.allCash = allCash * (1 + soldRewardRand);
+
+        aquariumSlotData.growthTime = UnityEngine.Random.Range(aquariumFish.GrowthTime[0], aquariumFish.GrowthTime[1]);
+        aquariumSlotData.mutants = 0;
+        for (int j = 0; j < aquariumSlotData.fishMQ; j++)
+        {
+            if (UnityEngine.Random.Range(0, 1f) < aquariumFish.MutantProb)
+            {
+                aquariumSlotData.mutants++;
+            }
+        }
+    }
+    void NewSlotData()
+    {
+        int curMapId = MapId;
+
+        var mapDatas = _tables.TbMapData.DataList;
+        var maxMapID = GContext.container.Resolve<PlayerData>().lastMapId;
+
+        //非当前地图
+        var mapIDs = new List<int>();
+        for (int i = 0; i < mapDatas.Count; i++)
+        {
+            if (mapDatas[i].ID <= maxMapID)
+            {
+                if (mapDatas[i].ID != curMapId)
+                {
+                    mapIDs.Add(mapDatas[i].ID);
+                }
+            }
+            else
+            {
+                break;
+            }
+        }
+        if (mapIDs.Count == 0)
+        {
+            data.mapId = maxMapID;
+        }
+        else
+        {
+            data.mapId = mapIDs[UnityEngine.Random.Range(0, mapIDs.Count)];
+        }
+
+        List<AquariumSlotData> slotDatas = new List<AquariumSlotData>();
+        List<AquariumHurtData> aquariumHurtDatas = new List<AquariumHurtData>();
+        List<AquariumResultData> aquariumResultDatas = new List<AquariumResultData>();
+
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+        MapData mapData = _tables.TbMapData.GetOrDefault(data.mapId);
+        List<AquariumEgg> TankEggList = _tables.TbAquariumEgg.DataList;
+        float eggAllWeight = -0.0001f;
+        eggNames = new List<string>();
+        for (int i = 0; i < TankEggList.Count; i++)
+        {
+            eggNames.Add(TankEggList[i].Icon);
+            eggAllWeight += TankEggList[i].Weight;
+        }
+        for (int i = 0; i < data.slot; i++)
+        {
+            AquariumSlotData aquariumSlotData = new AquariumSlotData();
+            //权重取蛋
+            float eggWeight = UnityEngine.Random.Range(0, eggAllWeight);
+            float curEggWeight = 0;
+            AquariumEgg tankEgg = TankEggList[0];
+            foreach (var item in TankEggList)
+            {
+                curEggWeight += item.Weight;
+                if (curEggWeight > eggWeight)
+                {
+                    tankEgg = item;
+                    break;
+                }
+            }
+            aquariumSlotData.eggId = tankEgg.ID;
+            SetAquariumFish(mapData, aquariumSlotData, tankEgg);
+            aquariumSlotData.startTime = dateTime;
+            SetTime(aquariumSlotData, tankEgg);
+            aquariumSlotData.index = i;
+            slotDatas.Add(aquariumSlotData);
+
+            AquariumHurtData aquariumHurtData = new AquariumHurtData();
+            aquariumHurtDatas.Add(aquariumHurtData);
+
+            AquariumResultData aquariumResultData = new AquariumResultData();
+            aquariumResultDatas.Add(aquariumResultData);
+        }
+        data.slotDatas = slotDatas;
+        data.aquariumHurtDatas = aquariumHurtDatas;
+        data.aquariumResultDatas = aquariumResultDatas;
+    }
+
+    public void Speedup(bool isGuide)
+    {
+        var dateTime = ZZTimeHelper.UtcNow();
+        float AdAccelerate = _tables.TbAquariumConfig.AdAccelerate;
+        if (isGuide)
+        {
+            AdAccelerate = _tables.TbAquariumConfig.AdAccelerateFirst;
+        }
+        List<AquariumSlotData> slotDataList = data.slotDatas;
+        List<AquariumResultData> aquariumReportDatas = data.aquariumResultDatas;
+        for (int i = 0; i < slotDataList.Count; i++)
+        {
+            var slotData = slotDataList[i];
+
+            //售卖或者丢失
+            if (slotData.IsResult() || aquariumReportDatas[slotData.index].IsResult())
+            { continue; }
+            var HatchTime = slotData.FishHatchTime();
+            if (HatchTime <= dateTime)
+            {
+                //鱼加速
+                slotData.accelerationGrowth += AdAccelerate;
+            }
+            else
+            {
+                float s = (float)(HatchTime - dateTime).TotalHours;
+                if (s <= 0)
+                {
+                    slotData.accelerationGrowth += AdAccelerate;
+                }
+                else if (AdAccelerate > s)
+                {
+                    slotData.accelerationHatch += s;
+                    slotData.accelerationGrowth += AdAccelerate - s;
+                }
+                else
+                {
+                    slotData.accelerationHatch += AdAccelerate;
+                }
+            }
+        }
+        data.adCount++;
+        SaveData();
+    }
+
+    public void SellFish(List<AquariumSlotData> slotDataList)
+    {
+        sellList = new List<AquariumSlotData>();
+        var dateTime = ZZTimeHelper.UtcNow();
+        PlayerData playerData = GContext.container.Resolve<PlayerData>();
+        var weight = GetWeightMag();
+        AquariumFish aquariumFish;
+        FishData fishData;
+        DateTime startTime;
+        float injuryH;
+        float weightIncEvent;
+        List<ItemData> itemDatas = new List<ItemData>();
+        PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();
+        float CashMag = (1 + playerData.benefitsCashMag) * (1 + playerData.benefitsAquariumCashMag);
+        for (int i = 0; i < slotDataList.Count; i++)
+        {
+            var slotData = slotDataList[i];
+            sellList.Add(slotData);
+            if (slotData.allCash == 0)
+            {
+                slotData.allCash = 1;
+            }
+            //奖励
+            aquariumFish = _tables.TbAquariumFish.GetOrDefault(slotData.aquariumFishID);
+            startTime = slotData.FishHatchTime();
+            injuryH = slotData.injuryGrowthTime;
+            weightIncEvent = (1 + weight[slotData.aquariumFishID - 1]) * CashMag;
+
+            float normalH = (float)(dateTime - startTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+
+            float rewardProgress = normalH / slotData.growthTime;
+
+            if (injuryH > normalH && injuryH > slotData.growthTime)
+            {
+                rewardProgress = 1 - ((injuryH - normalH) / slotData.growthTime);
+            }
+
+            if (rewardProgress > 1)
+            {
+                rewardProgress = 1;
+            }
+
+            //金币显示
+            ItemData itemData = new ItemData();
+
+            int fishQ = slotData.fishMQ;
+            bool is_injured = false;
+            if (injuryH > normalH)
+            {
+                fishQ -= data.aquariumHurtDatas[slotData.index].fishLQ;
+                is_injured = true;
+                if (fishQ <= 0)
+                {
+                    fishQ = 1;
+                }
+            }
+            for (int j = 0; j < fishQ; j++)
+            {
+                if (j < slotData.mutants)
+                {
+                    itemData.count += (int)(slotData.allCash * (1 + aquariumFish.MutantGrowthExtraSoldReward * rewardProgress) * (1 + aquariumFish.MutantExtraSoldReward) * weightIncEvent);
+                }
+                else
+                {
+                    itemData.count += (int)(slotData.allCash * (1 + aquariumFish.GrowthExtraSoldReward * rewardProgress) * weightIncEvent);
+                }
+            }
+            itemData.id = 1002;
+
+            itemDatas.Add(itemData);
+            slotData.cash = itemData.count;
+
+            //重量
+            Item item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
+            fishData = _tables.TbFishData.GetOrDefault(item.RedirectID);
+            float weightCount = fishData.BaseWeight * (1 + aquariumFish.GrowthExtraSoldReward * rewardProgress) * weightIncEvent;
+            playerFishData.SetWeight(fishData.ID, weightCount);
+#if AGG
+            int cardLevel = playerFishData.GetDataLevel(fishData.ID);
+            using (var e = GEvent.GameEvent("aquarium_sell"))
+            {
+                e.AddContent("map_id", data.mapId)
+                    .AddContent("total_eggpots", data.slot)
+                    .AddContent("fish_eggs_quality", slotData.eggId)
+                    .AddContent("mature_percent", rewardProgress)
+                    .AddContent("fish_id", fishData.ID)
+                    .AddContent("fishcard_level", cardLevel)
+                    .AddContent("fish_quality", slotData.aquariumFishID)
+                    .AddContent("mutant_count", slotData.mutants)
+                    .AddContent("is_injured", is_injured)
+                    .AddContent("fish_count", slotData.fishMQ)
+                    .AddContent("is_dead", false)
+                    .AddContent("reward_cash", slotData.cash);
+            }
+#endif
+        }
+        //GContext.Publish(new ShowData(itemDatas));
+        GContext.container.Resolve<PlayerItemData>().AddItem(itemDatas);
+        //GContext.Publish(new ShowData());
+        CheckInHome();
+        SaveData();
+    }
+
+    public float SetRewardCount(int dropID)
+    {
+        DropPackageList dropPackageList = _tables.TbDrop[dropID].DropList;
+        return dropPackageList.DropCountList[0];
+    }
+
+    public void CheckInHome()
+    {
+        data.isHome = true;
+        List<AquariumResultData> aquariumResultDatas = data.aquariumResultDatas;
+        var slotDatas = data.slotDatas;
+        for (int i = 0; i < data.slot; i++)
+        {
+            if (!slotDatas[i].IsResult() && !aquariumResultDatas[i].IsResult())
+            {
+                data.isHome = false;
+            }
+        }
+        if (data.isHome)
+        {
+#if AGG
+            PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();
+            for (int i = 0; i < data.slot; i++)
+            {
+                if (!slotDatas[i].IsResult() && aquariumResultDatas[i].IsResult())
+                {
+                    var fishItem = _tables.TbItem.GetOrDefault(slotDatas[i].fishItemID);
+                    int cardLevel = playerFishData.GetDataLevel(fishItem.RedirectID);
+                    using (var e = GEvent.GameEvent("aquarium_sell"))
+                    {
+                        e.AddContent("map_id", data.mapId)
+                        .AddContent("total_eggpots", data.slot)
+                            .AddContent("fish_eggs_quality", slotDatas[i].eggId)
+                            .AddContent("mature_percent", 0)
+                            .AddContent("fish_id", fishItem.RedirectID)
+                            .AddContent("fishcard_level", cardLevel)
+                            .AddContent("fish_quality", slotDatas[i].aquariumFishID)
+                            .AddContent("mutant_count", slotDatas[i].mutants)
+                            .AddContent("is_injured", true)
+                            .AddContent("is_dead", true)
+                            .AddContent("fish_count", 0)
+                            .AddContent("reward_cash", 0);
+                    }
+                }
+            }
+#endif
+            //_ = UIManager.Instance.ShowUI(UITypes.AquariumReportPopupPanel);
+            SaveData();
+        }
+    }
+    void SaveData(bool all = false)
+    {
+        if (all)
+        {
+            UpdateAquariumAllDataRequest request = new UpdateAquariumAllDataRequest();
+            request.playFabId = GContext.container.Resolve<IUserService>().UserId;
+            request.data = new AquariumServerData()
+            {
+                startTime = data.startTime,
+                mapId = data.mapId,
+                slot = data.slot,
+                slotDatas = data.slotDatas,
+                aquariumResultDatas = data.aquariumResultDatas,
+                aquariumHurtDatas = data.aquariumHurtDatas,
+            };
+            customServerMgr.CustomServerPost("aquarium/UpdateAquariumData", Newtonsoft.Json.JsonConvert.SerializeObject(request));
+        }
+        else
+        {
+            UpdateSlotDatasRequest request = new UpdateSlotDatasRequest();
+            request.playFabId = GContext.container.Resolve<IUserService>().UserId;
+            request.slotDatas = data.slotDatas;
+            customServerMgr.CustomServerPost("aquarium/UpdateSlotData", Newtonsoft.Json.JsonConvert.SerializeObject(request));
+        }
+        PlayFabMgr.Instance.UpdateUserDataValue(AquariumEventDataKey, Newtonsoft.Json.JsonConvert.SerializeObject(data));
+    }
+
+    public List<float> GetWeightMag()
+    {
+        PlayerFishData playerFishData = GContext.container.Resolve<PlayerFishData>();
+        PlayerData playerData = GContext.container.Resolve<PlayerData>();
+        List<float> weight = new List<float>() { 0, 0, 0, 0, 0, 0 };
+        List<int> fishCount = new List<int>() { 0, 0, 0, 0, 0, 0 };
+        MapData mapData = _tables.TbMapData.GetOrDefault(data.mapId);
+        var fishList = mapData.FishList;
+        for (int j = 0; j < fishList.Count; j++)
+        {
+            var data = _tables.TbFishData.GetOrDefault(fishList[j]);
+            fishCount[data.Quality - 1]++;
+            int level = playerFishData.GetDataLevel(fishList[j]);
+            if (level > 0)
+            {
+                FishCard fishCard = _tables.TbFishCard.GetOrDefault(data.FishCardID);
+                weight[data.Quality - 1] += fishCard.WeightMagList[level - 1];
+            }
+        }
+        for (int i = 0; i < weight.Count; i++)
+        {
+            weight[i] /= fishCount[i];
+        }
+        weight[5] = playerData.benefitsEventFishCashMag;
+
+        return weight;
+    }
+}
+

Assets/Scripts/Aquarium/DataCenter/AquariumManager.cs.meta

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

Assets/Scripts/Aquarium/DataCenter/AquariumModel.cs

@@ -0,0 +1,188 @@
+using System.Collections.Generic;
+using System;
+
+public class AquariumSlotData
+{
+    public int index { get; set; }
+    public int eggId { set; get; }
+    public int fishItemID { set; get; }
+    public int aquariumFishID { set; get; }
+    /// <summary>
+    /// 是否变异
+    /// </summary>
+    public int mutants { set; get; }
+
+    /// <summary>
+    /// maximum quantity 孵化的数量
+    /// </summary>
+    public int fishMQ { set; get; }
+
+    /// <summary>
+    /// 鱼卵开始孵化
+    /// </summary>
+    public DateTime startTime { set; get; }
+
+    /// <summary>
+    /// 孵化时间
+    /// </summary>
+    public float hatchTime { set; get; }
+    /// <summary>
+    /// 成长时间
+    /// </summary>
+    public float growthTime { set; get; }
+
+    /// <summary>
+    /// 孵化加速时间 每次加量不会超出当前剩余时间
+    /// </summary>
+    public float accelerationHatch { set; get; }
+
+    /// <summary>
+    /// 成长加速时间
+    /// </summary>
+    public float accelerationGrowth { set; get; }
+
+
+    /// <summary>
+    /// 多次受伤的恢复时间
+    /// </summary>
+    public float allRecoveryTime { set; get; }
+    public float recoveryTime { set; get; }
+
+    /// <summary>
+    /// 发现受伤时的成长时间 自然时间+加速成长 - 当时全部恢复时间
+    /// </summary>
+    public float injuryGrowthTime { set; get; }
+
+    /// <summary>
+    /// 全部结算的钱
+    /// </summary>
+    public float allCash { get; set; }
+
+    /// <summary>
+    /// 结算的钱
+    /// </summary>
+    public int cash { get; set; }
+
+    /// <summary>
+    /// 鱼从孵化到成熟的时间 孵化间+成长时间-加速孵化-加速成长+恢复时间
+    /// </summary>
+    /// <returns></returns>
+    public DateTime FishGrowthTime()
+    {
+        return startTime.AddHours(hatchTime + growthTime - accelerationHatch - accelerationGrowth + allRecoveryTime);
+    }
+    public DateTime FishHatchTime()
+    {
+        return startTime.AddHours(hatchTime - accelerationHatch);
+    }
+
+    public bool IsResult()
+    {
+        return cash > 0;
+    }
+}
+
+public class AquariumHurtData
+{
+    /// <summary>
+    /// lost quantity 被刺数量服务器修改
+    /// </summary>
+    public int fishLQ { set; get; }
+    /// <summary>
+    /// 服务器标记受伤 injuryTime > slotData.allRecoveryTime 受新伤
+    /// </summary>
+    public float injuryTime { set; get; }
+}
+
+public class AquariumResultData
+{
+    /// <summary>
+    /// 如果鱼被刺走
+    /// </summary>
+    public string playerID { set; get; }
+    public string avatar { get; set; }
+    public string displayName { get; set; }
+    public bool IsResult()
+    {
+        return !string.IsNullOrEmpty(playerID);
+    }
+}
+
+
+public class AquariumManagerData
+{
+    /// <summary>
+    /// 客户端维护数据
+    /// </summary>
+    //CCCCCCCCCCCCCC客户端维护数据CCCCCCCCCCCCCC
+    public DateTime startTime { set; get; }
+    public int mapId { set; get; } = 101;
+    public int slot { set; get; }
+
+    public List<AquariumSlotData> slotDatas { set; get; }
+    //CCCCCCCCCCCCCC客户端维护数据CCCCCCCCCCCCCC
+
+    //SSSSSSSSSSSSSS结算，服务器刺鱼刺走SSSSSSSSSSSSSS
+    public List<AquariumResultData> aquariumResultDatas { set; get; }
+
+    public List<AquariumHurtData> aquariumHurtDatas { set; get; }
+    //SSSSSSSSSSSSSS被刺鱼受伤SSSSSSSSSSSSSS
+
+    public int adCount { set; get; }
+    public bool isHome { set; get; }
+    public int startCount { set; get; }
+    public int refreshCount { set; get; }
+    public int refreshDay { set; get; }
+}
+
+public class AquariumServerData
+{
+    public DateTime startTime { set; get; }
+    public int mapId { set; get; }
+    public int slot { set; get; }
+    public List<AquariumSlotData> slotDatas { set; get; }
+
+    public List<AquariumResultData> aquariumResultDatas { set; get; }
+
+    public List<AquariumHurtData> aquariumHurtDatas { set; get; }
+}
+public class UpdateAquariumAllDataRequest
+{
+    public string playFabId { set; get; }
+    public AquariumServerData data { get; set; }
+}
+public class GetAquariumDataRequest
+{
+    public string playFabId { set; get; }
+}
+public class GetAquariumDataResp
+{
+    public int code { set; get; }
+    public string playFabId { set; get; }
+    public AquariumServerData data { get; set; }
+}
+
+public class UpdateSlotDatasRequest
+{
+    public string playFabId { set; get; }
+    public List<AquariumSlotData> slotDatas { set; get; }
+}
+
+public class RobFishRequest
+{
+    //GContext.container.Resolve<SmallGameData>().AlbumEventID
+    public int timeEventId { set; get; }
+    public string playerId { set; get; }
+    /// <summary>
+    /// 被抢的人
+    /// </summary>
+    public string playFabId { set; get; }
+    /// <summary>
+    /// 被抢的槽位
+    /// </summary>
+    public int slotIndex { set; get; }
+    /// <summary>
+    /// 是否抢走
+    /// </summary>
+    public bool isRob { set; get; }
+}

Assets/Scripts/Aquarium/DataCenter/AquariumModel.cs.meta

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

Assets/Scripts/Aquarium/DataCenter/AquariumShooterFishManager.cs

@@ -0,0 +1,491 @@
+using asap.core;
+using cfg;
+using game;
+using GameCore;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using UnityEngine;
+
+public class AquariumShooterFishManager
+{
+    private cfg.Tables _tables;
+    private ICustomServerMgr customServerMgr;
+    public AquariumServerData serverData { get; private set; }
+    public int MapId => serverData?.mapId ?? 101;
+    List<int> HuntResult = null;
+    List<int> DropID = null;
+
+    public AquariumShooterFishManager()
+    {
+        _tables = GContext.container.Resolve<Tables>();
+        customServerMgr = GContext.container.Resolve<ICustomServerMgr>();
+    }
+
+    void RobotSetFish(MapData mapData, AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
+    {
+        //权重取鱼
+        List<int> FishIDList;
+
+        List<FishItemList> fishList = mapData.DropFishList;
+        float allProb = tankEgg.HatchFishQualityProb.Sum();
+        float prob = UnityEngine.Random.Range(0, allProb);
+        float curProb = 0;
+        int fishQuality = tankEgg.HatchFishQuality[^1];
+        for (int k = 0; k < tankEgg.HatchFishQuality.Count; k++)
+        {
+            curProb += tankEgg.HatchFishQualityProb[k];
+            if (curProb > prob)
+            {
+                fishQuality = tankEgg.HatchFishQuality[k];
+                break;
+            }
+        }
+        //品质大于6？？？
+        if (6 > fishQuality)
+        {
+            FishIDList = fishList[fishQuality - 1].FishIDList;
+            aquariumSlotData.fishItemID = FishIDList[UnityEngine.Random.Range(0, FishIDList.Count)];
+        }
+        else
+        {
+            FishIDList = _tables.TbAquariumConfig.AquariumSpFishList;
+            aquariumSlotData.fishItemID = FishIDList[UnityEngine.Random.Range(0, FishIDList.Count)];
+        }
+        aquariumSlotData.aquariumFishID = fishQuality;
+    }
+
+    void RobotSetFishCount(AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
+    {
+        int allProb = tankEgg.HatchFishQuantityProb.Sum();
+        int prob = UnityEngine.Random.Range(0, allProb);
+        int curProb = 0;
+        int fishCount = tankEgg.HatchFishQuantity[0];
+        for (int k = 0; k < tankEgg.HatchFishQuantity.Count; k++)
+        {
+            curProb += tankEgg.HatchFishQuantityProb[k];
+            if (curProb > prob)
+            {
+                fishCount = tankEgg.HatchFishQuantity[k];
+                break;
+            }
+        }
+        aquariumSlotData.fishMQ = fishCount;
+    }
+
+    void RobotSetTime(AquariumSlotData aquariumSlotData, AquariumEgg tankEgg)
+    {
+        AquariumFish tankFish = _tables.TbAquariumFish.GetOrDefault(aquariumSlotData.aquariumFishID);
+        aquariumSlotData.growthTime = UnityEngine.Random.Range(tankFish.GrowthTime[0], tankFish.GrowthTime[1]);
+        aquariumSlotData.hatchTime = UnityEngine.Random.Range(tankEgg.HatchTime[0], tankEgg.HatchTime[1]);
+
+        aquariumSlotData.mutants = 0;
+        for (int j = 0; j < aquariumSlotData.fishMQ; j++)
+        {
+            if (UnityEngine.Random.Range(0, 1f) < tankFish.MutantProb)
+            {
+                aquariumSlotData.mutants++;
+            }
+        }
+    }
+
+    AquariumServerData SetRobot(string playFabId)
+    {
+        int b = Convert.ToInt32(playFabId, 16);
+        Robot robot = _tables.TbRobot.GetOrDefault(b);
+        string AquariumServerDataStr = PlayerPrefs.GetString("AquariumServerData" + playFabId[^1]);
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+        AquariumServerData localServerData = new AquariumServerData();
+        if (!string.IsNullOrEmpty(AquariumServerDataStr))
+        {
+            try
+            {
+                localServerData = JsonConvert.DeserializeObject<AquariumServerData>(AquariumServerDataStr);
+                //防止改时间导致的机器人数据错误(蛋未孵化)
+                if (localServerData.startTime < ZZTimeHelper.UtcNow())
+                {
+                    Debug.Log($"nextOpponent InitFish SetRobotMapId {localServerData.mapId}");
+                    return localServerData;
+                }
+            }
+            catch (Exception)
+            {
+
+                Debug.LogError("AquariumServerDataStr Error");
+            }
+        }
+        localServerData.mapId = GContext.container.Resolve<SmallGameData>().RobotMapId;
+        localServerData.startTime = ZZTimeHelper.UtcNow();
+        localServerData.slot = robot.HatchEggPots;
+
+        List<AquariumSlotData> slotData = new List<AquariumSlotData>();
+        List<AquariumResultData> aquariumResultDatas = new List<AquariumResultData>();
+        List<AquariumHurtData> aquariumHurtDatas = new List<AquariumHurtData>();
+
+        List<AquariumEgg> TankEggList = _tables.TbAquariumEgg.DataList;
+        float eggAllWeight = -0.0001f;
+        for (int i = 0; i < TankEggList.Count; i++)
+        {
+            eggAllWeight += TankEggList[i].Weight;
+        }
+        bool isGrowth = false;
+        MapData mapData = _tables.TbMapData.GetOrDefault(localServerData.mapId);
+
+        for (int i = 0; i < localServerData.slot; i++)
+        {
+            AquariumSlotData aquariumSlotData = new AquariumSlotData();
+            //权重取蛋
+            float eggWeight = UnityEngine.Random.Range(0, eggAllWeight);
+            float curEggWeight = 0;
+            AquariumEgg tankEgg = TankEggList[0];
+            foreach (var item in TankEggList)
+            {
+                curEggWeight += item.Weight;
+                if (curEggWeight > eggWeight)
+                {
+                    tankEgg = item;
+                    break;
+                }
+            }
+            aquariumSlotData.eggId = tankEgg.ID;
+            RobotSetFish(mapData, aquariumSlotData, tankEgg);
+
+            //取鱼的数量
+            RobotSetFishCount(aquariumSlotData, tankEgg);
+            RobotSetTime(aquariumSlotData, tankEgg);
+            aquariumSlotData.startTime = dateTime;
+            if (robot != null)
+            {
+                if (robot.HatchProb > UnityEngine.Random.Range(0, 1f))
+                {
+                    isGrowth = true;
+                    aquariumSlotData.accelerationHatch = aquariumSlotData.hatchTime + 1;
+                    aquariumSlotData.accelerationGrowth = aquariumSlotData.growthTime *
+                        UnityEngine.Random.Range(robot.MatureProgress[0], robot.MatureProgress[1]);
+                }
+            }
+            aquariumSlotData.index = i;
+            slotData.Add(aquariumSlotData);
+
+            aquariumResultDatas.Add(new AquariumResultData());
+            aquariumHurtDatas.Add(new AquariumHurtData());
+        }
+        if (!isGrowth)
+        {
+            slotData[0].accelerationHatch = slotData[0].hatchTime + 1;
+            slotData[0].accelerationGrowth = slotData[0].growthTime *
+                UnityEngine.Random.Range(robot.MatureProgress[0], robot.MatureProgress[1]);
+
+        }
+        localServerData.slotDatas = slotData;
+        localServerData.aquariumResultDatas = aquariumResultDatas;
+        localServerData.aquariumHurtDatas = aquariumHurtDatas;
+        PlayerPrefs.SetString("AquariumServerData" + playFabId[^1], JsonConvert.SerializeObject(localServerData));
+
+        //保存 数据
+        return localServerData;
+    }
+
+    public AquariumServerData GetDataFishHuntInit(string playFabId, FishHuntInit inti)
+    {
+        int b = Convert.ToInt32(playFabId, 16);
+        Robot robot = _tables.TbRobot.GetOrDefault(b);
+        HuntResult = inti.HuntResult;
+        DropID = inti.DropID;
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+        AquariumServerData localServerData = new AquariumServerData();
+        localServerData.mapId = inti.MapID;
+        localServerData.startTime = ZZTimeHelper.UtcNow();
+        List<int> Fishlist = inti.Fishlist;
+        List<int> FishQuatitylist = inti.FishQuatitylist;
+        List<int> FishQualitylist = inti.FishQualitylist;
+        List<int> FishMutantlist = inti.FishMutantlist;
+        List<float> FishGrowthlist = inti.FishGrowthlist;
+        localServerData.slot = Fishlist.Count;
+
+        List<AquariumSlotData> slotData = new List<AquariumSlotData>();
+        List<AquariumResultData> aquariumResultDatas = new List<AquariumResultData>();
+        List<AquariumHurtData> aquariumHurtDatas = new List<AquariumHurtData>();
+
+        for (int i = 0; i < localServerData.slot; i++)
+        {
+            AquariumSlotData aquariumSlotData = new AquariumSlotData();
+            aquariumSlotData.eggId = 1;
+            aquariumSlotData.fishItemID = Fishlist[i];
+            aquariumSlotData.aquariumFishID = FishQualitylist[i];
+            aquariumSlotData.fishMQ = FishQuatitylist[i];
+            aquariumSlotData.startTime = dateTime;
+            aquariumSlotData.hatchTime = 1;
+            aquariumSlotData.growthTime = 1;
+            aquariumSlotData.accelerationHatch = 1.1f;
+            aquariumSlotData.accelerationGrowth = aquariumSlotData.growthTime * FishGrowthlist[i];
+
+            aquariumSlotData.mutants = FishMutantlist[i];
+            aquariumSlotData.index = i;
+            slotData.Add(aquariumSlotData);
+
+            aquariumResultDatas.Add(new AquariumResultData());
+            aquariumHurtDatas.Add(new AquariumHurtData());
+        }
+        localServerData.slotDatas = slotData;
+        localServerData.aquariumResultDatas = aquariumResultDatas;
+        localServerData.aquariumHurtDatas = aquariumHurtDatas;
+        serverData = localServerData;
+        //保存 数据
+        return serverData;
+    }
+
+    public async Task<AquariumServerData> GetData(string playFabId, bool isRobot, bool canEmpty)
+    {
+        HuntResult = null;
+        DropID = null;
+
+        if (isRobot)
+        {
+            serverData = SetRobot(playFabId);
+            return serverData;
+        }
+        GetAquariumDataRequest request = new GetAquariumDataRequest();
+        request.playFabId = playFabId;
+        string result = await customServerMgr.CustomServerPost("aquarium/GetAquariumData", Newtonsoft.Json.JsonConvert.SerializeObject(request));
+        if (result != null)
+        {
+            var resp = JsonConvert.DeserializeObject<GetAquariumDataResp>(result);
+            if (resp.code == 0)
+            {
+                var data = resp.data;
+                List<AquariumSlotData> slotDatas = data.slotDatas;
+                if (slotDatas == null)
+                {
+                    return null;
+                }
+                if (canEmpty)
+                {
+                    serverData = resp.data;
+                    return serverData;
+                }
+                var time = ZZTimeHelper.UtcNow();
+                List<AquariumResultData> aquariumResultDatas = data.aquariumResultDatas;
+                for (int i = 0; i < slotDatas.Count; i++)
+                {
+                    AquariumSlotData slotData = slotDatas[i];
+                    slotData.index = i;
+                    var HatchTime = slotData.FishHatchTime();
+
+                    if (HatchTime < time)
+                    {
+                        if (!slotData.IsResult() && aquariumResultDatas.Count > i && !aquariumResultDatas[i].IsResult())
+                        {
+                            serverData = resp.data;
+                            return serverData;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                Debug.LogWarning("GetAquariumDataRequest Null");
+                if (canEmpty)
+                {
+                    PlayerData playerData = GContext.container.Resolve<PlayerData>();
+                    AquariumServerData data = new AquariumServerData();
+                    data.startTime = ZZTimeHelper.UtcNow();
+                    data.slot = playerData.benefitsAquariumLimit;
+                    List<AquariumInit> inits = _tables.TbAquariumInit.DataList;
+
+                    NewSlotInitData(inits[0], data);
+                    serverData = data;
+                    return serverData;
+                }
+            }
+        }
+        return null;
+    }
+    void NewSlotInitData(AquariumInit init, AquariumServerData data)
+    {
+        data.mapId = init.MapID;
+        List<AquariumSlotData> slotDatas = new List<AquariumSlotData>();
+        List<AquariumHurtData> aquariumHurtDatas = new List<AquariumHurtData>();
+        List<AquariumResultData> aquariumResultDatas = new List<AquariumResultData>();
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+
+        List<int> Egglist = init.Egglist;
+        List<int> FishQualitylist = init.FishQualitylist;
+        List<int> FishList = init.Fishlist;
+        List<int> FishQuatitylist = init.FishQuatitylist;
+        List<int> FishMutantlist = init.FishMutantlist;
+
+
+        for (int i = 0; i < data.slot; i++)
+        {
+            AquariumSlotData aquariumSlotData = new AquariumSlotData();
+            aquariumSlotData.eggId = Egglist[i];
+            aquariumSlotData.aquariumFishID = FishQualitylist[i];
+            aquariumSlotData.fishMQ = FishQuatitylist[i];
+            aquariumSlotData.fishItemID = FishList[i];
+
+            var tankEgg = _tables.TbAquariumEgg.GetOrDefault(Egglist[i]);
+
+            aquariumSlotData.startTime = dateTime;
+            aquariumSlotData.hatchTime = UnityEngine.Random.Range(tankEgg.HatchTime[0], tankEgg.HatchTime[1]);
+
+            AquariumFish aquariumFish = _tables.TbAquariumFish.GetOrDefault(FishQualitylist[i]);
+
+            aquariumSlotData.growthTime = UnityEngine.Random.Range(aquariumFish.GrowthTime[0], aquariumFish.GrowthTime[1]);
+            aquariumSlotData.mutants = FishMutantlist[i];
+            aquariumSlotData.index = i;
+            slotDatas.Add(aquariumSlotData);
+
+            AquariumHurtData aquariumHurtData = new AquariumHurtData();
+            aquariumHurtDatas.Add(aquariumHurtData);
+
+            AquariumResultData aquariumResultData = new AquariumResultData();
+            aquariumResultDatas.Add(aquariumResultData);
+        }
+        data.slotDatas = slotDatas;
+        data.aquariumHurtDatas = aquariumHurtDatas;
+        data.aquariumResultDatas = aquariumResultDatas;
+    }
+    public float RobFishRequest(int changeTargetCount, int multiple, string playFabId, int index, int groupId, OpponentItemData opponentItemData, out bool isRob, out int addRankCount)
+    {
+        GContext.container.Resolve<SmallGameData>().SaveFishHuntGameCount();
+        AquariumSlotData slotData = serverData.slotDatas[groupId];
+        AquariumFish aquariumFish = _tables.TbAquariumFish.GetOrDefault(slotData.aquariumFishID);
+        //刺鱼奖励
+        float extra = 0;
+        if (index < slotData.mutants)
+        {
+            extra += aquariumFish.AttackMutantExtraReward;
+        }
+        isRob = false;
+        ItemData itemDatas = GContext.container.Resolve<PlayerItemData>().GetItemDataOne(aquariumFish.AttackReward);
+        float ExtraReward = 0;
+        if (HuntResult != null)
+        {
+            itemDatas = GContext.container.Resolve<PlayerItemData>().GetItemDataOne(DropID[groupId]);
+            if (HuntResult[groupId] == 1)
+            {
+                if (index < slotData.mutants)
+                {
+                    ExtraReward = aquariumFish.StealMutantExtraReward;
+                }
+                else
+                {
+                    ExtraReward = aquariumFish.StealExtraReward;
+                }
+                isRob = true;
+            }
+        }
+        else
+        {
+            float random = UnityEngine.Random.Range(0, 1f);
+            if (index < slotData.mutants)
+            {
+                if (random <= aquariumFish.StealMutantProb)
+                {
+                    ExtraReward = aquariumFish.StealMutantExtraReward;
+                    isRob = true;
+                }
+            }
+            else
+            {
+                if (random <= aquariumFish.StealProb)
+                {
+                    ExtraReward = aquariumFish.StealExtraReward;
+                    isRob = true;
+                }
+            }
+        }
+
+        extra += UnityEngine.Random.Range(0, aquariumFish.StealRewardRand) - aquariumFish.StealRewardRand * 0.5f;
+
+        itemDatas.count = (int)(itemDatas.count * (1 + extra) * multiple * (1 + ExtraReward));
+        SuperHunt superHunt = GContext.container.Resolve<BuffDataCenter>().GetWeelyBuffTimeData<SuperHunt>();
+        float superCashBonus = 0;
+        if (superHunt != null)
+        {
+            superCashBonus = superHunt.CashBonus;
+        }
+        //itemDatas.count *= (1 + superCashBonus);
+        //获取奖励
+        GContext.container.Resolve<PlayerItemData>().AddItem(itemDatas);
+
+        var _fishingEventData = GContext.container.Resolve<FishingEventData>();
+        if (_fishingEventData.rankInit != null)
+        {
+            int point = _fishingEventData.rankInit.PointRobbery[1];
+            if (isRob)
+            {
+                point = _fishingEventData.rankInit.PointRobbery[2];
+            }
+            if (index < slotData.mutants)
+            {
+                point += _fishingEventData.rankInit.PointRobbery[3];
+            }
+            addRankCount = point * multiple;
+            _fishingEventData.AddRankTarget(addRankCount);
+        }
+        else
+        {
+            addRankCount = 0;
+        }
+
+        if (opponentItemData.isRobot)
+        {
+            int i = groupId;
+
+            List<AquariumHurtData> aquariumHurtDatas = serverData.aquariumHurtDatas;
+
+            //鱼被刺走
+            if (isRob)
+            {
+                //aquariumHurtDatas[i].fishLQ++;
+
+                ////鱼全部被刺走,重置
+                //if (aquariumHurtDatas[i].fishLQ >= slotData.fishMQ)
+                //{
+                //    aquariumHurtDatas[i].fishLQ = 0;
+                //}
+                PlayerPrefs.DeleteKey("AquariumServerData" + playFabId[^1]);
+                //PlayerPrefs.SetString("AquariumServerData" + playFabId[^1], JsonConvert.SerializeObject(serverData));
+            }
+        }
+        else
+        {
+            //通知服务器刺伤谁的鱼
+            RobFishRequest request = new RobFishRequest();
+            request.timeEventId = GContext.container.Resolve<SmallGameData>().AlbumEventID;
+            request.playFabId = playFabId;
+            request.slotIndex = groupId;
+            if (UnityEngine.Random.Range(0, 1f) <= aquariumFish.RealStealProb)
+            {
+                request.isRob = isRob;
+            }
+            request.playerId = GContext.container.Resolve<IUserService>().UserId;
+            customServerMgr.CustomServerPost("aquarium/RobFish", Newtonsoft.Json.JsonConvert.SerializeObject(request));
+        }
+
+        Debug.Log($"target_source  isRobot: {opponentItemData.isRobot}  target_group: {opponentItemData.target_group} target_source {opponentItemData.target_source}");
+
+
+#if AGG
+        using (var e = GEvent.GameEvent("fish_raid"))
+        {
+            Item item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
+            e.AddContent("fish_id", item.RedirectID)
+                .AddContent("fish_quality", slotData.aquariumFishID)
+                .AddContent("is_mutant", slotData.mutants > index)
+                .AddContent("result", isRob ? 1 : 0)
+                .AddContent("target_accountid", opponentItemData.isRobot ? "-1" : playFabId)
+                .AddContent("target_group", opponentItemData.target_group)
+                .AddContent("target_source", opponentItemData.target_source)
+                .AddContent("fish_multiple",multiple)
+                .AddContent("target_change_count", changeTargetCount)
+                .AddContent("reward_cash", itemDatas.count);
+        }
+#endif
+        return itemDatas.count;
+    }
+}

Assets/Scripts/Aquarium/DataCenter/AquariumShooterFishManager.cs.meta

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