备份CatanBuilding瘦身独立工程

Assets/Scripts/Aquarium/AquariumCameraManager.cs

@@ -0,0 +1,168 @@
+using cfg;
+using Cinemachine;
+using DG.Tweening;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class AquariumCameraManager : MonoBehaviour
+{
+    public CinemachineVirtualCamera cameraVirtual;
+    public CinemachineVirtualCamera[] followFishCameras;
+    CinemachineVirtualCamera followFishCamera;
+    int showCameraIndex = 0;
+
+    public GameObject crossbowGo;
+    public CinemachineVirtualCamera followArrowCamera;
+    public Camera crossbowCamera;
+    public Transform handRoot;
+    public Vector2 cameraOffset = Vector2.zero;
+    public float startPosZ = -2;
+    public float moveTimeZ = 0.5f;
+
+    public float cameraToFishDis = 3;//鱼最长包围盒的倍率，用于控制箭飞行时相机距离鱼的距离，和把鱼拉回来时距离相机的距离
+    public float zoomFishExtraDistance = 1.5f;
+    CrossbowCameraMove crossbowCameraMove;
+    AquariumCameraMove aquariumCameraMove;
+    public RenderTexture rt;
+    FishMovement followFish;
+    private void Awake()
+    {
+        for (int i = 0; i < followFishCameras.Length; i++)
+        {
+            followFishCameras[i].gameObject.SetActive(false);
+        }
+        crossbowGo.SetActive(false);
+        crossbowCamera.gameObject.SetActive(false);
+    }
+
+    public Vector2 SetRotationAngle()
+    {
+        float halfFOV = 30;
+        float maxX = Mathf.Max(0, cameraOffset.y - halfFOV);
+
+        //float aspect = (float)Screen.height / Screen.width;
+        //aspect = Mathf.Min(Mathf.Max(aspect, 1f), 2.2f);
+
+        //float halfFOVInRadians = halfFOV * Mathf.Deg2Rad;
+        //float tanHalfFOV = Mathf.Tan(halfFOVInRadians);
+        //float angle = cameraOffset.x - Mathf.Atan(tanHalfFOV / aspect) * Mathf.Rad2Deg;
+        //float maxY = Mathf.Max(0, angle);
+
+        float maxY = ConvertTools.CalculateActualRotationAngle(cameraOffset.x);
+        return new Vector2(maxX, maxY);
+    }
+
+    public void PlayAquarium(FishingAquariumAct fishingAquariumAct)
+    {
+        aquariumCameraMove = gameObject.AddComponent<AquariumCameraMove>();
+        Vector2 vector = SetRotationAngle();
+        aquariumCameraMove.Init(vector, fishingAquariumAct);
+        transform.position = new Vector3(0, 0, startPosZ);
+    }
+
+    public void FollowFishCamera(FishMovement fish)
+    {
+        followFish = fish;
+        if (fish == null)
+        {
+            StopFollowFishCamera();
+            return;
+        }
+        NextCamera();
+        followFishCamera.gameObject.SetActive(true);
+    }
+    void NextCamera()
+    {
+        if (followFishCamera != null)
+        {
+            followFishCamera.gameObject.SetActive(false);
+        }
+        showCameraIndex++;
+        showCameraIndex %= followFishCameras.Length;
+        followFishCamera = followFishCameras[showCameraIndex];
+    }
+    public void FollowFishCamera(FishEgg egg)
+    {
+        followFish = null;
+        if (egg == null)
+        {
+            StopFollowFishCamera();
+            return;
+        }
+        NextCamera();
+        followFishCamera.gameObject.SetActive(true);
+        Vector3 targetPos = egg.transform.position;
+        float r = /*followFish.AvoidRadius * cameraToFishDis + */zoomFishExtraDistance;
+        targetPos.z -= r;
+        followFishCamera.transform.position = targetPos;
+    }
+
+    public void StopFollowFishCamera()
+    {
+        for (int i = 0; i < followFishCameras.Length; i++)
+        {
+            followFishCameras[i].gameObject.SetActive(false);
+        }
+        followFish = null;
+    }
+
+    private void Update()
+    {
+        if (followFish != null)
+        {
+            Vector3 targetPos = followFish.transform.position;
+            float r = followFish.AvoidRadius * cameraToFishDis + zoomFishExtraDistance;
+            targetPos.z -= r;
+            followFishCamera.transform.position = targetPos;
+        }
+    }
+
+
+    public void MoveCamera()
+    {
+        transform.DOMoveZ(0, moveTimeZ).SetDelay(0.66f);
+    }
+
+    public void PlayCrossbow(FishMovement guide)
+    {
+        crossbowGo.SetActive(true);
+        crossbowCamera.gameObject.SetActive(true);
+        crossbowCamera.targetTexture = rt;
+        crossbowCameraMove = gameObject.AddComponent<CrossbowCameraMove>();
+        Vector2 vector = SetRotationAngle();
+        crossbowCameraMove.Init(this, handRoot, vector, guide);
+
+    }
+
+    public void Target()
+    {
+        crossbowCameraMove.Target();
+    }
+
+    public void TriggerCrossbow(string value)
+    {
+        crossbowCameraMove.TriggerCrossbow(value);
+    }
+
+    public void Shoot(float[] FxScale, Dictionary<string, GameObject> fx_hunt_prefab, bool isRob, float shootTime, FishMovement targetMovement)
+    {
+        crossbowCameraMove.Shoot(FxScale, fx_hunt_prefab, isRob, cameraToFishDis, shootTime, targetMovement);
+    }
+
+    public float Capture(float fishToCameraDistance, float lineDrawMinTime, float lineDrawSpeed, FishMovement targetMovement)
+    {
+        return crossbowCameraMove.Capture(fishToCameraDistance, lineDrawMinTime, cameraToFishDis, lineDrawSpeed, targetMovement);
+    }
+    public void Captureed()
+    {
+        crossbowCameraMove.Captureed();
+    }
+    public void Escape(float arrowEscapeTime)
+    {
+        crossbowCameraMove.Escape(arrowEscapeTime);
+    }
+    public void HideCrossbow(bool isHide)
+    {
+        crossbowCameraMove.HideCrossbow(isHide);
+    }
+}

Assets/Scripts/Aquarium/AquariumCameraManager.cs.meta

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

Assets/Scripts/Aquarium/AquariumCameraMove.cs

@@ -0,0 +1,104 @@
+using DG.Tweening;
+using UnityEngine;
+
+public class AquariumCameraMove : MonoBehaviour
+{
+    int layerMask;
+
+    //屏幕拖动比例
+    float dragCameraScale = 0.03f;
+    private Vector3 initialRotation;
+    Vector3 _curMousePos;
+    Vector3 _offsetEuler;
+    Quaternion targetRotation;
+    Vector2 cameraOffset;
+    Quaternion startRot;
+    float duration = 0.65f;
+    FishingAquariumAct fishingAquariumAct;
+    GameObject curClick;
+    private void Awake()
+    {
+        layerMask = 1 << LayerMask.NameToLayer("fish");
+        startRot = transform.rotation;
+    }
+    public void Init(Vector2 cameraOffset, FishingAquariumAct fishingAquariumAct)
+    {
+        this.fishingAquariumAct = fishingAquariumAct;
+        this.cameraOffset = cameraOffset;
+    }
+
+    float CheckAngle(float value)
+    {
+        float angle = value - 180;
+
+        if (angle > 0)
+            return angle - 180;
+
+        return angle + 180;
+    }
+
+    private void LateUpdate()
+    {
+        if (Input.GetMouseButtonDown(0) && fishingAquariumAct.CanDragMove())
+        {
+            transform.DOKill();
+            _curMousePos = Input.mousePosition;
+            _offsetEuler = Vector3.zero;
+            initialRotation = transform.rotation.eulerAngles;
+            initialRotation.x = CheckAngle(initialRotation.x);
+            initialRotation.y = CheckAngle(initialRotation.y);
+            targetRotation = transform.rotation;
+            curClick = SelectTarget();
+        }
+        else if (Input.GetMouseButton(0) && fishingAquariumAct.CanDragMove())
+        {
+            Vector3 ver = Input.mousePosition - _curMousePos;
+            if (ver.magnitude > 5)
+            {
+                _offsetEuler.x -= ver.y * dragCameraScale;
+                _offsetEuler.y += ver.x * dragCameraScale;
+                var targetEulerAngles = initialRotation + _offsetEuler;
+
+                // Clamp the rotation angles
+                targetEulerAngles.x = Mathf.Clamp(targetEulerAngles.x, -cameraOffset.x, cameraOffset.x);
+                targetEulerAngles.y = Mathf.Clamp(targetEulerAngles.y, -cameraOffset.y, cameraOffset.y);
+                targetEulerAngles.z = 0;
+                _offsetEuler = targetEulerAngles - initialRotation;
+
+                targetRotation = Quaternion.Euler(targetEulerAngles);
+                //transform.rotation = targetRotation;
+                _curMousePos = Input.mousePosition;
+            }
+            transform.rotation = Quaternion.Angle(targetRotation, transform.rotation) > 0.1f
+                ? Quaternion.Lerp(transform.rotation, targetRotation, 0.2f)
+                : targetRotation;
+        }
+        else if (Input.GetMouseButtonUp(0))
+        {
+            transform.DORotateQuaternion(startRot, duration);
+            GameObject localClick = SelectTarget();
+            if (localClick != null && localClick == curClick)
+            {
+                var fish = curClick.GetComponentInParent<AquariumFishBase>();
+                fishingAquariumAct.OnClickFish(fish.slotData.index);
+                curClick = null;
+            }
+        }
+
+    }
+    private GameObject SelectTarget()
+    {
+        var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
+        if (Physics.Raycast(ray, out var hit, 100, layerMask))
+        {
+            //Debug.Log($"<color=#e94242>hit: {hit.collider.gameObject.layer}</color>");
+
+            //if (hit.collider.gameObject.layer == layerMask)
+            //{
+                //Debug.Log($"<color=#e94242>hit position: {hit.point}</color>");
+                return hit.collider.gameObject;
+            //}
+        }
+        return null;
+    }
+}

Assets/Scripts/Aquarium/AquariumCameraMove.cs.meta

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

Assets/Scripts/Aquarium/AquariumFishBase.cs

@@ -0,0 +1,7 @@
+using UnityEngine;
+
+public class AquariumFishBase : MonoBehaviour
+{
+    public AquariumSlotData slotData;
+
+}

Assets/Scripts/Aquarium/AquariumFishBase.cs.meta

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

Assets/Scripts/Aquarium/AquariumFishController.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+public class AquariumFishController : MonoBehaviour
+{
+    public AquariumCameraManager cameraManager;
+    public FishManager fishManager;
+    public FishEggManager fishEggManager;
+    public AquariumObstacleManager obstacleManager;
+    private void Awake()
+    {
+        if (obstacleManager != null && fishManager != null)
+        {
+            fishManager.obstacleGo = obstacleManager.obstacleGo;
+        }
+    }  
+}

Assets/Scripts/Aquarium/AquariumFishController.cs.meta

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

Assets/Scripts/Aquarium/AquariumObstacleManager.cs

@@ -0,0 +1,8 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class AquariumObstacleManager : MonoBehaviour
+{
+    public List<GameObject> obstacleGo = new List<GameObject>();
+}

Assets/Scripts/Aquarium/AquariumObstacleManager.cs.meta

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

Assets/Scripts/Aquarium/Crossbow.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+public class Crossbow : MonoBehaviour
+{
+    public GameObject root;
+    public Transform crosshair_P;
+    public GameObject icon_nml;
+    public GameObject icon_notarget;
+    public Animator animator;
+    public Transform TopLine;
+    public Transform EndLine;
+    public List<Transform> LineList;
+    public LineRenderer fishingLineRenderer;
+
+    public Transform LeftHandTargets;
+    public Transform RightHandTargets;
+    private void Awake()
+    {
+        if (icon_nml != null)
+        {
+            icon_nml.transform.localPosition = new Vector3(0, 0.005f, 0);
+        }
+        if (icon_notarget != null)
+        {
+            icon_notarget.transform.localPosition = new Vector3(0, 0.005f, 0);
+        }
+    }
+}

Assets/Scripts/Aquarium/Crossbow.cs.meta

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

Assets/Scripts/Aquarium/CrossbowArrow.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+public class CrossbowArrow : MonoBehaviour
+{
+    public GameObject crossbow;
+    public Animator animator;
+    public Transform TopLine;
+    public Transform EndLine;
+    public List<Transform> LineList;
+}

Assets/Scripts/Aquarium/CrossbowArrow.cs.meta

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

Assets/Scripts/Aquarium/CrossbowCameraMove.cs

@@ -0,0 +1,510 @@
+using asap.core;
+using cfg;
+using DG.Tweening;
+using Game;
+using GameCore;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+
+public class CrossbowCameraMove : MonoBehaviour
+{
+    Vector3 _curMousePos;
+    Vector3 _offsetEuler;
+    Quaternion targetRotation;
+    //屏幕拖动比例
+    float dragCameraScale = 0.03f;
+    private Vector3 initialRotation;
+    bool isFinish;
+    Transform handRoot;
+    HandController HandController;
+    GameObject handAB;
+    Crossbow crossbow;
+    CrossbowArrow crossbowArrow;
+    AquariumCameraManager manager;
+    int state = 0;//0:未开始 1:射击结束 2:收紧线 3:逃脱
+    Vector2 cameraOffset;
+
+    public FishMovement guide;
+
+
+    private void Awake()
+    {
+        crossbow = GetComponentInChildren<Crossbow>();
+        crossbowArrow = GetComponentInChildren<CrossbowArrow>();
+        crossbowArrow.gameObject.SetActive(false);
+        crossbow.fishingLineRenderer.enabled = false;
+        crossbowPos = crossbow.animator.transform.localPosition;
+    }
+    public void Init(AquariumCameraManager aquariumCameraManager, Transform handRoot, Vector2 cameraOffset, FishMovement guide)
+    {
+        this.manager = aquariumCameraManager;
+        this.cameraOffset = cameraOffset;
+        this.handRoot = handRoot;
+        this.guide = guide;
+        LoadHand();
+    }
+    public void LoadHand()
+    {
+        GloveData gloveData = GContext.container.Resolve<PlayerFishData>().GetGloveData;
+        InitRodHandAsync(gloveData);
+    }
+    async void InitRodHandAsync(GloveData gloveData)
+    {
+        string path = gloveData.Fbx;
+
+        if (handAB != null)
+        {
+            Addressables.ReleaseInstance(handAB);
+        }
+        handAB = await Addressables.InstantiateAsync(gloveData.Fbx, handRoot).Task;
+        if (handAB != null)
+        {
+            HandController = handAB.GetComponent<HandController>();
+            if (crossbow != null)
+            {
+                HandController.SetHandTargets(crossbow.RightHandTargets, crossbow.LeftHandTargets, null);
+            }
+        }
+    }
+    public float CheckAngle(float value)
+    {
+        float angle = value - 180;
+
+        if (angle > 0)
+            return angle - 180;
+
+        return angle + 180;
+    }
+
+    //收线音效
+    Sound soundLine;
+    AudioClip lineAudio;
+
+    async void PlaySoundLine(string audioName)
+    {
+        StopSoundLine();
+        lineAudio = await Addressables.LoadAssetAsync<AudioClip>(audioName).Task;
+        if (lineAudio)
+        {
+            soundLine = GContext.container.Resolve<ISoundService>().GetNewFishingSound(lineAudio);
+            soundLine.audioSource.Play();
+            soundLine.audioSource.loop = true;
+        }
+    }
+    void StopSoundLine()
+    {
+        if (soundLine)
+        {
+            soundLine.audioSource.Stop();
+            soundLine.ReturnPool();
+            soundLine = null;
+        }
+    }
+
+    public void TriggerCrossbow(string value)
+    {
+        crossbow.animator.SetBool("Aim", value == "Aim");
+        crossbow.animator.SetBool("Back", value == "Back");
+        crossbow.animator.SetBool("Shoot", value == "Shoot");
+
+        //crossbow.animator.SetTrigger(value);
+    }
+
+    public async void Shoot(float[] FxScale, Dictionary<string, GameObject> fx_hunt_prefab, bool isRob, float cameraToFishDis, float shootTime, FishMovement fish)
+    {
+        crossbow.animator.SetTrigger("Shoot");
+
+        Vector3 targetPos = fish.targetPos;
+        manager.crossbowCamera.gameObject.SetActive(false);
+        Vector3 cameraposition = manager.crossbowCamera.transform.position;
+        float r = fish.AvoidRadius * cameraToFishDis;
+
+        float t = 1 - r / (targetPos - cameraposition).magnitude;
+        if (t < 0)
+        {
+            t = 0;
+        }
+        Vector3 newVector = Vector3.Lerp(cameraposition, targetPos, t);
+
+        GContext.Publish(new EventFishingSound("audio_huntingfish_shoot"));
+        crossbowArrow.gameObject.SetActive(true);
+        crossbow.fishingLineRenderer.enabled = true;
+        manager.cameraVirtual.gameObject.SetActive(false);
+        var cameraParent = manager.followArrowCamera.transform.parent;
+        //parent.position = manager.crossbowCamera.transform.position;
+        await Awaiters.NextFrame;
+        cameraParent.gameObject.SetActive(true);
+        manager.followArrowCamera.transform.localPosition = new Vector3(0.25f, 0.25f, -0.25f);
+        //cameraParent.position = manager.crossbowCamera.transform.position;
+        cameraParent.DOMove(newVector, shootTime).SetEase(Ease.Linear);
+        manager.followArrowCamera.LookAt = crossbowArrow.transform;
+        PlaySoundLine("audio_huntingfish_airflow");
+        transform.rotation = Quaternion.LookRotation(targetPos - transform.position);
+        crossbow.root.SetActive(false);
+        handRoot.gameObject.SetActive(false);
+        GameObject hunt_shoot_go = null;
+        if (fx_hunt_prefab.TryGetValue("fx_aquarium_hunt_shoot", out GameObject hunt_shoot))
+        {
+            hunt_shoot_go = Instantiate(hunt_shoot, crossbowArrow.transform);
+        }
+        crossbowArrow.transform.DOMove(targetPos, shootTime).SetEase(Ease.Linear);
+        await Awaiters.Seconds(shootTime);
+        manager.followArrowCamera.LookAt = null;
+        state = 1;
+        AddLinePos();
+        crossbowArrow.animator.SetTrigger("Shoot");
+        if (hunt_shoot_go != null)
+        {
+            Destroy(hunt_shoot_go);
+        }
+
+
+        if (fish.fish != null)
+        {
+            int q = fish.slotData.aquariumFishID - 1;
+            float fxScale = FxScale[q] / fish.transform.localScale.x;
+            GameObject hunt_fishhitbig_go = null;
+            GameObject hunt_fishhitsmall_go = null;
+            GameObject hunt_fishhurt_go = null;
+
+            Transform fishPos = isRob ? fish.fish.mouthPos : fish.fishPos;
+
+            if (fish.fish.Root && fx_hunt_prefab.TryGetValue("fx_aquarium_hunt_fishhitbig", out GameObject hunt_fishhitbig))
+            {
+                hunt_fishhitbig_go = Instantiate(hunt_fishhitbig, fish.fish.Root);
+                hunt_fishhitbig_go.transform.localScale = Vector3.one * fxScale;
+                hunt_fishhitbig_go.transform.rotation = Quaternion.identity;
+            }
+            if (fishPos && fx_hunt_prefab.TryGetValue("fx_aquarium_hunt_fishhitsmall", out GameObject hunt_fishhitsmall))
+            {
+                hunt_fishhitsmall_go = Instantiate(hunt_fishhitsmall, fishPos);
+                hunt_fishhitsmall_go.transform.localScale = Vector3.one * fxScale;
+                hunt_fishhitsmall_go.transform.rotation = Quaternion.identity;
+            }
+            if (fishPos && fx_hunt_prefab.TryGetValue("fx_aquarium_hunt_fishhurt", out GameObject hunt_fishhurt))
+            {
+                hunt_fishhurt_go = Instantiate(hunt_fishhurt, fishPos);
+                hunt_fishhurt_go.transform.localScale = Vector3.one * fxScale;
+            }
+
+
+            if (isRob)
+            {
+                GameObject hunt_capture_go = null;
+                if (fish.fish.Root && fx_hunt_prefab.TryGetValue("fx_aquarium_hunt_capture", out GameObject hunt_capture))
+                {
+                    hunt_capture_go = Instantiate(hunt_capture, fish.fish.Root);
+                    hunt_capture_go.transform.localScale = Vector3.one * fxScale;
+                }
+            }
+            else
+            {
+                GameObject hunt_escape_go = null;
+                if (fx_hunt_prefab.TryGetValue("fx_aquarium_hunt_escape", out GameObject hunt_escape))
+                {
+                    hunt_escape_go = Instantiate(hunt_escape, fish.fish.Root);
+                    hunt_escape_go.transform.localScale = Vector3.one * fxScale;
+                }
+            }
+            crossbowArrow.transform.parent = fishPos;
+            crossbowArrow.transform.localPosition = Vector3.zero;
+            if (isRob)
+            {
+                GContext.Publish(new EventFishingSound("audio_huntingfish_hitbig"));
+            }
+            else
+            {
+                GContext.Publish(new EventFishingSound("audio_huntingfish_hitsmall"));
+            }
+        }
+        StopSoundLine();
+        HideCrossbow(false);
+        crossbow.animator.SetTrigger("Capture");
+    }
+    Vector3 crossbowPos;
+    public void HideCrossbow(bool isHide)
+    {
+        guide = null;
+        if (isHide)
+        {
+            crossbowPos = crossbow.animator.transform.localPosition;
+            crossbow.animator.transform.localPosition = Vector3.back * 100;
+        }
+        else
+        {
+            crossbow.animator.transform.localPosition = crossbowPos;
+        }
+        //handRoot.localPosition = isHide ? Vector3.back * 100 : new Vector3(0, 1, -0.5f);
+    }
+
+    List<ParabolaHarmonicSimulation> vector3s = new List<ParabolaHarmonicSimulation>();
+    float lineChengeTime = 1;
+
+
+    public void Escape(float arrowEscapeTime)
+    {
+        GContext.Publish(new EventFishingSound("audio_huntingfish_escape"));
+        manager.followArrowCamera.LookAt = null;
+        HideCrossbow(false);
+        crossbowArrow.animator.SetTrigger("Escape");
+        crossbow.animator.SetTrigger("Escape");
+        crossbowArrow.transform.parent = crossbow.transform.parent;
+        crossbowArrow.transform.DOMoveY(-5, arrowEscapeTime).OnComplete(() =>
+        {
+            state = 2;
+            vector3s.Clear();
+        });
+        state = 1;
+        AddLinePos();
+    }
+    public void Target()
+    {
+        isFinish = true;
+    }
+
+    public float Capture(float fishToCameraDistance, float lineDrawMinTime, float cameraToFishDis, float lineDrawSpeed, FishMovement targetMovement)
+    {
+        manager.cameraVirtual.transform.DOKill();
+        manager.cameraVirtual.transform.localPosition = Vector3.zero;
+        manager.followArrowCamera.transform.position = manager.cameraVirtual.transform.position;
+        manager.followArrowCamera.transform.rotation = manager.cameraVirtual.transform.rotation;
+        manager.followArrowCamera.LookAt = targetMovement.transform;
+        crossbow.root.SetActive(true);
+        handRoot.gameObject.SetActive(true);
+        crossbowArrow.animator.SetTrigger("Capture");
+        PlaySoundLine("audio_huntingfish_capture");
+
+        state = 2;
+        vector3s.Clear();
+
+        Vector3 vector3 = targetMovement.targetPos;
+        Vector3 targetPos = crossbow.transform.position;
+        float r = targetMovement.AvoidRadius * cameraToFishDis;
+        float t = 1 - r / (targetPos - vector3).magnitude;
+        if (t < 0)
+        {
+            t = 0;
+        }
+        Vector3 newVector = Vector3.Lerp(vector3, targetPos, t);
+        newVector.z += fishToCameraDistance;
+        var captureTime = (crossbowArrow.transform.position - newVector).magnitude / lineDrawSpeed;
+        if (captureTime < lineDrawMinTime)
+        {
+            captureTime = lineDrawMinTime;
+        }
+        targetMovement.transform.DOMove(newVector, captureTime).SetEase(Ease.Linear)
+            .OnComplete(() => crossbow.animator.SetTrigger("CaptureEnd"));
+        return captureTime;
+    }
+    public void Captureed()
+    {
+        StopSoundLine();
+        crossbowArrow.transform.parent = crossbow.transform.parent;
+        crossbowArrow.transform.DOMoveY(-10, 3)
+            .OnComplete(() => crossbow.fishingLineRenderer.enabled = false);
+    }
+    async void AddLinePos()
+    {
+        float allTime = 1f;
+        float time = allTime;
+        float timeInterval = 0;
+        vector3s.Clear();
+        float elapsedTime = 0.02f;
+
+        while (time > 0)
+        {
+            elapsedTime = Time.deltaTime;
+            timeInterval += elapsedTime;
+            await Awaiters.Seconds(elapsedTime);
+            time -= elapsedTime;
+            ParabolaHarmonicSimulation parabolaHarmonicSimulation = new ParabolaHarmonicSimulation();
+            parabolaHarmonicSimulation.startPos = crossbowArrow.EndLine.position;
+            parabolaHarmonicSimulation.starTime = timeInterval;
+            parabolaHarmonicSimulation.curTime = timeInterval;
+            parabolaHarmonicSimulation.allTime = allTime;
+            vector3s.Add(parabolaHarmonicSimulation);
+        }
+    }
+    Vector3 GetCurPos(ParabolaHarmonicSimulation data, out float zeroTime)
+    {
+        data.curTime += Time.deltaTime;
+        float starTime = data.starTime;
+        float curTime = data.curTime - starTime;
+
+        //归0时间
+        zeroTime = curTime / data.allTime;
+        Vector3 vector3 = (crossbow.TopLine.position + crossbowArrow.EndLine.position) / 2;
+        if (zeroTime < 1)
+        {
+            Vector3 startPos = Vector3.Lerp(data.startPos, crossbowArrow.EndLine.position, zeroTime);
+
+            float time = curTime / lineChengeTime;
+            if (time < 1)
+            {
+                return Vector3.Lerp(startPos, vector3, time);
+            }
+        }
+
+        return vector3;
+    }
+
+    public float maxSegmentLength = 0.5f;
+
+
+    private List<Vector3> CalculateBezierPoint(List<Vector3> curPoints)
+    {
+        List<Vector3> points = new List<Vector3>();
+        points.Add(curPoints[0]);
+        for (int i = 1; i < curPoints.Count - 1; i++)
+        {
+            points.Add(CalculateBezierPoint(curPoints[i - 1], curPoints[i], curPoints[i + 1], 0.4f));
+        }
+        points.Add(curPoints[curPoints.Count - 1]);
+        return points;
+    }
+    //2次贝塞尔曲线
+    private Vector3 CalculateBezierPoint(Vector3 start, Vector3 midPoint, Vector3 end, float t)
+    {
+        Vector3 P0 = start;
+        Vector3 P1 = midPoint;
+        Vector3 P2 = end;
+        float u = 1 - t;
+        float tt = t * t;
+        float uu = u * u;
+        Vector3 p = uu * P0;
+        p += 2 * u * t * P1;
+        p += tt * P2;
+        return p;
+    }
+
+
+
+    private void LateUpdate()
+    {
+        if (crossbow != null && crossbowArrow.gameObject.activeSelf
+            && crossbow.fishingLineRenderer != null
+            && crossbow.fishingLineRenderer.enabled)
+        {
+            // 计算钓鱼线上的点
+            List<Vector3> linePoints = new List<Vector3>();
+            linePoints.Add(crossbow.EndLine.position);
+            for (int i = 0; i < crossbow.LineList.Count; i++)
+            {
+                linePoints.Add(crossbow.LineList[i].position);
+            }
+            linePoints.Add(crossbow.TopLine.position);
+
+            if (state == 1)
+            {
+                List<Vector3> newPoints = new List<Vector3>();
+                int count = vector3s.Count;
+                for (int i = 0; i < count; i++)
+                {
+                    Vector3 vector = GetCurPos(vector3s[i], out float zeroTime);
+                    if (zeroTime < 1)
+                    {
+                        newPoints.Add(vector);
+                    }
+                }
+                List<Vector3> refinedPoints = new List<Vector3>();
+                if (newPoints.Count > 0)
+                {
+                    refinedPoints.Add(newPoints[0]);
+                    for (int i = 1; i < newPoints.Count; i++)
+                    {
+                        Vector3 lastPoint = refinedPoints[refinedPoints.Count - 1];
+                        Vector3 currentPoint = newPoints[i];
+                        float distance = Vector3.Distance(lastPoint, currentPoint);
+                        if (distance > maxSegmentLength)
+                        {
+                            int segments = Mathf.FloorToInt(distance / maxSegmentLength);
+                            for (int j = 1; j <= segments; j++)
+                            {
+                                float t = j / (float)segments;
+                                Vector3 intermediatePoint = Vector3.Lerp(lastPoint, currentPoint, t);
+                                refinedPoints.Add(intermediatePoint);
+                            }
+                        }
+                        else
+                        {
+                            refinedPoints.Add(currentPoint);
+                        }
+                    }
+                }
+
+                refinedPoints.Add(crossbowArrow.EndLine.position);
+                for (int i = 0; i < crossbowArrow.LineList.Count; i++)
+                {
+                    refinedPoints.Add(crossbowArrow.LineList[i].position);
+                }
+                linePoints.AddRange(CalculateBezierPoint(refinedPoints));
+            }
+            else
+            {
+                linePoints.Add(crossbowArrow.LineList[^1].position);
+            }
+
+            // 绘制钓鱼线
+            crossbow.fishingLineRenderer.positionCount = linePoints.Count;
+            crossbow.fishingLineRenderer.SetPositions(linePoints.ToArray());
+        }
+        //}
+
+
+        //private void LateUpdate()
+        //{
+        if (isFinish)
+        {
+            return;
+        }
+
+        if (Input.GetMouseButtonDown(0))
+        {
+            _curMousePos = Input.mousePosition;
+            _offsetEuler = Vector3.zero;
+            initialRotation = transform.rotation.eulerAngles;
+            initialRotation.x = CheckAngle(initialRotation.x);
+            initialRotation.y = CheckAngle(initialRotation.y);
+            targetRotation = transform.rotation;
+        }
+        else if (Input.GetMouseButton(0))
+        {
+            Vector3 ver = Input.mousePosition - _curMousePos;
+            if (ver.magnitude > 5)
+            {
+                _offsetEuler.x -= ver.y * dragCameraScale;
+                _offsetEuler.y += ver.x * dragCameraScale;
+                var targetEulerAngles = initialRotation + _offsetEuler;
+
+                //Debug.Log($"<color=#e94242> targetEulerAngles: {targetEulerAngles}</color>");
+                // Clamp the rotation angles
+                targetEulerAngles.x = Mathf.Clamp(targetEulerAngles.x, -cameraOffset.x, cameraOffset.x);
+                targetEulerAngles.y = Mathf.Clamp(targetEulerAngles.y, -cameraOffset.y, cameraOffset.y);
+                targetEulerAngles.z = 0;
+                _offsetEuler = targetEulerAngles - initialRotation;
+                //Debug.Log($"<color=#e94242> targetEulerAngles ===: {targetEulerAngles}</color>");
+                targetRotation = Quaternion.Euler(targetEulerAngles);
+                //transform.rotation = targetRotation;
+                _curMousePos = Input.mousePosition;
+            }
+            transform.rotation = Quaternion.Angle(targetRotation, transform.rotation) > 0.1f
+                ? Quaternion.Lerp(transform.rotation, targetRotation, 0.2f)
+                : targetRotation;
+        }
+        else
+        {
+
+            if (guide != null)
+            {
+                //Vector3 targetDirection = target.transform.position - crossbowlowCamera.position;
+                //Vector3 currentDirection = crossbowlowCamera.forward;
+                //Quaternion rotationToTarget = Quaternion.FromToRotation(currentDirection, targetDirection);
+                //Quaternion rotation = rotationToTarget * transform.rotation;
+                Quaternion rotation = Quaternion.LookRotation(guide.transform.position - transform.position);
+                rotation = Quaternion.Slerp(transform.rotation, rotation, Time.deltaTime * 2);
+                transform.eulerAngles = new Vector3(rotation.eulerAngles.x, rotation.eulerAngles.y, 0);
+            }
+        }
+    }
+}

Assets/Scripts/Aquarium/CrossbowCameraMove.cs.meta

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

Assets/Scripts/Aquarium/DataCenter.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0b2b0621c926cf74ebf77318beb3ec48
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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: 

Assets/Scripts/Aquarium/FishEgg.cs

@@ -0,0 +1,43 @@
+using asap.core;
+using cfg;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+
+public class FishEgg : AquariumFishBase
+{
+    GameObject goPrefab;
+    AquariumEgg egg;
+    public async void LoadEgg(AquariumSlotData slotData)
+    {
+        this.slotData = slotData;
+        if (egg != null)
+        {
+            return;
+        }
+        Tables tables = GContext.container.Resolve<Tables>();
+        egg = tables.TbAquariumEgg.GetOrDefault(slotData.eggId);
+        goPrefab = await Addressables.InstantiateAsync(egg.Prefab, transform).Task;
+        if (egg == null)
+        {
+            Addressables.ReleaseInstance(goPrefab);
+            goPrefab = null;
+        }
+        else if (goPrefab != null)
+        {
+            goPrefab.transform.localPosition = Vector3.zero;
+        }
+    }
+    public void RemoveEgg()
+    {
+        egg = null;
+        if (goPrefab != null)
+        {
+            Addressables.ReleaseInstance(goPrefab);
+            goPrefab = null;
+        }
+    }
+    private void OnDestroy()
+    {
+        RemoveEgg();
+    }
+}

Assets/Scripts/Aquarium/FishEgg.cs.meta

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

Assets/Scripts/Aquarium/FishEggManager.cs

@@ -0,0 +1,24 @@
+using UnityEngine;
+
+public class FishEggManager : MonoBehaviour
+{
+    public FishEgg[] eggs;
+    public void AddEgg(AquariumSlotData slotData)
+    {
+        eggs[slotData.index].LoadEgg(slotData);
+    }
+    public void RemoveEgg(int index)
+    {
+        //蛋孵化的动画
+        //await Awaiters.NextFrame;
+        eggs[index].RemoveEgg();
+    }
+    public FishEgg GetEgg(int index)
+    {
+        if (eggs.Length > index)
+        {
+            return eggs[index];
+        }
+        return null;
+    }
+}

Assets/Scripts/Aquarium/FishEggManager.cs.meta

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

Assets/Scripts/Aquarium/FishManager.cs

@@ -0,0 +1,204 @@
+using asap.core;
+using cfg;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using Random = UnityEngine.Random;
+
+public class FishManager : MonoBehaviour
+{
+    [SerializeField] private GameObject fishPrefab;
+    public Vector3 tankSize;
+    private Vector3 _tankCenter = Vector3.zero;
+    public Vector3 tankCenter => _tankCenter;
+    [Header("Fish Parameters")]
+    public float avoidRadius;
+    public float alignRadius;
+    public float obstacleDetectionRadius;
+    public float avoidance, alignment, cohesion, trigger, obstacle, areaConstrain, maxVel, minVel, angularAcc, magnitudeAcc, dvLerp;
+    public float zMoveRatio = 0.4f;
+    private Vector3 HalfSize => tankSize / 2;
+
+    public Dictionary<int, GameObject> fishUnDownloadAlter;
+    Dictionary<int, List<FishMovement>> _fishGroups = new Dictionary<int, List<FishMovement>>();
+    [NonSerialized]
+    public List<FishMovement> allFish = new List<FishMovement>();
+    [NonSerialized]
+    public List<GameObject> obstacleGo = new List<GameObject>();
+
+    public float MaxLoadTime { set; get; } = 50;
+    private void Start()
+    {
+        _tankCenter = transform.position;
+        fishPrefab.gameObject.SetActive(false);
+    }
+
+    /// <summary>
+    /// 初始鱼群
+    /// </summary>
+    /// <param name="mutantMaterial"> 是否变异 变异材质 </param>
+    /// <param name="fishItemID">鱼的item ID</param>
+    /// <param name="count">鱼当前剩余的数量</param>
+    /// <param name="groupId">鱼群分组</param>
+    /// 
+    public void AddFish(Material mutantMaterial, GameObject fxLeftEye, GameObject fxRightEye,
+        AquariumSlotData slotData, int count, int groupId)
+    {
+        if (_fishGroups.ContainsKey(groupId))
+        {
+            return;
+        }
+        var fishGroup = new List<FishMovement>();
+        _fishGroups[groupId] = fishGroup;
+        Tables tables = GContext.container.Resolve<Tables>();
+        Item item = tables.TbItem.GetOrDefault(slotData.fishItemID);
+        var fishData = tables.TbFishData.GetOrDefault(item.RedirectID);
+        float startSizeZ = (slotData.aquariumFishID - 1) * zMoveRatio * tankSize.z;
+        var position = GetRandomPositionAndRotation(startSizeZ);
+        var rot = Random.rotation;
+
+        for (int i = 0; i < count; i++)
+        {
+            var go = Instantiate(fishPrefab, position + Random.onUnitSphere, rot, transform);
+            go.SetActive(true);
+            go.name = $"fish{groupId}_{i}";
+            var movement = go.GetComponent<FishMovement>();
+            movement.index = i;
+            movement.groupId = groupId;
+            float mutantScale = 1;
+            if (i < slotData.mutants)
+            {
+                mutantScale = tables.TbFishMutant.AquariumScale[fishData.Quality - 1];
+            }
+            go.transform.localScale = Vector3.one * fishData.AquariumMinScale * mutantScale;
+            movement.Init(this, slotData, startSizeZ, fishData, mutantScale);
+            fishGroup.Add(movement);
+            allFish.Add(movement);
+        }
+        LoadFish(fishGroup, mutantMaterial, fxLeftEye, fxRightEye);
+    }
+
+    async void LoadFish(List<FishMovement> fishMovements, Material mutantMaterial, GameObject fxLeftEye, GameObject fxRightEye)
+    {
+        for (int i = 0; i < fishMovements.Count; i++)
+        {
+            if (fishMovements[i] == null || fishMovements[i].isResult)
+            {
+                return;
+            }
+            await fishMovements[i].LoadFish(mutantMaterial, fxLeftEye, fxRightEye);
+        }
+    }
+
+    private Vector3 GetRandomPositionAndRotation(float startSizeZ)
+    {
+        var HalfSize = tankSize / 2;
+        var pos = new Vector3(
+            x: UnityEngine.Random.Range(-HalfSize.x, HalfSize.x),
+            y: UnityEngine.Random.Range(-HalfSize.y, HalfSize.y) / 2,
+            z: UnityEngine.Random.Range(-HalfSize.z, HalfSize.z));
+        pos += tankCenter;
+        pos.z += startSizeZ;
+        return pos;
+    }
+
+    public void RemoveFish(int groupId)
+    {
+        if (!_fishGroups.TryGetValue(groupId, out List<FishMovement> fishGroup))
+        {
+            return;
+        }
+        if (fishGroup.Count > 0)
+        {
+            for (int i = 0; i < fishGroup.Count; i++)
+            {
+                Destroy(fishGroup[i].gameObject);
+                allFish.Remove(fishGroup[i]);
+            }
+        }
+        _fishGroups.Remove(groupId);
+    }
+    public void SetFishScale(int groupId, float scale, int mutants, float aquariumScale)
+    {
+        if (!_fishGroups.TryGetValue(groupId, out List<FishMovement> fishGroup))
+        {
+            return;
+        }
+
+        if (fishGroup.Count > 0)
+        {
+            for (int i = 0; i < fishGroup.Count; i++)
+            {
+                if (i < mutants)
+                {
+                    fishGroup[i].transform.localScale = Vector3.one * scale * aquariumScale;
+                }
+                else
+                {
+                    fishGroup[i].transform.localScale = Vector3.one * scale;
+                }
+            }
+        }
+    }
+    public FishMovement GetFish(int groupId)
+    {
+        if (!_fishGroups.TryGetValue(groupId, out List<FishMovement> fishGroup))
+        {
+            return null;
+        }
+
+        if (fishGroup.Count > 0)
+        {
+            return fishGroup[0];
+        }
+        return null;
+    }
+    public void AllEscape()
+    {
+        for (int i = 0; i < allFish.Count; i++)
+        {
+            allFish[i].AllEscape();
+        }
+    }
+
+#if UNITY_EDITOR
+    private void OnDrawGizmos()
+    {
+        _tankCenter = transform.position;
+        Gizmos.color = Color.cyan;
+        // Gizmos.DrawCube(_tankCenter, tankSize);
+        var halfSize = tankSize / 2;
+
+        // Define the 8 vertices of the cube
+        var vertices = new Vector3[8]
+        {
+            _tankCenter + new Vector3(-halfSize.x, -halfSize.y, -halfSize.z),
+            _tankCenter + new Vector3(halfSize.x, -halfSize.y, -halfSize.z),
+            _tankCenter + new Vector3(halfSize.x, -halfSize.y, halfSize.z),
+            _tankCenter + new Vector3(-halfSize.x, -halfSize.y, halfSize.z),
+            _tankCenter + new Vector3(-halfSize.x, halfSize.y, -halfSize.z),
+            _tankCenter + new Vector3(halfSize.x, halfSize.y, -halfSize.z),
+            _tankCenter + new Vector3(halfSize.x, halfSize.y, halfSize.z),
+            _tankCenter + new Vector3(-halfSize.x, halfSize.y, halfSize.z)
+        };
+
+        // Draw bottom square
+        Gizmos.DrawLine(vertices[0], vertices[1]);
+        Gizmos.DrawLine(vertices[1], vertices[2]);
+        Gizmos.DrawLine(vertices[2], vertices[3]);
+        Gizmos.DrawLine(vertices[3], vertices[0]);
+
+        // Draw top square
+        Gizmos.DrawLine(vertices[4], vertices[5]);
+        Gizmos.DrawLine(vertices[5], vertices[6]);
+        Gizmos.DrawLine(vertices[6], vertices[7]);
+        Gizmos.DrawLine(vertices[7], vertices[4]);
+
+        // Draw vertical edges
+        Gizmos.DrawLine(vertices[0], vertices[4]);
+        Gizmos.DrawLine(vertices[1], vertices[5]);
+        Gizmos.DrawLine(vertices[2], vertices[6]);
+        Gizmos.DrawLine(vertices[3], vertices[7]);
+    }
+#endif
+}

Assets/Scripts/Aquarium/FishManager.cs.meta

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

Assets/Scripts/Aquarium/FishMovement.cs

@@ -0,0 +1,482 @@
+using asap.core;
+using cfg;
+using DG.Tweening;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Unity.Mathematics;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+
+public class FishMovement : AquariumFishBase
+{
+    [SerializeField] private Rigidbody rb;
+    private Vector3 Orientation => transform.rotation * Vector3.forward;
+    public int index = 0, groupId = -1;
+    public Rigidbody Rb => rb;
+    FishManager fishManager;
+    GameObject goPrefab;
+    float startSizeZ = 0;
+    float avoidRadius = 0;
+    float maxPitchAngle = 30f;
+    GameObject leftEye;
+    GameObject rightEye;
+    public float AvoidRadius => avoidRadius * transform.localScale.x;
+    public Vector3 targetPos;
+    public Transform fishPos;
+    GameObject fishUnDownloadAlter;
+    public FishData fishData;
+    public Fish fish;
+    List<Collider> colliders = new List<Collider>();
+    //public int triggerCount;
+    public bool isResult;
+    public float mutantScale;
+    float loadTime;
+    float startLoadTime;
+    public void Init(FishManager fishManager, AquariumSlotData slotData, float startSizeZ, FishData fishData, float mutantScale)
+    {
+        this.mutantScale = mutantScale;
+        this.slotData = slotData;
+        this.fishData = fishData;
+        this.fishManager = fishManager;
+        this.startSizeZ = startSizeZ;
+        rb.velocity = rb.rotation * Vector3.forward;
+        LoadFishUnDownloadAlter(fishData.Quality - 1);
+        startLoadTime = Time.time;
+    }
+    public void RemoveEye()
+    {
+        if (leftEye != null)
+        {
+            DestroyImmediate(leftEye);
+        }
+        if (rightEye != null)
+        {
+            DestroyImmediate(rightEye);
+        }
+    }
+    void LoadFishUnDownloadAlter(int quality)
+    {
+        if (fishManager.fishUnDownloadAlter != null && fishManager.fishUnDownloadAlter.ContainsKey(quality))
+        {
+            fishUnDownloadAlter = Instantiate(fishManager.fishUnDownloadAlter[quality], transform);
+            fish = fishUnDownloadAlter.GetComponent<Fish>();
+            fish.animator.transform.localPosition = Vector3.zero;
+            fish.EnableCollider();
+            avoidRadius = fish.GetColliderSize(fishManager.avoidRadius);
+            fishUnDownloadAlter.transform.localPosition = Vector3.zero;
+            fishUnDownloadAlter.transform.localEulerAngles = Vector3.up * 180;
+            fishUnDownloadAlter.transform.localScale = Vector3.one;
+            fishUnDownloadAlter.name = $"{fishUnDownloadAlter.name}_{index}";
+        }
+
+    }
+
+
+    public async Task LoadFish(Material mutantMaterial, GameObject fxLeftEye, GameObject fxRightEye)
+    {
+        goPrefab = await Addressables.InstantiateAsync(fishData.Fbx, transform).Task;
+        loadTime = Time.time - startLoadTime;
+        if (rb == null || isResult || loadTime > fishManager.MaxLoadTime)
+        {
+            Debug.LogWarning($"LoadFish TimeOut:{loadTime} {fishData.Fbx}");
+            Addressables.ReleaseInstance(goPrefab);
+            goPrefab = null;
+        }
+        else if (goPrefab != null)
+        {
+            //Destroy(fishUnDownloadAlter);
+            //fishUnDownloadAlter = null;
+            if (fishUnDownloadAlter != null)
+            {
+                fishUnDownloadAlter.SetActive(false);
+            }
+            fish = goPrefab.GetComponent<Fish>();
+            fish.animator.transform.localPosition = Vector3.zero;
+            fish.EnableCollider();
+            fish.animator.Play("Swim01", 0, UnityEngine.Random.Range(0, 0.8f));
+            avoidRadius = fish.GetColliderSize(fishManager.avoidRadius);
+            goPrefab.transform.localPosition = Vector3.zero;
+            goPrefab.transform.localEulerAngles = Vector3.up * 180;
+            goPrefab.transform.localScale = Vector3.one;
+            goPrefab.name = $"{fishData.Fbx}_{index}";
+            if (slotData.mutants <= index)
+            {
+                return;
+            }
+            var _tables = GContext.container.Resolve<Tables>();
+            float eyeScale = _tables.TbFishMutant.FxAquariumScale[fishData.Quality - 1];
+            if (fish.LeftEye != null && fxLeftEye != null)
+            {
+                leftEye = Instantiate(fxLeftEye);
+                leftEye.transform.localScale = Vector3.one * eyeScale;
+                leftEye.transform.parent = fish.LeftEye;
+                leftEye.transform.localPosition = Vector3.zero;
+                leftEye.transform.localRotation = Quaternion.identity;
+            }
+
+            if (fish.RightEye != null && fxRightEye != null)
+            {
+                rightEye = Instantiate(fxRightEye);
+                rightEye.transform.localScale = Vector3.one * eyeScale;
+                rightEye.transform.parent = fish.RightEye;
+                rightEye.transform.localPosition = Vector3.zero;
+                rightEye.transform.localRotation = Quaternion.identity;
+            }
+
+            Renderer[] meshRenderer = goPrefab.GetComponentsInChildren<Renderer>();
+            if (meshRenderer != null && meshRenderer.Length > 0)
+            {
+                var render = meshRenderer[0];
+                var materials = render.materials;
+                for (int i = 0; i < materials.Length; i++)
+                {
+                    var material = materials[i];
+                    var material_P = new Material(mutantMaterial);
+                    material_P.SetTexture("_BaseMap", material.GetTexture("_BaseMap"));
+                    material_P.SetTexture("_BumpMap", material.GetTexture("_BumpMap"));
+                    materials[i] = material_P;
+                }
+                render.materials = materials;
+            }
+        }
+    }
+
+    public void OnShoot(bool isRob, float speed, float time, Vector3 reasonableCenter, Vector3 reasonableLocation, float reasonableDistance)
+    {
+        rb.isKinematic = true;
+        isResult = true;
+
+        var pos = transform.position;
+        var startPos = Vector3.zero;
+        startPos.z = UnityEngine.Random.Range(-reasonableLocation.z, reasonableLocation.z);
+        if (pos.x > fishManager.tankCenter.x)
+        {
+            startPos.x = UnityEngine.Random.Range(0, reasonableLocation.x);
+        }
+        else
+        {
+            startPos.x = UnityEngine.Random.Range(-reasonableLocation.x, 0);
+        }
+        if (pos.y > fishManager.tankCenter.y)
+        {
+            startPos.y = UnityEngine.Random.Range(0, reasonableLocation.y);
+        }
+        else
+        {
+            startPos.y = UnityEngine.Random.Range(-reasonableLocation.y, 0);
+        }
+        transform.position = startPos + reasonableCenter;
+
+        targetPos = startPos + reasonableCenter + rb.rotation * Vector3.forward * reasonableDistance;
+
+        float l = speed * time;
+        float t = l / (targetPos - transform.position).magnitude;
+        if (t < 1)
+        {
+            targetPos = Vector3.Lerp(transform.position, targetPos, t);
+        }
+        //转弯
+        //Quaternion rotation1 = Quaternion.LookRotation(targetPos - transform.position);
+        //transform.DORotateQuaternion(rotation1, time * 0.8f);
+        // Move the fish along the path
+        transform.DOMove(targetPos, time).SetEase(Ease.Linear);
+
+        SetTargetPos(isRob);
+    }
+
+    void SetTargetPos(bool isRob)
+    {
+         fishPos = fish.mouthPos;
+        if (!isRob)
+        {
+            int i = UnityEngine.Random.Range(0, 3);
+            if (i == 0)
+            {
+                fishPos = fish.Fin;
+            }
+            else if (i == 1)
+            {
+                fishPos = fish.Neck;
+            }
+            else if (i == 2)
+            {
+                fishPos = fish.Tail;
+            }
+        }
+        if (fishPos != null)
+        {
+            targetPos += fishPos.position - transform.position;
+        }
+    }
+
+    public void AllEscape()
+    {
+        if (!isResult)
+        {
+            rb.isKinematic = true;
+            isResult = true;
+            var ta = transform.position + rb.rotation * Vector3.forward * 50;
+            transform.DOMove(ta, 3).OnComplete(() => fish.gameObject.SetActive(false)).SetEase(Ease.Linear);
+        }
+    }
+
+    public void SetFishSpeed(float speed, float time)
+    {
+        if (fish != null)
+        {
+            float curSpeed = speed;
+            DOTween.To(() => speed, x => curSpeed = x, 1f, time).OnUpdate(() =>
+            {
+                fish.FishAnimSpeed = curSpeed;
+            });
+        }
+    }
+
+    public void Shock(float distance, float time, AnimationCurve shockCurve)
+    {
+        transform.DOMoveZ(transform.position.z + distance, time).SetEase(shockCurve);
+    }
+
+    public void Capture(float minSpeed, float maxSpeed, float addRotation, float addRotationPeriod)
+    {
+        fish.FishAnimSpeed = UnityEngine.Random.Range(minSpeed, maxSpeed);
+        //鱼的朝向y轴 增加 rotation
+        float add = UnityEngine.Random.Range(-addRotation, addRotation);
+        Quaternion rotation = Quaternion.AngleAxis(add, Vector3.up);
+        rb.rotation = rb.rotation * rotation; //rb.transform.forward;
+        StartCoroutine(AddRotation(addRotation, addRotationPeriod));
+    }
+
+    IEnumerator AddRotation(float addRotation, float addRotationPeriod)
+    {
+        Quaternion startRotation = rb.rotation;
+        while (enabled)
+        {
+            float add = UnityEngine.Random.Range(-addRotation, addRotation);
+            Quaternion rotation = Quaternion.AngleAxis(add, Vector3.up);
+            //rb.rotation = startRotation * rotation; //rb.transform.forward;
+            transform.DORotateQuaternion(startRotation * rotation, addRotationPeriod);
+            yield return new WaitForSeconds(addRotationPeriod);
+        }
+    }
+
+    public void Escape(float distance, float duration)
+    {
+        transform.DOKill();
+        rb.isKinematic = true;
+        isResult = true;
+        var ta = transform.position + rb.rotation * Vector3.forward * distance;
+        transform.DOMove(ta, duration).OnComplete(() => fish.gameObject.SetActive(false)).SetEase(Ease.InSine);
+    }
+    public void OnShooted(bool isRob)
+    {
+        if (fish != null)
+        {
+            fish.animator.SetInteger("HurtIndex", isRob ? 2 : 1);
+            fish.animator.SetTrigger("Hurt");
+        }
+        rb.isKinematic = true;
+        isResult = true;
+    }
+    private void OnTriggerEnter(Collider other)
+    {
+        colliders.Add(other);
+    }
+    private void OnTriggerExit(Collider other)
+    {
+        colliders.Remove(other);
+    }
+
+    private Vector3 _dv = Vector3.zero;
+    private Vector3 _lastDv = Vector3.zero;
+    private void FixedUpdate()
+    {
+        if (fishManager == null || isResult)
+        {
+            return;
+        }
+        var s = fishManager.tankSize / 2;
+        float offsetX = fishManager.tankCenter.x;
+        float offsetY = fishManager.tankCenter.y;
+        float offsetZ = fishManager.tankCenter.z + startSizeZ;
+
+        //区域外
+        _dv = Vector3.zero;
+        // Area Constraint
+
+        if (rb.position.x > s.x + offsetX)
+        {
+            _dv += Vector3.left * (rb.position.x - s.x - offsetX);
+
+        }
+        else if (rb.position.x < -s.x + offsetX)
+        {
+            _dv += Vector3.right * (-s.x + offsetX - rb.position.x);
+        }
+        if (rb.position.y > s.y + offsetY)
+        {
+            _dv += Vector3.down * (rb.position.y - s.y - offsetY);
+        }
+        else if (rb.position.y < -s.y + offsetY)
+        {
+            _dv += Vector3.up * (-s.y + offsetY - rb.position.y);
+        }
+        if (rb.position.z > s.z + offsetZ)
+        {
+            _dv += Vector3.back * (rb.position.z - s.z - offsetZ);
+        }
+        else if (rb.position.z < -s.z + offsetZ)
+        {
+            _dv += Vector3.forward * (-s.z + offsetZ - rb.position.z);
+        }
+        _dv *= fishManager.areaConstrain;
+
+        // Boids Constraint
+        var colliderCount = fishManager.allFish.Count;
+        // var flockMates = new List<Rigidbody>();
+        var alignVelocity = Vector3.zero;
+        var avoidPosition = Vector3.zero;
+        var coherePosition = Vector3.zero;
+        int alignBoidCount = 0, avoidBoidCount = 0, cohereBoidCount = 0;
+
+        for (int i = colliders.Count - 1; i >= 0; i--)
+        {
+            if (colliders[i] == null)
+            {
+                colliders.RemoveAt(i);
+                continue;
+            }
+            Transform obstacleTransform = colliders[i].transform;
+            var fromToVector = obstacleTransform.position - transform.position;
+            var distance = fromToVector.magnitude;
+            _dv -= fromToVector.normalized / distance * fishManager.trigger;
+        }
+
+        for (int i = 0; i < fishManager.obstacleGo.Count; i++)
+        {
+            Transform obstacleTransform = fishManager.obstacleGo[i].transform;
+            Vector3 localScale = obstacleTransform.localScale / 2;
+            Vector3 localPos = obstacleTransform.position;
+            if (transform.position.x < localPos.x - localScale.x)
+            {
+                localPos.x -= localScale.x;
+            }
+            else if (transform.position.x > localPos.x + localScale.x)
+            {
+                localPos.x += localScale.x;
+            }
+
+            if (transform.position.y < localPos.y - localScale.y)
+            {
+                localPos.y -= localScale.y;
+            }
+            else if (transform.position.y > localPos.y + localScale.y)
+            {
+                localPos.y += localScale.y;
+            }
+
+            if (transform.position.z < localPos.z - localScale.z)
+            {
+                localPos.z -= localScale.z;
+            }
+            else if (transform.position.z > localPos.z + localScale.z)
+            {
+                localPos.z += localScale.z;
+            }
+
+            var fromToVector = localPos - transform.position;
+            var distance = fromToVector.magnitude;
+            // Obstacle has a higher weight than other boids
+            if (distance <= fishManager.obstacleDetectionRadius)
+            {
+                _dv -= fromToVector.normalized / distance * fishManager.obstacle;
+            }
+        }
+
+        for (int i = 0; i < colliderCount; i++)
+        {
+            var flockMate = fishManager.allFish[i];
+            var fromToVector = fishManager.allFish[i].transform.position - transform.position;
+            var distance = fromToVector.magnitude;
+
+            if (fishManager.allFish[i].gameObject.name == gameObject.name || flockMate is null)
+                continue;
+
+            if (flockMate.groupId == groupId && distance <= fishManager.alignRadius)
+            {
+                alignBoidCount++;
+                alignVelocity += flockMate.Rb.velocity;
+            }
+
+            if (flockMate.fishData.Quality >= fishData.Quality
+                && distance <= (AvoidRadius + flockMate.AvoidRadius))
+            // && ((triggerCount > 0 && flockMate.groupId == groupId) || flockMate.groupId != groupId)
+            //)
+            {
+                avoidBoidCount++;
+                avoidPosition += flockMate.Rb.position;
+            }
+
+            if (flockMate.groupId == groupId)
+            {
+                cohereBoidCount++;
+                coherePosition += flockMate.Rb.position;
+            }
+        }
+
+        if (avoidBoidCount > 0)
+            _dv += (rb.position - avoidPosition / avoidBoidCount) * fishManager.avoidance;
+        if (alignBoidCount > 0)
+            _dv += (alignVelocity / alignBoidCount - rb.velocity) * fishManager.alignment;
+        if (cohereBoidCount > 0)
+            _dv += (coherePosition / cohereBoidCount - rb.position) * fishManager.cohesion;
+        _dv = Vector3.Lerp(_lastDv, _dv, math.saturate(fishManager.dvLerp));
+        _lastDv = _dv;
+        var targetVelocity = rb.velocity + _dv * Time.fixedDeltaTime;
+        var newVelocity = Vector3.RotateTowards(rb.transform.forward * rb.velocity.magnitude, targetVelocity, fishManager.angularAcc,
+            fishManager.magnitudeAcc);
+
+        //仰角限制
+        float maxPitchAngle = 30f;
+        float maxY = Mathf.Sin(maxPitchAngle * Mathf.Deg2Rad) * newVelocity.magnitude;
+        newVelocity.y = Mathf.Clamp(newVelocity.y, -maxY, maxY);
+
+        if (newVelocity.magnitude < 0.001)
+        {
+            return;
+        }
+        rb.rotation = Quaternion.LookRotation(newVelocity);
+        newVelocity = Vector3.RotateTowards(newVelocity, targetVelocity, fishManager.angularAcc,
+           fishManager.magnitudeAcc);
+
+        maxY = Mathf.Sin(maxPitchAngle * Mathf.Deg2Rad) * newVelocity.magnitude;
+        newVelocity.y = Mathf.Clamp(newVelocity.y, -maxY, maxY);
+
+        float angle = Vector3.Angle(rb.velocity, targetVelocity);
+        newVelocity *= 1 - (angle / 185);
+        rb.velocity = newVelocity;
+
+        //Max-Min Constraint
+        if (rb.velocity.magnitude > fishManager.maxVel)
+            rb.velocity = rb.velocity.normalized * fishManager.maxVel;
+        else if (rb.velocity.magnitude < fishManager.minVel)
+            rb.velocity = rb.velocity.normalized * fishManager.minVel;
+    }
+    private void OnDestroy()
+    {
+        if (goPrefab != null)
+        {
+            Addressables.ReleaseInstance(goPrefab);
+            goPrefab = null;
+        }
+    }
+    private void OnDrawGizmosSelected()
+    {
+        // Display the explosion radius when selected
+        Gizmos.color = Color.red;
+        Gizmos.DrawWireSphere(transform.position, AvoidRadius);
+        Gizmos.color = Color.blue;
+        Gizmos.DrawLine(transform.position, transform.position + _dv * (5 * Time.fixedDeltaTime));
+    }
+}

Assets/Scripts/Aquarium/FishMovement.cs.meta

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

Assets/Scripts/Aquarium/FishingAquariumAct.cs

@@ -0,0 +1,483 @@
+using asap.core;
+using System.Threading.Tasks;
+using UniRx;
+using UnityEngine.AddressableAssets;
+using GameCore;
+using UnityEngine;
+using System.Collections.Generic;
+using cfg;
+using System;
+using System.Collections;
+
+public struct AquariumEnterMapScene
+{
+    public bool isShowUI;
+}
+public struct EnterMaped
+{
+
+}
+public struct ChangeFishEvent
+{
+    public List<int> addFish;
+    public List<int> removeFish;
+}
+
+public class FishingAquariumAct : AGameAct
+{
+    /// <summary>
+    /// 1 == 进匹配 2 == 退出匹配 3 == 进水族馆 4 == 退出水族馆 5 == 退到匹配
+    /// </summary>
+    public static int CloudType = 0;
+    AquariumManager AM;
+    CompositeDisposable disposables;
+    GameObject aquarium;
+    GameObject _light;
+    AquariumFishController aquariumFishController;
+    cfg.Tables _tables;
+    AquariumInit aquariumInit;
+    Material mutantMaterial;
+    GameObject fxLeftEye;
+    GameObject fxRightEye;
+
+    AquariumPanel aquariumPanel;
+
+    Dictionary<int, GameObject> fishUnDownloadAlter = new Dictionary<int, GameObject>();
+    public static EventAggregator eventAggregator;
+
+    public override async Task<bool> StartAsync()
+    {
+        eventAggregator = new EventAggregator();
+        _tables = GContext.container.Resolve<cfg.Tables>();
+        aquariumInit = _tables.TbAquariumInit.DataList[0];
+        disposables = new CompositeDisposable();
+        GContext.container.Unregister<AquariumManager>();
+        GContext.container.Unregister<FishingData>();
+        var fishingData = new FishingData();
+        GContext.container.RegisterInstance(fishingData);
+        AM = new AquariumManager();
+        await AM.Synchrodata();
+        GContext.container.RegisterInstance(AM);
+        eventAggregator.GetEvent<AquariumEnterMapScene>().Subscribe(OnEnterMapScene).AddTo(disposables);
+        eventAggregator.GetEvent<ChangeFishEvent>().Subscribe(OnChangeFishEvent).AddTo(disposables);
+        disposables.Add(GContext.OnEvent<InGradeAquariumEvent>().Subscribe(OnInAquariumEnevt));
+        // 加载场景
+        GContext.Publish(new HideHomePanelEvent());
+        mutantMaterial = await Addressables.LoadAssetAsync<Material>(_tables.TbFishMutant.Material).Task;
+        fxLeftEye = await Addressables.LoadAssetAsync<GameObject>(_tables.TbFishMutant.FxLeftEye).Task;
+        fxRightEye = await Addressables.LoadAssetAsync<GameObject>(_tables.TbFishMutant.FxRightEye).Task;
+
+        if (AM.data.isHome || AM.data.slotDatas == null)
+        {
+            await EnterStartScene();
+        }
+        else
+        {
+            await EnterMapScene();
+            await Awaiters.Seconds(1);
+            ShowAquariumPanel();
+        }
+
+        return await base.StartAsync();
+    }
+
+    async void ShowAquariumPanel()
+    {
+        GameObject go = await UIManager.Instance.ShowUILoad(UITypes.AquariumPanel);
+        aquariumPanel = go.GetComponent<AquariumPanel>();
+        aquariumPanel.Init(this);
+        _ = StartCoroutine(StartTime());
+        aquariumFishController.cameraManager.MoveCamera();
+    }
+
+    async Task EnterStartScene()
+    {
+        await LoadScene();
+        await UIManager.Instance.ShowUILoad(UITypes.AquariumDetectPanel);
+    }
+
+    /// <summary>
+    /// 提前加载地图，之后加载UI
+    /// </summary>
+    /// <returns></returns>
+    async Task EnterMapScene()
+    {
+        List<AquariumSlotData> slotDatas = AM.data.slotDatas;
+        for (int i = 0; i < AM.data.slot; i++)
+        {
+            AquariumSlotData slotData = slotDatas[i];
+            Item item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
+            if (!fishUnDownloadAlter.ContainsKey(item.Quality - 1))
+            {
+                int id = _tables.GetItemData(_tables.TbGlobalConfig.FishUnDownloadAlter[item.Quality - 1]).RedirectID;
+                FishData fishData = _tables.TbFishData.GetOrDefault(id);
+                fishUnDownloadAlter[item.Quality - 1] = await Addressables.LoadAssetAsync<GameObject>(fishData.Fbx).Task;
+            }
+        }
+        await LoadScene();
+        InitFish();
+    }
+    async Task LoadScene()
+    {
+        ReleaseAquarium();
+
+        var mapData = _tables.TbMapData.DataMap[AM.MapId];
+
+        string prefabName = mapData.AquariumPrefab;
+        aquarium = await Addressables.InstantiateAsync(prefabName).Task;
+        if (disposables == null)
+        {
+            ReleaseAquarium();
+            return;
+        }
+        aquariumFishController = aquarium.GetComponent<AquariumFishController>();
+        aquariumFishController.fishManager.MaxLoadTime = 50;
+        aquariumFishController.cameraManager.PlayAquarium(this);
+    }
+
+    async void OnEnterMapScene(AquariumEnterMapScene aem)
+    {
+        if (aem.isShowUI)
+        {
+            ShowAquariumPanel();
+        }
+        else if (AM.data.isHome || AM.data.slotDatas == null)
+        {
+            CloudType = 5;
+            await UIManager.Instance.ShowUINotLoading(UITypes.AquariumCloudPanel);
+            await Awaiters.Seconds(0.75f);
+            await EnterStartScene();
+            UIManager.Instance.DestroyUI(UITypes.AquariumReportPopupPanel);
+            aquariumPanel = null;
+            UIManager.Instance.DestroyUI(UITypes.AquariumPanel);
+            GContext.Publish(new EndTransition());
+        }
+        else
+        {
+            await EnterMapScene();
+            eventAggregator.Publish(new EnterMaped());
+        }
+    }
+    void OnChangeFishEvent(ChangeFishEvent e)
+    {
+        List<int> removeFish = e.removeFish;
+        if (removeFish != null && removeFish.Count > 0)
+        {
+            for (int i = 0; i < removeFish.Count; i++)
+            {
+                aquariumFishController.fishManager.RemoveFish(removeFish[i]);
+            }
+        }
+
+        List<int> addFish = e.addFish;
+        if (addFish != null && addFish.Count > 0)
+        {
+            List<AquariumSlotData> slotDatas = AM.data.slotDatas;
+            List<AquariumResultData> aquariumResultDatas = AM.data.aquariumResultDatas;
+            for (int i = 0; i < addFish.Count; i++)
+            {
+                //当蛋孵化时添加鱼
+                int index = addFish[i];
+                AquariumSlotData slotData = slotDatas[index];
+                var time = ZZTimeHelper.UtcNow();
+                if (slotData.FishHatchTime() < time && !slotData.IsResult() && !aquariumResultDatas[index].IsResult())
+                {
+                    EggToFish(slotData, index);
+                }
+            }
+        }
+    }
+    /// <summary>
+    ///蛋孵化 添加鱼
+    /// </summary>
+    /// <param name="slotData"></param>
+    /// <param name="index"></param>
+    void EggToFish(AquariumSlotData slotData, int index)
+    {
+        aquariumFishController.fishEggManager.RemoveEgg(index);
+        AddFish(slotData, index, slotData.fishMQ);
+    }
+    void OnInAquariumEnevt(InGradeAquariumEvent e)
+    {
+        Debug.Log("OnInAquariumEnevt");
+
+        if (aquarium != null)
+        {
+            aquarium.SetActive(e.type == 1);
+        }
+    }
+
+    void InitFish()
+    {
+        List<AquariumSlotData> slotDatas = AM.data.slotDatas;
+        if (slotDatas == null)
+        {
+            return;
+        }
+        aquariumFishController.fishManager.fishUnDownloadAlter = fishUnDownloadAlter;
+        var time = ZZTimeHelper.UtcNow();
+        List<AquariumResultData> aquariumResultDatas = AM.data.aquariumResultDatas;
+
+        for (int i = 0; i < AM.data.slot; i++)
+        {
+            AquariumSlotData slotData = slotDatas[i];
+            slotData.index = i;
+            var HatchTime = slotData.FishHatchTime();
+
+            if (HatchTime < time)
+            {
+                if (!slotData.IsResult() && !aquariumResultDatas[i].IsResult())
+                {
+                    //检查是否受伤
+                    //正常的成长时间 自然时间+加速成长-总恢复时间
+                    float normalH = (float)(time - HatchTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+
+                    float injuryH = slotData.injuryGrowthTime;
+                    int fishQ = slotData.fishMQ;
+                    if (injuryH < normalH)
+                    {
+                        AM.data.aquariumHurtDatas[i].fishLQ = 0;
+                    }
+                    else
+                    {
+                        fishQ -= AM.data.aquariumHurtDatas[i].fishLQ;
+                        if (fishQ <= 0)
+                        {
+                            fishQ = 1;
+                        }
+                    }
+                    AddFish(slotData, i, fishQ);
+                }
+            }
+            else
+            {
+                //初始化蛋
+                aquariumFishController.fishEggManager.AddEgg(slotData);
+            }
+        }
+    }
+    IEnumerator StartTime()
+    {
+        List<AquariumSlotData> slotDatas = AM.data.slotDatas;
+        List<AquariumResultData> aquariumResultDatas = AM.data.aquariumResultDatas;
+        for (int i = 0; i < AM.Slot; i++)
+        {
+            if (!aquariumResultDatas[i].IsResult() && !slotDatas[i].IsResult())
+            {
+                SetFishScale(slotDatas[i], i);
+            }
+        }
+        while (aquariumPanel != null)
+        {
+            DateTime dateTime = ZZTimeHelper.UtcNow();
+
+            aquariumPanel.OnUpdate(dateTime);
+            for (int i = 0; i < AM.Slot; i++)
+            {
+                if (!aquariumResultDatas[i].IsResult() && !slotDatas[i].IsResult() && slotDatas[i].FishGrowthTime() > dateTime)
+                {
+                    SetFishScale(slotDatas[i], i);
+                }
+            }
+            yield return Awaiters.Seconds(1);
+        }
+    }
+    /// <summary>
+    /// 加载鱼的模型
+    /// </summary>
+    /// <param name="aquariumSlotData"></param>
+    /// <param name="index"></param>
+    void AddFish(AquariumSlotData aquariumSlotData, int index, int count)
+    {
+        aquariumFishController.fishManager.AddFish(
+            mutantMaterial, fxLeftEye, fxRightEye,
+            aquariumSlotData, count, index);
+    }
+
+    GameObject reportPrefab;
+    int reportIndex;
+    public async Task<GameObject> LoadFish(int index, Transform fishParent)
+    {
+        reportIndex = index;
+        AquariumSlotData slotData = AM.data.slotDatas[index];
+        Item item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
+        var fishData = _tables.TbFishData.GetOrDefault(item.RedirectID);
+        if (reportPrefab != null)
+        {
+            Addressables.ReleaseInstance(reportPrefab);
+            reportPrefab = null;
+        }
+        var Prefab = await Addressables.InstantiateAsync(fishData.Fbx, fishParent).Task;
+        if (fishParent == null || reportIndex != index)
+        {
+            Addressables.ReleaseInstance(Prefab);
+            Prefab = null;
+            return null;
+        }
+        else if (Prefab != null)
+        {
+            reportPrefab = Prefab;
+            var fish = reportPrefab.GetComponent<Fish>();
+            fish.animator.transform.localPosition = Vector3.zero;
+            fish.EnableCollider();
+            fish.animator.Play("Swim01", 0, UnityEngine.Random.Range(0, 0.8f));
+            fish.animator.transform.localPosition = Vector3.zero;
+            reportPrefab.transform.localPosition = Vector3.zero;
+            reportPrefab.transform.localScale = Vector3.one * fishData.TankScale;
+
+            var TankRotation = fishData.TankRotation;
+            reportPrefab.transform.localRotation = Quaternion.Euler(TankRotation[0], TankRotation[1], TankRotation[2]);
+
+            if (slotData.mutants <= 0 || mutantMaterial == null)
+            {
+                return reportPrefab;
+            }
+
+            float eyeScale = _tables.TbFishMutant.FxAquariumScale[fishData.Quality - 1];
+            if (fish.LeftEye != null && fxLeftEye != null)
+            {
+                var leftEye = Instantiate(fxLeftEye);
+                leftEye.transform.localScale = Vector3.one * eyeScale;
+                leftEye.transform.parent = fish.LeftEye;
+                leftEye.transform.localPosition = Vector3.zero;
+                leftEye.transform.localRotation = Quaternion.identity;
+            }
+            if (fish.RightEye != null && fxRightEye != null)
+            {
+                var rightEye = Instantiate(fxRightEye);
+                rightEye.transform.localScale = Vector3.one * eyeScale;
+                rightEye.transform.parent = fish.RightEye;
+                rightEye.transform.localPosition = Vector3.zero;
+                rightEye.transform.localRotation = Quaternion.identity;
+            }
+
+            Renderer[] meshRenderer = reportPrefab.GetComponentsInChildren<Renderer>();
+            if (meshRenderer != null && meshRenderer.Length > 0)
+            {
+                var render = meshRenderer[0];
+                var materials = render.materials;
+                for (int i = 0; i < materials.Length; i++)
+                {
+                    var material = materials[i];
+                    var material_P = new Material(mutantMaterial);
+                    material_P.SetTexture("_BaseMap", material.GetTexture("_BaseMap"));
+                    material_P.SetTexture("_BumpMap", material.GetTexture("_BumpMap"));
+                    materials[i] = material_P;
+                }
+                render.materials = materials;
+            }
+        }
+        return reportPrefab;
+    }
+    /// <summary>
+    /// 刷新鱼的大小
+    /// </summary>
+    /// <param name="aquariumSlotData"></param>
+    /// <param name="index"></param>
+    void SetFishScale(AquariumSlotData slotData, int index)
+    {
+        var dateTime = ZZTimeHelper.UtcNow();
+        DateTime startTime = slotData.FishHatchTime();
+
+        float normalH = (float)(dateTime - startTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+
+        float progress = normalH / slotData.growthTime;
+        if (progress > 1)
+        {
+            progress = 1;
+        }
+        Item item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
+        FishData fishData = _tables.TbFishData.GetOrDefault(item.RedirectID);
+        float scale = fishData.AquariumMinScale + (fishData.AquariumMaxScale - fishData.AquariumMinScale) * progress;
+        aquariumFishController.fishManager.SetFishScale(index, scale, slotData.mutants, _tables.TbFishMutant.AquariumScale[fishData.Quality - 1]);
+    }
+    void ReleaseAquarium()
+    {
+        if (aquarium != null)
+        {
+            Addressables.ReleaseInstance(aquarium);
+            aquarium = null;
+        }
+    }
+    public override async System.Threading.Tasks.Task StopAsync()
+    {
+        if (reportPrefab != null)
+        {
+            Addressables.ReleaseInstance(reportPrefab);
+            reportPrefab = null;
+        }
+        if (mutantMaterial != null)
+        {
+            Addressables.Release(mutantMaterial);
+            mutantMaterial = null;
+        }
+        if (fxLeftEye != null)
+        {
+            Addressables.Release(fxLeftEye);
+            fxLeftEye = null;
+        }
+        if (fxRightEye != null)
+        {
+            Addressables.Release(fxRightEye);
+            fxRightEye = null;
+        }
+
+        eventAggregator = null;
+        ReleaseAquarium();
+        if (fishUnDownloadAlter != null)
+        {
+            foreach (var item in fishUnDownloadAlter)
+            {
+                Addressables.Release(item.Value);
+            }
+        }
+        disposables?.Dispose();
+        disposables = null;
+        aquariumPanel = null;
+        UIManager.Instance.DestroyUI(UITypes.AquariumDetectPanel);
+        UIManager.Instance.DestroyUI(UITypes.AquariumPanel);
+        GContext.container.Unregister<AquariumManager>();
+        GContext.container.Unregister<FishingData>();
+        await base.StopAsync();
+    }
+
+    public void OnClickFish(int index)
+    {
+        aquariumPanel.OnClickFish(index);
+    }
+
+    #region UI操作
+
+    public bool CanDragMove()
+    {
+        return aquariumPanel != null && aquariumPanel.CanDragMove;
+    }
+
+    public void FollowFishCamera(AquariumSlotData slotData, bool isEgg)
+    {
+        if (isEgg)
+        {
+            var egg = aquariumFishController.fishEggManager.GetEgg(slotData.index);
+            aquariumFishController.cameraManager.FollowFishCamera(egg);
+        }
+        else
+        {
+            var fish = aquariumFishController.fishManager.GetFish(slotData.index);
+            aquariumFishController.cameraManager.FollowFishCamera(fish);
+        }
+
+    }
+
+    public void StopFollowFishCamera()
+    {
+        aquariumFishController.cameraManager.StopFollowFishCamera();
+    }
+
+    #endregion
+
+
+    protected override void OnDestroy()
+    {
+
+    }
+}

Assets/Scripts/Aquarium/FishingAquariumAct.cs.meta

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

Assets/Scripts/Aquarium/ShooterFishAct.cs

@@ -0,0 +1,552 @@
+using asap.core;
+using System.Threading.Tasks;
+using UniRx;
+using UnityEngine.AddressableAssets;
+using UnityEngine;
+using System.Collections.Generic;
+using cfg;
+using System;
+using game;
+using GameCore;
+using System.Linq;
+using DG.Tweening;
+using System.Collections;
+
+public class ShooterFishAct : AGameAct
+{
+    AquariumShooterFishManager AM;
+    CompositeDisposable disposables;
+    GameObject aquarium;
+    cfg.Tables _tables;
+    AquariumInit aquariumInit;
+    Material mutantMaterial;
+    GameObject fxLeftEye;
+    GameObject fxRightEye;
+
+    AquariumFishController aquariumFishController;
+    Dictionary<int, GameObject> fishUnDownloadAlter = new Dictionary<int, GameObject>();
+    OpponentItemData localOpponentItemData;
+    FishMovement targetMovement;
+    EventFishHuntingPanel eventFishHuntingPanel;
+    bool shoot = false;
+    [Header("General Settings")]
+    public float[] FxScale;//不同品质的鱼的特效缩放大小
+    Dictionary<string, GameObject> fx_hunt_prefab = new Dictionary<string, GameObject>();
+
+    [Header("Aim Settings")]
+    public float AimCameraMoveDelay = 0.05f;//延迟这么久开始挪动相机
+    public float AimCameraMoveTime = 0.4f;//相机后续挪动时间，挪到位置后
+    public Vector3 AimCameraMovePos;//相机挪到这个位置
+    public AnimationCurve AimCameraMoveCurve = AnimationCurve.Linear(0, 1, 1, 1); //时间缩放曲线
+    float fieldOfView = 60;
+
+    [Header("Back Settings")]
+    public float BackShowDelay = 0.1f;//延迟这么久开始显示弩箭
+    public float BackCameraMoveTime = 0.25f;//相机后续挪动时间
+    public float AimBlockTime = 0.25f;//相机挪回去之后，在这段时间内禁止开镜射鱼
+
+    [Header("Shoot Settings")]
+    public float ShootTime = 1;
+    public float ShootDelay = 0.2f;//延迟这么久干掉弩箭模型
+
+    public float timeStartScale = 0.5f; //开始慢镜头时间
+    public float timeEndScale = 1f; //结束慢镜头时间
+    public AnimationCurve timeScaleCurve = AnimationCurve.Linear(0, 1, 1, 1); //时间缩放曲线
+
+    public Vector3 reasonableLocation;
+    public Vector3 reasonableCenter;
+    public float reasonableMinDistance = 2;
+    public float reasonableMaxDistance = 5;
+    public float[] shootSwimSpeed = new float[2] { 1.25f, 1.75f }; //射鱼时鱼的最小速度，最大速度
+
+    [Header("Escape Settings")]
+    public AnimationCurve EscapeShockCurve = AnimationCurve.Linear(0, 1, 1, 1); //在这段时间里，位移一个距离的受击位移曲线
+    public float[] EscapeShockTime;//不同品质的鱼的受击时间
+    public float[] EscapeShockDistance;//不同品质的鱼的受击距离
+    public float EscapeDelay = 0.5f;//鱼的Hurt01动画播放时间，延迟这么久箭会脱落
+    public float EscapeDistance = 30;
+    public float EscapeDuration = 2;
+    public float EscapeAnimSpeed = 3;//鱼逃跑时动画播放的速度
+    public float EscapeAnimRecoverTime = 1.5f;//鱼逃跑时动画恢复的时间
+    public float escapeRewardUIDelay = 1.25f;//鱼开始游走算起，多长时间出现结算UI
+    public float ArrowEscapeTime = 2;
+
+    [Header("Capture Settings")]
+    public AnimationCurve CaptureShockCurve = AnimationCurve.Linear(0, 1, 1, 1); //在这段时间里，位移一个距离的受击位移曲线
+    public float[] CaptureShockTime;//不同品质的鱼的受击时间
+    public float[] CaptureShockDistance;//不同品质的鱼的受击距离
+    public float CaptureDelay = 1.16f;//鱼的Hurt02动画播放时间，延迟这么久往回拉
+    public float lineDrawSpeed = 4f;//每秒往回拉的距离
+    public float lineDrawMinTime = 1.25f;//最少也得拉这么长时间
+    public float fishAnimMinSpeed = 1.5f;
+    public float fishAnimMaxSpeed = 3;
+    public float addRotation = 15;
+    public float addRotationPeriod = 0.75f;//拉回时，每间隔这段时间，鱼会从-addRotation到+addRotation中随机一个值，然后摆动过去
+    public float fishToCameraDistance = 1f;//额外的距离
+    public float fishDisappearDelay = 0.4f;//拉回来后，鱼延迟消失的时间
+
+    public override async Task<bool> StartAsync()
+    {
+        UIManager.Instance.DestroyUI(UITypes.EventGamePlayPanel);
+        _tables = GContext.container.Resolve<cfg.Tables>();
+        aquariumInit = _tables.TbAquariumInit.DataList[0];
+        disposables = new CompositeDisposable();
+        GContext.container.Unregister<AquariumShooterFishManager>();
+
+        AM = new AquariumShooterFishManager();
+        GContext.container.RegisterInstance(AM);
+        localOpponentItemData = GContext.container.Resolve<SmallGameData>().GetBankHeistOpponent(EnemyType.Aquarium);
+
+        List<FishHuntInit> huntInits = _tables.TbFishHuntInit.DataList;
+        if (GContext.container.Resolve<SmallGameData>().FishHuntGameCount < huntInits.Count && GContext.container.Resolve<LeadboardData>().fishingEvent == null)
+        {
+            FishHuntInit inti = huntInits[GContext.container.Resolve<SmallGameData>().FishHuntGameCount];
+            var itemDatas = GContext.container.Resolve<SmallGameData>().opponentItemDatas.Where(x => x.isRobot).ToList();
+            //机器人数据
+            localOpponentItemData = itemDatas[UnityEngine.Random.Range(0, itemDatas.Count)];
+            GContext.container.Resolve<SmallGameData>().opponentData = localOpponentItemData;
+            AM.GetDataFishHuntInit(localOpponentItemData.playFabID, inti);
+        }
+        else
+        {
+            await AM.GetData(localOpponentItemData.playFabID, localOpponentItemData.isRobot, false);
+
+            if (AM.serverData == null)
+            {
+                var itemDatas = GContext.container.Resolve<SmallGameData>().opponentItemDatas.Where(x => x.isRobot).ToList();
+                //机器人数据
+                localOpponentItemData = itemDatas[UnityEngine.Random.Range(0, itemDatas.Count)];
+                localOpponentItemData.target_group = GContext.container.Resolve<SmallGameData>().opponentData.target_group;
+
+                GContext.container.Resolve<SmallGameData>().opponentData = localOpponentItemData;
+                await AM.GetData(localOpponentItemData.playFabID, localOpponentItemData.isRobot, false);
+            }
+        }
+
+        GContext.OnEvent<ChangeSmallGameTargetEvent>().Subscribe(ChangeSmallGameTargetEvent).AddTo(disposables);
+
+        // 加载场景
+        mutantMaterial = await Addressables.LoadAssetAsync<Material>(_tables.TbFishMutant.Material).Task;
+        fxLeftEye = await Addressables.LoadAssetAsync<GameObject>(_tables.TbFishMutant.FxLeftEye).Task;
+        fxRightEye = await Addressables.LoadAssetAsync<GameObject>(_tables.TbFishMutant.FxRightEye).Task;
+
+        await LoadFX();
+
+        await EnterMapScene();
+
+        return await base.StartAsync();
+    }
+
+    async Task LoadFX()
+    {
+        ///fx_aquarium_hunt_shoot
+        ///fx_aquarium_hunt_fishhitbig
+        ///fx_aquarium_hunt_fishhitsmall
+        ///fx_aquarium_hunt_fishhurt
+        ///fx_aquarium_hunt_escape
+        ///fx_aquarium_hunt_capture
+        GameObject fx_aquarium_hunt_shoot = await Addressables.LoadAssetAsync<GameObject>("fx_aquarium_hunt_shoot").Task;
+        if (fx_aquarium_hunt_shoot != null)
+        {
+            fx_hunt_prefab["fx_aquarium_hunt_shoot"] = fx_aquarium_hunt_shoot;
+        }
+
+        GameObject fx_aquarium_hunt_fishhitbig = await Addressables.LoadAssetAsync<GameObject>("fx_aquarium_hunt_fishhitbig").Task;
+        if (fx_aquarium_hunt_fishhitbig != null)
+        {
+            fx_hunt_prefab["fx_aquarium_hunt_fishhitbig"] = fx_aquarium_hunt_fishhitbig;
+        }
+
+        GameObject fx_aquarium_hunt_fishhitsmall = await Addressables.LoadAssetAsync<GameObject>("fx_aquarium_hunt_fishhitsmall").Task;
+        if (fx_aquarium_hunt_fishhitsmall != null)
+        {
+            fx_hunt_prefab["fx_aquarium_hunt_fishhitsmall"] = fx_aquarium_hunt_fishhitsmall;
+        }
+
+        GameObject fx_aquarium_hunt_fishhurt = await Addressables.LoadAssetAsync<GameObject>("fx_aquarium_hunt_fishhurt").Task;
+        if (fx_aquarium_hunt_fishhurt != null)
+        {
+            fx_hunt_prefab["fx_aquarium_hunt_fishhurt"] = fx_aquarium_hunt_fishhurt;
+        }
+
+        GameObject fx_aquarium_hunt_escape = await Addressables.LoadAssetAsync<GameObject>("fx_aquarium_hunt_escape").Task;
+        if (fx_aquarium_hunt_escape != null)
+        {
+            fx_hunt_prefab["fx_aquarium_hunt_escape"] = fx_aquarium_hunt_escape;
+        }
+
+        GameObject fx_aquarium_hunt_capture = await Addressables.LoadAssetAsync<GameObject>("fx_aquarium_hunt_capture").Task;
+        if (fx_aquarium_hunt_capture != null)
+        {
+            fx_hunt_prefab["fx_aquarium_hunt_capture"] = fx_aquarium_hunt_capture;
+        }
+
+    }
+
+    public async void ChangeSmallGameTargetEvent(ChangeSmallGameTargetEvent changeSmallGameTargetEvent)
+    {
+        await UIManager.Instance.ShowUI(UITypes.CloudTransitionPanel);
+        OpponentItemData opponentItemData = changeSmallGameTargetEvent.opponentItemData;
+        AquariumServerData data = await AM.GetData(opponentItemData.playFabID, opponentItemData.isRobot, !changeSmallGameTargetEvent.random);
+        if (data == null)
+        {
+            var itemDatas = GContext.container.Resolve<SmallGameData>().opponentItemDatas.Where(x => x.isRobot).ToList();
+            //机器人数据
+            opponentItemData = itemDatas[UnityEngine.Random.Range(0, itemDatas.Count)];
+            opponentItemData.target_group = GContext.container.Resolve<SmallGameData>().opponentData.target_group;
+            GContext.container.Resolve<SmallGameData>().opponentData = opponentItemData;
+            data = await AM.GetData(opponentItemData.playFabID, opponentItemData.isRobot, false);
+        }
+
+        await Task.Delay(500);
+        if (data != null)
+        {
+            changeSmallGameTargetEvent.opponentItemData = opponentItemData;
+            localOpponentItemData = opponentItemData;
+            //机器人数据
+            if (aquarium != null)
+            {
+                Addressables.ReleaseInstance(aquarium);
+                aquarium = null;
+            }
+            await EnterMapScene();
+        }
+        else
+        {
+            GContext.container.Resolve<SmallGameData>().opponentData = localOpponentItemData;
+        }
+        changeSmallGameTargetEvent.ts.SetResult(data != null);
+        GContext.Publish(new EndTransition());
+    }
+
+    async Task EnterMapScene()
+    {
+        List<AquariumSlotData> slotDatas = AM.serverData.slotDatas;
+        for (int i = 0; i < slotDatas.Count; i++)
+        {
+            AquariumSlotData slotData = slotDatas[i];
+            Item item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
+            if (!fishUnDownloadAlter.ContainsKey(item.Quality - 1))
+            {
+                int id = _tables.GetItemData(_tables.TbGlobalConfig.FishUnDownloadAlter[item.Quality - 1]).RedirectID;
+                FishData fishData = _tables.TbFishData.GetOrDefault(id);
+                fishUnDownloadAlter[item.Quality - 1] = await Addressables.LoadAssetAsync<GameObject>(fishData.Fbx).Task;
+            }
+        }
+        await LoadScene();
+        Debug.Log($"EnterMap OpponentData playerID {localOpponentItemData.playFabID}");
+        InitFish();
+        await Awaiters.Seconds(1);
+        StartTime();
+        ShowCrossbowLow();
+    }
+    async void ShowCrossbowLow()
+    {
+        await Awaiters.Seconds(0.5f);
+        GameObject panel = await UIManager.Instance.ShowUINotLoading(UITypes.EventFishHuntingPanel);
+        eventFishHuntingPanel = panel.GetComponent<EventFishHuntingPanel>();
+        eventFishHuntingPanel.shooterFishAct = this;
+        bool isGuide = GContext.container.Resolve<GuideDataCenter>().InspectTriggerGuide("EventFishHuntingPanel");
+        FishMovement guide = null;
+        if (isGuide && GContext.container.Resolve<GuideDataCenter>().curGroupDefine.groupName == GroupName.Raid)
+        {
+            guide = GetMutantFish();
+        }
+        aquariumFishController.cameraManager.PlayCrossbow(guide);
+    }
+    async Task LoadScene()
+    {
+        var mapData = _tables.TbMapData.DataMap[AM.MapId];
+
+        string prefabName = mapData.AquariumPrefab;
+        aquarium = await Addressables.InstantiateAsync(prefabName).Task;
+        aquariumFishController = aquarium.GetComponent<AquariumFishController>();
+        aquariumFishController.fishManager.MaxLoadTime = 0.5f;
+    }
+
+
+    void InitFish()
+    {
+        Debug.Log($"nextOpponent InitFish MapID {AM.serverData.mapId}");
+
+        List<AquariumSlotData> slotDatas = AM.serverData.slotDatas;
+        if (slotDatas == null)
+        {
+            return;
+        }
+        aquariumFishController.fishManager.fishUnDownloadAlter = fishUnDownloadAlter;
+        var time = ZZTimeHelper.UtcNow();
+        List<AquariumResultData> aquariumResultDatas = AM.serverData.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[i].IsResult())
+                {
+                    //检查是否受伤
+                    //正常的成长时间 自然时间+加速成长-总恢复时间
+                    float normalH = (float)(time - HatchTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+
+                    float injuryH = slotData.injuryGrowthTime;
+                    int fishQ = slotData.fishMQ;
+                    if (injuryH < normalH)
+                    {
+                        AM.serverData.aquariumHurtDatas[i].fishLQ = 0;
+                    }
+                    else
+                    {
+                        fishQ -= AM.serverData.aquariumHurtDatas[i].fishLQ;
+                        if (fishQ <= 0)
+                        {
+                            fishQ = 1;
+                        }
+                    }
+                    AddFish(slotData, i, fishQ);
+                }
+            }
+            //else
+            //{
+            //    //初始化蛋
+            //    aquariumFishController.fishEggManager.AddEgg(i, slotData.eggId);
+            //}
+        }
+    }
+    void StartTime()
+    {
+        List<AquariumSlotData> slotDatas = AM.serverData.slotDatas;
+        List<AquariumResultData> aquariumResultDatas = AM.serverData.aquariumResultDatas;
+        for (int i = 0; i < slotDatas.Count; i++)
+        {
+            if (!aquariumResultDatas[i].IsResult() && !slotDatas[i].IsResult())
+            {
+                SetFishScale(slotDatas[i], i);
+            }
+        }
+    }
+    /// <summary>
+    /// 加载鱼的模型
+    /// </summary>
+    /// <param name="aquariumSlotData"></param>
+    /// <param name="index"></param>
+    void AddFish(AquariumSlotData aquariumSlotData, int index, int count)
+    {
+        aquariumFishController.fishManager.AddFish(
+          mutantMaterial, fxLeftEye, fxRightEye,
+          aquariumSlotData,
+          count,
+          index);
+    }
+
+    FishMovement GetMutantFish()
+    {
+        List<AquariumSlotData> slotDatas = AM.serverData.slotDatas;
+        AquariumSlotData aquariumSlotData = null;
+        for (int i = 0; i < slotDatas.Count; i++)
+        {
+            aquariumSlotData = slotDatas[i];
+            if (aquariumSlotData.mutants > 0)
+            {
+                break;
+            }
+        }
+        return aquariumFishController.fishManager.GetFish(aquariumSlotData.index);
+    }
+
+    /// <summary>
+    /// 刷新鱼的大小
+    /// </summary>
+    /// <param name="aquariumSlotData"></param>
+    /// <param name="index"></param>
+    void SetFishScale(AquariumSlotData slotData, int index)
+    {
+        var dateTime = ZZTimeHelper.UtcNow();
+        DateTime startTime = slotData.FishHatchTime();
+
+        float normalH = (float)(dateTime - startTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+
+        float progress = normalH / slotData.growthTime;
+        if (progress > 1)
+        {
+            progress = 1;
+        }
+        Item item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
+        FishData fishData = _tables.TbFishData.GetOrDefault(item.RedirectID);
+        float scale = fishData.AquariumMinScale + (fishData.AquariumMaxScale - fishData.AquariumMinScale) * progress;
+        aquariumFishController.fishManager.SetFishScale(index, scale, slotData.mutants, _tables.TbFishMutant.AquariumScale[fishData.Quality - 1]);
+    }
+
+    public void OnTargetChange(FishMovement fish)
+    {
+        this.targetMovement = fish;
+    }
+
+    public IEnumerator AniCameraMove()
+    {
+        GContext.Publish(EShootState.Aim);
+        shoot = false;
+        aquariumFishController.cameraManager.TriggerCrossbow("Aim");
+        yield return new WaitForSeconds(AimCameraMoveDelay);
+        DOTween.Kill("FieldOfView");
+        aquariumFishController.cameraManager.cameraVirtual.transform.DOKill();
+        aquariumFishController.cameraManager.cameraVirtual.transform.DOLocalMove(AimCameraMovePos, AimCameraMoveTime)
+            .SetEase(AimCameraMoveCurve);
+        cfg.Crossbow crossBow = _tables.TbCrossbow.DataList[0];
+        float fov = aquariumFishController.cameraManager.cameraVirtual.m_Lens.FieldOfView;
+        DOTween.To(() => fov, x => fov = x, crossBow.AimFov, AimCameraMoveTime).OnUpdate(() =>
+        {
+            aquariumFishController.cameraManager.cameraVirtual.m_Lens.FieldOfView = fov;
+        }).SetId("FieldOfView");
+        yield return new WaitForSeconds(AimCameraMoveTime);
+        aquariumFishController.cameraManager.HideCrossbow(true);
+        shoot = true;
+    }
+
+    public IEnumerator OnBack()
+    {
+        shoot = false;
+        DOTween.Kill("FieldOfView");
+        aquariumFishController.cameraManager.cameraVirtual.transform.DOKill();
+        aquariumFishController.cameraManager.cameraVirtual.transform.DOLocalMove(Vector3.zero, BackCameraMoveTime);
+        float fov = aquariumFishController.cameraManager.cameraVirtual.m_Lens.FieldOfView;
+        DOTween.To(() => fov, x => fov = x, fieldOfView, AimCameraMoveTime).OnUpdate(() =>
+        {
+            aquariumFishController.cameraManager.cameraVirtual.m_Lens.FieldOfView = fov;
+        }).SetId("FieldOfView");
+        yield return new WaitForSeconds(BackShowDelay);
+        aquariumFishController.cameraManager.HideCrossbow(false);
+        GContext.Publish(EShootState.Back);
+        aquariumFishController.cameraManager.TriggerCrossbow("Back");
+    }
+
+    public FishMovement Target()
+    {
+        if (shoot)
+        {
+            bool hasTarget = targetMovement != null;
+            if (hasTarget)
+            {
+                aquariumFishController.cameraManager.Target();
+                //结算
+                targetMovement.fish.SetTrigger("Idle");
+                return targetMovement;
+            }
+        }
+        return null;
+    }
+
+    public async Task OnShoot(bool isRob)
+    {
+        aquariumFishController.cameraManager.TriggerCrossbow("Shoot");
+        GContext.Publish(EShootState.Shoot);
+        DOTween.Kill("FieldOfView");
+        ///先操作鱼，获取终点
+        await Awaiters.Seconds(ShootDelay);
+        aquariumFishController.cameraManager.cameraVirtual.m_Lens.FieldOfView = fieldOfView;
+        float speed = UnityEngine.Random.Range(shootSwimSpeed[0], shootSwimSpeed[1]);
+        targetMovement.OnShoot(isRob, speed, ShootTime, reasonableCenter, reasonableLocation, UnityEngine.Random.Range(reasonableMinDistance, reasonableMaxDistance));
+        aquariumFishController.cameraManager.Shoot(FxScale, fx_hunt_prefab, isRob, ShootTime, targetMovement);
+        aquariumFishController.fishManager.AllEscape();
+        StartCoroutine(TimeScale());
+        aquariumFishController.fishManager.avoidance *= 10;
+        aquariumFishController.fishManager.cohesion = 0;
+        aquariumFishController.fishManager.alignment = 0;
+        aquariumFishController.fishManager.areaConstrain = 0;
+    }
+
+    IEnumerator TimeScale()
+    {
+        yield return new WaitForSeconds(timeStartScale);
+        targetMovement.fish.SetTrigger("Swim01");
+
+        DOTween.To(() => 0.01f, x => Time.timeScale = x, 1,
+            timeEndScale - timeStartScale)
+            .SetEase(timeScaleCurve);
+        yield return new WaitForSeconds(timeEndScale);
+        Time.timeScale = 1f;
+    }
+
+    public async Task OnShooted(bool isRob)
+    {
+        targetMovement.OnShooted(isRob);
+
+        if (isRob)
+        {
+            float captureShockTime = CaptureShockTime[targetMovement.slotData.aquariumFishID - 1];//不同品质的鱼的受击时间
+            float captureShockDistance = CaptureShockDistance[targetMovement.slotData.aquariumFishID - 1];//不同品质的鱼的受击距离
+            targetMovement.Shock(captureShockDistance, captureShockTime, CaptureShockCurve);
+            await Awaiters.Seconds(CaptureDelay);
+            targetMovement.Capture(fishAnimMinSpeed, fishAnimMaxSpeed, addRotation, addRotationPeriod);
+            float captureTime = aquariumFishController.cameraManager.Capture(fishToCameraDistance, lineDrawMinTime, lineDrawSpeed, targetMovement);
+            GContext.Publish(EShootState.Capture);
+
+            await Awaiters.Seconds(captureTime + fishDisappearDelay);
+            //aquariumFishController.cameraManager.crossbowGo.SetActive(false);
+            aquariumFishController.cameraManager.Captureed();
+            targetMovement.gameObject.SetActive(false);
+        }
+        else
+        {
+            float escapeShockTime = EscapeShockTime[targetMovement.slotData.aquariumFishID - 1];//不同品质的鱼的受击时间
+            float escapeShockDistance = EscapeShockDistance[targetMovement.slotData.aquariumFishID - 1];//不同品质的鱼的受击距离
+            targetMovement.Shock(escapeShockDistance, escapeShockTime, EscapeShockCurve);
+            await Awaiters.Seconds(EscapeDelay);
+            targetMovement.Escape(EscapeDistance, EscapeDuration);
+            targetMovement.SetFishSpeed(EscapeAnimSpeed, EscapeAnimRecoverTime);
+            aquariumFishController.cameraManager.Escape(ArrowEscapeTime);
+            GContext.Publish(EShootState.Escape);
+            await Awaiters.Seconds(escapeRewardUIDelay);
+        }
+    }
+
+    public override async System.Threading.Tasks.Task StopAsync()
+    {
+        foreach (var item in fx_hunt_prefab)
+        {
+            Addressables.Release(item.Value);
+        }
+        fx_hunt_prefab.Clear();
+        if (mutantMaterial != null)
+        {
+            Addressables.Release(mutantMaterial);
+            mutantMaterial = null;
+        }
+        if (fxLeftEye != null)
+        {
+            Addressables.Release(fxLeftEye);
+            fxLeftEye = null;
+        }
+        if (fxRightEye != null)
+        {
+            Addressables.Release(fxRightEye);
+            fxRightEye = null;
+        }
+        if (aquarium != null)
+        {
+            Addressables.ReleaseInstance(aquarium);
+            aquarium = null;
+        }
+        if (fishUnDownloadAlter != null)
+        {
+            foreach (var item in fishUnDownloadAlter)
+            {
+                Addressables.Release(item.Value);
+            }
+        }
+        eventFishHuntingPanel = null;
+        UIManager.Instance.DestroyUI(UITypes.EventFishHuntingPanel);
+        disposables?.Dispose();
+        disposables = null;
+        GContext.container.Unregister<AquariumShooterFishManager>();
+        await base.StopAsync();
+    }
+
+    protected override void OnDestroy()
+    {
+
+    }
+}

Assets/Scripts/Aquarium/ShooterFishAct.cs.meta

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

Assets/Scripts/Aquarium/UI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 080346d6d7b97ef4aa1e27d6b2430915
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Aquarium/UI/AquariumBtnGift.cs

@@ -0,0 +1,78 @@
+using asap.core;
+using GameCore;
+using System;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumBtnGift : MonoBehaviour
+{
+    Button btn_enter;
+    TMP_Text text_time;
+    TriggerPackData triggerPackData;
+    TriggerPackBuyData triggerPack;
+    private void Awake()
+    {
+        triggerPackData = GContext.container.Resolve<TriggerPackData>();
+        btn_enter = GetComponent<Button>();
+        text_time = transform.Find("text_time").GetComponent<TMP_Text>();
+        var triggerPackDic = triggerPackData.GetTriggerPackList(6);
+        if (triggerPackDic.Count <= 0)
+        {
+            gameObject.SetActive(false);
+            return;
+        }
+        triggerPack = triggerPackDic[0];
+        TimeSpan now = triggerPackData.GetCurTriggerPackEndTime(triggerPack);
+        if (now.TotalSeconds < 0)
+        {
+            gameObject.SetActive(false);
+            return;
+        }
+    }
+
+    void OnEnable()
+    {
+        if (triggerPack != null)
+        {
+            SetEndTime();
+        }
+    }
+    private void Start()
+    {
+        btn_enter.onClick.AddListener(OnClick);
+    }
+    async void OnClick()
+    {
+        btn_enter.enabled = false;
+        await UIManager.Instance.ShowUILoad(UITypes.AquariumGiftPopupPanel);
+        btn_enter.enabled = true;
+    }
+
+    void SetEndTime()
+    {
+        DateTime curTime = ZZTimeHelper.UtcNow().UtcNowOffset();
+        DateTime endTime = GlobalUtils.TryParseDateTime(triggerPack.time, curTime);
+        TimeSpan now = endTime - curTime;
+        double seconds = now.TotalSeconds;
+        if (seconds < 1)
+        {
+            gameObject.SetActive(false);
+        }
+        else
+        {
+            this.AttachTimer((float)seconds,
+                () => { gameObject.SetActive(false); },
+                (elapsed) =>
+                {
+                    if (triggerPack.index > 0)
+                    {
+                        gameObject.SetActive(false);
+                        return;
+                    }
+                    now = endTime - ZZTimeHelper.UtcNow().UtcNowOffset();
+                    text_time.text = ConvertTools.ConvertTime2(now.Days, now.Hours, now.Minutes, now.Seconds);
+                }, useRealTime: true);
+        }
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumBtnGift.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumCardWeight.cs

@@ -0,0 +1,14 @@
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumCardWeight : MonoBehaviour
+{
+    public Image icon;
+    public TMP_Text text_level;
+    private void Reset()
+    {
+        icon = transform.Find("icon").GetComponent<Image>();
+        text_level = transform.Find("text_level").GetComponent<TMP_Text>();
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumCardWeight.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumCloudPanel.cs

@@ -0,0 +1,149 @@
+using asap.core;
+using GameCore;
+using System;
+using System.Collections;
+using UnityEngine;
+using UniRx;
+using TMPro;
+using UnityEngine.UI;
+using cfg;
+using UnityEngine.AddressableAssets;
+
+public class AquariumCloudPanel : MonoBehaviour
+{
+    Animation ani;
+    IDisposable disposable;
+    Image image_map;
+    TMP_Text text_map;
+    TMP_Text text_level;
+    AquariumManagerData data;
+    int type = 0;
+
+    AudioClip doorvault_gear;
+    Sound sound_doorvault_gear;
+    private void Awake()
+    {
+        ani = GetComponent<Animation>();
+        disposable = GContext.OnEvent<EndTransition>().Subscribe(EndTransition);
+        image_map = transform.Find("RandomMapPanel/Item/img_map").GetComponent<Image>();
+        text_map = transform.Find("RandomMapPanel/result/text_map").GetComponent<TMP_Text>();
+        text_level = transform.Find("RandomMapPanel/result/fishcard/text_level").GetComponent<TMP_Text>();
+
+        type = FishingAquariumAct.CloudType;
+        StartCoroutine(OnStart());
+        Synchrodata();
+    }
+    void Synchrodata()
+    {
+        //从服务器拿数据
+        string dataStr = PlayFabMgr.Instance.GetLocalData(AquariumManager.AquariumEventDataKey);
+        if (!string.IsNullOrEmpty(dataStr))
+        {
+            data = Newtonsoft.Json.JsonConvert.DeserializeObject<AquariumManagerData>(dataStr);
+            if (data != null)
+            {
+                Tables _tables = GContext.container.Resolve<Tables>();
+                var mapData = _tables.TbMapData.DataMap[data.mapId];
+                GContext.container.Resolve<IUIService>().SetImageSprite(image_map, mapData.Bg);
+                text_map.text = LocalizationMgr.GetText(mapData.Name_l10n_key);
+                string levelLV = LocalizationMgr.GetText("UI_FishingMapPanel_101006");
+                int fishCardLevel = GContext.container.Resolve<PlayerFishData>().GetFishLevelByMap(data.mapId);
+                text_level.text = levelLV + fishCardLevel.ToString();
+            }
+        }
+    }
+    IEnumerator OnStart()
+    {
+        string cloud_in = "aquarium_cloud_in_2";
+        float time = 0.75f;
+        switch (type)
+        {
+            case 2:
+                cloud_in = "aquarium_cloud_in_3";
+                time = 1.25f;
+                break;
+            default:
+                break;
+        }
+
+        if (disposable != null)
+        {
+            ani.Play(cloud_in);
+
+        }
+        yield return new WaitForSeconds(time);//入场动画播完
+        PlayRodAudio("audio_ui_aquarium_doorvault_gear");
+        if (disposable != null)
+        {
+            ani.Play("aquarium_cloud_loop_2");
+        }
+    }
+
+    void StopRodAudio()
+    {
+        if (doorvault_gear)
+        {
+            Addressables.Release(doorvault_gear);
+            doorvault_gear = null;
+        }
+        if (sound_doorvault_gear)
+        {
+            sound_doorvault_gear.audioSource.Stop();
+            sound_doorvault_gear.ReturnPool();
+            sound_doorvault_gear = null;
+        }
+    }
+    async void PlayRodAudio(string audioName)
+    {
+        StopRodAudio();
+        doorvault_gear = await Addressables.LoadAssetAsync<AudioClip>(audioName).Task;
+        if (disposable == null)
+        {
+            if (doorvault_gear)
+            {
+                Addressables.Release(doorvault_gear);
+                doorvault_gear = null;
+            }
+            return;
+        }
+        sound_doorvault_gear = GContext.container.Resolve<ISoundService>().GetNewUISound(doorvault_gear);
+        sound_doorvault_gear.audioSource.Play();
+        sound_doorvault_gear.audioSource.loop = true;
+    }
+    public void EndTransition(EndTransition endTransition)
+    {
+        StartCoroutine(End());
+        StopRodAudio();
+    }
+    private void OnDisable()
+    {
+        Dispose();
+    }
+    IEnumerator End()
+    {
+        string cloud_out = "aquarium_cloud_out_2";
+        float time = 1.25f;
+        switch (type)
+        {
+            case 1:
+            case 5:
+                cloud_out = "aquarium_cloud_out_3";
+                time = 0.866f;
+                break;
+            default:
+                break;
+        }
+
+        image_map.gameObject.SetActive(false);
+        ani.Play(cloud_out);
+        Dispose();
+        yield return new WaitForSeconds(time);//退场动画播完
+        UIManager.Instance.DestroyUI(UITypes.AquariumCloudPanel);
+    }
+    void Dispose()
+    {
+        disposable?.Dispose();
+        disposable = null;
+    }
+
+}

Assets/Scripts/Aquarium/UI/AquariumCloudPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumDetectEgg.cs

@@ -0,0 +1,60 @@
+using asap.core;
+using DG.Tweening;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumDetectEgg : MonoBehaviour
+{
+    RectTransform Content;
+    GameObject icon_item;
+    int allCount = 5;
+    float height;
+    int maIndex = 2;
+    int curAllCount;
+    IUIService uIService;
+    private void Init()
+    {
+        uIService = GContext.container.Resolve<IUIService>();
+        Content = transform.Find("Viewport/Content").GetComponent<RectTransform>();
+        icon_item = transform.Find("Viewport/Content/Item").gameObject;
+        height = icon_item.GetComponent<RectTransform>().rect.height;
+        icon_item.SetActive(false);
+    }
+    public void SetIcon(List<string> iconNameList, string curIcon, int index)
+    {
+        Init();
+        curAllCount = 0;
+        //List<string> 得到一个新的随机顺序的列表
+        string str;
+        string curStr = curIcon;
+        allCount += index;
+        for (int i = 0; i < allCount + maIndex; i++)
+        {
+            str = iconNameList[Random.Range(0, iconNameList.Count)];
+            SetMapBg(str);
+        }
+        SetMapBg(curStr);
+        SetMapBg(iconNameList[Random.Range(0, iconNameList.Count)]);
+    }
+    void SetMapBg(string bg)
+    {
+        GameObject go = Instantiate(icon_item, Content);
+        Image image = go.transform.GetChild(0).GetComponent<Image>();
+        go.SetActive(true);
+        uIService.SetImageSprite(image, bg);
+        curAllCount++;
+    }
+    public void Play()
+    {
+        var sequence = DOTween.Sequence();
+        sequence.Append(Content.DOAnchorPosY(allCount * height, 0.08f * allCount).SetLoops(2, LoopType.Restart).SetEase(Ease.Linear));
+
+        //跑马灯动画
+        float index2 = allCount + maIndex + Random.Range(-0.5f, 0.5f);
+        sequence.Append(Content.DOAnchorPosY(index2 * height, 0.2f).SetEase(Ease.Linear));
+        sequence.Append(Content.DOAnchorPosY((allCount + maIndex) * height, 0.2f).SetEase(Ease.InSine));
+        sequence.Play();
+    }
+
+}

Assets/Scripts/Aquarium/UI/AquariumDetectEgg.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumDetectPanel.cs

@@ -0,0 +1,275 @@
+using asap.core;
+using cfg;
+using game;
+using Game;
+using GameCore;
+using System;
+using System.Collections;
+using TMPro;
+using UniRx;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+using UnityEngine.UI;
+
+public class AquariumDetectPanel : BasePanel
+{
+    AquariumManager AM;
+    Animation anim;
+    Button btn_close;
+    Button btn_enter;
+    Button btn_enter_gray;
+    TMP_Text text_info;
+    TMP_Text text_time;
+    Button btn_event;
+    GameObject event_redpoint;
+    Button btn_slot;
+    TMP_Text text_num_slot;
+    GameObject slot_redpoint;
+    GameObject slot_tips;
+    TMP_Text text_title_tips;
+    TMP_Text text_title_info;
+    Button btn_questionmark;
+
+    AquariumRandomMapPanel randomMapPanel;
+    int maxSlot = 6;
+    DateTime refreshTime;
+    bool isCutTo = false;
+
+    AudioClip doorvault_gear;
+    Sound sound_doorvault_gear;
+    AudioClip searchingroll_single;
+    Sound sound_searchingroll_single;
+    string audioName;
+    int refreshTimeInt;
+    private void Awake()
+    {
+        AM = GContext.container.Resolve<AquariumManager>();
+        anim = GetComponent<Animation>();
+        btn_close = transform.Find("btn_close").GetComponent<Button>();
+        btn_enter = transform.Find("root_main/btn_enter/btn_green").GetComponent<Button>();
+        btn_enter_gray = transform.Find("root_main/btn_enter_gray/btn_green").GetComponent<Button>();
+        text_info = transform.Find("root_main/btn_enter_gray/text_info").GetComponent<TMP_Text>();
+        text_time = transform.Find("root_main/text_time").GetComponent<TMP_Text>();
+        btn_event = transform.Find("root_main/btn_event").GetComponent<Button>();
+        event_redpoint = transform.Find("root_main/btn_event/redpoint").gameObject;
+        btn_slot = transform.Find("root_main/btn_slot").GetComponent<Button>();
+        text_num_slot = transform.Find("root_main/btn_slot/text_num").GetComponent<TMP_Text>();
+        slot_redpoint = transform.Find("root_main/btn_slot/redpoint").gameObject;
+        slot_tips = transform.Find("root_main/slot_tips").gameObject;
+        text_title_tips = transform.Find("root_main/slot_tips/text_title").GetComponent<TMP_Text>();
+        text_title_info = transform.Find("root_main/slot_tips/text_info").GetComponent<TMP_Text>();
+        btn_questionmark = transform.Find("root_main/title/btn_questionmark").GetComponent<Button>();
+
+        randomMapPanel = transform.Find("RandomMapPanel").GetComponent<AquariumRandomMapPanel>();
+        event_redpoint.SetActive(false);
+
+    }
+    protected override void Start()
+    {
+        GContext.container.Resolve<GuideDataCenter>().InspectTriggerGuide("AquariumDetectPanel");
+
+        //randomMapPanel.gameObject.SetActive(false);
+        base.Start();
+        btn_event.onClick.AddListener(OnClickEvent);
+        btn_enter.onClick.AddListener(OnClickMaching);
+        btn_close.onClick.AddListener(OnClickClose);
+        btn_questionmark.onClick.AddListener(async () =>
+            await UIManager.Instance.ShowUI(UITypes.AquariumInfoPopupPanel));
+        btn_slot.onClick.AddListener(() => slot_tips.SetActive(!slot_tips.activeSelf));
+        int Slot = GContext.container.Resolve<PlayerData>().benefitsAquariumLimit;
+        text_num_slot.text = $"{Slot}/{maxSlot}";
+        text_title_tips.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_2", $"{Slot}/{maxSlot}");
+        if (Slot == maxSlot)
+        {
+            text_title_info.text = LocalizationMgr.GetText("UI_AquariumPanel_4");
+        }
+        else
+        {
+            int level = GContext.container.Resolve<PlayerData>().benefitsLevel[6];
+            var Benefits = GContext.container.Resolve<Tables>().TBBenefits.GetOrDefault(7);
+            if (Benefits == null || level + 1 >= Benefits.AccountLevel.Count)
+            {
+                Debug.LogError("No account data AquariumLimit up");
+            }
+            else
+            {
+                text_title_info.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_3", Benefits.AccountLevel[level + 1]);
+            }
+        }
+
+        var nowTime = ZZTimeHelper.UtcNow().UtcNowOffset();
+        refreshTime = nowTime.Date.AddDays(1);
+        if (nowTime.Date.DayOfYear != AM.data.refreshDay)
+        {
+            AM.data.refreshCount = 0;
+            AM.data.adCount = 0;
+            AM.data.refreshDay = nowTime.Date.DayOfYear;
+        }
+
+        refreshTimeInt = GContext.container.Resolve<Tables>().TbAquariumConfig.RefreshTime;
+        bool isRefresh = AM.data.refreshCount < refreshTimeInt;
+        if (!isRefresh)
+        {
+            ShowInfo();
+        }
+        btn_enter.transform.parent.gameObject.SetActive(isRefresh);
+        btn_enter_gray.transform.parent.gameObject.SetActive(!isRefresh);
+        text_time.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_44", refreshTimeInt - AM.data.refreshCount, refreshTimeInt);
+    }
+
+    void ShowInfo()
+    {
+        //剩余时间
+        TimeSpan duration = refreshTime - ZZTimeHelper.UtcNow().UtcNowOffset();
+        string textValue = LocalizationMgr.GetText("UI_AquariumPanel_7");
+        text_info.text = string.Format(textValue, ConvertTools.ConvertTime2(duration));
+        var timer = Observable.Interval(TimeSpan.FromSeconds(1))
+                              .TakeWhile(seconds => seconds <= duration.TotalSeconds)
+                              .Subscribe(seconds => text_info.text =
+                                            string.Format(textValue, ConvertTools.ConvertTime2(duration.Subtract(TimeSpan.FromSeconds(seconds))))
+                                             , Refresh)
+                              .AddTo(disposables);
+    }
+    void Refresh()
+    {
+        AM.data.adCount = 0;
+        AM.data.refreshCount = 0;
+        AM.data.refreshDay = ZZTimeHelper.UtcNow().UtcNowOffset().Date.DayOfYear;
+        text_time.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_44", refreshTimeInt, refreshTimeInt);
+        btn_enter.transform.parent.gameObject.SetActive(true);
+        btn_enter_gray.transform.parent.gameObject.SetActive(false);
+    }
+    void OnClickEvent()
+    {
+        _ = UIManager.Instance.ShowUI(UITypes.EventReportPopupPanel);
+    }
+
+    async void GetSearchingrollSingle()
+    {
+        searchingroll_single = await Addressables.LoadAssetAsync<AudioClip>("audio_ui_aquarium_doorvault_searchingroll_single").Task;
+        if (searchingroll_single != null && this != null)
+        {
+            sound_searchingroll_single = GContext.container.Resolve<ISoundService>().GetNewUISound(searchingroll_single);
+        }
+    }
+
+    IDisposable enterMap;
+    void OnClickMaching()
+    {
+        StartCoroutine(StartClickMaching());
+    }
+    IEnumerator StartClickMaching()
+    {
+        //randomMapPanel.gameObject.SetActive(true);
+        anim.Play("match_map_start");
+        yield return new WaitForSeconds(1);
+        PlayRodAudio("audio_ui_fishingduel_matchingloop");
+        randomMapPanel.SetMap();
+        enterMap = FishingAquariumAct.eventAggregator.GetEvent<EnterMaped>().Subscribe(EnterMaped);
+        randomMapPanel.InitEgg();
+        FishingAquariumAct.eventAggregator.Publish(new AquariumEnterMapScene());
+        yield return new WaitForSeconds(3);
+        StopRodAudio();
+        GContext.Publish(new VibrationData(HapticTypes.HeavyImpact));
+        anim.Play("match_egg_start");
+        GetSearchingrollSingle();
+        yield return new WaitForSeconds(1);
+        PlayRodAudio("audio_ui_aquarium_doorvault_searchingroll_loop");
+        randomMapPanel.PlayEgg();
+        yield return new WaitForSeconds(1.5f);
+        StopRodAudio();
+        for (int i = 1; i < AM.Slot; i++)
+        {
+            yield return new WaitForSeconds(0.16f);
+            if (sound_searchingroll_single != null)
+            {
+                sound_searchingroll_single.audioSource.Play();
+            }
+        }
+        anim.Play("aquarium_cloud_in");
+        yield return new WaitForSeconds(3.5f);
+        PlayRodAudio("audio_ui_aquarium_doorvault_gear");
+        anim.Play("aquarium_cloud_loop");
+        randomMapPanel.HideMap();
+        yield return new WaitForSeconds(1f);
+        OnClose();
+    }
+    void StopRodAudio()
+    {
+        if (doorvault_gear)
+        {
+            Addressables.Release(doorvault_gear);
+            doorvault_gear = null;
+        }
+        if (sound_doorvault_gear)
+        {
+            sound_doorvault_gear.audioSource.Stop();
+            sound_doorvault_gear.ReturnPool();
+            sound_doorvault_gear = null;
+        }
+    }
+    private void OnDisable()
+    {
+        this.audioName = "";
+        StopRodAudio();
+
+        if (searchingroll_single)
+        {
+            Addressables.Release(searchingroll_single);
+            searchingroll_single = null;
+        }
+        if (sound_searchingroll_single)
+        {
+            sound_searchingroll_single.audioSource.Stop();
+            sound_searchingroll_single.ReturnPool();
+            sound_searchingroll_single = null;
+        }
+    }
+    async void PlayRodAudio(string audioName)
+    {
+        this.audioName = audioName;
+        StopRodAudio();
+        var local_doorvault_gear = await Addressables.LoadAssetAsync<AudioClip>(audioName).Task;
+        if (local_doorvault_gear == null)
+        {
+            return;
+        }
+        if (this.audioName != audioName)
+        {
+            Addressables.Release(local_doorvault_gear);
+            return;
+        }
+        doorvault_gear = local_doorvault_gear;
+        sound_doorvault_gear = GContext.container.Resolve<ISoundService>().GetNewUISound(doorvault_gear);
+        sound_doorvault_gear.audioSource.Play();
+        sound_doorvault_gear.audioSource.loop = true;
+    }
+    void EnterMaped(EnterMaped enterMaped)
+    {
+        enterMap?.Dispose();
+        enterMap = null;
+        OnClose();
+    }
+
+    async void OnClose()
+    {
+        if (isCutTo)
+        {
+            StopRodAudio();
+            anim.Play("aquarium_cloud_out");
+            FishingAquariumAct.eventAggregator.Publish(new AquariumEnterMapScene() { isShowUI = true });
+            await Awaiters.Seconds(2.0f);
+            UIManager.Instance.DestroyUI(UITypes.AquariumDetectPanel);
+        }
+        else
+        {
+            isCutTo = true;
+        }
+    }
+
+    void OnClickClose()
+    {
+        FishingAquariumAct.CloudType = 2;
+        GContext.Publish(new UnloadActToNextAct(transitionPanel: UITypes.AquariumCloudPanel, time: 1.25f));
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumDetectPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumEggTips.cs

@@ -0,0 +1,88 @@
+using asap.core;
+using cfg;
+using GameCore;
+using System;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumEggTips : MonoBehaviour, IAquariumTips
+{
+    public Image icon;
+    public TMP_Text text_name;
+    public Image bar;
+    public TMP_Text text_time;
+    public Button btn_speedup;
+    public GameObject[] card_info;
+    AquariumSlotData slotData;
+    AquariumSlot aquariumSlot;
+    public void SetActive(bool value)
+    {
+        gameObject.SetActive(value);
+    }
+    public void SetData(AquariumSlot aquariumSlot)
+    {
+        this.aquariumSlot = aquariumSlot;
+        this.slotData = aquariumSlot.slotData;
+
+        for (int i = 0; i < card_info.Length; i++)
+        {
+            card_info[i].SetActive(false);
+        }
+
+        UpdateBar(ZZTimeHelper.UtcNow());
+
+        AquariumEgg aquariumEgg = GContext.container.Resolve<Tables>().TbAquariumEgg.GetOrDefault(slotData.eggId);
+
+        if (aquariumEgg != null)
+        {
+            text_name.text = LocalizationMgr.GetText(aquariumEgg.Name_l10n_key);
+            var quantity = aquariumEgg.HatchFishQuantity;
+            GContext.container.Resolve<IUIService>().SetImageSprite(icon, aquariumEgg.Icon);
+
+            List<int> hatchFishQuality = aquariumEgg.HatchFishQuality;
+            bool showNum = false;
+            int max = 1;
+            int min = hatchFishQuality[0];
+            if (hatchFishQuality.Count > 1)
+            {
+                showNum = true;
+                max = hatchFishQuality[^1];
+            }
+            int index = 0;
+            TMP_Text text_fish_num;
+            for (int i = 0; i < hatchFishQuality.Count; i++)
+            {
+                index = hatchFishQuality[i] - 1;
+                if (index < card_info.Length)
+                {
+                    card_info[index].SetActive(true);
+                    text_fish_num = card_info[index].transform.Find("text_fish_num").GetComponent<TMP_Text>();
+                    if (showNum)
+                    {
+                        text_fish_num.text = $"{min}～{max}";
+                    }
+                    else
+                    {
+                        text_fish_num.text = min.ToString();
+                    }
+                }
+            }
+        }
+    }
+
+    public bool UpdateBar(DateTime dateTime)
+    {
+        float time = (float)(dateTime - slotData.startTime).TotalHours + slotData.accelerationHatch;
+        bar.fillAmount = time / slotData.hatchTime;
+        int timeRemaining = (int)((slotData.hatchTime - time) * 3600);
+        if (timeRemaining <= 0)
+        {
+            return false;
+        }
+        TimeSpan timeSpan = new TimeSpan(0, 0, timeRemaining);
+        text_time.text = ConvertTools.ConvertTime2(timeSpan);
+        return true;
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumEggTips.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumFishTips.cs

@@ -0,0 +1,200 @@
+using asap.core;
+using cfg;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using GameCore;
+
+public class AquariumFishTips : MonoBehaviour, IAquariumTips
+{
+    public Image icon;
+    public Image tag_fish;
+    public TMP_Text text_name;
+    public Image bar;
+    public Image bar_hurt;
+    public TMP_Text text_time;
+    public GameObject recoverting;
+    public TMP_Text text_time2;
+    public GameObject killed;
+    public GameObject sold;
+    public TMP_Text text_killed;
+    public GameObject text_max;
+    public Button btn_speedup;
+    public Button btn_sell;
+    public TMP_Text text_cash;
+    public GameObject mutated;
+    public TMP_Text fishcard;
+    AquariumSlotData slotData;
+    Item item;
+    FishData fishData;
+    AquariumSlot aquariumSlot;
+    AquariumFish aquariumFish;
+    AquariumManager AM;
+    Tables _tables;
+
+    DateTime StartTime;
+    float injuryH;
+    float allRewardCount;
+    float baseRewardCount;
+    float WeightIncEvent;
+    public void SetActive(bool value)
+    {
+        gameObject.SetActive(value);
+    }
+    public void SetData(AquariumSlot aquariumSlot)
+    {
+        AM = GContext.container.Resolve<AquariumManager>();
+
+        _tables = GContext.container.Resolve<Tables>();
+        this.aquariumSlot = aquariumSlot;
+        this.slotData = aquariumSlot.slotData;
+        item = _tables.TbItem.GetOrDefault(slotData.fishItemID);
+        fishData = _tables.TbFishData.GetOrDefault(item.RedirectID);
+        aquariumFish = _tables.TbAquariumFish.GetOrDefault(slotData.aquariumFishID);
+        StartTime = slotData.FishHatchTime();
+        injuryH = slotData.injuryGrowthTime;
+        mutated.SetActive(slotData.mutants > 0);
+        text_name.text = LocalizationMgr.GetText(item.Name_l10n_key);
+        GContext.container.Resolve<IUIService>().SetImageSprite(tag_fish, "icon_fish_rate_tag_" + item.Quality);
+        PlayerFishData.SetFishIcon(icon, item);//鱼头像
+
+        PlayerData playerData = GContext.container.Resolve<PlayerData>();
+        var weights = GContext.container.Resolve<AquariumManager>().GetWeightMag();
+        float weight = weights[slotData.aquariumFishID - 1];
+        fishcard.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_40", weight.ToPercentageString());
+        WeightIncEvent = (1 + weight) * (1 + playerData.benefitsCashMag) * (1 + playerData.benefitsAquariumCashMag);
+
+        baseRewardCount = slotData.allCash;
+        allRewardCount = 0;
+        int fishQ = slotData.fishMQ;
+        for (int i = 0; i < fishQ; i++)
+        {
+            if (slotData.mutants > i)
+            {
+                allRewardCount += baseRewardCount * WeightIncEvent * (1 + aquariumFish.MutantGrowthExtraSoldReward) * (1 + aquariumFish.MutantExtraSoldReward);
+            }
+            else
+            {
+                allRewardCount += baseRewardCount * WeightIncEvent * (1 + aquariumFish.GrowthExtraSoldReward);
+            }
+        }
+
+        UpdateBar(ZZTimeHelper.UtcNow());
+    }
+
+
+    public bool UpdateBar(DateTime dateTime)
+    {
+        //正常的成长进度 自然时间+加速成长 - 全部恢复时间
+        float normalH = (float)(dateTime - StartTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+
+        //受伤时的成长进度加上本次恢复时间大于正常的成长进度
+        bar_hurt.gameObject.SetActive(false);
+        text_time.gameObject.SetActive(true);
+        recoverting.gameObject.SetActive(false);
+        text_max.gameObject.SetActive(false);
+        btn_speedup.gameObject.SetActive(true);
+        btn_sell.gameObject.SetActive(false);
+        killed.SetActive(false);
+        sold.SetActive(false);
+        float timeProgress = 1;
+
+        if (aquariumSlot.slotState == 5)
+        {
+            bar.transform.parent.gameObject.SetActive(false);
+            killed.SetActive(true);
+            btn_speedup.gameObject.SetActive(false);
+            text_time.gameObject.SetActive(false);
+            AquariumResultData aquariumResultDatas = AM.data.aquariumResultDatas[slotData.index];
+            text_killed.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_42", aquariumResultDatas.displayName);
+            text_cash.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_26", $"{0}/{ConvertTools.GetNumberString2((int)allRewardCount)}");
+            return false;
+        }
+        else if (aquariumSlot.slotState == 4)
+        {
+            bar.transform.parent.gameObject.SetActive(false);
+            sold.SetActive(true);
+            btn_speedup.gameObject.SetActive(false);
+            text_time.gameObject.SetActive(false);
+            text_cash.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_26", $"{ConvertTools.GetNumberString2(slotData.cash)}/{ConvertTools.GetNumberString2((int)allRewardCount)}");
+            return false;
+        }
+        else
+        {
+
+            bar.transform.parent.gameObject.SetActive(true);
+            timeProgress = normalH / slotData.growthTime;
+            bar.fillAmount = 1;
+            if (injuryH > normalH)
+            {
+                text_time.gameObject.SetActive(false);
+                recoverting.gameObject.SetActive(true);
+                bar_hurt.gameObject.SetActive(true);
+                bar_hurt.fillAmount = (injuryH - normalH) / slotData.recoveryTime;
+
+                int timeRemaining = (int)((injuryH - normalH) * 3600);
+                TimeSpan timeSpan = new TimeSpan(0, 0, timeRemaining);
+                text_time2.text = ConvertTools.ConvertTime2(timeSpan);
+
+                if (injuryH / slotData.growthTime > 1)
+                {
+                    timeProgress = 1 - ((injuryH - normalH) / slotData.growthTime);
+                }
+                bar.fillAmount = 0;
+            }
+            else if (normalH >= slotData.growthTime)
+            {
+                text_time.gameObject.SetActive(false);
+                text_max.gameObject.SetActive(true);
+                btn_speedup.gameObject.SetActive(false);
+                btn_sell.gameObject.SetActive(true);
+                timeProgress = 1;
+            }
+            else
+            {
+                bar.fillAmount = normalH / slotData.growthTime;
+            }
+
+            if (timeProgress < 1)
+            {
+                int timeRemaining = (int)(slotData.growthTime * (1 - timeProgress) * 3600);
+                TimeSpan timeSpan = new TimeSpan(0, 0, timeRemaining);
+                text_time.text = ConvertTools.ConvertTime2(timeSpan);
+            }
+
+        }
+
+        float rewardProgress = timeProgress;// normalH / slotData.growthTime;
+        if (rewardProgress > 1)
+        {
+            rewardProgress = 1;
+        }
+
+        //金币显示
+        int fishQ = slotData.fishMQ;
+        if (injuryH > normalH)
+        {
+            fishQ -= GContext.container.Resolve<AquariumManager>().data.aquariumHurtDatas[slotData.index].fishLQ;
+            if (fishQ <= 0)
+            {
+                fishQ = 1;
+            }
+        }
+        float rewardCount = 0;
+        for (int i = 0; i < fishQ; i++)
+        {
+            if (slotData.mutants > i)
+            {
+                rewardCount += baseRewardCount * (1 + aquariumFish.MutantExtraSoldReward) * (1 + aquariumFish.MutantGrowthExtraSoldReward * rewardProgress) * WeightIncEvent;
+            }
+            else
+            {
+                rewardCount += baseRewardCount * (1 + aquariumFish.GrowthExtraSoldReward * rewardProgress) * WeightIncEvent;
+            }
+        }
+
+        text_cash.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_26", $"{ConvertTools.GetNumberString2((int)(rewardCount))}/{ConvertTools.GetNumberString2((int)allRewardCount)}");
+        return true;
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumFishTips.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumInfoPopupPanel.cs

@@ -0,0 +1,16 @@
+using GameCore;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumInfoPopupPanel : MonoBehaviour
+{
+    private Button btnClose;
+    private void Awake()
+    {
+        btnClose = transform.Find("btn_close").GetComponent<Button>();
+    }
+    void Start()
+    {
+        btnClose.onClick.AddListener(() => UIManager.Instance.DestroyUI(UITypes.AquariumInfoPopupPanel));
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumInfoPopupPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumPanel.cs

@@ -0,0 +1,429 @@
+using asap.core;
+using cfg;
+using game;
+using GameCore;
+using System;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+using UniRx;
+using UnityEngine.UI;
+
+public class AquariumPanel : BasePanel
+{
+    Button btn_close;
+    Button btn_event;
+    Button btn_progress;
+    Button btn_fishcard;
+    TMP_Text text_level;
+    Button btn_questionmark;
+    Button btn_sell;
+    Button btn_speedup;
+    Head head;
+    TMP_Text text_name;
+    TMP_Text text_title;
+    Button btn_close_tips;
+    GameObject redpoint;
+    AquariumManager AM;
+    Tables tables;
+    AquariumSlot[] aquariumSlot;
+    bool updateBar = true;
+    IUIService uIService;
+    IAquariumTips aquariumTips;
+    AquariumEggTips aquariumEggTips;
+    AquariumFishTips aquariumFishTips;
+
+    AquariumSlot curAquariumSlot;
+
+    FishingAquariumAct fishingAquariumAct;
+
+    UIDrag moveCameraPanel;
+    bool canDragMove = false;
+    public bool CanDragMove => canDragMove;
+    MapData mapData;
+
+    private void Awake()
+    {
+        GContext.OnEvent<GetUIAsyncEvent>().Subscribe(GetUIAsyncEvent).AddTo(disposables);
+
+        GContext.OnEvent<ChangeMapDataAsyncEvent>().Subscribe(e =>
+        {
+            UIManager.Instance.DestroyUI(UITypes.FishcardBenefitPopupPanel);
+            GContext.container.Resolve<PlayerData>().SetCurrentMapId(e.mapID);
+            OnClickClose();
+            e.source?.SetResult(false);
+        }).AddTo(disposables);
+        transform.SetAsFirstSibling();
+        reportService = GContext.container.Resolve<IReportService>();
+        eventReport = transform.Find("root/Event_report").GetComponent<EventReport>();
+        tables = GContext.container.Resolve<Tables>();
+        uIService = GContext.container.Resolve<IUIService>();
+        AM = GContext.container.Resolve<AquariumManager>();
+        text_name = transform.Find("root/title/bg/text_name").GetComponent<TMP_Text>();
+        head = transform.Find("root/title/btn_head").GetComponent<Head>();
+        btn_event = transform.Find("root/btn_event").GetComponent<Button>();
+        btn_progress = transform.Find("root/btn_progress").GetComponent<Button>();
+        btn_fishcard = transform.Find("root/btn_fishcard").GetComponent<Button>();
+        btn_close = transform.Find("btn_close").GetComponent<Button>();
+        btn_questionmark = transform.Find("root/title/btn_questionmark").GetComponent<Button>();
+        text_level = transform.Find("root/btn_fishcard/text_level").GetComponent<TMP_Text>();
+        aquariumSlot = transform.Find("root/partner").GetComponentsInChildren<AquariumSlot>();
+        text_title = transform.Find("root/title/text_title").GetComponent<TMP_Text>();
+        moveCameraPanel = transform.Find("moveCameraPanel").GetComponent<UIDrag>();
+        redpoint = transform.Find("root/btn_fishcard/redpoint").gameObject;
+        btn_sell = transform.Find("btn_2/btn_sell").GetComponent<Button>();
+        btn_speedup = transform.Find("btn_2/btn_speedup").GetComponent<Button>();
+
+        aquariumEggTips = transform.Find("egg_tips").GetComponent<AquariumEggTips>();
+        aquariumFishTips = transform.Find("fish_tips").GetComponent<AquariumFishTips>();
+        btn_close_tips = transform.Find("btn_close_tips").GetComponent<Button>();
+        SetMoveCameraPanel();
+    }
+    void SetMoveCameraPanel()
+    {
+        moveCameraPanel.OnPointerDownCall = () =>
+        {
+            canDragMove = true;
+        };
+        moveCameraPanel.OnPointerUpCall = () =>
+        {
+            canDragMove = false;
+        };
+        //moveCameraPanel.OnDragCall = (eventData) =>
+        //{
+        //    Debug.Log(" Pointer OnDragCall");
+        //};
+    }
+    void GetUIAsyncEvent(GetUIAsyncEvent data)
+    {
+        if (data.uIType == UITypes.FishingMapPanel.Name && !data.show)
+        {
+            SetRed();
+            string levelLV = LocalizationMgr.GetText("UI_FishingMapPanel_101006");
+            int fishCardLevel = GContext.container.Resolve<PlayerFishData>().GetFishLevelByMap(AM.MapId);
+            text_level.text = levelLV + fishCardLevel.ToString();
+        }
+    }
+    protected override void Start()
+    {
+        var fishingData = GContext.container.Resolve<FishingData>();
+
+        fishingData.MapId = AM.MapId;
+
+        updateBar = true;
+        base.Start();
+        GContext.container.Resolve<GuideDataCenter>().InspectTriggerGuide("AquariumPanel");
+        aquariumEggTips.btn_speedup.onClick.AddListener(OnClickSpeedup);
+        aquariumFishTips.btn_speedup.onClick.AddListener(OnClickSpeedup);
+        btn_speedup.onClick.AddListener(OnClickSpeedup);
+        aquariumFishTips.btn_sell.onClick.AddListener(ShowFishSellingPopupPanel);
+        btn_close_tips.onClick.AddListener(CloseTips);
+
+        btn_event.onClick.AddListener(() => _ = UIManager.Instance.ShowUI(UITypes.EventReportPopupPanel));
+        btn_fishcard.onClick.AddListener(async () =>
+            await UIManager.Instance.ShowUI(UITypes.FishcardBenefitPopupPanel));
+        btn_sell.onClick.AddListener(ShowFishSellingPopupPanel);
+        btn_progress.onClick.AddListener(OnClickProgress);
+        btn_close.onClick.AddListener(OnClickClose);
+        btn_questionmark.onClick.AddListener(async () =>
+            await UIManager.Instance.ShowUI(UITypes.AquariumInfoPopupPanel));
+        text_name.text = GContext.container.Resolve<IUserService>().DisplayName;
+        head.SetData(GContext.container.Resolve<IUserService>().AvatarUrl);
+
+        mapData = tables.TbMapData.GetOrDefault(AM.MapId);
+        text_title.text = LocalizationMgr.GetText(mapData.Name_l10n_key);
+
+        string levelLV = LocalizationMgr.GetText("UI_FishingMapPanel_101006");
+        int fishCardLevel = GContext.container.Resolve<PlayerFishData>().GetFishLevelByMap(AM.MapId);
+        text_level.text = levelLV + fishCardLevel.ToString();
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+        Item item;
+        AquariumEgg aquariumEgg;
+        bool isShowSell = false;
+        bool isShowSpeedup = false;
+        for (int i = 0; i < aquariumSlot.Length; i++)
+        {
+            if (i < AM.Slot)
+            {
+                AquariumSlotData slotData = AM.data.slotDatas[i];
+                if (slotData.startTime.AddHours(slotData.hatchTime - slotData.accelerationHatch) > dateTime)
+                {
+                    aquariumEgg = tables.TbAquariumEgg.GetOrDefault(slotData.eggId);
+                    //还没孵化
+                    uIService.SetImageSprite(aquariumSlot[i].icon_egg, aquariumEgg.Icon);
+                }
+
+                item = tables.TbItem.GetOrDefault(slotData.fishItemID);
+                PlayerFishData.SetFishIcon(aquariumSlot[i].icon_fish, item);//鱼头像
+                uIService.SetImageSprite(aquariumSlot[i].icon_rate, "icon_fish_rate_tag_" + item.Quality);
+                aquariumSlot[i].InitSlot(i, slotData, OnClickSlot, OnFishStateChange);
+                if (aquariumSlot[i].slotState == 2 || aquariumSlot[i].slotState == 3)
+                {
+                    isShowSell = true;
+                }
+                if (aquariumSlot[i].slotState < 3)
+                {
+                    isShowSpeedup = true;
+                }
+            }
+            else
+            {
+                aquariumSlot[i].gameObject.SetActive(false);
+            }
+        }
+        btn_sell.gameObject.SetActive(isShowSell);
+        btn_speedup.gameObject.SetActive(isShowSpeedup);
+        AM.CheckInHome();
+        NextReport();
+        SetRed();
+    }
+    void SetRed()
+    {
+        bool isRedPoint = GContext.container.Resolve<PlayerFishData>().GetMapRed(mapData.FishList);
+        redpoint.SetActive(isRedPoint);
+    }
+    public void OnUpdate(DateTime dateTime)
+    {
+        if (!updateBar)
+        {
+            return;
+        }
+        for (int i = 0; i < AM.Slot; i++)
+        {
+            aquariumSlot[i].UpdateBar(dateTime);
+        }
+        if (aquariumTips != null && curAquariumSlot != null && curAquariumSlot.slotState < 3)
+        {
+            aquariumTips.UpdateBar(dateTime);
+        }
+    }
+    public void Init(FishingAquariumAct fishingAquariumAct)
+    {
+        this.fishingAquariumAct = fishingAquariumAct;
+    }
+
+    async void ShowFishSellingPopupPanel()
+    {
+        GameObject go = await UIManager.Instance.ShowUI(UITypes.FishSellingPopupPanel);
+        FishSellingPopupPanel fishSellingPopupPanel = go.GetComponent<FishSellingPopupPanel>();
+        fishSellingPopupPanel.Init(OnSellFish);
+        aquariumFishTips.gameObject.SetActive(false);
+    }
+
+    async void OnSellFish()
+    {
+        GameObject go = await UIManager.Instance.ShowUI(UITypes.AquariumReportPopupPanel);
+        AquariumReportPopupPanel aquariumReportPopupPanel = go.GetComponent<AquariumReportPopupPanel>();
+        aquariumReportPopupPanel.InitData(fishingAquariumAct);
+        OnFishStateChange();
+    }
+
+    /// <summary>
+    /// 鱼当前状态倒计时结束
+    /// 售卖鱼刷新
+    /// </summary>
+    void OnFishStateChange()
+    {
+        bool isShowSell = false;
+        bool isShowSpeedup = false;
+        List<int> addFish = new List<int>();
+        List<int> removeFish = new List<int>();
+        for (int i = 0; i < AM.Slot; i++)
+        {
+            if (aquariumSlot[i].slotState > 3)
+            {
+                continue;
+            }
+            int oldState = aquariumSlot[i].slotState;
+            aquariumSlot[i].SetState();
+            if (oldState != aquariumSlot[i].slotState)
+            {
+                if (oldState == 1 && (aquariumSlot[i].slotState == 2 || aquariumSlot[i].slotState == 3))
+                {
+                    //添加鱼
+                    addFish.Add(i);
+                }
+                else if (aquariumSlot[i].slotState == 4)
+                {
+                    //删除鱼
+                    removeFish.Add(i);
+                }
+            }
+            if (aquariumSlot[i].slotState == 2 || aquariumSlot[i].slotState == 3)
+            {
+                isShowSell = true;
+            }
+            if (aquariumSlot[i].slotState < 3)
+            {
+                isShowSpeedup = true;
+            }
+        }
+        btn_sell.gameObject.SetActive(isShowSell);
+        btn_speedup.gameObject.SetActive(isShowSpeedup);
+        //修改显示的鱼
+        if (removeFish.Count > 0 || addFish.Count > 0)
+        {
+            if (aquariumTips != null && curAquariumSlot != null)
+            {
+                bool isShow = aquariumTips.UpdateBar(ZZTimeHelper.UtcNow());
+                if (!isShow)
+                {
+                    CloseTips();
+                }
+            }
+            ChangeFishEvent changeFishEvent = new ChangeFishEvent();
+            changeFishEvent.addFish = addFish;
+            changeFishEvent.removeFish = removeFish;
+            FishingAquariumAct.eventAggregator.Publish(changeFishEvent);
+        }
+    }
+    void CloseTips()
+    {
+        if (curAquariumSlot != null && aquariumTips != null)
+        {
+            curAquariumSlot.selected.SetActive(false);
+            aquariumTips.SetActive(false);
+            btn_close_tips.gameObject.SetActive(false);
+            curAquariumSlot = null;
+            aquariumTips = null;
+        }
+        fishingAquariumAct.StopFollowFishCamera();
+    }
+
+    public void OnClickFish(int index)
+    {
+        if (index < aquariumSlot.Length)
+        {
+            OnClickSlot(aquariumSlot[index]);
+        }
+    }
+
+    void OnClickSlot(AquariumSlot aquariumSlot)
+    {
+        if (curAquariumSlot != null && aquariumTips != null)
+        {
+            if (curAquariumSlot == aquariumSlot)
+            {
+                CloseTips();
+                return;
+            }
+            curAquariumSlot.selected.SetActive(false);
+            aquariumTips.SetActive(false);
+        }
+        curAquariumSlot = aquariumSlot;
+        curAquariumSlot.selected.SetActive(true);
+        AquariumSlotData slotData = aquariumSlot.slotData;
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+        bool isEgg = false;
+        if (slotData.FishHatchTime() > dateTime)
+        {
+            //还没孵化
+            isEgg = true;
+            aquariumTips = aquariumEggTips;
+        }
+        else
+        {
+            //已经孵化
+            aquariumTips = aquariumFishTips;
+        }
+        if (curAquariumSlot.slotState < 4)
+        {
+            fishingAquariumAct.FollowFishCamera(slotData, isEgg);
+        }
+        aquariumTips.SetActive(true);
+        aquariumTips.SetData(curAquariumSlot);
+        btn_close_tips.gameObject.SetActive(true);
+    }
+    async void OnClickSpeedup()
+    {
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+
+        if (aquariumTips != null && curAquariumSlot != null && curAquariumSlot.slotState < 3)
+        {
+            bool isShow = aquariumTips.UpdateBar(dateTime);
+            if (!isShow)
+            {
+                CloseTips();
+                return;
+            }
+        }
+        var go = await UIManager.Instance.ShowUI(UITypes.SpeedupPopupPanel);
+        if (go != null)
+        {
+            //判断是否置灰
+            bool isAd = AM.data.adCount < tables.TbAquariumConfig.AdMaxTime;
+            SpeedupPopupPanel speedupPopupPanel = go.GetComponent<SpeedupPopupPanel>();
+            string adContent = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_44", tables.TbAquariumConfig.AdMaxTime - AM.data.adCount, tables.TbAquariumConfig.AdMaxTime);
+            if (isAd)
+            {
+                speedupPopupPanel.SetData(OnAdsSucceed, StartSpeedUp, adContent);
+            }
+            else
+            {
+                speedupPopupPanel.SetData(null, null, adContent);
+            }
+        }
+    }
+    void StartSpeedUp(bool isGuide)
+    {
+        updateBar = false;
+        //加速成功
+        AM.Speedup(isGuide);
+    }
+    void OnAdsSucceed()
+    {
+        updateBar = true;
+        if (aquariumTips != null && curAquariumSlot != null && curAquariumSlot.slotState < 3)
+        {
+            bool isShow = aquariumTips.UpdateBar(ZZTimeHelper.UtcNow());
+            if (!isShow)
+            {
+                CloseTips();
+            }
+        }
+        OnFishStateChange();
+    }
+
+    async void OnClickProgress()
+    {
+        await UIManager.Instance.ShowUI(UITypes.PlayerGradePanel);
+        GContext.Publish(new HideHomePanelEvent());
+        GContext.Publish(new ChangeTabEvent() { index = 1 });
+    }
+    void OnClickClose()
+    {
+        FishingAquariumAct.CloudType = 4;
+        GContext.Publish(new UnloadActToNextAct(transitionPanel: UITypes.AquariumCloudPanel, time: 0.75f));
+    }
+
+    EventReport eventReport;
+    IReportService reportService;
+    bool isEnable = true;
+
+    private void OnDisable()
+    {
+        isEnable = false;
+    }
+
+    async void PlayEventReport(ReportData reportEvent)
+    {
+        eventReport.gameObject.SetActive(true);
+        eventReport.SetData(reportEvent.playFabId, reportEvent.content, reportEvent.type);
+        await Awaiters.Seconds(4f);
+        if (!isEnable)
+        {
+            return;
+        }
+        eventReport.gameObject.SetActive(false);
+
+        NextReport();
+    }
+    void NextReport()
+    {
+        var data = reportService.GetAquariumReportData();
+        if (data != null)
+        {
+            PlayEventReport(data);
+        }
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumRandomMapPanel.cs

@@ -0,0 +1,139 @@
+using asap.core;
+using cfg;
+using DG.Tweening;
+using GameCore;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumRandomMapPanel : MonoBehaviour
+{
+    AquariumManager AM;
+    RectTransform Content;
+    GameObject img_map;
+    int allCount = 5;
+    float height;
+    int maIndex = 2;
+    IUIService uIService;
+
+    GameObject result;
+    TMP_Text text_map;
+    TMP_Text text_level;
+    AquariumDetectEgg[] aquariumDetectEggs;
+    Transform eggRoot;
+    Tables _tables;
+    Transform door;
+    private void Awake()
+    {
+        _tables = GContext.container.Resolve<Tables>();
+        uIService = GContext.container.Resolve<IUIService>();
+        AM = GContext.container.Resolve<AquariumManager>();
+        Content = transform.Find("Viewport/Content").GetComponent<RectTransform>();
+        img_map = transform.Find("Viewport/Content/Item").gameObject;
+        height = img_map.GetComponent<RectTransform>().rect.height;
+        img_map.SetActive(false);
+        result = transform.Find("result").gameObject;
+        text_map = transform.Find("result/text_map").GetComponent<TMP_Text>();
+        text_level = transform.Find("result/fishcard/text_level").GetComponent<TMP_Text>();
+        eggRoot = transform.Find("eggRoot");
+        aquariumDetectEggs = eggRoot.GetComponentsInChildren<AquariumDetectEgg>();
+        //eggRoot.gameObject.SetActive(false);
+        door = transform.Find("door");
+    }
+    //private void Start()
+    //{
+    //    result.SetActive(false);
+    //}
+    public void SetMap()
+    {
+        PlayerData playerData = GContext.container.Resolve<PlayerData>();
+        AM.GetRandmMap();
+        var lastMapID = playerData.lastMapId;
+        List<MapData> mapDatas = _tables.TbMapData.DataList;
+        List<int> indexs = new List<int>();
+        for (int i = 0; i < mapDatas.Count; i++)
+        {
+            if (mapDatas[i].ID <= lastMapID)
+            {
+                indexs.Add(i);
+            }
+            else
+            {
+                break;
+            }
+        }
+        while (indexs.Count < allCount)
+        {
+            indexs.AddRange(indexs);
+        }
+        List<int> newIDs = new List<int>();
+        for (int i = 0; i < allCount; i++)
+        {
+            int mapIDIndex = indexs[Random.Range(0, indexs.Count)];
+            newIDs.Add(mapIDIndex);
+            indexs.Remove(mapIDIndex);
+        }
+        newIDs.AddRange(newIDs);
+        for (int i = 0; i < allCount + maIndex; i++)
+        {
+            SetMapBg(mapDatas[newIDs[i]].Bg);
+        }
+        var mapData = _tables.TbMapData.DataMap[AM.MapId];
+        SetMapBg(mapData.Bg);
+        SetMapBg(mapDatas[newIDs[0]].Bg);
+        text_map.text = LocalizationMgr.GetText(mapData.Name_l10n_key);
+        string levelLV = LocalizationMgr.GetText("UI_FishingMapPanel_101006");
+        int fishCardLevel = GContext.container.Resolve<PlayerFishData>().GetFishLevelByMap(AM.MapId);
+        text_level.text = levelLV + fishCardLevel.ToString();
+        var sequence = DOTween.Sequence();
+        sequence.Append(door.DOLocalMoveX(900, 0.5f).SetEase(Ease.Linear));
+        sequence.Append(Content.DOAnchorPosY(allCount * height, 0.8f).SetLoops(2, LoopType.Restart).SetEase(Ease.Linear));
+        //跑马灯动画
+        float index2 = allCount + maIndex + Random.Range(-0.5f, 0.5f);
+        sequence.Append(Content.DOAnchorPosY(index2 * height, 0.2f).SetEase(Ease.Linear));
+        sequence.Append(Content.DOAnchorPosY((allCount + maIndex) * height, 0.2f).SetEase(Ease.InSine));
+        sequence.Play();
+    }
+    void SetMapBg(string bg)
+    {
+        GameObject go = Instantiate(img_map, Content);
+        Image image = go.transform.GetChild(0).GetComponent<Image>();
+        go.SetActive(true);
+        uIService.SetImageSprite(image, bg);
+    }
+
+    public void InitEgg()
+    {
+        //开始随机蛋蛋
+        for (int i = 0; i < aquariumDetectEggs.Length; i++)
+        {
+            if (i < AM.Slot)
+            {
+                AquariumEgg aquariumEgg = _tables.TbAquariumEgg.GetOrDefault(AM.data.slotDatas[i].eggId);
+                aquariumDetectEggs[i].SetIcon(AM.eggNames, aquariumEgg.Icon, i);
+            }
+            else
+            {
+                aquariumDetectEggs[i].gameObject.SetActive(false);
+            }
+        }
+    }
+
+    public void PlayEgg()
+    {
+        //开始随机蛋蛋
+        for (int i = 0; i < aquariumDetectEggs.Length; i++)
+        {
+            if (i < AM.Slot)
+            {
+                AquariumEgg aquariumEgg = _tables.TbAquariumEgg.GetOrDefault(AM.data.slotDatas[i].eggId);
+                aquariumDetectEggs[i].Play();
+            }
+        }
+    }
+    public void HideMap()
+    {
+        Content.gameObject.SetActive(false);
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumRandomMapPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumReportFishItem.cs

@@ -0,0 +1,38 @@
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumReportFishItem : MonoBehaviour
+{
+    [Header("Fish Info")]
+    public Transform mask_bg;
+    public Image fish_icon;
+    public Image icon_rate;
+    public Image icon_egg;
+
+    [Header("Cash Info")]
+    public GameObject fish_info;
+    public TMP_Text text_cash;
+    public TMP_Text text_fish_name;
+
+    [Header("Player Info")]
+    public GameObject player_info;
+    public TMP_Text text_player_name;
+    public Head text_player_head;
+
+    public int index;
+
+    private void Reset()
+    {
+        mask_bg = transform.Find("mask_bg2").GetComponent<Transform>();
+        fish_icon = transform.Find("mask_bg2/icon_fish").GetComponent<Image>();
+        icon_rate = transform.Find("mask_bg2/icon_rate").GetComponent<Image>();
+        icon_egg = transform.Find("mask_bg2/icon_egg").GetComponent<Image>();
+        fish_info = transform.Find("fish_info").gameObject;
+        text_cash = transform.Find("fish_info/text_cash").GetComponent<TMP_Text>();
+        text_fish_name = transform.Find("fish_info/text_name").GetComponent<TMP_Text>();
+        player_info = transform.Find("player_info").gameObject;
+        text_player_name = transform.Find("player_info/text_name").GetComponent<TMP_Text>();
+        text_player_head = transform.Find("player_info/text_name/btn_head").GetComponent<Head>();
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumReportFishItem.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumReportPopupPanel.cs

@@ -0,0 +1,372 @@
+using asap.core;
+using cfg;
+using DG.Tweening;
+using Game;
+using GameCore;
+using System;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+using UniRx;
+
+public class AquariumReportPopupPanel : MonoBehaviour
+{
+    public Button btn_next;
+    public GameObject receive;
+    public GameObject photo;
+
+    public TMP_Text text_gold;
+    public TMP_Text text_energy;
+    public TMP_Text txt_diamond;
+    public TMP_Text text_num;
+    public GameObject[] _lights;
+    public float showTime = 0.3f;
+    public Transform reward_show;
+    public RawImage icon;
+    public Image tag_fish;
+    public TMP_Text text_fish_name;
+
+    public Transform fishIconRT;
+    public RawImage rawImage;
+    RenderTexture rt;
+    Camera rtCamera;
+    Transform avatarCapture;
+    int fieldOfView = 60;
+    //鱼距离相机的位置
+    int fishPosZ = 20;
+    public GameObject mutated;
+
+    List<AquariumSlotData> aquariumSlotDatas;
+    AquariumSlotData curData;
+    int curIndex;
+    int allCount;
+    int Energy;
+    int curDiamond;
+    ulong Gold;
+    bool isClose;
+    bool isClickClose;
+    IDisposable disposable;
+    private Tables _tables;
+    Item item;
+    AquariumManager AM;
+    Vector3 startPosition;
+    FishingAquariumAct aquariumAct;
+    Item fishItem;
+    bool isEnable = true;
+    public SpriteRenderer bg_photo;
+    private void Awake()
+    {
+        _tables = GContext.container.Resolve<Tables>();
+        item = _tables.TbItem.GetOrDefault(1002);
+
+        AM = GContext.container.Resolve<AquariumManager>();
+        aquariumSlotDatas = AM.sellList;
+
+        Energy = GContext.container.Resolve<PlayerData>().Energy;
+        Gold = GContext.container.Resolve<PlayerData>().gold;
+        curDiamond = GContext.container.Resolve<PlayerData>().diamond;
+        ShowItemCount();
+        text_energy.text = ConvertTools.GetNumberString2(Energy);
+        text_gold.text = ConvertTools.GetNumberString2(Gold);
+        txt_diamond.text = ConvertTools.GetNumberString2(curDiamond);
+        allCount = aquariumSlotDatas.Count;
+
+        avatarCapture = fishIconRT.Find("avatarCapture");
+        rtCamera = fishIconRT.Find("Camera").GetComponent<Camera>();
+        startPosition = avatarCapture.localPosition;
+        curIndex = 0;
+        disposable = GContext.OnEvent<ResAddEvent>().Subscribe(x =>
+        {
+            NumPlay(x.id);
+        });
+    }
+
+    public void InitData(FishingAquariumAct aquariumAct)
+    {
+        this.aquariumAct = aquariumAct;
+        SetRT();
+        SetData();
+    }
+
+    void SetRT()
+    {
+        fishIconRT.transform.position = Vector3.back * 30;
+        RectTransform raw = rawImage.GetComponent<RectTransform>();
+        rt = new RenderTexture((int)raw.rect.width, (int)raw.rect.height, 24, RenderTextureFormat.ARGB32);
+
+        rtCamera.fieldOfView = fieldOfView;
+        rtCamera.enabled = true;
+        rtCamera.targetTexture = rt;
+        rawImage.texture = rt;
+        rtCamera.Render();
+    }
+
+    private void Start()
+    {
+        var mapData = _tables.TbMapData.DataMap[AM.MapId];
+
+        string prefabName = mapData.AquariumPrefab;
+        Transform bg = photo.transform.Find($"bg_{prefabName}");
+        if (bg != null)
+        {
+            bg_photo.sprite = bg.GetComponent<Image>().sprite;
+        }
+        btn_next.onClick.AddListener(OnClickNext);
+    }
+    async void ShowFish()
+    {
+        GameObject fishGo = await aquariumAct.LoadFish(curData.index, avatarCapture);
+        if (fishGo != null)
+        {
+            var fishData = _tables.TbFishData.GetOrDefault(fishItem.RedirectID);
+
+            var TankPosition = fishData.TankPosition;
+            Vector3 pos = new Vector3(TankPosition[0], TankPosition[1], TankPosition[2] + fishPosZ);
+            Transform avatar = avatarCapture;
+            pos += startPosition;
+            avatar.localPosition = pos;
+            //fish.transform.localPosition = pos;
+        }
+    }
+
+    async void SetData()
+    {
+        isClose = false;
+        isClickClose = false;
+        curData = aquariumSlotDatas[curIndex];
+        mutated.SetActive(curData.mutants > 0);
+        photo.SetActive(false);
+        fishItem = _tables.TbItem.GetOrDefault(curData.fishItemID);
+        ShowFish();
+        photo.SetActive(true);
+        text_fish_name.text = LocalizationMgr.GetText(fishItem.Name_l10n_key);
+        GContext.container.Resolve<IUIService>().SetImageSprite(tag_fish, "icon_fish_rate_tag_" + fishItem.Quality);
+
+        int audioName = curIndex % 4 + 1;
+        GContext.Publish(new EventUISound($"audio_ui_getreward_{audioName}"));
+        float showCount = curData.allCash;
+        ItemShow itemShow = GContext.container.Resolve<Tables>().TbItemShow.GetOrDefault(1002);
+        int light_index = 1;
+        if (itemShow != null)
+        {
+            light_index = 0;
+            showCount = (showCount / GContext.container.Resolve<PlayerItemData>().ExtraCoinMag());
+            for (int i = itemShow.Count.Count - 1; i >= 0; i--)
+            {
+                if (showCount > itemShow.Count[i])
+                {
+                    light_index = i + 1;
+                    break;
+                }
+            }
+        }
+        if (light_index >= _lights.Length)
+        {
+            light_index = _lights.Length - 1;
+        }
+        for (int i = 0; i < _lights.Length; i++)
+        {
+            _lights[i].SetActive(i == light_index);
+        }
+        curIndex++;
+        receive.SetActive(false);
+        receive.SetActive(true);
+        var progress = 0f;
+        //text_num.text = ConvertTools.GetNumberString2(curData.cash);
+        int cash = curData.cash;
+        DOTween.Kill("AddCash");
+        await Awaiters.Seconds(showTime);
+
+        DOTween.To(() => progress, x => progress = x, 1f, 0.8f).OnUpdate(() =>
+        {
+            text_num.text = ConvertTools.GetNumberString2((int)(cash * progress));
+        }).SetId("AddCash");
+        await Awaiters.Seconds(0.5f);
+        await ParticleAttractor(showCount);
+        isClose = true;
+        if (isClickClose)
+        {
+            Close();
+        }
+    }
+    void NumPlay(int id)
+    {
+        if (id != 1002)
+        {
+            return;
+        }
+        GoldAddAnim(curData.cash);
+    }
+    void GoldAddAnim(float add)
+    {
+        DOTween.Kill("report_text_gold");
+        text_gold.text = ConvertTools.GetNumberString2(Gold);
+        float progress = 0;
+        ulong glod = Gold;
+        DOTween.To(() => progress, x => progress = x, 1, 0.4f).OnUpdate(() =>
+        {
+            Gold = glod + (ulong)(add * progress);
+            text_gold.text = ConvertTools.GetNumberString2(Gold);
+        }).SetDelay(0.5f).SetId("report_text_gold");
+    }
+
+    void ShowItemCount()
+    {
+        if (aquariumSlotDatas != null)
+        {
+            for (int i = 0; i < aquariumSlotDatas.Count; i++)
+            {
+                ulong curGold = (ulong)aquariumSlotDatas[i].cash;
+                if (Gold > curGold)
+                {
+                    Gold -= curGold;
+                }
+            }
+        }
+    }
+
+    void Close()
+    {
+        isClickClose = false;
+        isClose = false;
+        receive.SetActive(false);
+        UIManager.Instance.DestroyUI(UITypes.AquariumReportPopupPanel);
+        if (AM.data.isHome)
+        {
+            FishingAquariumAct.eventAggregator.Publish(new AquariumEnterMapScene());
+        }
+    }
+
+    void OnClickNext()
+    {
+        if (curIndex >= allCount)
+        {
+            receive.SetActive(false);
+            if (isClose)
+            {
+                Close();
+            }
+            else
+            {
+                isClickClose = true;
+            }
+            return;
+        }
+        SetData();
+    }
+
+    public async System.Threading.Tasks.Task ParticleAttractor(float showCount)
+    {
+        //1001 1002 另外一种配法
+        //ItemShow itemShow = _tables.TbItemShow.GetOrDefault(item.ID);
+        //string fxName = itemShow.Fx[0];
+        //for (int i = itemShow.Count.Count - 1; i >= 0; i--)
+        //{
+        //    if (showCount > itemShow.Count[i])
+        //    {
+        //        fxName = itemShow.Fx[i + 1];
+        //        break;
+        //    }
+        //}
+        string fxName = "fx_ui_reward_common_money_01";// item.Fx;
+        if (fishItem.Quality > 3)
+        {
+            fxName = "fx_ui_reward_common_money_02";
+        }
+
+        Transform fxP = reward_show.Find(fxName);
+
+        if (fxP == null)
+        {
+            GContext.Publish(new ResAddEvent(item.ID, item.Type, item.SubType));
+            return;
+        }
+        GameObject fx = Instantiate(fxP.gameObject, reward_show);
+        ParticleSystem particleSystem = fx.transform.Find("Scale/quan03").GetComponent<ParticleSystem>();
+        if (particleSystem != null)
+        {
+            reward_show.gameObject.SetActive(true);
+            //fx.transform.position = transform.position;
+            ParticleAttractorData particleAttractorData = new ParticleAttractorData()
+            {
+                Type = item.Type,
+                SubType = item.SubType,
+                Priority = -1,
+            };
+            GContext.Publish(particleAttractorData);
+            if (particleAttractorData.Priority > -1 && particleAttractorData.uIParticleAttractorCenter != null)
+            {
+                var particleRenderer = particleSystem.GetComponent<ParticleSystemRenderer>();
+                var sprite = icon.texture;
+
+                var uIParticleAttractorCenter = particleAttractorData.uIParticleAttractorCenter;
+                //多个粒子飞向同一个target时,隐藏前一个粒子
+                var particleAttractor = uIParticleAttractorCenter.GetUIParticleAttractor();
+                particleAttractor?.Clear();
+                particleAttractor.particleSystem = null;
+                //particleAttractor.enabled = false;
+                Texture texture = sprite;// await GContext.container.Resolve<IUIService>().GetTexture(item.Icon, "RewardPopupPanel");
+                if (!isEnable)
+                {
+                    return;
+                }
+                //_TextureSample0
+                particleRenderer.material.SetTexture("_TextureSample0", texture);
+                //particleRenderer.material.SetTextureScale("_TextureSample0", new Vector2(sprite.textureRect.width / texture.width, sprite.textureRect.height / texture.height));
+                //particleRenderer.material.SetTextureOffset("_TextureSample0", new Vector2(sprite.textureRect.x / texture.width, sprite.textureRect.y / texture.height));
+                particleSystem.Clear();
+
+                var main = particleSystem.main;
+                int maxCount = main.maxParticles;
+                if (showCount < maxCount)
+                {
+                    int addCount = (int)showCount;
+                    main.maxParticles = addCount;
+                    //var emission = particleSystem.emission;
+                    //emission.rateOverTime = 0;
+                    //emission.SetBursts(new ParticleSystem.Burst[] { new ParticleSystem.Burst(0.0f, addCount) });
+                }
+                fx.SetActive(true);
+                if (particleAttractor != null)
+                {
+                    particleAttractor.particleSystem = particleSystem;
+                    particleAttractor.enabled = true;
+                }
+                await Awaiters.Seconds(0.2f);
+                if (!isEnable)
+                {
+                    return;
+                }
+                GContext.Publish(new ResAddEvent(item.ID, item.Type, item.SubType));
+                await Awaiters.Seconds(1.8f);
+                if (!isEnable)
+                {
+                    return;
+                }
+                if (particleAttractor != null && particleAttractor.particleSystem == particleSystem)
+                {
+                    particleAttractor.Clear();
+                    particleAttractor.enabled = false;
+                    particleAttractor = null;
+                }
+            }
+        }
+        Destroy(fx);
+        return;
+    }
+
+    private void OnDisable()
+    {
+        isEnable = false;
+        disposable?.Dispose();
+        disposable = null;
+        rtCamera.targetTexture = null;
+        if (rt != null)
+        {
+            rt.Release();
+            Destroy(rt);
+            rt = null;
+        }
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumReportPopupPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumReportPopupPanelOld.cs

@@ -0,0 +1,78 @@
+using asap.core;
+using cfg;
+using GameCore;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumReportPopupPanelOld : MonoBehaviour
+{
+    Button btn_confirm;
+    TMP_Text text_num;
+    AquariumManager AM;
+    GameObject fishItemPrefab;
+    Transform fish_info_root;
+    Tables tables;
+    private void Awake()
+    {
+        tables = GContext.container.Resolve<Tables>();
+        AM = GContext.container.Resolve<AquariumManager>();
+        text_num = transform.Find("root/bg_reward/text_num").GetComponent<TMP_Text>();
+        btn_confirm = transform.Find("root/btn_confirm/btn_green").GetComponent<Button>();
+        fish_info_root = transform.Find("root/fish_info1");
+        fishItemPrefab = transform.Find("root/fish_info1/fish").gameObject;
+    }
+    private void Start()
+    {
+        btn_confirm.onClick.AddListener(OnClickConfirm);
+        int allCash = 0;
+        AquariumReportFishItem fishItem = null;
+        Item item = null;
+        MapData mapData = tables.TbMapData.GetOrDefault(AM.data.mapId);
+        IUIService uiService = GContext.container.Resolve<IUIService>();
+
+        List<AquariumResultData> aquariumReportDatas = AM.data.aquariumResultDatas;
+        for (int i = 0; i < AM.data.slot; i++)
+        {
+            fishItem = Instantiate(fishItemPrefab, fish_info_root).GetComponent<AquariumReportFishItem>();
+            fishItem.gameObject.SetActive(true);
+            fishItem.index = i;
+
+            AquariumResultData aquariumSettlementData = aquariumReportDatas[i];
+            AquariumSlotData slotData = AM.data.slotDatas[i];
+            item = tables.TbItem.GetOrDefault(slotData.fishItemID);
+            PlayerFishData.SetFishIcon(fishItem.fish_icon, item);//鱼头像
+            uiService.SetImageSprite(fishItem.icon_rate, "icon_fish_rate_tag_" + item.Quality);
+            var bgbg = fishItem.mask_bg.Find(mapData.AquariumBg);
+            bgbg.gameObject.SetActive(true);
+            AquariumEgg aquariumEgg = GContext.container.Resolve<Tables>().TbAquariumEgg.GetOrDefault(slotData.eggId);
+            if (aquariumEgg != null)
+            {
+                uiService.SetImageSprite(fishItem.icon_egg, aquariumEgg.Icon);
+            }
+
+            fishItem.fish_info.SetActive(slotData.cash > 0);
+            fishItem.player_info.SetActive(slotData.cash <= 0);
+
+            if (slotData.cash > 0)
+            {
+                fishItem.text_fish_name.text = LocalizationMgr.GetText(item.Name_l10n_key);
+                fishItem.text_cash.text = ConvertTools.GetNumberString2(slotData.cash);
+                allCash += slotData.cash;
+            }
+            else if (slotData.cash <= 0)
+            {
+                fishItem.text_player_name.text = aquariumSettlementData.displayName;
+                fishItem.text_player_head.SetData(aquariumSettlementData.avatar);
+            }
+
+        }
+
+        text_num.text = ConvertTools.GetNumberString2(allCash);
+    }
+    void OnClickConfirm()
+    {
+        FishingAquariumAct.eventAggregator.Publish(new AquariumEnterMapScene());
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumReportPopupPanelOld.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumSlot.cs

@@ -0,0 +1,255 @@
+using asap.core;
+using DG.Tweening;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumSlot : MonoBehaviour
+{
+    public Button btn_click;
+    public Image icon_egg;
+    public GameObject mask_fish;
+    public Image icon_fish;
+    public Image icon_rate;
+    public GameObject selected;
+    public GameObject done;
+    public GameObject icon_hurt;
+    public GameObject icon_killed;
+    public GameObject icon_sold;
+    public GameObject redpoint;
+    public AquariumSlotData slotData;
+    public Image bar;
+    public Image bar_hurt;
+    Action<AquariumSlot> onClick;
+    Action onFishStateChange;
+    public int index;
+    /// <summary>
+    /// 1 == egg 2 == fish 3 == done 4 == sell 5 == lose
+    /// </summary>
+    [HideInInspector]
+    public int slotState = 0;
+    AquariumManager AM;
+    //private void Reset()
+    //{
+    //    btn_click = GetComponent<Button>();
+    //    icon_egg = transform.Find("icon_egg").GetComponent<Image>();
+    //    mask_fish = transform.Find("mask_fish").gameObject;
+    //    icon_fish = transform.Find("mask_fish/icon_fish").GetComponent<Image>();
+    //    icon_rate = transform.Find("mask_fish/icon_rate").GetComponent<Image>();
+    //    selected = transform.Find("selected").gameObject;
+    //    done = transform.Find("mask_fish/done").gameObject;
+    //    icon_hurt = transform.Find("icon_hurt").gameObject;
+    //    icon_killed = transform.Find("icon_killed").gameObject;
+    //    icon_sold = transform.Find("icon_sold").gameObject;
+    //    redpoint = transform.Find("redpoint").gameObject;
+    //    bar = transform.Find("bg_bar/bar").GetComponent<Image>();
+    //    bar_hurt = transform.Find("bg_bar/bar_hurt").GetComponent<Image>();
+    //}
+
+    private void Awake()
+    {
+        redpoint.SetActive(false);
+        btn_click.onClick.AddListener(OnClick);
+    }
+    void OnClick()
+    {
+        //if (slotState == 4)
+        //{
+        //    return;
+        //}
+        onClick?.Invoke(this);
+    }
+    public void InitSlot(int index, AquariumSlotData slotData, Action<AquariumSlot> onClick, Action onFishStateChange)
+    {
+        AM = GContext.container.Resolve<AquariumManager>();
+        this.index = index;
+        this.slotData = slotData;
+        this.onClick = onClick;
+        this.onFishStateChange = onFishStateChange;
+        SetState();
+        InitBar();
+    }
+    public void SetState()
+    {
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+        var HatchTime = slotData.FishHatchTime();
+        var FishGrowthTime = slotData.FishGrowthTime();
+        bool isHatch = HatchTime < dateTime;
+        TimeSpan offsetTime = new TimeSpan();
+        bool isUpdate = false;
+        done.gameObject.SetActive(false);
+        icon_hurt.gameObject.SetActive(false);
+        bar_hurt.gameObject.SetActive(false);
+        icon_killed.gameObject.SetActive(false);
+        bar.gameObject.SetActive(true);
+        redpoint.SetActive(false);
+        if (isHatch)
+        {
+            //鱼鱼
+            slotState = 2;
+            icon_egg.gameObject.SetActive(false);
+            mask_fish.gameObject.SetActive(true);
+
+            bool growth = FishGrowthTime < dateTime;
+
+            List<AquariumResultData> aquariumReportDatas = AM.data.aquariumResultDatas;
+
+            //售卖或者丢失
+            if (slotData.IsResult())
+            {
+                slotState = 4;
+                //btn_click.enabled = false;
+                done.gameObject.SetActive(true);
+                icon_sold.gameObject.SetActive(true);
+                bar.gameObject.SetActive(false);
+            }
+            else if (aquariumReportDatas[slotData.index].IsResult())
+            {
+                slotState = 5;
+                icon_killed.gameObject.SetActive(true);
+                done.gameObject.SetActive(true);
+                bar.gameObject.SetActive(false);
+            }
+            else
+            {
+                //检查是否受伤
+                //正常的成长时间 自然时间+加速成长-总恢复时间
+                float normalH = (float)(dateTime - HatchTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+
+                float injuryH = slotData.injuryGrowthTime;
+
+                //受伤时的成长进度大于正常的成长进度=还没恢复
+                isUpdate = true;
+                if (injuryH > normalH)
+                {
+                    bar.gameObject.SetActive(false);
+                    bar_hurt.gameObject.SetActive(true);
+                    icon_hurt.gameObject.SetActive(true);
+                    offsetTime = dateTime.AddHours(injuryH - normalH) - dateTime;
+                }
+                else if (growth)
+                {
+                    //成熟并且没有受伤
+                    slotState = 3;
+                    isUpdate = false;
+                    redpoint.SetActive(true);
+                }
+                else
+                {
+
+                    bar_hurt.gameObject.SetActive(false);
+                    icon_hurt.gameObject.SetActive(false);
+                    offsetTime = FishGrowthTime - dateTime;
+                }
+            }
+        }
+        else
+        {
+            isUpdate = true;
+            offsetTime = HatchTime - dateTime;
+            //蛋蛋
+            slotState = 1;
+            icon_egg.gameObject.SetActive(true);
+            mask_fish.gameObject.SetActive(false);
+            done.gameObject.SetActive(false);
+        }
+        if (isUpdate)
+        {
+            StartCoroutine(UpdateTime((float)offsetTime.TotalSeconds));
+        }
+    }
+
+    void InitBar()
+    {
+        if (slotState == 5)
+        {
+            bar.fillAmount = 0;
+            return;
+        }
+        if (slotState == 4)
+        {
+            bar.fillAmount = 0;
+            return;
+        }
+        DateTime dateTime = ZZTimeHelper.UtcNow();
+
+        if (slotState == 1)
+        {
+            float time = (float)(dateTime - slotData.startTime).TotalHours + slotData.accelerationHatch;
+            bar.fillAmount = time / slotData.hatchTime;
+            return;
+        }
+        var StartTime = slotData.FishHatchTime();
+        //正常的成长进度 自然时间+加速成长 - 全部恢复时间
+        float normalH = (float)(dateTime - StartTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+        //受伤时的成长进度
+        float injuryH = slotData.injuryGrowthTime;
+
+        //受伤时的成长进度大于正常的成长进度
+        float timeProgress = 1;
+        if (injuryH > normalH)
+        {
+            bar_hurt.fillAmount = (injuryH - normalH) / slotData.growthTime;
+            timeProgress = 0;// injuryH / slotData.growthTime;
+        }
+        else if (normalH < slotData.growthTime)
+        {
+            timeProgress = normalH / slotData.growthTime;
+        }
+        bar.fillAmount = timeProgress;
+    }
+
+    public void UpdateBar(DateTime dateTime)
+    {
+        if (slotState == 5)
+        {
+            bar.fillAmount = 0;
+            return;
+        }
+        if (slotState == 4)
+        {
+            //bar.DOFillAmount(1, 0.9f);
+            bar.fillAmount = 0;
+            return;
+        }
+        if (slotState == 1)
+        {
+            float time = (float)(dateTime - slotData.startTime).TotalHours + slotData.accelerationHatch;
+            var fillAmount = time / slotData.hatchTime;
+            bar.DOFillAmount(fillAmount, 0.9f);
+            return;
+        }
+        var StartTime = slotData.FishHatchTime();
+        //正常的成长进度 自然时间+加速成长 - 全部恢复时间
+        float normalH = (float)(dateTime - StartTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+        //受伤时的成长进度
+        float injuryH = slotData.injuryGrowthTime;
+
+        //受伤时的成长进度大于正常的成长进度
+        float timeProgress = 1;
+        if (injuryH > normalH)
+        {
+            var fillAmount = (injuryH - normalH) / slotData.recoveryTime;
+            bar_hurt.DOFillAmount(fillAmount, 0.9f);
+            //timeProgress = injuryH / slotData.growthTime;
+            bar.fillAmount = 0;
+        }
+        else if (normalH < slotData.growthTime)
+        {
+            timeProgress = normalH / slotData.growthTime;
+            bar.DOFillAmount(timeProgress, 0.9f);
+        }
+        else
+        {
+            bar.DOFillAmount(timeProgress, 0.9f);
+        }
+    }
+    IEnumerator UpdateTime(float s)
+    {
+        yield return new WaitForSeconds(s);
+        //发送事件，状态修改
+        onFishStateChange?.Invoke();
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumSlot.cs.meta

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

Assets/Scripts/Aquarium/UI/AquariumUpdatePopupPanel.cs

@@ -0,0 +1,93 @@
+using asap.core;
+using game;
+using GameCore;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class AquariumUpdatePopupPanel : MonoBehaviour
+{
+    Transform map;
+    RewardItemNew[] rewards;
+    Button btn_sure;
+    bool isShowBox;
+
+    private void Awake()
+    {
+        btn_sure = transform.Find("root/bg/btn_sure/btn_green").GetComponent<Button>();
+        map = transform.Find("root/bg/rewards");
+        rewards = map.GetComponentsInChildren<RewardItemNew>();
+    }
+    private void Start()
+    {
+        OpenBox();
+        btn_sure.onClick.AddListener(OnBtnSure);
+    }
+    void OnBtnSure()
+    {
+        UIManager.Instance.DestroyUI(UITypes.AquariumUpdatePopupPanel);
+    }
+    void OpenBox()
+    {
+        var _dataProvider = GContext.container.Resolve<FishingBoxDataProvier>();
+        Dictionary<int, int> FishingBoxs = _dataProvider.Data.FishingBoxs;
+        isShowBox = false;
+        int index = 0;
+
+        foreach (var box in FishingBoxs)
+        {
+            var boxCount = box.Value;
+            if (boxCount > 0)
+            {
+                int id = box.Key;
+
+                isShowBox = true;
+                rewards[index].SetData(new ItemData(id, boxCount));
+            }
+            rewards[index].gameObject.SetActive(boxCount > 0);
+            index++;
+            if (index >= 5)
+            {
+                break;
+            }
+        }
+        map.gameObject.SetActive(isShowBox);
+    }
+    private void OnDisable()
+    {
+        if (isShowBox)
+        {
+            var _dataProvider = GContext.container.Resolve<FishingBoxDataProvier>();
+            Dictionary<int, int> FishingBoxs = _dataProvider.Data.FishingBoxs;
+            var FishingNewBoxs = _dataProvider.Data.FishingNewBoxs;
+            int index = 0;
+
+            foreach (var box in FishingBoxs)
+            {
+                var boxCount = box.Value;
+                if (boxCount > 0)
+                {
+                    int id = box.Key;
+                    if (FishingNewBoxs.ContainsKey(id))
+                    {
+                        FishingNewBoxs[id] += boxCount;
+                    }
+                    else
+                    {
+                        FishingNewBoxs.Add(id, boxCount);
+                    }
+                }
+                index++;
+                if (index >= 5)
+                {
+                    break;
+                }
+            }
+
+            _dataProvider.Data.FishingBoxs.Clear();
+            _dataProvider.Data.Save();
+            GContext.Publish(new ShowData(null, RewardType.FishBoxOpen, 1));
+        }
+        GContext.Publish(new FaceUICloseEvent());
+    }
+}

Assets/Scripts/Aquarium/UI/AquariumUpdatePopupPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/EventFishHuntingAim.cs

@@ -0,0 +1,145 @@
+using asap.core;
+using cfg;
+using DG.Tweening;
+using GameCore;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class EventFishHuntingAim : MonoBehaviour
+{
+    LayerMask layerMask;
+    GameObject target;
+    FishMovement fish;
+    [HideInInspector]
+    public EventFishHuntingPanel eventFishHuntingPanel;
+    public Animator animator;
+    public bool isFinish;
+    public float AimTime => crossbow.AimTime;
+    Vector3 screenPosition;
+    cfg.Crossbow crossbow;
+    float shakeTime = 0;
+    float rotate = 0;
+    Vector3 currentPos;
+    Vector3 newPos;
+    float time;
+    //CrossbowCameraMove crossbowCameraMove;
+    private void Awake()
+    {
+        crossbow = GContext.container.Resolve<Tables>().TbCrossbow.DataList[0];
+        layerMask = LayerMask.NameToLayer("fish");
+    }
+
+    private void OnEnable()
+    {
+        animator.SetInteger("AimIndex", crossbow.AimIndex);
+        Time.timeScale = crossbow.TimescaleRate;
+        transform.localPosition = Vector3.zero;
+        shakeTime = 0;
+        rotate = 1;
+    }
+
+
+    void Shake()
+    {
+        float timeRotate = shakeTime / crossbow.AimTime;
+        shakeTime += Time.deltaTime;
+        List<float> shakeSpeed = crossbow.ShakeSpeed;
+        float speed = shakeSpeed[0] - (shakeSpeed[0] - shakeSpeed[1]) * timeRotate;
+
+        if (rotate >= 1)
+        {
+            rotate = 0;
+            var ShakeRandRange = crossbow.ShakeRandRange;
+            float shakeRand1 = ShakeRandRange[0][0] - (ShakeRandRange[0][0] - ShakeRandRange[1][0]) * timeRotate;
+            float shakeRand2 = ShakeRandRange[0][1] - (ShakeRandRange[0][1] - ShakeRandRange[1][1]) * timeRotate;
+            //抖动相机
+            float x = UnityEngine.Random.Range(shakeRand1, shakeRand2);
+            float y = UnityEngine.Random.Range(shakeRand1, shakeRand2);
+            currentPos = transform.localPosition;
+
+            bool directionX = UnityEngine.Random.Range(0, 2) == 0;
+            bool directionY = UnityEngine.Random.Range(0, 2) == 0;
+            if (!directionX)
+            {
+                x = -x;
+            }
+            if (!directionY)
+            {
+                y = -y;
+            }
+            newPos = new Vector3(x, y, 0);
+            float dis = Vector3.Distance(currentPos, newPos);
+            time = dis / speed;
+        }
+        rotate += Time.deltaTime / time;
+        transform.localPosition = Vector3.Lerp(currentPos, newPos, rotate);
+    }
+    private void Update()
+    {
+        if (shakeTime < crossbow.AimTime)
+        {
+            Shake();
+        }
+    }
+
+    private void LateUpdate()
+    {
+        //if (isGuide)
+        //{
+        //    OnGuide();
+        //    return;
+        //}
+        if (isFinish || eventFishHuntingPanel == null)
+        {
+            return;
+        }
+        target = SelectTarget();
+        if (target != null)
+        {
+            fish = target.GetComponentInParent<FishMovement>();
+        }
+        else
+        {
+            fish = null;
+        }
+        eventFishHuntingPanel.ChangeTarget(fish);
+        if (Input.GetMouseButtonUp(0))
+        {
+            eventFishHuntingPanel.OnUpAim();
+        }
+    }
+
+    private GameObject SelectTarget()
+    {
+        screenPosition = UIManager.Instance.UICanvas.worldCamera.WorldToScreenPoint(transform.position);
+
+        var ray = Camera.main.ScreenPointToRay(screenPosition);
+        if (Physics.Raycast(ray, out var hit))
+        {
+            if (hit.collider.gameObject.layer == layerMask)
+            {
+                return hit.collider.gameObject;
+            }
+        }
+        return null;
+    }
+
+    public void Trigger(string value)
+    {
+        if (gameObject.activeSelf)
+        {
+            animator.SetTrigger(value);
+        }
+    }
+    private void OnDisable()
+    {
+        Time.timeScale = 1;
+        transform.DOKill();
+    }
+    //void OnGuide()
+    //{
+    //    Quaternion rotation = Quaternion.LookRotation(target.transform.position - transform.position);
+    //    rotation = Quaternion.Slerp(transform.rotation, rotation, Time.deltaTime * 2);
+    //    crossbowCameraMove.transform.eulerAngles = new Vector3(rotation.eulerAngles.x, rotation.eulerAngles.y, 0);
+    //}
+}

Assets/Scripts/Aquarium/UI/EventFishHuntingAim.cs.meta

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

Assets/Scripts/Aquarium/UI/EventFishHuntingPanel.cs

@@ -0,0 +1,406 @@
+using asap.core;
+using cfg;
+using DG.Tweening;
+using game;
+using GameCore;
+using TMPro;
+using UniRx;
+using UnityEngine;
+using UnityEngine.UI;
+using System.Collections;
+
+public class EventFishHuntingPanel : MonoBehaviour
+{
+    Tables _tables;
+    Head head;
+    Button switchbtn;
+    GameObject exchange;
+    GameObject title;
+    Button btn_aim;
+
+    TMP_Text text_name;
+
+    GameObject fish_info;
+    Image tag_fish;
+    TMP_Text text_fish_name;
+    GameObject mutated;
+
+    GameObject mutated_settlement;
+    GameObject root_settlement;
+    GameObject kill;
+    GameObject hurt;
+    Button btn_close;
+    Transform photo;
+    SpriteRenderer bg_photo;
+    Transform fishIconRT;
+    RawImage rawImage;
+    RenderTexture rt;
+    GameObject fishGo;
+    Camera rtCamera;
+    Transform avatarCapture;
+    Transform avatarEscape;
+    int fieldOfView = 60;
+    //鱼距离相机的位置
+    int fishPosZ = 20;
+
+    SmallGameData smallGameData;
+    string playFabId;
+    OpponentItemData opponentItemData;
+    bool isClick = false;
+    AquariumShooterFishManager AM;
+    int multiple;
+    [HideInInspector]
+    public ShooterFishAct shooterFishAct;
+    EventFishHuntingAim eventFishHuntingAim;
+
+    FishMovement fishMovement;
+
+    FishMovement curTarget;
+    int changeTargetCount = 0;
+    UIDownUp uIDownUp;
+    protected CompositeDisposable disposables = new CompositeDisposable();
+    private void Awake()
+    {
+        multiple = GContext.container.Resolve<PlayerData>().GetMagnification();
+        AM = GContext.container.Resolve<AquariumShooterFishManager>();
+
+        smallGameData = GContext.container.Resolve<SmallGameData>();
+        _tables = GContext.container.Resolve<Tables>();
+        text_name = transform.Find("root/title/bg/text_name").GetComponent<TMP_Text>();
+        head = transform.Find("root/title/btn_head").GetComponent<Head>();
+        switchbtn = transform.Find("root/switch/btn_switch/btn_green").GetComponent<Button>();
+        exchange = transform.Find("root/switch").gameObject;
+        title = transform.Find("root/title").gameObject;
+        btn_aim = transform.Find("root/btn_hunt").GetComponent<Button>();
+        kill = transform.Find("root/root_settlement/kill").gameObject;
+        hurt = transform.Find("root/root_settlement/hurt").gameObject;
+        root_settlement = transform.Find("root/root_settlement").gameObject;
+        btn_close = transform.Find("root/root_settlement/btn_play/btn_green").GetComponent<Button>();
+
+        fish_info = transform.Find("root/fish_info").gameObject;
+        tag_fish = fish_info.transform.Find("text_name/tag_fish").GetComponent<Image>();
+        text_fish_name = fish_info.transform.Find("text_name").GetComponent<TMP_Text>();
+        mutated = fish_info.transform.Find("mutated").gameObject;
+        mutated_settlement = transform.Find("root/root_settlement/photo/mutated").gameObject;
+        photo = transform.Find("root/root_settlement/photo");
+        bg_photo = photo.Find("mask_bg2/icon_fish/Camera/bg_photo").GetComponent<SpriteRenderer>();
+        fishIconRT = transform.Find("root/root_settlement/photo/mask_bg2/icon_fish");
+        avatarCapture = fishIconRT.Find("avatarCapture");
+        avatarEscape = fishIconRT.Find("avatarEscape");
+        rtCamera = fishIconRT.Find("Camera").GetComponent<Camera>();
+        rawImage = transform.Find("root/root_settlement/photo/mask_bg2/RawImage").GetComponent<RawImage>();
+
+        text_num = transform.Find("root/root_settlement/photo/reward/text_num").GetComponent<TMP_Text>();
+        text_num_buff = transform.Find("root/root_settlement/photo/reward/text_num/text_num_buff").GetComponent<TMP_Text>();
+        fx_ui_eventbankheistreward_money_01 = transform.Find("root/root_settlement/particle/fx_ui_eventbankheistreward_money_01").gameObject;
+        btn_close = transform.Find("root/root_settlement/btn_play/btn_green").GetComponent<Button>();
+        bg_extra = transform.Find("root/root_settlement/photo/bonus").gameObject;
+        reward_extra = transform.Find("root/root_settlement/photo/bonus/reward").GetComponent<RewardItemNew>();
+        tag_fish_settlement = transform.Find("root/root_settlement/photo/icon_rate").GetComponent<Image>();
+        text_fish_name_settlement = transform.Find("root/root_settlement/photo/text_name").GetComponent<TMP_Text>();
+        uIDownUp = transform.Find("root/OpenHuntingAim").GetComponent<UIDownUp>();
+        eventFishHuntingAim = transform.Find("root/EventFishHuntingAim").GetComponent<EventFishHuntingAim>();
+        eventFishHuntingAim.eventFishHuntingPanel = this;
+    }
+    private void Start()
+    {
+        GContext.OnEvent<ChangeSmallGameTargetEvent>().Subscribe(ChangeSmallGameTarget).AddTo(disposables);
+        opponentItemData = smallGameData.opponentData;
+
+        playFabId = smallGameData.opponentData.playFabID;
+        GContext.OnEvent<GetClubPlayInfoEvent>().Where(x => x.id == playFabId).Subscribe(SetAvatar).AddTo(disposables);
+        IUserService userService = GContext.container.Resolve<IUserService>();
+        PlayInfo clubPlayInfo = userService.GetPlayInfo(playFabId);
+        SetAvatar(clubPlayInfo);
+        if (GContext.container.Resolve<LeadboardData>().IsOpenleaderboard)
+        {
+            switchbtn.onClick.AddListener(OnClickHead);
+        }
+        else
+        {
+            exchange.SetActive(false);
+            switchbtn.enabled = false;
+            //exchange.SetActive(false);
+        }
+        btn_aim.onClick.AddListener(OnClickAni);
+        btn_close.onClick.AddListener(OnClickClose);
+        uIDownUp.onDown.AddListener(OnDownAim);
+        Debug.Log($"target_source Start isRobot: {opponentItemData.isRobot}  target_group: {opponentItemData.target_group} target_source {opponentItemData.target_source}");
+    }
+
+    void OnClickClose()
+    {
+        GContext.Publish(new UnloadActToNextAct());
+    }
+    bool opening = false;
+    IEnumerator aniCameraMoveCoroutine;
+    void OnDownAim()
+    {
+        opening = true;
+        aniCameraMoveCoroutine = shooterFishAct.AniCameraMove();
+        StartCoroutine(FishHuntingAim());
+        //计时UP
+        uIDownUp.onUp.AddListener(OnUpAim);
+    }
+
+    IEnumerator FishHuntingAim()
+    {
+        yield return StartCoroutine(aniCameraMoveCoroutine);
+        if (!opening)
+        {
+            yield break;
+        }
+        eventFishHuntingAim.gameObject.SetActive(true);
+        float aimTime = eventFishHuntingAim.AimTime;
+        yield return new WaitForSeconds(aimTime);
+        ChangeTarget(null);
+        OnUpAim();
+    }
+
+    public async void OnUpAim()
+    {
+        if (!opening)
+        {
+            return;
+        }
+        uIDownUp.onUp.RemoveAllListeners();
+        OnClickAni();
+        eventFishHuntingAim.isFinish = true;
+        StopAllCoroutines();
+        opening = false;
+        uIDownUp.gameObject.SetActive(false);
+
+        eventFishHuntingAim.Trigger("Aim");
+        if (fishMovement == null)
+        {
+            await StartCoroutine(shooterFishAct.OnBack());
+            eventFishHuntingAim.isFinish = false;
+            eventFishHuntingAim.gameObject.SetActive(false);
+            await Awaiters.Seconds(shooterFishAct.AimBlockTime);
+            uIDownUp.gameObject.SetActive(true);
+        }
+        else
+        {
+            await Awaiters.Seconds(2);
+            eventFishHuntingAim.gameObject.SetActive(false);
+        }
+    }
+
+    async void OnClickAni()
+    {
+        isClick = true;
+        fishMovement = shooterFishAct.Target();
+        if (fishMovement != null)
+        {
+            eventFishHuntingAim.Trigger("Shoot");
+            int getGlodCount = (int)AM.RobFishRequest(changeTargetCount, multiple, playFabId, fishMovement.index, fishMovement.groupId, opponentItemData, out bool isRob, out int addRankCount);
+            await shooterFishAct.OnShoot(isRob);
+            title.SetActive(false);
+            exchange.SetActive(false);
+            btn_aim.gameObject.SetActive(false);
+            UIManager.Instance.DestroyUI(UITypes.EventBankHeistOpponentPopupPanel);
+            ShowFish(isRob);
+
+            await Awaiters.Seconds(shooterFishAct.ShootTime);
+            tag_fish_settlement.sprite = tag_fish.sprite;
+            text_fish_name_settlement.text = text_fish_name.text;
+            mutated_settlement.SetActive(fishMovement.index < fishMovement.slotData.mutants);
+            GContext.Publish(new VibrationData(HapticTypes.MediumImpact));
+            hurt.SetActive(!isRob);
+            kill.SetActive(isRob);
+            fx_ui_eventbankheistreward_money_01.SetActive(isRob);
+            await shooterFishAct.OnShooted(isRob);
+            SetData(getGlodCount, addRankCount);
+
+            var mapData = _tables.TbMapData.DataMap[AM.MapId];
+
+            string prefabName = mapData.AquariumPrefab;
+            Transform bg = photo.Find($"bg_{prefabName}");
+            if (bg != null)
+            {
+                bg_photo.sprite = bg.GetComponent<Image>().sprite;
+            }
+
+            root_settlement.SetActive(true);
+            fish_info.SetActive(false);
+        }
+        else
+        {
+            eventFishHuntingAim.Trigger("Back");
+            ToastPanel.Show(LocalizationMgr.GetText("UI_AquariumPanel_46"));
+        }
+        //exchange.SetActive(false);
+    }
+
+    async void OnClickHead()
+    {
+        //选择对象
+        await UIManager.Instance.ShowUI(UITypes.EventBankHeistOpponentPopupPanel);
+    }
+
+
+    public void ChangeTarget(FishMovement fish)
+    {
+        if (shooterFishAct == null)
+        {
+            return;
+        }
+
+        shooterFishAct.OnTargetChange(fish);
+        if (fish != curTarget)
+        {
+            fish_info.SetActive(fish != null);
+            curTarget = fish;
+            if (curTarget != null)
+            {
+                var item = _tables.TbItem.GetOrDefault(curTarget.slotData.fishItemID);
+                mutated.SetActive(curTarget.slotData.mutants > curTarget.index);
+                text_fish_name.text = LocalizationMgr.GetText(item.Name_l10n_key);
+                GContext.container.Resolve<IUIService>().SetImageSprite(tag_fish, "icon_fish_rate_tag_" + item.Quality);
+            }
+        }
+    }
+
+    async void ChangeSmallGameTarget(ChangeSmallGameTargetEvent data)
+    {
+        //exchange.SetActive(false);
+        switchbtn.enabled = false;
+        if (await data.ts.Task)
+        {
+            changeTargetCount++;
+            opponentItemData = data.opponentItemData;
+            playFabId = data.opponentItemData.playFabID;
+            IUserService userService = GContext.container.Resolve<IUserService>();
+            PlayInfo clubPlayInfo = userService.GetPlayInfo(playFabId);
+            SetAvatar(clubPlayInfo);
+            fish_info.SetActive(false);
+        }
+        //exchange.SetActive(true);
+        switchbtn.enabled = true;
+    }
+
+    public void SetAvatar(PlayInfo clubPlayInfo)
+    {
+        if (clubPlayInfo != null)
+        {
+            text_name.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_29", clubPlayInfo.name);
+            head.SetData(clubPlayInfo.avatarUrl);
+        }
+    }
+    void SetAvatar(GetClubPlayInfoEvent getClubPlayInfoEvent)
+    {
+        if (getClubPlayInfoEvent.id == playFabId)
+        {
+            text_name.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_29", getClubPlayInfoEvent.name);
+            head.SetData(getClubPlayInfoEvent.avatarUrl);
+        }
+    }
+
+
+    private void OnDisable()
+    {
+        if (rt != null)
+        {
+            rt.Release();
+            Destroy(rt);
+            rt = null;
+        }
+        if (fishGo != null)
+        {
+            Destroy(fishGo);
+        }
+        rtCamera.targetTexture = null;
+        disposables?.Dispose();
+        disposables = null;
+    }
+
+
+    GameObject fx_ui_eventbankheistreward_money_01;
+    TMP_Text text_num;
+    TMP_Text text_num_buff;
+    RewardItemNew reward_extra;
+    GameObject bg_extra;
+    int add = 0;
+    Image tag_fish_settlement;
+    TMP_Text text_fish_name_settlement;
+    void ShowFish(bool isRob)
+    {
+        if (fishMovement != null)
+        {
+            RectTransform raw = rawImage.GetComponent<RectTransform>();
+            rt = new RenderTexture((int)raw.rect.width, (int)raw.rect.height, 24, RenderTextureFormat.ARGB32);
+
+            rtCamera.fieldOfView = fieldOfView;
+            rtCamera.enabled = true;
+            var TankPosition = fishMovement.fishData.TankPosition;
+            Vector3 pos = new Vector3(TankPosition[0], TankPosition[1], TankPosition[2] + fishPosZ);
+            Transform avatar = isRob ? avatarCapture : avatarEscape;
+            //rawImage.color = isRob ? Color.white : Color.black;
+            pos += avatar.localPosition;
+            avatar.localPosition = pos;
+            //fishMovement.RemoveEye();
+            fishGo = Instantiate(fishMovement.fish.gameObject, avatar);
+            Fish fish = fishGo.GetComponent<Fish>();
+            fish.animator.transform.localPosition = Vector3.zero;
+            var TankRotation = fishMovement.fishData.TankRotation;
+            fish.transform.localRotation = Quaternion.Euler(TankRotation[0], TankRotation[1], TankRotation[2]);
+            fish.transform.localScale = Vector3.one * fishMovement.fishData.TankScale * fishMovement.mutantScale;
+            //fish.transform.localPosition = pos;
+            rtCamera.targetTexture = rt;
+            rawImage.texture = rt;
+            rtCamera.Render();
+        }
+        //var mapData = _tables.TbMapData.DataMap[AM.MapId];
+        //var AquariumBg = transform.Find($"root/root_settlement/photo/mask_bg2/{mapData.AquariumBg}");
+        //if (AquariumBg != null)
+        //{
+        //    AquariumBg.gameObject.SetActive(true);
+        //}
+    }
+
+    void SetData(int glod, int addRankCount)
+    {
+        //superCashBonus = 0.5f;
+        FishingEventData _fishingEventData = GContext.container.Resolve<FishingEventData>();
+        bool isRankInit = _fishingEventData.rankInit != null;
+        if (isRankInit && addRankCount > 0)
+        {
+            reward_extra.SetData(new ItemData() { id = _fishingEventData.rankInit.TokenID, count = addRankCount });
+            //GContext.container.Resolve<SmallGameData>().image_extra_pos = bg_extra.transform.position;
+            bg_extra.SetActive(true);
+        }
+        else
+        {
+            bg_extra.SetActive(false);
+        }
+        //this.multiple = multiple;
+        add = glod;
+
+        GContext.Publish(new TargetAddData(1002, 0, add));
+        StartCoroutine(ShowMoney());
+    }
+
+    IEnumerator ShowMoney()
+    {
+        text_num.text = "";
+        text_num_buff.text = "";
+        SuperHunt superHunt = GContext.container.Resolve<BuffDataCenter>().GetWeelyBuffTimeData<SuperHunt>(true);
+        float superCashBonus = 0;
+        if (superHunt != null)
+        {
+            superCashBonus = superHunt.CashBonus;
+        }
+        if (superCashBonus > 0.001f)
+        {
+            text_num.color = Color.black;
+            text_num_buff.color = Color.white;
+        }
+        yield return new WaitForSeconds(1.2f);
+        int gold = 0;
+        DOTween.To(() => gold, x => gold = x, add, 1f).OnUpdate(() =>
+        {
+            text_num.text = ConvertTools.GetNumberString2(gold);
+            text_num_buff.text = text_num.text;
+        });
+    }
+}

Assets/Scripts/Aquarium/UI/EventFishHuntingPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/FishSellingPopupPanel.cs

@@ -0,0 +1,119 @@
+using asap.core;
+using GameCore;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class FishSellingPopupPanel : MonoBehaviour
+{
+    Button btn_close;
+    Button btn_sure;
+
+    Transform content;
+    GameObject Item;
+
+    AquariumManager AM;
+    List<SellingPopupItem> items = new List<SellingPopupItem>();
+    Action sellSure;
+    List<AquariumSlotData> slotDataSureList;
+    private void Awake()
+    {
+        AM = GContext.container.Resolve<AquariumManager>();
+        btn_close = transform.Find("btn_close").GetComponent<Button>();
+        btn_sure = transform.Find("root/btn_sure/btn_green").GetComponent<Button>();
+
+        content = transform.Find("root/panel_list/ScrollView/Viewport/Content");
+        Item = content.Find("Item").gameObject;
+        Item.SetActive(false);
+    }
+
+    private void Start()
+    {
+        btn_close.onClick.AddListener(OnClickClose);
+        btn_sure.onClick.AddListener(OnClickSure);
+        ShowFish();
+    }
+    public void Init(Action sellSure)
+    {
+        this.sellSure = sellSure;
+    }
+    void ShowFish()
+    {
+        List<AquariumSlotData> slotDataList = AM.data.slotDatas;
+        if (slotDataList == null)
+        {
+            return;
+        }
+
+        List<AquariumResultData> aquariumResultDatas = AM.data.aquariumResultDatas;
+
+        var time = ZZTimeHelper.UtcNow();
+        for (int i = 0; i < AM.data.slot; i++)
+        {
+            AquariumSlotData slotData = slotDataList[i];
+            if (slotData.FishHatchTime() < time && !slotData.IsResult())
+            {
+                GameObject go = Instantiate(Item, content);
+                go.SetActive(true);
+                SellingPopupItem item = go.GetComponent<SellingPopupItem>();
+                item.SetData(slotData);
+                items.Add(item);
+
+                if (item.bar.IsActive() && slotData.FishGrowthTime() < time)
+                {
+                    item.checkmark.SetActive(true);
+                }
+                else
+                {
+                    item.checkmark.SetActive(false);
+                }
+            }
+        }
+    }
+    async void OnClickSure()
+    {
+        slotDataSureList = new List<AquariumSlotData>();
+        bool isAllMax = true;
+        for (int i = 0; i < items.Count; i++)
+        {
+            if (items[i].IsSell())
+            {
+                slotDataSureList.Add(items[i].slotData);
+                if (!items[i].isMax)
+                {
+                    isAllMax = false;
+                }
+            }
+        }
+        if (slotDataSureList.Count > 0)
+        {
+            if (isAllMax)
+            {
+                Sure();
+            }
+            else
+            {
+                GameObject go = await UIManager.Instance.ShowUI(UITypes.NoticeConfirmPopupPanel);
+                var noticeConfirmPopupPanel = go.GetComponent<NoticeConfirmPopupPanel>();
+                string title = LocalizationMgr.GetText("UI_AquariumPanel_11");
+                string info = LocalizationMgr.GetText("UI_AquariumPanel_12");
+                string right_text = LocalizationMgr.GetText("UI_AquariumPanel_13");
+                string left_text = LocalizationMgr.GetText("UI_COMMON_cancel");
+                noticeConfirmPopupPanel.Init(2,title, info, onClickRight: Sure, btn_left_text: left_text, btn_right_text: right_text);
+            }
+        }
+    }
+
+    void Sure()
+    {
+        AM.SellFish(slotDataSureList);
+        sellSure?.Invoke();
+        UIManager.Instance.DestroyUI(UITypes.FishSellingPopupPanel);
+    }
+
+    void OnClickClose()
+    {
+        UIManager.Instance.DestroyUI(UITypes.FishSellingPopupPanel);
+    }
+}

Assets/Scripts/Aquarium/UI/FishSellingPopupPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/FishcardBenefitPopupPanel.cs

@@ -0,0 +1,58 @@
+using asap.core;
+using cfg;
+using GameCore;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class FishcardBenefitPopupPanel : MonoBehaviour
+{
+    Button btn_close;
+    Button btn_mask;
+    Button btn_go;
+    TMP_Text text_map;
+    TMP_Text text_level;
+    AquariumCardWeight[] aquariumCardWeights;
+    AquariumManager AM;
+    private void Awake()
+    {
+        AM = GContext.container.Resolve<AquariumManager>();
+        btn_close = transform.Find("btn_close").GetComponent<Button>();
+        btn_mask = transform.Find("mask").GetComponent<Button>();
+        text_map = transform.Find("root/bg/map/text_name").GetComponent<TMP_Text>();
+        text_level = transform.Find("root/bg/level/text_num").GetComponent<TMP_Text>();
+        aquariumCardWeights = transform.Find("root/bg/weight_bonus").GetComponentsInChildren<AquariumCardWeight>();
+        btn_go = transform.Find("root/bg/btn_go/btn_green").GetComponent<Button>();
+    }
+    void Start()
+    {
+        Tables _tables = GContext.container.Resolve<Tables>();
+        btn_close.onClick.AddListener(OnClickClose);
+        btn_mask.onClick.AddListener(OnClickClose);
+        var mapData = _tables.TbMapData.DataMap[AM.MapId];
+        text_map.text = LocalizationMgr.GetText(mapData.Name_l10n_key);
+        //string levelLV = LocalizationMgr.GetText("UI_FishingMapPanel_101006");
+        int fishCardLevel = GContext.container.Resolve<PlayerFishData>().GetFishLevelByMap(AM.MapId);
+
+        List<float> weight = AM.GetWeightMag();
+
+        text_level.text = /*levelLV +*/ fishCardLevel.ToString();
+        for (int i = 0; i < aquariumCardWeights.Length; i++)
+        {
+            aquariumCardWeights[i].text_level.text = weight[i].ToPercentageString();
+        }
+        btn_go.onClick.AddListener(GoTO);
+    }
+
+    async void GoTO()
+    {
+        await UIManager.Instance.ShowUI(UITypes.FishingMapPanel);
+        OnClickClose();
+    }
+
+    void OnClickClose()
+    {
+        UIManager.Instance.DestroyUI(UITypes.FishcardBenefitPopupPanel);
+    }
+}

Assets/Scripts/Aquarium/UI/FishcardBenefitPopupPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/IAquariumTips.cs

@@ -0,0 +1,9 @@
+
+using System;
+
+public interface IAquariumTips
+{
+    void SetData(AquariumSlot aquariumSlot);
+    bool UpdateBar(DateTime dateTime);
+    void SetActive(bool value);
+}

Assets/Scripts/Aquarium/UI/IAquariumTips.cs.meta

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

Assets/Scripts/Aquarium/UI/SellingPopupItem.cs

@@ -0,0 +1,198 @@
+using asap.core;
+using cfg;
+using GameCore;
+using System;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class SellingPopupItem : MonoBehaviour
+{
+    public Button btn_toggle;
+    public GameObject checkmark;
+    public GameObject icon_hurt;
+    public GameObject icon_killed;
+    public Image bar;
+    public Image bar_hurt;
+    public Image icon_fish;
+    public GameObject done;
+    public Image icon_rate;
+    public TMP_Text text_time;
+    public GameObject recoverting;
+    public TMP_Text text_time2;
+    public GameObject text_max;
+    public TMP_Text text_cash;
+    public GameObject killed;
+    public TMP_Text text_killed;
+    public AquariumSlotData slotData;
+    AquariumFish aquariumFish;
+    DateTime StartTime;
+    float injuryH;
+    float baseRewardCount;
+    float allRewardCount;
+    float WeightIncEvent;
+    AquariumManager AM;
+    AquariumResultData aquariumResultDatas;
+    [HideInInspector]
+    public bool isMax;
+    private void Awake()
+    {
+        btn_toggle.onClick.AddListener(Click);
+    }
+
+    void Click()
+    {
+        if (aquariumResultDatas != null && aquariumResultDatas.IsResult())
+        {
+            ToastPanel.Show(LocalizationMgr.GetText("UI_ToastPanel_97"));
+            return;
+        }
+        checkmark.SetActive(!checkmark.activeSelf);
+    }
+    public bool IsSell()
+    {
+        return aquariumResultDatas == null || checkmark.activeSelf && !aquariumResultDatas.IsResult();
+    }
+    public void SetData(AquariumSlotData slotData)
+    {
+        AM = GContext.container.Resolve<AquariumManager>();
+        aquariumResultDatas = AM.data.aquariumResultDatas[slotData.index];
+
+        this.slotData = slotData;
+        aquariumFish = GContext.container.Resolve<Tables>().TbAquariumFish.GetOrDefault(slotData.aquariumFishID);
+        StartTime = slotData.FishHatchTime();
+        injuryH = slotData.injuryGrowthTime;
+        Item item = GContext.container.Resolve<Tables>().TbItem.GetOrDefault(slotData.fishItemID);
+        PlayerFishData.SetFishIcon(icon_fish, item);//鱼头像
+        GContext.container.Resolve<IUIService>().SetImageSprite(icon_rate, $"icon_fish_rate_tag_{item.Quality}");
+
+        PlayerData playerData = GContext.container.Resolve<PlayerData>();
+        var weight = GContext.container.Resolve<AquariumManager>().GetWeightMag();
+        WeightIncEvent = (1 + weight[slotData.aquariumFishID - 1]) * (1 + playerData.benefitsCashMag) * (1 + playerData.benefitsAquariumCashMag);
+
+        //金币显示
+        baseRewardCount = slotData.allCash;
+        allRewardCount = 0;
+        int fishQ = slotData.fishMQ;
+        for (int i = 0; i < fishQ; i++)
+        {
+            if (slotData.mutants > i)
+            {
+                allRewardCount += baseRewardCount * WeightIncEvent * (1 + aquariumFish.MutantExtraSoldReward) * (1 + aquariumFish.MutantGrowthExtraSoldReward);
+            }
+            else
+            {
+                allRewardCount += baseRewardCount * WeightIncEvent * (1 + aquariumFish.GrowthExtraSoldReward);
+            }
+        }
+
+        UpdateBar(ZZTimeHelper.UtcNow());
+    }
+    public void UpdateBar(DateTime dateTime)
+    {
+        //正常的成长进度 自然时间+加速成长 - 全部恢复时间
+        float normalH = (float)(dateTime - StartTime).TotalHours + slotData.accelerationGrowth - slotData.allRecoveryTime;
+        //受伤时的成长进度
+
+        //受伤时的成长进度大于正常的成长进度
+        float timeProgress;
+        float barProgress;
+        bar_hurt.gameObject.SetActive(false);
+        icon_hurt.gameObject.SetActive(false);
+        text_time.gameObject.SetActive(true);
+        text_max.gameObject.SetActive(false);
+        text_time.gameObject.SetActive(true);
+        recoverting.gameObject.SetActive(false);
+        isMax = false;
+        timeProgress = normalH / slotData.growthTime;
+        bar.gameObject.SetActive(true);
+        if (aquariumResultDatas.IsResult())
+        {
+            bar.gameObject.SetActive(false);
+            done.SetActive(true);
+            killed.SetActive(true);
+            text_time.gameObject.SetActive(false);
+            AquariumResultData aquariumResultDatas = AM.data.aquariumResultDatas[slotData.index];
+            text_killed.text = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_42", aquariumResultDatas.displayName);
+        }
+        else
+        {
+            bar.fillAmount = 1;
+
+            if (injuryH > normalH)
+            {
+                text_time.gameObject.SetActive(false);
+                recoverting.gameObject.SetActive(true);
+                bar.gameObject.SetActive(false);
+                bar_hurt.gameObject.SetActive(true);
+                icon_hurt.gameObject.SetActive(true);
+                bar_hurt.fillAmount = (injuryH - normalH) / slotData.recoveryTime;
+                barProgress = injuryH / slotData.growthTime;
+                if (barProgress > 1)
+                {
+                    timeProgress = 1 - ((injuryH - normalH) / slotData.growthTime);
+                }
+
+                int timeRemaining = (int)((injuryH - normalH) * 3600);
+                TimeSpan timeSpan = new TimeSpan(0, 0, timeRemaining);
+                text_time2.text = ConvertTools.ConvertTime2(timeSpan);
+
+                if (timeProgress < 0)
+                {
+                    timeProgress = 0;
+                }
+            }
+            else if (normalH >= slotData.growthTime)
+            {
+                text_time.gameObject.SetActive(false);
+                text_max.gameObject.SetActive(true);
+                timeProgress = 1;
+                barProgress = 1;
+                isMax = true;
+            }
+            else
+            {
+
+                barProgress = normalH / slotData.growthTime;
+                bar.fillAmount = barProgress;
+            }
+
+            if (timeProgress < 1)
+            {
+                int timeRemaining = (int)(slotData.growthTime * (1 - timeProgress) * 3600);
+                TimeSpan timeSpan = new TimeSpan(0, 0, timeRemaining);
+                text_time.text = ConvertTools.ConvertTime2(timeSpan);
+            }
+        }
+
+        float rewardProgress = timeProgress;// normalH / slotData.growthTime;
+        if (rewardProgress > 1)
+        {
+            rewardProgress = 1;
+        }
+        //金币显示
+        int fishQ = slotData.fishMQ;
+        if (injuryH > normalH)
+        {
+            fishQ -= GContext.container.Resolve<AquariumManager>().data.aquariumHurtDatas[slotData.index].fishLQ;
+            if (fishQ <= 0)
+            {
+                fishQ = 1;
+            }
+        }
+        float rewardCount = 0;
+        for (int i = 0; i < fishQ; i++)
+        {
+            if (slotData.mutants > i)
+            {
+                rewardCount += baseRewardCount * (1 + aquariumFish.MutantExtraSoldReward) * (1 + aquariumFish.MutantGrowthExtraSoldReward * rewardProgress) * WeightIncEvent;
+            }
+            else
+            {
+                rewardCount += baseRewardCount * (1 + aquariumFish.GrowthExtraSoldReward * rewardProgress) * WeightIncEvent;
+            }
+        }
+
+        text_cash.text = $"{ConvertTools.GetNumberString2((int)(rewardCount))}/{ConvertTools.GetNumberString2((int)allRewardCount)}";
+    }
+}

Assets/Scripts/Aquarium/UI/SellingPopupItem.cs.meta

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

Assets/Scripts/Aquarium/UI/SpeedupPopupPanel.cs

@@ -0,0 +1,146 @@
+using asap.core;
+using cfg;
+using game;
+using GameCore;
+using System;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class SpeedupPopupPanel : MonoBehaviour
+{
+    AdvertButton advertButton;
+    Button freeButton;
+    Button btn_diamonds;
+    Button btn_diamonds_gray;
+    TMP_Text text_info;
+    TMP_Text p_text_num;
+    TMP_Text p_text_num_gray;
+
+    Button btn_close;
+    Action OnSucceedCall;
+    Action<bool> StartSeedUp;
+    TMP_Text p_text;
+    TMP_Text p_text1;
+    TMP_Text text_time;
+    GameObject speedupPopupPanel;
+    GameObject aquariumSpeedupPanel;
+    private void Awake()
+    {
+        speedupPopupPanel = transform.Find("SpeedupPopupPanel").gameObject;
+        aquariumSpeedupPanel = transform.Find("AquariumSpeedupPanel").gameObject;
+        btn_diamonds = transform.Find("SpeedupPopupPanel/root/btn_diamonds/btn_adv").GetComponent<Button>();
+        btn_diamonds_gray = transform.Find("SpeedupPopupPanel/root/btn_diamonds_gray/btn_adv").GetComponent<Button>();
+        advertButton = transform.Find("SpeedupPopupPanel/root/btn_advert").GetComponent<AdvertButton>();
+        btn_close = transform.Find("SpeedupPopupPanel/btn_close").GetComponent<Button>();
+        text_info = transform.Find("SpeedupPopupPanel/root/bg_time/text_time").GetComponent<TMP_Text>();
+        p_text = transform.Find("SpeedupPopupPanel/root/btn_advert/btn_adv/Ani_Container/p_text").GetComponent<TMP_Text>();
+        p_text1 = transform.Find("SpeedupPopupPanel/root/btn_advert/btn_ticket/Ani_Container/p_text").GetComponent<TMP_Text>();
+        p_text_num = transform.Find("SpeedupPopupPanel/root/btn_diamonds/btn_adv/Ani_Container/content_cost/cost/p_text_num").GetComponent<TMP_Text>();
+        p_text_num_gray = transform.Find("SpeedupPopupPanel/root/btn_diamonds_gray/btn_adv/Ani_Container/content_cost/cost/p_text_num").GetComponent<TMP_Text>();
+        text_time = transform.Find("SpeedupPopupPanel/root/text_time").GetComponent<TMP_Text>();
+        freeButton = transform.Find("SpeedupPopupPanel/root/btn_free").GetComponent<Button>();
+    }
+    private void Start()
+    {
+        bool isGuide = GContext.container.Resolve<GuideDataCenter>().InspectTriggerGuide("SpeedupPopupPanel");
+        p_text_num_gray.text = p_text_num.text = GContext.container.Resolve<Tables>().TbAquariumConfig.AdAccelerateDiamondCost.ToString();
+        btn_close.onClick.AddListener(OnClickClose);
+        Tables tables = GContext.container.Resolve<Tables>();
+        string contnet = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_16", tables.TbAquariumConfig.AdAccelerate * 60);
+        if (isGuide)
+        {
+            //advertButton.SetData(null, AdvertPopupType.Aquarium);
+            //advertButton.advBtn.onClick.AddListener(GuideAdsSucceed);
+            freeButton.onClick.AddListener(GuideAdsSucceed);
+            //p_text1.text = p_text.text = LocalizationMgr.GetText("UI_BattlePassPanel_3");
+            contnet = LocalizationMgr.GetFormatTextValue("UI_AquariumPanel_16", tables.TbAquariumConfig.AdAccelerateFirst * 60);
+        }
+        else
+        {
+            advertButton.SetData(OnAdsSucceed, AdvertPopupType.Aquarium);
+        }
+        advertButton.gameObject.SetActive(!isGuide);
+        freeButton.gameObject.SetActive(isGuide);
+        btn_diamonds.onClick.AddListener(OnClickDiamonds);
+        advertButton.advBtnGray.onClick.AddListener(ShowToast);
+        btn_diamonds_gray.onClick.AddListener(ShowToast);
+        text_info.text = contnet;
+    }
+    public void SetData(Action onSucceed, Action<bool> startSeedUp, string adContent)
+    {
+        if (onSucceed == null)
+        {
+            advertButton.SetGray();
+        }
+        btn_diamonds.gameObject.SetActive(onSucceed != null);
+        btn_diamonds_gray.gameObject.SetActive(onSucceed == null);
+        OnSucceedCall = onSucceed;
+        StartSeedUp = startSeedUp;
+        text_time.text = adContent;
+    }
+
+    void ShowToast()
+    {
+        ToastPanel.Show(LocalizationMgr.GetText("UI_ToastPanel_60"));
+    }
+
+    void OnClickDiamonds()
+    {
+        if (OnSucceedCall == null)
+        {
+            ShowToast();
+            return;
+        }
+        var curDiamond = GContext.container.Resolve<PlayerData>().diamond;
+        int diamondCost = GContext.container.Resolve<Tables>().TbAquariumConfig.AdAccelerateDiamondCost;
+        if (curDiamond >= diamondCost)
+        {
+            GContext.container.Resolve<PlayerData>().AddDiamond(-diamondCost);
+            OnSucceed(false);
+#if AGG
+            using (var e = GEvent.GameEvent("aquarium_speedup"))
+            {
+                e.AddContent("speedup_type", 1);
+            }
+#endif
+        }
+        else
+        {
+            //_ = UIManager.Instance.ShowUI(UITypes.LackOfResourceConfirmPopupPanel);
+            ToastPanel.Show(LocalizationMgr.GetText("UI_ToastPanel_59"));
+        }
+    }
+    void GuideAdsSucceed()
+    {
+        OnSucceed(true);
+    }
+    void OnAdsSucceed()
+    {
+        OnSucceed(false);
+#if AGG
+        using (var e = GEvent.GameEvent("aquarium_speedup"))
+        {
+            e.AddContent("speedup_type", 2);
+        }
+#endif
+    }
+    async void OnSucceed(bool isGuide)
+    {
+        StartSeedUp?.Invoke(isGuide);
+        speedupPopupPanel.SetActive(false);
+        aquariumSpeedupPanel.SetActive(true);
+        await Awaiters.Seconds(2f);
+        OnSucceedCall?.Invoke();
+        await Awaiters.Seconds(0.5f);
+        UIManager.Instance.DestroyUI(UITypes.SpeedupPopupPanel);
+    }
+    void OnClickClose()
+    {
+        UIManager.Instance.DestroyUI(UITypes.SpeedupPopupPanel);
+    }
+    private void OnDestroy()
+    {
+        GContext.container.Resolve<GuideDataCenter>().InspectTriggerGuide("AquariumPanel");
+    }
+}

Assets/Scripts/Aquarium/UI/SpeedupPopupPanel.cs.meta

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

Assets/Scripts/Aquarium/UI/UIDownUp.cs

@@ -0,0 +1,29 @@
+using UnityEngine;
+using UnityEngine.EventSystems;
+using static UnityEngine.UI.Button;
+
+public class UIDownUp : MonoBehaviour, IPointerDownHandler, IPointerUpHandler
+{
+    private ButtonClickedEvent m_OnDown = new ButtonClickedEvent();
+    private ButtonClickedEvent m_OnUp = new ButtonClickedEvent();
+    public ButtonClickedEvent onDown
+    {
+        get { return m_OnDown; }
+        set { m_OnDown = value; }
+    }
+
+    public ButtonClickedEvent onUp
+    {
+        get { return m_OnUp; }
+        set { m_OnUp = value; }
+    }
+    public void OnPointerDown(PointerEventData eventData)
+    {
+        m_OnDown.Invoke();
+    }
+
+    public void OnPointerUp(PointerEventData eventData)
+    {
+        m_OnUp.Invoke();
+    }
+}

Assets/Scripts/Aquarium/UI/UIDownUp.cs.meta

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