Liubing\LB
3d8d4d18f3
先修复一下，错误的场景 删除不必要的钓场资产 修复into场景 update:更新meta文件，修复报错 update:修复资源 修复第一章节建造 修复建造第三章 update:删除多余内容 update:更新README.md update:还原图标 update:更新README update:更新配置
2428 lines
89 KiB
C#
2428 lines
89 KiB
C#
using asap.core;
|
||
using cfg;
|
||
using DG.Tweening;
|
||
using Game;
|
||
using GameCore;
|
||
using System;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.Threading.Tasks;
|
||
using UniRx;
|
||
using UnityEngine;
|
||
using UnityEngine.AddressableAssets;
|
||
using Random = UnityEngine.Random;
|
||
|
||
public class GetFishingBehaviorB
|
||
{
|
||
public FishingBehaviorB fishingBehavior;
|
||
}
|
||
public class ShowHandEvent
|
||
{
|
||
public bool isShow;
|
||
}
|
||
[DefaultExecutionOrder(10000)]
|
||
public partial class FishingBehaviorB : MonoBehaviour
|
||
{
|
||
Tables _tables;
|
||
[Header("RELATED OBJECT SETTINGS")]
|
||
[SerializeField]
|
||
private GameObject _bait;
|
||
GameObject baitAB;
|
||
|
||
public GameObject GetBait => _bait;
|
||
[SerializeField] private GameObject _fish;
|
||
[NonSerialized] public Transform FishAnimationRoot;
|
||
public FishCome fishCome;
|
||
[NonSerialized] public Transform FishComeAnimationRoot;
|
||
public GameObject GetFish => _fish;
|
||
|
||
private Vector3 _baitFowardDirection;
|
||
|
||
[Header("FISHINGROD SETTINGS")]
|
||
//相机初始化
|
||
public Animator _cameraAnimator;
|
||
public Animator cameraAnimator => _cameraAnimator;
|
||
int rodType;
|
||
public int RodType => rodType;
|
||
[SerializeField] private GameObject _fishingRodHandle;
|
||
public Animator rodHandleAni;
|
||
|
||
private Vector3 _targetPos;
|
||
[NonSerialized] public Animator fishingRodAnimator;
|
||
[NonSerialized] public Animator fishAnimator;
|
||
[NonSerialized] public Fish FishBehaviour;
|
||
Material F_whitemarli_P;
|
||
GameObject FxChangeFish;
|
||
bool isShowFish = false;
|
||
[NonSerialized] public Fish FishSwimBehaviour;
|
||
//private Bait BaitBehaviour;
|
||
[NonSerialized] public Rod RodBehaviour;
|
||
GameObject rodPrefab;
|
||
[Header("FISHING LINE SETTINGS")]
|
||
[Tooltip("_lineResolution:The length of the line section depends on the distance. X = close, Y = far")]
|
||
[SerializeField]
|
||
private Vector2 _lineResolution; // 钓鱼线的分辨率
|
||
|
||
[SerializeField] private Transform _lineStartPos; // 钓鱼线的起始位置
|
||
[SerializeField] private Vector2 _lineStartOffsetScreen = new Vector2(0.3f, 1.5f); //鱼线起始位置停留位置偏移
|
||
[SerializeField] private float _lineMoveTimer = 1f; //鱼线移动时间
|
||
|
||
FishingBehaviorConf fishingBehaviorConf;
|
||
[Space(10)]
|
||
|
||
//相机偏转最大角度
|
||
[SerializeField]
|
||
private float _cameraMaxAngel = 11f; //相机偏转最大角度
|
||
|
||
//相机偏转最大角度鱼的X轴偏移
|
||
[SerializeField] private float _cameraMaxAngelOffset = 15f; //相机偏转最大角度鱼的X轴偏移
|
||
|
||
[Space(10)]
|
||
//水面高度
|
||
[SerializeField] private float _waterHeight = -2.7f; //水面高度
|
||
|
||
//鱼游动区域
|
||
|
||
float _fishSwimAreaZFar = 75f; //鱼游动Z轴远端
|
||
float _fishSwimAreaZNear = 15f; //鱼游动Z轴近端
|
||
float _fishSwimAreaXFar = 17.5f; //鱼游动X轴远端
|
||
float _fishSwimAreaXNear = 5f; //鱼游动X轴近端
|
||
|
||
public float fishSwimAreaZFar => _fishSwimAreaZFar;
|
||
public float fishSwimAreaZNear => _fishSwimAreaZNear;
|
||
|
||
HandController HandController;
|
||
GameObject handAB;
|
||
//=============================================================================================
|
||
|
||
private Dictionary<string, GameObject> _effectDic = new Dictionary<string, GameObject>();
|
||
[NonSerialized] public GameObject _curFishEffect;
|
||
//_drawing
|
||
[NonSerialized] public GameObject fx_fishing_splashloop;
|
||
[NonSerialized] public GameObject fx_fishing_splashwaveloop;
|
||
[NonSerialized] public GameObject fx_fishing_splashloopreeling;
|
||
[NonSerialized] public GameObject fx_fishing_jumpout;
|
||
[NonSerialized] public GameObject fx_fishing_jumpinto;
|
||
[NonSerialized] public GameObject fx_fishing_splashinto;
|
||
|
||
GameObject fxWaterDrop;
|
||
//_drawing
|
||
private int Count = 20;
|
||
//private float ReelVibrationInterval = 0;
|
||
private DropAfterDrop dropAfterDrop = null;
|
||
Transform dropAfterDropParent = null;
|
||
GameObject collectingEffect = null;
|
||
public Vector3 image_extra_pos { set; get; }
|
||
GameObject FishPrefab;
|
||
GameObject FishSwimPrefab;
|
||
public GameObject fx_fishbosscome;
|
||
GameObject curFish;
|
||
string currentFishPath;
|
||
string currentSwimFishPath;
|
||
// 参数设置
|
||
private float _simulateGravityOnLine = -0.7f; // 模拟重力
|
||
private float _currentGravityOnLine = 0f; // 当前重力
|
||
private float _gravityonLineTimer = 0f; // 重力计时器
|
||
|
||
public float LineDistance { get; private set; }
|
||
|
||
private Vector3 _endLinePos; //结束时鱼线的位置
|
||
|
||
//================================================================================================
|
||
|
||
[Space(10)]
|
||
//代码设置属性
|
||
private bool _isChangelineStartPos = false;
|
||
public bool IsChangelineStartPos { set { _isChangelineStartPos = value; } }
|
||
private bool _isCastLine;
|
||
//mainCamera 是否对准鱼
|
||
public bool CameraToFish { set; get; }
|
||
public Vector3 GetFishPos()
|
||
{
|
||
if (FishBehaviour == null)
|
||
{
|
||
return _fish.transform.position;
|
||
}
|
||
if (FishBehaviour.mouthPos == null)
|
||
{
|
||
return FishBehaviour.transform.position;
|
||
}
|
||
return FishBehaviour.mouthPos.transform.position;
|
||
}
|
||
//UI吃鱼大鱼游过来
|
||
[NonSerialized] public bool NotMove = false;
|
||
FishingData fishingData;
|
||
|
||
CollectingData collectingData;
|
||
float FinUnderwaterOffset;
|
||
protected CompositeDisposable disposables = new CompositeDisposable();
|
||
|
||
private void OnEnable()
|
||
{
|
||
StartRodSpidleTime();
|
||
rodHandleAni = _fishingRodHandle.GetComponent<Animator>();
|
||
fishAnimator = _fish.transform.GetComponent<Animator>();
|
||
SetRodType();
|
||
}
|
||
public void Init()
|
||
{
|
||
fishingData = GContext.container.Resolve<FishingData>();
|
||
fishingBehaviorConf = fishingData.fishingBehaviorConf;
|
||
collectingData = GContext.container.Resolve<CollectingData>();
|
||
GContext.OnEvent<IsCancelledEvent>().Subscribe((e) =>
|
||
{
|
||
IsCancelled();
|
||
}).AddTo(disposables);
|
||
GContext.OnEvent<IsRecastEvent>().Subscribe((e) =>
|
||
{
|
||
IsRecast(e.isRecast);
|
||
}).AddTo(disposables); ;
|
||
|
||
GContext.OnEvent<GetFishingBehaviorB>().Subscribe((e) =>
|
||
{
|
||
e.fishingBehavior = this;
|
||
}).AddTo(disposables);
|
||
|
||
GContext.OnEvent<ShowHandEvent>().Subscribe(OnEnableHand).AddTo(disposables);
|
||
|
||
var _camera = _cameraAnimator.transform.Find("Camera");
|
||
fishingData.SetCamera(_camera);
|
||
LoadBait();
|
||
LoadEffect();
|
||
fishAnimator = _fish.transform.GetComponent<Animator>();
|
||
FishAnimationRoot = _fish.transform.Find("FishAnimationRoot");
|
||
FishComeAnimationRoot = fishCome.transform.Find("FishAnimationRoot");
|
||
_tables = GContext.container.Resolve<Tables>();
|
||
//初始地图配置
|
||
var SwimmingAreaX = fishingData.SwimmingAreaX();
|
||
var SwimmingAreaZ = fishingData.SwimmingAreaZ();
|
||
_fishSwimAreaXNear = SwimmingAreaX[0];
|
||
_fishSwimAreaXFar = SwimmingAreaX[1];
|
||
_fishSwimAreaZNear = SwimmingAreaZ[0];
|
||
_fishSwimAreaZFar = SwimmingAreaZ[1];
|
||
_cameraMaxAngel = ConvertTools.CalculateActualRotationAngle(fishingData.CameraMaxAngle());
|
||
_cameraMaxAngelOffset = fishingData.FishMaxAngle();
|
||
rodHandleAni = _fishingRodHandle.GetComponent<Animator>();
|
||
}
|
||
public async Task LoadHand()
|
||
{
|
||
GloveData gloveData = GContext.container.Resolve<PlayerFishData>().GetGloveData;
|
||
string path = gloveData.Fbx;
|
||
|
||
if (handAB != null)
|
||
{
|
||
Addressables.ReleaseInstance(handAB);
|
||
}
|
||
handAB = await Addressables.InstantiateAsync(gloveData.Fbx, transform).Task;
|
||
if (handAB != null)
|
||
{
|
||
HandController = handAB.GetComponent<HandController>();
|
||
if (RodBehaviour != null)
|
||
{
|
||
HandController.SetHandTargets(RodBehaviour.RightHandTargets, RodBehaviour.LeftHandTargets, RodBehaviour.BodyTargets);
|
||
}
|
||
}
|
||
}
|
||
async void LoadBait()
|
||
{
|
||
baitAB = await Addressables.InstantiateAsync("BaitRoot", _bait.transform).Task;
|
||
baitAB.transform.localPosition = Vector3.zero;
|
||
baitAB.transform.localRotation = Quaternion.identity;
|
||
baitAB.transform.localScale = Vector3.one;
|
||
}
|
||
public float GetSpeedHpCurveValue(float key)
|
||
{
|
||
return fishingBehaviorConf.speedHpCurve.Evaluate(key);
|
||
}
|
||
public void OnFishingEnable()
|
||
{
|
||
//初始化鱼饵组件、投掷位置、方向
|
||
_baitFowardDirection = _fishingRodHandle.transform.forward;
|
||
_baitFowardDirection = Quaternion.AngleAxis(-90, Vector3.up) * _baitFowardDirection;
|
||
}
|
||
public async void GMInitFishAsync(string path, float scale)
|
||
{
|
||
currentFishPath = path;
|
||
//准备开始钓鱼
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.gameObject.SetActive(false);
|
||
if (FishBehaviour.modeGo)
|
||
{
|
||
Addressables.ReleaseInstance(FishBehaviour.modeGo);
|
||
}
|
||
Addressables.Release(FishPrefab);
|
||
DestroyImmediate(FishBehaviour.gameObject);
|
||
FishBehaviour = null;
|
||
}
|
||
Transform parent = _fish.transform.Find("FishAnimationRoot");
|
||
var fishPrefab = await Addressables.LoadAssetAsync<GameObject>(path).Task;
|
||
if (fishPrefab != null)
|
||
{
|
||
if (currentFishPath != path || FishBehaviour != null)
|
||
{
|
||
Addressables.Release(fishPrefab);
|
||
return;
|
||
}
|
||
var go = Instantiate(fishPrefab, parent);
|
||
if (go == null)
|
||
return;
|
||
go.transform.localPosition = Vector3.zero;
|
||
FishPrefab = fishPrefab;
|
||
FishBehaviour = go.GetComponent<Fish>();
|
||
FishBehaviour.transform.localScale = Vector3.one * scale;
|
||
Vector3 vector3 = Vector3.zero;
|
||
if (FishBehaviour.mouthPos != null)
|
||
{
|
||
FishBehaviour.animator.Play("Idle01", 0, 0);
|
||
vector3 = -FishBehaviour.animator.transform.InverseTransformPoint(FishBehaviour.mouthPos.position);
|
||
vector3.z = -vector3.z;
|
||
}
|
||
FishBehaviour.animator.transform.localPosition = vector3;
|
||
FishBehaviour.transform.localRotation = Quaternion.identity;
|
||
GContext.Publish(new FishRotateEvent(0, 1, rodType));
|
||
}
|
||
}
|
||
public void InitFishAsync(string path, float scale, bool isShow, DropAfterDrop dropAfterDrop = null)
|
||
{
|
||
currentFishPath = path;
|
||
//准备开始钓鱼
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.gameObject.SetActive(false);
|
||
if (FishBehaviour.modeGo)
|
||
{
|
||
Addressables.ReleaseInstance(FishBehaviour.modeGo);
|
||
}
|
||
Addressables.Release(FishPrefab);
|
||
DestroyImmediate(FishBehaviour.gameObject);
|
||
FishBehaviour = null;
|
||
}
|
||
LoadFish(path, scale, isShow, dropAfterDrop: dropAfterDrop);
|
||
if (isShow)
|
||
{
|
||
ShowDefaultFish();
|
||
}
|
||
}
|
||
public void DestroySwimFish()
|
||
{
|
||
if (FishSwimBehaviour != null)
|
||
{
|
||
FishSwimBehaviour.gameObject.SetActive(false);
|
||
Addressables.Release(FishSwimPrefab);
|
||
DestroyImmediate(FishSwimBehaviour.gameObject);
|
||
FishSwimBehaviour = null;
|
||
}
|
||
currentSwimFishPath = null;
|
||
if (fx_fishbosscome != null)
|
||
{
|
||
Addressables.ReleaseInstance(fx_fishbosscome);
|
||
DestroyImmediate(fx_fishbosscome);
|
||
fx_fishbosscome = null;
|
||
}
|
||
}
|
||
public async void InitSwimFishAsync(FishData swimFishData)
|
||
{
|
||
if (fishCome == null)
|
||
{
|
||
return;
|
||
}
|
||
var path = swimFishData.Fbx;
|
||
var scale = swimFishData.CruiseScale;
|
||
if (currentSwimFishPath != path)
|
||
{
|
||
currentSwimFishPath = path;
|
||
//准备开始钓鱼
|
||
if (FishSwimBehaviour != null)
|
||
{
|
||
FishSwimBehaviour.gameObject.SetActive(false);
|
||
Addressables.ReleaseInstance(fx_fishbosscome);
|
||
Addressables.Release(FishSwimPrefab);
|
||
DestroyImmediate(FishSwimBehaviour.gameObject);
|
||
FishSwimBehaviour = null;
|
||
fx_fishbosscome = null;
|
||
}
|
||
Transform parent = fishCome.transform.Find("FishAnimationRoot");
|
||
|
||
var fishPrefab = await Addressables.LoadAssetAsync<GameObject>(path).Task;
|
||
if (fishPrefab != null)
|
||
{
|
||
if (currentSwimFishPath != path)
|
||
{
|
||
Addressables.Release(fishPrefab);
|
||
return;
|
||
}
|
||
var go = Instantiate(fishPrefab, parent);
|
||
if (go != null)
|
||
{
|
||
go.SetActive(false);
|
||
go.transform.localPosition = Vector3.zero;
|
||
FishSwimPrefab = fishPrefab;
|
||
FishSwimBehaviour = go.GetComponent<Fish>();
|
||
Vector3 vector3 = Vector3.zero;
|
||
if (FishSwimBehaviour.mouthPos != null)
|
||
{
|
||
vector3 = -FishSwimBehaviour.animator.transform.InverseTransformPoint(FishSwimBehaviour.mouthPos.position);
|
||
vector3.z = -vector3.z;
|
||
}
|
||
FishSwimBehaviour.animator.transform.localPosition = vector3;
|
||
FishSwimBehaviour.transform.localRotation = Quaternion.identity;
|
||
FishSwimBehaviour.transform.localScale = Vector3.one * scale;
|
||
FishSwimBehaviour.FishAnimSpeed = swimFishData.AnimSpeed;
|
||
fishCome.animator.speed = swimFishData.AnimSpeed;
|
||
fx_fishbosscome = await Addressables.InstantiateAsync("fx_fishing_fishbosscome", transform).Task;
|
||
if (fx_fishbosscome)
|
||
{
|
||
fx_fishbosscome.transform.localScale = Vector3.one * swimFishData.SlashFxScale;
|
||
fx_fishbosscome.SetActive(false);
|
||
}
|
||
float offset = fishingData.swimFishData.UnderwaterOffset;
|
||
if (FishSwimBehaviour != null && FishSwimBehaviour.Fin != null)
|
||
{
|
||
offset -= FishSwimBehaviour.Fin.position.y - fishCome.transform.position.y;
|
||
}
|
||
fishCome.SetPosY(offset);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
public void SetFishScale(float fishScale)
|
||
{
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.transform.localScale = Vector3.one * fishScale;
|
||
}
|
||
}
|
||
|
||
void SetRodType()
|
||
{
|
||
cameraAnimator.SetInteger("_rodtype", rodType);
|
||
rodHandleAni.SetInteger("_rodtype", rodType);
|
||
fishAnimator.SetInteger("_rodtype", rodType);
|
||
}
|
||
|
||
public async System.Threading.Tasks.Task InitFishRodAsync(RodData fishRodData)
|
||
{
|
||
rodType = (int)fishRodData.Type;
|
||
fishingData.rodType = rodType;
|
||
SetRodType();
|
||
|
||
int skindID = GContext.container.Resolve<PlayerFishData>().GetRodSkin(fishRodData.ID);
|
||
if (skindID <= 0)
|
||
{
|
||
return;
|
||
}
|
||
var fishRodSkinData = _tables.TbRodSkinData.GetOrDefault(skindID);
|
||
if (fishRodSkinData == null)
|
||
{
|
||
return;
|
||
}
|
||
string path = fishRodSkinData.Fbx;
|
||
|
||
float FishingScale = fishRodSkinData.FishingScale;
|
||
var goPrefab = await Addressables.LoadAssetAsync<GameObject>(path).Task;
|
||
if (goPrefab == null)
|
||
{
|
||
Debug.LogError("Load Rod Elemental as Default Rod");
|
||
goPrefab = await Addressables.LoadAssetAsync<GameObject>("Rod_elemental").Task;
|
||
}
|
||
_bait.transform.SetParent(transform);
|
||
if (goPrefab != null)
|
||
{
|
||
if (rodPrefab)
|
||
{
|
||
Addressables.Release(rodPrefab);
|
||
}
|
||
rodPrefab = goPrefab;
|
||
var go = Instantiate(goPrefab, transform.Find("FishingRodHandle")); //await Addressables.InstantiateAsync(path, transform.Find("FishingRodHandle")).Task;
|
||
go.transform.localPosition = Vector3.zero;
|
||
go.transform.localScale = Vector3.one * FishingScale;
|
||
if (RodBehaviour != null)
|
||
{
|
||
DestroyImmediate(RodBehaviour.gameObject);
|
||
}
|
||
|
||
RodBehaviour = go.GetComponent<Rod>();
|
||
fishingRodAnimator = RodBehaviour.rod.GetComponent<Animator>();
|
||
if (gameObject.activeInHierarchy)
|
||
StartRodSpidleTime();
|
||
//Set HandIK Target
|
||
if (HandController != null)
|
||
{
|
||
HandController.SetHandTargets(RodBehaviour.RightHandTargets, RodBehaviour.LeftHandTargets, RodBehaviour.BodyTargets);
|
||
}
|
||
|
||
if (RodBehaviour.cCDIK != null)
|
||
{
|
||
RodBehaviour.cCDIK.enabled = false;
|
||
}
|
||
//准备开始钓鱼
|
||
SetShowRod(true);
|
||
PrepareFishing();
|
||
}
|
||
}
|
||
Coroutine spIdle;
|
||
public void ShowRod(bool isShow)
|
||
{
|
||
if (RodBehaviour != null)
|
||
{
|
||
RodBehaviour.rod.SetActive(isShow);
|
||
if (HandController != null)
|
||
{
|
||
HandController.SetActive(isShow);
|
||
}
|
||
GContext.Publish(ERightState.Idle);
|
||
}
|
||
}
|
||
public void OnEnableHand(ShowHandEvent value)
|
||
{
|
||
if (HandController != null)
|
||
{
|
||
HandController.SetActive(value.isShow);
|
||
}
|
||
}
|
||
void StartRodSpidleTime()
|
||
{
|
||
if (spIdle != null)
|
||
{
|
||
StopCoroutine(spIdle);
|
||
spIdle = null;
|
||
}
|
||
if (fishingRodAnimator != null && fishingBehaviorConf != null)
|
||
{
|
||
spIdle = StartCoroutine(RodSpidleTime());
|
||
}
|
||
}
|
||
IEnumerator RodSpidleTime()
|
||
{
|
||
while (true)
|
||
{
|
||
yield return new WaitForSeconds(fishingBehaviorConf.rodSpidleTime);
|
||
float spidle = Random.value;
|
||
if (spidle <= fishingBehaviorConf.rodSpidle)
|
||
{
|
||
fishingRodAnimator.SetTrigger("_spidle");
|
||
}
|
||
}
|
||
}
|
||
//准备开始钓鱼
|
||
public void PrepareFishing()
|
||
{
|
||
if (fxWaterDrop != null)
|
||
{
|
||
fxWaterDrop.SetActive(false);
|
||
}
|
||
_isCastLine = false;
|
||
_currentGravityOnLine = 0f;
|
||
_gravityonLineTimer = 0f;
|
||
_isChangelineStartPos = false;
|
||
fishAnimator.SetTrigger("_idle");
|
||
cameraAnimator.SetBool("_maxcomboExit", false);
|
||
cameraAnimator.SetBool("_maxcombo", false);
|
||
}
|
||
public void SetShowRod(bool isShowRod)
|
||
{
|
||
if (RodBehaviour != null)
|
||
{
|
||
if (RodBehaviour.rod != null)
|
||
{
|
||
ShowRod(isShowRod);
|
||
}
|
||
RodBehaviour.fishingLineRenderer.enabled = true;
|
||
RodBehaviour.fishingLineRenderer.gameObject.SetActive(isShowRod);
|
||
_bait.transform.SetParent(RodBehaviour.Bait);
|
||
_bait.transform.localPosition = Vector3.zero; //-Vector3.up * 0.1f;
|
||
_bait.transform.localRotation = Quaternion.Euler(Vector3.forward * 90);
|
||
_bait.gameObject.SetActive(true);
|
||
}
|
||
}
|
||
public async Task LoadEffect(string path, bool active = true)
|
||
{
|
||
if (_effectDic.ContainsKey(path))
|
||
{
|
||
_curFishEffect = _effectDic[path];
|
||
_curFishEffect.SetActive(false);
|
||
if (active)
|
||
{
|
||
_curFishEffect.SetActive(true);
|
||
}
|
||
|
||
Vector3 vector = _fish.transform.position;
|
||
vector.y = _waterHeight;
|
||
_curFishEffect.transform.position = vector;
|
||
}
|
||
else
|
||
{
|
||
_curFishEffect = null;
|
||
var prefab = await Addressables.InstantiateAsync(path, transform, true).Task;
|
||
if (prefab != null)
|
||
{
|
||
_curFishEffect = prefab;
|
||
_curFishEffect.gameObject.SetActive(active);
|
||
Vector3 vector = _fish.transform.position;
|
||
vector.y = _waterHeight;
|
||
_curFishEffect.transform.position = vector;
|
||
_effectDic.Add(path, _curFishEffect);
|
||
}
|
||
}
|
||
if (path == "fx_fishing_splashwaveloop")
|
||
{
|
||
fx_fishing_splashwaveloop = _curFishEffect;
|
||
_curFishEffect.transform.localScale = Vector3.one * fishingData.curFishData.SlashFxScale;
|
||
}
|
||
else if (path == "fx_fishing_splashloopreeling")
|
||
{
|
||
fx_fishing_splashloopreeling = _curFishEffect;
|
||
}
|
||
else if (path == "fx_fishing_splashloop")
|
||
{
|
||
fx_fishing_splashloop = _curFishEffect;
|
||
}
|
||
else if (path == "fx_fishing_jumpout")
|
||
{
|
||
fx_fishing_jumpout = _curFishEffect;
|
||
}
|
||
else if (path == "fx_fishing_jumpinto")
|
||
{
|
||
fx_fishing_jumpinto = _curFishEffect;
|
||
}
|
||
else if (path == "fx_fishing_splashinto")
|
||
{
|
||
fx_fishing_splashinto = _curFishEffect;
|
||
}
|
||
}
|
||
|
||
public async Task LoadEffectNoMove(string path, bool active = true)
|
||
{
|
||
GameObject effect = null;
|
||
if (_effectDic.ContainsKey(path))
|
||
{
|
||
effect = _effectDic[path];
|
||
effect.SetActive(active);
|
||
Vector3 vector = _fish.transform.position;
|
||
vector.y = _waterHeight;
|
||
effect.transform.position = vector;
|
||
}
|
||
else if (active)
|
||
{
|
||
var prefab = await Addressables.InstantiateAsync(path, transform, true).Task;
|
||
if (prefab != null)
|
||
{
|
||
effect = prefab;
|
||
effect.gameObject.SetActive(active);
|
||
Vector3 vector = _fish.transform.position;
|
||
vector.y = _waterHeight;
|
||
effect.transform.position = vector;
|
||
_effectDic[path] = effect;
|
||
}
|
||
}
|
||
}
|
||
|
||
public void SetCurFishEffectPos()
|
||
{
|
||
if (_curFishEffect != null)
|
||
{
|
||
Vector3 vector;
|
||
if (FishBehaviour != null && FishBehaviour.Tail != null)
|
||
{
|
||
vector = FishBehaviour.Tail.position;
|
||
}
|
||
else
|
||
{
|
||
vector = _fish.transform.position;
|
||
}
|
||
|
||
if (fx_fishing_splashloop)
|
||
{
|
||
fx_fishing_splashloop.transform.rotation = _fish.transform.rotation;
|
||
fx_fishing_splashloop.transform.position = vector;
|
||
}
|
||
vector = _fish.transform.position;
|
||
vector.y = _waterHeight;
|
||
_curFishEffect.transform.rotation = _fish.transform.rotation;
|
||
_curFishEffect.transform.position = vector;
|
||
fx_fishing_splashloopreeling.transform.position = vector;
|
||
}
|
||
if (fx_fishbosscome != null && FishSwimBehaviour != null)
|
||
{
|
||
Vector3 vector;
|
||
if (FishSwimBehaviour.Tail != null)
|
||
{
|
||
vector = FishSwimBehaviour.Tail.position;
|
||
fx_fishbosscome.transform.rotation = FishComeAnimationRoot.rotation;
|
||
}
|
||
else
|
||
{
|
||
vector = FishSwimBehaviour.transform.position;
|
||
}
|
||
vector.y = _waterHeight;
|
||
fx_fishbosscome.transform.position = vector;
|
||
}
|
||
}
|
||
public void PlayCollectingEffect()
|
||
{
|
||
if (dropAfterDrop != null && _effectDic.ContainsKey(dropAfterDrop.Fx))
|
||
{
|
||
collectingEffect = _effectDic[dropAfterDrop.Fx];
|
||
if (FishBehaviour != null && FishBehaviour.modeGo != null)
|
||
{
|
||
GameObject effect = Instantiate(collectingEffect, FishBehaviour.modeGo.transform);
|
||
effect.transform.localPosition = Vector3.zero;
|
||
effect.SetActive(true);
|
||
}
|
||
else
|
||
{
|
||
collectingEffect.transform.position = FishAnimationRoot.transform.position;
|
||
collectingEffect.SetActive(true);
|
||
}
|
||
}
|
||
}
|
||
|
||
public void SetEffectActive(string path, bool active)
|
||
{
|
||
if (_effectDic.ContainsKey(path))
|
||
{
|
||
GameObject effect = _effectDic[path];
|
||
effect.SetActive(active);
|
||
}
|
||
}
|
||
|
||
//开始抛鱼线
|
||
public async void CastLineBehavior()
|
||
{
|
||
//计算主画布分辨率下的宽高和屏幕的宽高的比列：
|
||
fishingData.mainCamera.DOLocalRotateQuaternion(Quaternion.identity, 0.1f);
|
||
await Awaiters.NextFrame;
|
||
|
||
CastBait();
|
||
//播放抛竿动画
|
||
fishingRodAnimator.SetTrigger("_throwing");
|
||
GContext.Publish(ERightState.Throwing);
|
||
_cameraAnimator.SetTrigger("_throwing");
|
||
|
||
rodHandleAni.SetBool("_idle", false);
|
||
rodHandleAni.SetTrigger("_drawing");
|
||
await Awaiters.Seconds(fishingBehaviorConf.audioDelay);
|
||
GContext.Publish(new EventFishingSound(SoundType.ThrowingAudio));
|
||
GContext.Publish(new VibrationData(1));
|
||
}
|
||
|
||
private void ConsumeBait()
|
||
{
|
||
if (fishingData.IsFree)
|
||
{
|
||
WaitForFishBiteED();
|
||
}
|
||
else
|
||
{
|
||
DoConsumeBait();
|
||
}
|
||
}
|
||
|
||
private void DoConsumeBait()
|
||
{
|
||
if (Application.internetReachability == NetworkReachability.NotReachable)
|
||
{
|
||
NoInternet();
|
||
}
|
||
else
|
||
{
|
||
ConsumeBaitOnPlayfab();
|
||
WaitForFishBiteED();
|
||
}
|
||
}
|
||
|
||
private async void NoInternet()
|
||
{
|
||
GameObject go = await UIManager.Instance.ShowUI(UITypes.NoticeConfirmPopupPanel);
|
||
var NoticeConfirmPopupPanel = go.GetComponent<NoticeConfirmPopupPanel>();
|
||
string info = LocalizationMgr.GetText("UI_FishingReconnectPanel_101003");
|
||
string label = LocalizationMgr.GetText("UI_FishingRewardPanel_101022");
|
||
string title = LocalizationMgr.GetText("UI_FishingReconnectPanel_101002");
|
||
NoticeConfirmPopupPanel.Init(1, title, info,
|
||
onClickLeft: DoConsumeBait,
|
||
onClose: DoConsumeBait,
|
||
btn_left_text: label);
|
||
}
|
||
|
||
private async void ConsumeBaitOnPlayfab()
|
||
{
|
||
var playerData = GContext.container.Resolve<PlayerData>();
|
||
EnergyDef energyDef = _tables.TbEnergyDef.DataList[playerData.magnification];
|
||
var energy = energyDef.Mag;
|
||
if (fishingData.IsRetry)
|
||
{
|
||
energy = energyDef.RetryCost;
|
||
}
|
||
var commonDatas = new Dictionary<string, string>(playerData.PlayerDataDic);
|
||
commonDatas["energy"] = (playerData.Energy - energy).ToString();
|
||
playerData.ReduceEnergy(energy, false);
|
||
if (!fishingData.IsPackItemFish())
|
||
{
|
||
GContext.Publish(new ConditionTypeEvent(ConditionType.ConsumeEnergy, energy));
|
||
}
|
||
var success = await PlayFabMgr.Instance.SyncDataImmidiate("NewPlayerDataDic",
|
||
Newtonsoft.Json.JsonConvert.SerializeObject(commonDatas));
|
||
Debug.Log($"[FishBehaviourB::ConsumeBaitOnPlayfab] {success}");
|
||
}
|
||
|
||
void LoadFish()
|
||
{
|
||
if (FishBehaviour == null)
|
||
{
|
||
int id = _tables.GetItemData(_tables.TbGlobalConfig.FishUnDownloadAlter[fishingData.curFishData.Quality - 1]).RedirectID;
|
||
var curFishData = _tables.GetFishData(id);
|
||
string path = curFishData.Fbx;
|
||
float scale = curFishData.MaxScale;
|
||
currentFishPath = path;
|
||
LoadFish(path, scale, isShowFish, false);
|
||
}
|
||
}
|
||
|
||
public float GetFishUnderwaterOffset()
|
||
{
|
||
float offset = fishingData.curFishData.UnderwaterOffset;
|
||
offset -= FinUnderwaterOffset;
|
||
offset += fishingData.ExtraUnderwaterOffset;
|
||
return offset;
|
||
}
|
||
async void LoadFish(string path, float scale, bool isShow = true, bool showDefault = true, DropAfterDrop dropAfterDrop = null)
|
||
{
|
||
this.dropAfterDrop = dropAfterDrop;
|
||
isShowFish = isShow;
|
||
Transform parent = _fish.transform.Find("FishAnimationRoot");
|
||
var fishPrefab = await Addressables.LoadAssetAsync<GameObject>(path).Task;
|
||
if (fishPrefab != null)
|
||
{
|
||
if (this == null || currentFishPath != path || FishBehaviour != null)
|
||
{
|
||
Addressables.Release(fishPrefab);
|
||
return;
|
||
}
|
||
var go = Instantiate(fishPrefab, parent);
|
||
if (go == null)
|
||
return;
|
||
go.transform.localPosition = Vector3.zero;
|
||
FishPrefab = fishPrefab;
|
||
FishBehaviour = go.GetComponent<Fish>();
|
||
SetFishScale(scale);
|
||
Vector3 vector3 = Vector3.zero;
|
||
if (FishBehaviour.mouthPos != null)
|
||
{
|
||
FishBehaviour.animator.Play("Swim01", 0, 0);
|
||
vector3 = -FishBehaviour.animator.transform.InverseTransformPoint(FishBehaviour.mouthPos.position);
|
||
vector3.z = -vector3.z;
|
||
}
|
||
go.SetActive(false);
|
||
FishBehaviour.animator.transform.localPosition = vector3;
|
||
FishBehaviour.transform.localRotation = Quaternion.identity;
|
||
if (FishBehaviour.Fin != null)
|
||
{
|
||
FinUnderwaterOffset = FishBehaviour.Fin.position.y - _fish.transform.position.y;
|
||
Vector3 ver = _fish.transform.position;
|
||
ver.y = GetFishUnderwaterOffset();
|
||
_fish.transform.position = ver;
|
||
}
|
||
if (dropAfterDrop != null && dropAfterDrop.Bone != "None")
|
||
{
|
||
curFish = FishBehaviour?.gameObject;
|
||
dropAfterDropParent = FishBehaviour.Find(dropAfterDrop.Bone);
|
||
if (dropAfterDropParent != null)
|
||
{
|
||
var modeGo = await Addressables.InstantiateAsync(dropAfterDrop.Mode).Task;
|
||
if (FishBehaviour == null || curFish == null || curFish != FishBehaviour.gameObject)
|
||
{
|
||
Addressables.ReleaseInstance(modeGo);
|
||
return;
|
||
}
|
||
if (modeGo != null)
|
||
{
|
||
CollectingPropScale collectingPropScale = _tables.TbCollectingPropScale[fishingData.curFishData.Quality];
|
||
var eulerAngles = modeGo.transform.localEulerAngles;
|
||
var localPosition = modeGo.transform.localPosition;
|
||
modeGo.transform.SetParent(dropAfterDropParent);
|
||
modeGo.transform.localScale *= collectingPropScale.Scale;
|
||
modeGo.transform.localEulerAngles = eulerAngles;
|
||
modeGo.transform.localPosition = localPosition;
|
||
FishBehaviour.modeGo = modeGo;
|
||
}
|
||
if (dropAfterDrop.Fx != "None" && !_effectDic.ContainsKey(dropAfterDrop.Fx))
|
||
{
|
||
var fxGo = await Addressables.InstantiateAsync(dropAfterDrop.Fx, transform, true).Task;
|
||
if (fxGo != null)
|
||
{
|
||
fxGo.SetActive(false);
|
||
fxGo.transform.localPosition = Vector3.zero;
|
||
_effectDic.Add(dropAfterDrop.Fx, fxGo);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ETChangeMaterial eTDropAfterDrop = collectingData.MaterialChange();
|
||
if (eTDropAfterDrop != null && eTDropAfterDrop.MaterialChange != "None")
|
||
{
|
||
MaterialChangeDelay();
|
||
}
|
||
FishBehaviour.gameObject.SetActive(isShowFish);
|
||
|
||
if (fx_fishing_splashloop == null)
|
||
{
|
||
fx_fishing_splashloop = await Addressables.InstantiateAsync("fx_fishing_splashloop", transform).Task;
|
||
}
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.SetActive(isShowFish);
|
||
fx_fishing_splashloop.transform.localScale = Vector3.one * fishingData.curFishData.SlashFxScale;
|
||
}
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.transform.localScale = Vector3.one * fishingData.curFishData.SlashFxScale;
|
||
}
|
||
}
|
||
else if (showDefault)
|
||
{
|
||
LoadFish();
|
||
}
|
||
}
|
||
async void ShowDefaultFish()
|
||
{
|
||
if (FishBehaviour == null)
|
||
{
|
||
await Awaiters.Seconds(3f);
|
||
LoadFish();
|
||
}
|
||
}
|
||
//鱼咬钩，显示按钮
|
||
void WiattingForFish()
|
||
{
|
||
ShowDefaultFish();
|
||
NotMove = false;
|
||
var pos = _bait.transform.position;
|
||
pos.y = GetFishUnderwaterOffset();
|
||
_fish.transform.position = pos;
|
||
LoadEffect("fx_fishing_splashtip");
|
||
fishingRodAnimator.SetTrigger("_biting");
|
||
}
|
||
|
||
public float WaitingZ()
|
||
{
|
||
return fishingBehaviorConf.flyDistance - fishingBehaviorConf.waitingDistance;
|
||
}
|
||
public void BaitMove()
|
||
{
|
||
flyEndPosTrue = _bait.transform.position;
|
||
|
||
GContext.Publish(new EventFishingSound(SoundType.audio_fishing_throwing_baitintowater));
|
||
GContext.Publish(new EventFishingSound(SoundType.audio_fishing_waiting_fishgathering));
|
||
|
||
StartCoroutine(PlayWaitingFx());
|
||
LoadEffect("fx_fishing_splashloopwaiting");
|
||
var fishEffect = _effectDic["fx_fishing_splashloopwaiting"];
|
||
float z = WaitingZ();
|
||
float timer = Mathf.Lerp(fishingBehaviorConf.waitingLineDrawMinTime, fishingBehaviorConf.waitingLineDrawMaxTime, Random.value);
|
||
_bait.transform.DOLocalMoveZ(z, timer).OnUpdate(
|
||
(() =>
|
||
{
|
||
flyEndPosTrue = _bait.transform.position;
|
||
if (fishEffect)
|
||
{
|
||
Vector3 vector = _bait.transform.position;
|
||
vector.y = _waterHeight;
|
||
fishEffect.transform.position = vector;
|
||
}
|
||
})); ;
|
||
StartCoroutine(WaitForFishBite(timer));
|
||
}
|
||
IEnumerator PlayWaitingFx()
|
||
{
|
||
Vector3 vector = _bait.transform.position;
|
||
vector.y = _waterHeight;
|
||
vector.z = WaitingZ();
|
||
var waitFx = fishingBehaviorConf.waitingPlay;
|
||
if (waitFx < 0)
|
||
{
|
||
waitFx = 0;
|
||
}
|
||
yield return new WaitForSeconds(waitFx);
|
||
var fishEffect = _effectDic.ContainsKey("fx_fishing_splashwaiting") ? _effectDic["fx_fishing_splashwaiting"] : null;
|
||
if (fishEffect != null)
|
||
{
|
||
fishEffect.transform.position = vector;
|
||
fishEffect.gameObject.SetActive(true);
|
||
}
|
||
}
|
||
private IEnumerator WaitForFishBite(float timer)
|
||
{
|
||
EventFishingSound eventFishingSound1 = new EventFishingSound(SoundType.audio_fishing_waiting);
|
||
EventFishingSound eventFishingSound2 = new EventFishingSound(SoundType.ReelingAudio, loop: true);
|
||
|
||
GContext.Publish(eventFishingSound1);
|
||
GContext.Publish(eventFishingSound2);
|
||
float EnhancedWaitingTime = fishingData.EnhancedWaitingTime;
|
||
timer += Mathf.Lerp(fishingBehaviorConf.waitingMinTime, fishingBehaviorConf.waitingMaxTime, Random.value) * (1 - EnhancedWaitingTime);
|
||
|
||
yield return new WaitForSeconds(timer);
|
||
|
||
if (eventFishingSound2.Sound != null)
|
||
{
|
||
GContext.Publish(new FadeOutEvent(eventFishingSound2.Sound));
|
||
}
|
||
else
|
||
{
|
||
eventFishingSound2.SkipPendingPlayback = true;
|
||
}
|
||
|
||
SetBaitStartPos();
|
||
ConsumeBait();
|
||
}
|
||
|
||
void WaitForFishBiteED()
|
||
{
|
||
WiattingForFish();
|
||
if (FishingPanel_Advanced.Instance != null)
|
||
{
|
||
FishingPanel_Advanced.Instance?.ShowDrawButton();
|
||
}
|
||
SetEffectActive("fx_fishing_splashloopwaiting", false);
|
||
GContext.Publish(new VibrationData(2));
|
||
}
|
||
|
||
|
||
void InitEffect()
|
||
{
|
||
LoadEffect("fx_fishing_splashinto", false);
|
||
//水线
|
||
LoadEffect("fx_fishing_splashloopwaiting", false);
|
||
//鱼群
|
||
LoadEffect("fx_fishing_splashwaiting", false);
|
||
LoadEffect("fx_fishing_splashwaveloop", false);
|
||
LoadEffect("fx_fishing_splashloopreeling", false);
|
||
LoadEffect("fx_fishing_splashpull", false);
|
||
LoadEffect("fx_fishing_splashtip", false);
|
||
LoadEffect("fx_fishing_jumpout", false);
|
||
LoadEffect("fx_fishing_jumpinto", false);
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.SetActive(false);
|
||
}
|
||
|
||
}
|
||
|
||
async Task LoadEffect()
|
||
{
|
||
await LoadEffect("fx_fishing_splashinto", false);
|
||
await LoadEffect("fx_fishing_splashloop", false);
|
||
//水线
|
||
await LoadEffect("fx_fishing_splashloopwaiting", false);
|
||
//鱼群
|
||
await LoadEffect("fx_fishing_splashwaiting", false);
|
||
await LoadEffect("fx_fishing_splashwaveloop", false);
|
||
await LoadEffect("fx_fishing_splashloopreeling", false);
|
||
await LoadEffect("fx_fishing_splashpull", false);
|
||
await LoadEffect("fx_fishing_splashtip", false);
|
||
await LoadEffect("fx_fishing_jumpout", false);
|
||
await LoadEffect("fx_fishing_jumpinto", false);
|
||
}
|
||
|
||
List<ParabolaHarmonicSimulation> vector3s = new List<ParabolaHarmonicSimulation>();
|
||
bool _isLineSin = false;
|
||
Vector3 flyEndPosTrue;
|
||
async void AddLinePos()
|
||
{
|
||
float allTime = fishingBehaviorConf.flyToWaterTime * fishingBehaviorConf.fishApproachingZRatio;
|
||
float time = allTime;
|
||
float timeInterval = 0;
|
||
vector3s.Clear();
|
||
flyEndPosTrue = new Vector3(0, _waterHeight, fishingBehaviorConf.flyDistance);
|
||
float zeroTime = allTime + fishingBehaviorConf.flyToWaterTime;
|
||
float elapsedTime = 0.03f;
|
||
|
||
while (_isCastLine)
|
||
{
|
||
float subTime = elapsedTime;
|
||
timeInterval += subTime;
|
||
zeroTime -= subTime;
|
||
await Awaiters.Seconds(elapsedTime);
|
||
if (time > 0)
|
||
{
|
||
time -= subTime;
|
||
_isLineSin = true;
|
||
ParabolaHarmonicSimulation parabolaHarmonicSimulation = new ParabolaHarmonicSimulation();
|
||
parabolaHarmonicSimulation.startPos = _lineStartPos.transform.position;
|
||
parabolaHarmonicSimulation.starTime = timeInterval;
|
||
parabolaHarmonicSimulation.allTime = allTime;
|
||
vector3s.Add(parabolaHarmonicSimulation);
|
||
}
|
||
for (int i = 0; i < vector3s.Count; i++)
|
||
{
|
||
vector3s[i].curTime = timeInterval;
|
||
}
|
||
}
|
||
_isLineSin = false;
|
||
}
|
||
Vector3 GetCurPos(ParabolaHarmonicSimulation data, out float zeroTime)
|
||
{
|
||
float starTime = data.starTime;
|
||
float curTime = data.curTime - starTime;
|
||
|
||
//归0时间
|
||
zeroTime = curTime / data.allTime;
|
||
Vector3 startPos = Vector3.Lerp(data.startPos, _lineStartPos.transform.position, zeroTime);
|
||
|
||
float time = curTime / fishingBehaviorConf.flyToWaterTime;
|
||
Vector3 vector3 = flyEndPosTrue;
|
||
if (time < 1)
|
||
{
|
||
float x = Mathf.Lerp(startPos.x, flyEndPosTrue.x, time);
|
||
float yTime = fishingBehaviorConf.flyDownCurve.Evaluate(time);
|
||
float y = Mathf.Lerp(startPos.y, flyEndPosTrue.y, time);
|
||
float zTime = fishingBehaviorConf.flyForwardCurve.Evaluate(time);
|
||
float z = Mathf.Lerp(startPos.z, flyEndPosTrue.z, zTime);
|
||
vector3 = new(x, y, z);
|
||
}
|
||
|
||
return vector3;
|
||
}
|
||
private async void CastBait()
|
||
{
|
||
InitEffect();
|
||
if (fishingBehaviorConf.fishFreeControlTime > 0f)
|
||
{
|
||
await new WaitForSeconds(fishingBehaviorConf.fishFreeControlTime);
|
||
_isCastLine = true;
|
||
_bait.transform.SetParent(transform);
|
||
_bait.transform.DOMoveX(0, fishingBehaviorConf.flyToWaterTime);
|
||
_bait.transform.DOMoveZ(fishingBehaviorConf.flyDistance, fishingBehaviorConf.flyToWaterTime).SetEase(fishingBehaviorConf.flyForwardCurve);
|
||
_cameraAnimator.SetTrigger("_waiting");
|
||
_bait.transform.DOMoveY(_waterHeight, fishingBehaviorConf.flyToWaterTime)
|
||
.SetEase(fishingBehaviorConf.flyDownCurve).OnComplete((() =>
|
||
{
|
||
fishingRodAnimator.SetTrigger("_waiting");
|
||
GContext.Publish(ERightState.Waiting);
|
||
LoadEffect("fx_fishing_splashinto");
|
||
Vector3 vector = _bait.transform.position;
|
||
vector.y = _waterHeight;
|
||
_curFishEffect.transform.position = vector;
|
||
BaitMove();
|
||
_bait.SetActive(false);
|
||
}));
|
||
AddLinePos();
|
||
}
|
||
else
|
||
{
|
||
await new WaitForSeconds(1.15f);
|
||
//当前动画_fishingRodAnimator播放时间
|
||
float time = fishingRodAnimator.GetCurrentAnimatorStateInfo(0).normalizedTime;
|
||
_isCastLine = true;
|
||
_cameraAnimator.SetTrigger("_waiting");
|
||
await new WaitForSeconds(time);
|
||
_bait.transform.SetParent(transform);
|
||
_bait.SetActive(false);
|
||
//鱼漂位置
|
||
Vector3 ver = _bait.transform.position;
|
||
ver.y = _waterHeight;
|
||
_bait.transform.position = ver;
|
||
fishingRodAnimator.SetTrigger("_waiting");
|
||
GContext.Publish(ERightState.Waiting);
|
||
LoadEffect("fx_fishing_splashinto");
|
||
Vector3 vector = _bait.transform.position;
|
||
vector.y = _waterHeight;
|
||
_curFishEffect.transform.position = vector;
|
||
BaitMove();
|
||
}
|
||
}
|
||
#if UNITY_EDITOR
|
||
public async void GMPiercingIndex(int index)
|
||
{
|
||
rodHandleAni.SetTrigger("_drawing");
|
||
_ = StartCoroutine(PiercingTimeScale(index - 1));
|
||
_cameraAnimator.SetInteger("_piercingState", index);
|
||
fishingRodAnimator.SetInteger("_piercingState", index);
|
||
_cameraAnimator.Play($"Piercing_{rodType}_0{index}");
|
||
fishingRodAnimator.Play($"Piercing0{index}");
|
||
GContext.Publish(ERightState.Piercing);
|
||
_cameraAnimator.SetTrigger("_drawing");
|
||
await Awaiters.Seconds(fishingBehaviorConf.PiercingAnimExitTime[index - 1]);
|
||
RodDrawing();
|
||
}
|
||
public void GMPiercingDIndex(int index)
|
||
{
|
||
rodHandleAni.SetTrigger("_drawing");
|
||
|
||
fishingRodAnimator.SetBool("_piercingExit", false);
|
||
_cameraAnimator.SetInteger("_piercingState", index);
|
||
fishingRodAnimator.SetInteger("_piercingState", index);
|
||
_cameraAnimator.Play($"PiercingSp_{rodType}_0{index}");
|
||
fishingRodAnimator.Play($"PiercingSp0{index}");
|
||
rodHandleAni.SetTrigger("_piercingSp");
|
||
_cameraAnimator.SetTrigger("_piercingSp");
|
||
fishingRodAnimator.SetTrigger("_piercingSp");
|
||
GContext.Publish(ERightState.PiercingSp);
|
||
_cameraAnimator.SetBool("_claim", false);
|
||
}
|
||
#endif
|
||
private void Update()
|
||
{
|
||
#if UNITY_EDITOR
|
||
if (Input.GetKey(KeyCode.C))
|
||
{
|
||
if (Input.GetKeyDown(KeyCode.Alpha1))
|
||
{
|
||
GMPiercingIndex(1);
|
||
}
|
||
else if (Input.GetKeyDown(KeyCode.Alpha2))
|
||
{
|
||
GMPiercingIndex(2);
|
||
}
|
||
else if (Input.GetKeyDown(KeyCode.Alpha3))
|
||
{
|
||
GMPiercingIndex(3);
|
||
}
|
||
}
|
||
else if (Input.GetKey(KeyCode.V))
|
||
{
|
||
if (Input.GetKeyDown(KeyCode.Alpha1))
|
||
{
|
||
GMPiercingDIndex(1);
|
||
}
|
||
else if (Input.GetKeyDown(KeyCode.Alpha2))
|
||
{
|
||
GMPiercingDIndex(2);
|
||
}
|
||
else if (Input.GetKeyDown(KeyCode.Alpha3))
|
||
{
|
||
GMPiercingDIndex(3);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
//如果鱼线还在空中，鱼线的张力动态更新
|
||
if (_isCastLine)
|
||
{
|
||
_gravityonLineTimer += Time.deltaTime;
|
||
//0~0.5秒后，鱼线上的重力从0到0.7f，鱼线类似向上的抛物线
|
||
if (_gravityonLineTimer < 0.5f)
|
||
_currentGravityOnLine = Mathf.Lerp(0, -_simulateGravityOnLine, _gravityonLineTimer / 0.5f);
|
||
else
|
||
_currentGravityOnLine = Mathf.Lerp(-_simulateGravityOnLine, _simulateGravityOnLine,
|
||
(_gravityonLineTimer - 0.5f) / 1f);
|
||
}
|
||
}
|
||
private void LateUpdate()
|
||
{
|
||
DrawFishingLine();
|
||
}
|
||
|
||
public void InitAni()
|
||
{
|
||
if (fishingRodAnimator != null)
|
||
{
|
||
fishingRodAnimator.SetBool("_shock", false);
|
||
fishingRodAnimator.SetBool("_drawing", false);
|
||
fishingRodAnimator.SetBool("_piercing", false);
|
||
fishingRodAnimator.SetBool("_release", false);
|
||
}
|
||
|
||
rodHandleAni.SetBool("_drawing", false);
|
||
_cameraAnimator.SetBool("_shock", false);
|
||
_cameraAnimator.SetBool("_drawing", false);
|
||
_cameraAnimator.SetBool("_piercing", false);
|
||
}
|
||
|
||
public void OnFild()
|
||
{
|
||
CloseIK();
|
||
_bait.transform.SetParent(RodBehaviour.Bait);
|
||
_bait.transform.localPosition = Vector3.zero; //-Vector3.up * 0.1f;
|
||
StartCoroutine(FailHideLine());
|
||
}
|
||
public void CloseIK()
|
||
{
|
||
if (RodBehaviour.cCDIK)
|
||
{
|
||
RodBehaviour.cCDIK.solver.IKPositionWeight = 0;
|
||
RodBehaviour.cCDIK.enabled = false;
|
||
}
|
||
}
|
||
|
||
IEnumerator OpenIKCo()
|
||
{
|
||
float startTime = 0;
|
||
RodBehaviour.cCDIK.enabled = true;
|
||
RodBehaviour.cCDIK.solver.target = FishAnimationRoot.transform;
|
||
while (startTime < 0.5f)
|
||
{
|
||
startTime += Time.deltaTime;
|
||
RodBehaviour.cCDIK.solver.IKPositionWeight = Mathf.Lerp(0, 1, startTime / 0.5f);
|
||
yield return null;
|
||
}
|
||
}
|
||
void SetIKTarget(Transform target)
|
||
{
|
||
if (RodBehaviour.cCDIK)
|
||
{
|
||
RodBehaviour.cCDIK.solver.target = target;
|
||
}
|
||
}
|
||
public void StartDrawing()
|
||
{
|
||
if (RodBehaviour.cCDIK != null)
|
||
{
|
||
StartCoroutine("OpenIKCo");
|
||
}
|
||
isShowFish = true;
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.gameObject.SetActive(true);
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
Vector3 vector;
|
||
if (FishBehaviour != null && FishBehaviour.Tail != null)
|
||
{
|
||
vector = FishBehaviour.Tail.position;
|
||
}
|
||
else
|
||
{
|
||
vector = _fish.transform.position;
|
||
}
|
||
fx_fishing_splashloop.transform.position = vector;
|
||
fx_fishing_splashloop.SetActive(true);
|
||
}
|
||
|
||
LoadFxChangeStartWater();
|
||
}
|
||
if (FishSwimBehaviour != null)
|
||
{
|
||
FishSwimBehaviour.gameObject.SetActive(true);
|
||
fishCome.FishComeMove(fishingBehaviorConf.bigFishSwimSpeed);
|
||
if (fx_fishbosscome != null)
|
||
{
|
||
Vector3 vector;
|
||
if (FishSwimBehaviour.Tail != null)
|
||
{
|
||
vector = FishSwimBehaviour.Tail.position;
|
||
fx_fishbosscome.transform.rotation = FishComeAnimationRoot.rotation;
|
||
}
|
||
else
|
||
{
|
||
vector = FishSwimBehaviour.transform.position;
|
||
}
|
||
vector.y = _waterHeight;
|
||
fx_fishbosscome.transform.position = vector;
|
||
fx_fishbosscome.SetActive(true);
|
||
}
|
||
}
|
||
_isCastLine = false;
|
||
//这里要基于鱼线的张力，来决定鱼线受重力的影响程度
|
||
_currentGravityOnLine = 0f; //To do
|
||
}
|
||
async Task LoadFxChangeStartWater()
|
||
{
|
||
ETChangeMaterial eTDropAfterDrop = collectingData.MaterialChange();
|
||
if (eTDropAfterDrop != null && eTDropAfterDrop.FxChangeStartWater != "None")
|
||
{
|
||
var prefab = await Addressables.InstantiateAsync(eTDropAfterDrop.FxChangeStartWater, transform, true).Task;
|
||
if (prefab != null)
|
||
{
|
||
Vector3 vector = _fish.transform.position;
|
||
vector.y = _waterHeight;
|
||
prefab.transform.position = vector;
|
||
_effectDic.Add(eTDropAfterDrop.FxChangeStartWater, prefab);
|
||
}
|
||
}
|
||
}
|
||
public float GetTurnTime()
|
||
{
|
||
var FishSpeedParam = _tables.TbFishStatsConfig.FishSpeedParam;
|
||
//鱼的转弯时间 = 配置的转弯时间 * 参数1 / (1 + 移动速度属性 * 参数2)
|
||
var turnTime = fishingBehaviorConf.turnTime * FishSpeedParam[2] / (1 + fishingData.FishSpeed * FishSpeedParam[3]);
|
||
turnTime = Math.Clamp(turnTime, FishSpeedParam[0], FishSpeedParam[1]);
|
||
return turnTime / fishingData.FishAnimSpeed;
|
||
}
|
||
|
||
void SetFfishWeight()
|
||
{
|
||
var _random = fishingData.curFishData.PointExtraParam * Random.Range(1 - fishingData.curFishData.WeightRandom, 1 + fishingData.curFishData.WeightRandom);
|
||
fishingData.random = _random;
|
||
//鱼的重量
|
||
var _fishWeight = fishingData.curFishData.BaseWeight * _random;
|
||
var ExtraPoint = fishingData.WeightIncEvent;
|
||
if (fishingData.IsNewItemFish())
|
||
{
|
||
ExtraPoint = GContext.container.Resolve<PlayerData>().benefitsEventFishCashMag;
|
||
}
|
||
_fishWeight *= (1 + ExtraPoint);
|
||
_fishWeight = Mathf.Round(_fishWeight * 100) / 100;
|
||
fishingData.fishWeight = _fishWeight;
|
||
}
|
||
|
||
public void SetCatchStatus()
|
||
{
|
||
NotMove = false;
|
||
|
||
GContext.Publish(new EventFishingSound(SoundType.audio_fishing_waiting_fishgathering));
|
||
EventFishingSound eventFishingSound = new EventFishingSound(SoundType.ReelingAudioReeling, loop: true);
|
||
EventFishingSound eventFishingSound1 = new EventFishingSound(SoundType.LineAudioReeling, loop: true);
|
||
|
||
//随机参数
|
||
SetFfishWeight();
|
||
GContext.Publish(eventFishingSound);
|
||
GContext.Publish(eventFishingSound1);
|
||
|
||
_targetPos = new Vector3(0, -3, fishingBehaviorConf.reelingToPullLength);
|
||
|
||
fishAnimator.speed = 1;
|
||
fishingRodAnimator.SetTrigger("_reeling");
|
||
rodHandleAni.SetTrigger("_reeling");
|
||
_cameraAnimator.SetTrigger("_reeling");
|
||
fishAnimator.SetBool("_drawing01", false);
|
||
fishAnimator.SetBool("_drawing02", false);
|
||
fishAnimator.SetBool("_drawing", false);
|
||
fishAnimator.SetBool("_idle", false);
|
||
|
||
SetPulling();
|
||
|
||
fishAnimator.SetTrigger("_reeling");
|
||
LoadEffect("fx_fishing_splashloopreeling");
|
||
HideSpSkillFx("DirtyStuck");
|
||
//拉鱼路径
|
||
Vector3 controlPoint = new Vector3(0, _targetPos.y, _fish.transform.position.z);
|
||
controlPoint.x = Mathf.Lerp(_targetPos.x, _fish.transform.position.x, 1.0f / 3.0f);
|
||
controlPoint.z = Mathf.Lerp(_targetPos.z, _fish.transform.position.z, 2.0f / 3.0f);
|
||
float distance = Vector3.Distance(_fish.transform.position, controlPoint) + Vector3.Distance(_targetPos, controlPoint);
|
||
float time = distance / fishingBehaviorConf.reelingSpeed;
|
||
if (time > fishingBehaviorConf.comebackTimeUpperLimit)
|
||
{
|
||
time = fishingBehaviorConf.comebackTimeUpperLimit;
|
||
}
|
||
RodBehaviour.transform.DOLocalRotateQuaternion(Quaternion.Euler(0, -fishingBehaviorConf.yRotationRodOffset, 0), time);
|
||
RodBehaviour.transform.DOLocalMove(Vector3.zero, time);
|
||
fishingData.mainCamera.transform.DOLocalRotate(Vector3.zero, time);
|
||
HandController.SetShoulderRota(Vector3.zero);
|
||
_fish.transform.DOKill();
|
||
Quaternion rotation = Quaternion.LookRotation(_fish.transform.position - controlPoint);
|
||
_fish.transform.DORotateQuaternion(rotation, GetTurnTime());
|
||
Vector3[] path = new Vector3[] { _fish.transform.position, controlPoint, _targetPos };
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.FishAnimSpeed = 1;
|
||
FishBehaviour.transform.DOKill();
|
||
FishBehaviour.transform.localPosition = Vector3.zero;
|
||
//ReelingScale 鱼缩放
|
||
Vector3 localScale = FishBehaviour.transform.localScale * fishingData.curFishData.ReelingScale;
|
||
FishBehaviour.animator.Play("Swim01", 0, 0);
|
||
FishBehaviour.transform.DOScale(localScale, time).OnUpdate
|
||
(
|
||
() =>
|
||
{
|
||
if (FishBehaviour.mouthPos != null)
|
||
{
|
||
Vector3 vector3 = Vector3.zero;
|
||
vector3 = -FishBehaviour.animator.transform.InverseTransformPoint(FishBehaviour.mouthPos.position);
|
||
vector3.z = -vector3.z;
|
||
FishBehaviour.animator.transform.localPosition = vector3;
|
||
}
|
||
}
|
||
).SetEase(Ease.Linear);
|
||
}
|
||
Vector3 zero = Vector3.one * fishingData.curFishData.SlashFxScale * 0.25f;
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.SetActive(true);
|
||
fx_fishing_splashwaveloop.transform.DOScale(zero, time).SetEase(Ease.Linear);
|
||
}
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.SetActive(true);
|
||
fx_fishing_splashloop.transform.DOScale(zero, time).SetEase(Ease.Linear);
|
||
}
|
||
float turnTime = 0;
|
||
Vector3 fishPos = _fish.transform.position;
|
||
// Move the fish along the path
|
||
_fish.transform.DOPath(path, time, PathType.CatmullRom)/*.SetDelay(GetTurnTime())*/
|
||
.OnUpdate(
|
||
(() =>
|
||
{
|
||
if (turnTime > GetTurnTime() + 0.2)
|
||
{
|
||
Quaternion rotation = Quaternion.LookRotation(fishPos - _fish.transform.position);
|
||
_fish.transform.rotation = rotation;
|
||
}
|
||
else if (turnTime > GetTurnTime())
|
||
{
|
||
Quaternion rotation = Quaternion.LookRotation(fishPos - _fish.transform.position);
|
||
_fish.transform.rotation = Quaternion.Lerp(_fish.transform.rotation, rotation, (turnTime - GetTurnTime()) * 5);
|
||
}
|
||
fishPos = _fish.transform.position;
|
||
turnTime += Time.deltaTime;
|
||
//reeling中
|
||
SetCurFishEffectPos();
|
||
Vector3 vector = _fish.transform.position;
|
||
vector.y = _waterHeight;
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.transform.rotation = _fish.transform.rotation;
|
||
fx_fishing_splashwaveloop.transform.position = vector;
|
||
}
|
||
|
||
}))
|
||
.SetEase(fishingBehaviorConf.reelCurve)
|
||
.OnComplete(
|
||
() =>
|
||
{
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.SetActive(false);
|
||
}
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.SetActive(false);
|
||
}
|
||
_fish.transform.DOKill();
|
||
//CloseIK(true);
|
||
_fish.transform.localRotation = Quaternion.identity;
|
||
_fish.transform.position = _targetPos;
|
||
var audios = fishingData.curFishData.AudioPullingOut;
|
||
string pullingOutSound = audios[Random.Range(0, audios.Count)];
|
||
GContext.Publish(new EventFishingSound(pullingOutSound));
|
||
if (eventFishingSound.Sound != null)
|
||
{
|
||
GContext.Publish(new FadeOutEvent(eventFishingSound.Sound));
|
||
}
|
||
else
|
||
{
|
||
eventFishingSound.SkipPendingPlayback = true;
|
||
}
|
||
|
||
if (eventFishingSound1.Sound != null)
|
||
{
|
||
GContext.Publish(new FadeOutEvent(eventFishingSound1.Sound));
|
||
}
|
||
else
|
||
{
|
||
eventFishingSound1.SkipPendingPlayback = true;
|
||
}
|
||
|
||
_cameraAnimator.SetBool("_claim", false);
|
||
fishAnimator.speed = 1;
|
||
GContext.Publish(new PlayNewItemFxEvent() { type = 1 });
|
||
GContext.Publish(ERightState.Pulling);
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.FishAnimSpeed = 1;
|
||
//ReelingScale 鱼缩放
|
||
Vector3 localScale = FishBehaviour.transform.localScale * fishingData.curFishData.PullingScale;
|
||
FishBehaviour.transform.DOScale(localScale, fishingBehaviorConf.jumpScaleTime).OnUpdate
|
||
(
|
||
() =>
|
||
{
|
||
if (FishBehaviour.mouthPos != null)
|
||
{
|
||
Vector3 vector3 = Vector3.zero;
|
||
vector3 = -FishBehaviour.animator.transform.InverseTransformPoint(FishBehaviour.mouthPos.position);
|
||
vector3.z = -vector3.z;
|
||
FishBehaviour.animator.transform.localPosition = vector3;
|
||
}
|
||
}
|
||
);
|
||
|
||
FishBehaviour.Pulling();
|
||
if (!string.IsNullOrEmpty(fishingData.curFishData.FxWaterDrop))
|
||
{
|
||
FxWaterDrop(fishingData.curFishData.FxWaterDrop);
|
||
}
|
||
//开始变材质
|
||
//if (dropAfterDrop != null)
|
||
{
|
||
MaterialChange();
|
||
}
|
||
}
|
||
|
||
if (fishingData.IsEventGameFish())
|
||
{
|
||
StartCoroutine(HideLine());
|
||
}
|
||
_cameraAnimator.SetTrigger("_pulling");
|
||
fishAnimator.SetTrigger("_pulling");
|
||
StartCoroutine(TimeScale());
|
||
StartCoroutine(ControlFishOutWater());
|
||
fishingRodAnimator.SetTrigger("_pulling");
|
||
|
||
StartCoroutine(Changeline());
|
||
StartCoroutine(PlayPullingSound());
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.SetActive(false);
|
||
}
|
||
LoadEffect("fx_fishing_splashpull");
|
||
|
||
if (!string.IsNullOrEmpty(fishingData.curFishData.FxWaterSplash))
|
||
GContext.Publish(new PlayerRaindropEvent() { FxWaterSplash = fishingData.curFishData.FxWaterSplash });
|
||
GContext.Publish(new VibrationData(21));
|
||
});
|
||
}
|
||
async void FxWaterDrop(string fxName)
|
||
{
|
||
if (fxWaterDrop != null)
|
||
{
|
||
if (fxName != fxWaterDrop.name)
|
||
{
|
||
Addressables.ReleaseInstance(fxWaterDrop);
|
||
fxWaterDrop = null;
|
||
}
|
||
else
|
||
{
|
||
fxWaterDrop.SetActive(false);
|
||
}
|
||
}
|
||
await new WaitForSeconds(fishingData.curFishData.DelayWaterDrop);
|
||
if (fxWaterDrop == null)
|
||
{
|
||
fxWaterDrop = await Addressables.InstantiateAsync(fxName, FishAnimationRoot).Task;
|
||
if (fxWaterDrop != null)
|
||
{
|
||
fxWaterDrop.name = fxName;
|
||
if (FishBehaviour == null)
|
||
{
|
||
Addressables.ReleaseInstance(fxWaterDrop);
|
||
fxWaterDrop = null;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
if (fxWaterDrop != null)
|
||
{
|
||
fxWaterDrop.SetActive(true);
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 是否需要变换
|
||
/// </summary>
|
||
public void MaterialChange()
|
||
{
|
||
ETChangeMaterial eTDropAfterDrop = collectingData.MaterialChange();
|
||
if (eTDropAfterDrop != null && eTDropAfterDrop.FxChange != "None")
|
||
{
|
||
FxChangeDelay();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 变换材质
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
async void MaterialChangeDelay()
|
||
{
|
||
ETChangeMaterial eTDropAfterDrop = collectingData.MaterialChange();
|
||
curFish = FishBehaviour?.gameObject;
|
||
await new WaitForSeconds(eTDropAfterDrop.MaterialChangeDelay);
|
||
F_whitemarli_P = await Addressables.LoadAssetAsync<Material>(eTDropAfterDrop.MaterialChange).Task;
|
||
if (FishBehaviour == null || curFish == null || curFish != FishBehaviour.gameObject)
|
||
{
|
||
Addressables.Release(F_whitemarli_P);
|
||
F_whitemarli_P = null;
|
||
return;
|
||
}
|
||
Renderer[] meshRenderer = FishBehaviour.gameObject.GetComponentsInChildren<Renderer>();
|
||
if (F_whitemarli_P != null && 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(F_whitemarli_P);
|
||
material_P.SetTexture("_BaseMap", material.GetTexture("_BaseMap"));
|
||
material_P.SetTexture("_BumpMap", material.GetTexture("_BumpMap"));
|
||
materials[i] = material_P;
|
||
}
|
||
render.materials = materials;
|
||
if (eTDropAfterDrop.FxAnimation != "None")
|
||
{
|
||
AnimationClip aniClip = await Addressables.LoadAssetAsync<AnimationClip>(eTDropAfterDrop.FxAnimation).Task;
|
||
if (aniClip != null)
|
||
{
|
||
Animation aniGo = render.gameObject.AddComponent<Animation>();
|
||
aniGo.playAutomatically = false;
|
||
aniGo.clip = aniClip;
|
||
aniGo.AddClip(aniClip, aniClip.name);
|
||
aniGo.Play(aniClip.name);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
async void FxChangeDelay()
|
||
{
|
||
ETChangeMaterial eTDropAfterDrop = collectingData.MaterialChange();
|
||
curFish = FishBehaviour?.gameObject;
|
||
await new WaitForSeconds(eTDropAfterDrop.FxChangeDelay);
|
||
GContext.Publish(new EventUISound(eTDropAfterDrop.AudioChange));
|
||
FxChangeFishDelay();
|
||
var prefab = await Addressables.LoadAssetAsync<GameObject>(eTDropAfterDrop.FxChange).Task;
|
||
GameObject fishEffect;
|
||
if (prefab != null)
|
||
{
|
||
if (FishBehaviour == null || curFish == null || curFish != FishBehaviour.gameObject)
|
||
{
|
||
Addressables.Release(prefab);
|
||
return;
|
||
}
|
||
fishEffect = Instantiate(prefab, transform, true);
|
||
fishEffect.transform.position = FishBehaviour.animator.transform.position;
|
||
CollectingPropScale collectingPropScale = _tables.TbCollectingPropScale[fishingData.curFishData.Quality];
|
||
fishEffect.transform.localScale *= collectingPropScale.Scale;
|
||
await Awaiters.Seconds(5);
|
||
Addressables.Release(prefab);
|
||
Destroy(fishEffect);
|
||
}
|
||
}
|
||
async void FxChangeFishDelay()
|
||
{
|
||
ETChangeMaterial eTDropAfterDrop = collectingData.MaterialChange();
|
||
if (eTDropAfterDrop.FxChangeFish != "None")
|
||
{
|
||
FxChangeFish = await Addressables.InstantiateAsync(eTDropAfterDrop.FxChangeFish).Task;
|
||
if (FxChangeFish != null)
|
||
{
|
||
if (FishBehaviour == null || curFish == null || curFish != FishBehaviour.gameObject)
|
||
{
|
||
Addressables.ReleaseInstance(FxChangeFish);
|
||
FxChangeFish = null;
|
||
return;
|
||
}
|
||
FxChangeFish.transform.position = FishBehaviour.animator.transform.position;
|
||
CollectingPropScale collectingPropScale = _tables.TbCollectingPropScale[fishingData.curFishData.Quality];
|
||
FxChangeFish.transform.localScale *= collectingPropScale.Scale;
|
||
}
|
||
}
|
||
}
|
||
IEnumerator Changeline()
|
||
{
|
||
yield return new WaitForSeconds(fishingBehaviorConf.fishingRodDisappearsPulling);
|
||
SetEffectActive("fx_fishing_splashloopreeling", false);
|
||
ChangelineStartPos();
|
||
}
|
||
IEnumerator PlayPullingSound()
|
||
{
|
||
var audios = fishingData.curFishData.AudioSplashPulling;
|
||
if (audios.Count > 0)
|
||
{
|
||
string pullingOutSound = audios[Random.Range(0, audios.Count)];
|
||
yield return new WaitForSeconds(fishingData.curFishData.DelaySplashPulling);
|
||
|
||
GContext.Publish(new EventFishingSound(pullingOutSound));
|
||
if (!string.IsNullOrEmpty(fishingData.curFishData.FxWaterSplash))
|
||
GContext.Publish(new PlayerRaindropEvent() { FxWaterSplash = fishingData.curFishData.FxWaterSplash });
|
||
}
|
||
}
|
||
|
||
IEnumerator TimeScale()
|
||
{
|
||
yield return new WaitForSeconds(fishingBehaviorConf.timeStartScale);
|
||
DOTween.To(() => 0.01f, x => Time.timeScale = x, 1,
|
||
fishingBehaviorConf.timeEndScale - fishingBehaviorConf.timeStartScale)
|
||
.SetEase(fishingBehaviorConf.timeScaleCurve);
|
||
yield return new WaitForSeconds(fishingBehaviorConf.timeEndScale);
|
||
Time.timeScale = 1f;
|
||
}
|
||
|
||
|
||
public void UIPreSwimB()
|
||
{ //天气压黑
|
||
var _fishEatfish = _tables.TbFishEatFish.GetOrDefault(fishingData.swimFishData.EatFishID);
|
||
if (_fishEatfish != null)
|
||
{
|
||
if (_fishEatfish.IsDarkness)
|
||
{
|
||
WeatherEvent weatherEvent = new WeatherEvent() { State = 1 };
|
||
GContext.Publish(weatherEvent);
|
||
fishingData.isWeather = true;
|
||
if (weatherEvent.IsPlay)
|
||
{
|
||
GContext.Publish(new EventBGMSound("BGM_WeatherChange"));
|
||
}
|
||
}
|
||
FishingPanel_Advanced.Instance?.ShowWarning(_fishEatfish.WarningAfterEat);
|
||
}
|
||
NotMove = true;
|
||
timer = 10;
|
||
fishCome.FishComeStop();
|
||
Shock();
|
||
}
|
||
public void PlayEatEndAni()
|
||
{
|
||
if (fx_fishbosscome != null)
|
||
{
|
||
fx_fishbosscome.SetActive(false);
|
||
}
|
||
DestroySwimFish();
|
||
SetDrawingForce(1);
|
||
StartCoroutine(UIEatFish());
|
||
}
|
||
public IEnumerator UIPreSwim()
|
||
{ //天气压黑
|
||
var _fishEatfish = _tables.TbFishEatFish.GetOrDefault(fishingData.swimFishData.EatFishID);
|
||
if (_fishEatfish != null)
|
||
{
|
||
if (_fishEatfish.IsDarkness)
|
||
{
|
||
WeatherEvent weatherEvent = new WeatherEvent() { State = 1 };
|
||
GContext.Publish(weatherEvent);
|
||
fishingData.isWeather = true;
|
||
if (weatherEvent.IsPlay)
|
||
{
|
||
GContext.Publish(new EventBGMSound("BGM_WeatherChange"));
|
||
}
|
||
}
|
||
FishingPanel_Advanced.Instance?.ShowWarning(_fishEatfish.WarningAfterEat);
|
||
}
|
||
if (FishSwimBehaviour != null)
|
||
{
|
||
FishSwimBehaviour.gameObject.SetActive(true);
|
||
}
|
||
if (fx_fishbosscome != null)
|
||
{
|
||
fx_fishbosscome.SetActive(true);
|
||
}
|
||
yield return fishCome.FishEatMove(fishingBehaviorConf.bigFishEatSpeed).AsIEnumerator();
|
||
NotMove = true;
|
||
timer = 10;
|
||
fishCome.FishComeStop();
|
||
float FishSwimSpeedTime = fishingBehaviorConf.bigFishEatTime;
|
||
float SwimDistance = fishSpeed * FishSwimSpeedTime;
|
||
var position = _fish.transform.position;
|
||
//勾股定理求X偏移
|
||
float z = (position.z - _strugglePoint.z);
|
||
float zQ = z * z;
|
||
float SwimDistanceQ = SwimDistance * SwimDistance;
|
||
float xS = SwimDistanceQ - zQ;
|
||
float x = 0;
|
||
if (xS > 0)
|
||
{
|
||
x = Mathf.Sqrt(xS);
|
||
}
|
||
else
|
||
{
|
||
_strugglePoint.z = position.z + SwimDistance;
|
||
}
|
||
//Mathf.Sqrt(y)
|
||
if (position.x < 0)
|
||
{
|
||
_strugglePoint.x = position.x + x;
|
||
}
|
||
else
|
||
{
|
||
_strugglePoint.x = position.x - x;
|
||
}
|
||
//转弯
|
||
Quaternion rotation = Quaternion.LookRotation(position - _strugglePoint);
|
||
_fish.transform.DORotateQuaternion(rotation, 0.1f);
|
||
_fish.transform.DOMove(_strugglePoint, FishSwimSpeedTime);
|
||
Vector3 posMid = (position + _strugglePoint) / 2;
|
||
//转弯
|
||
position.y = fishCome.transform.position.y;
|
||
var new_strugglePoint = _strugglePoint;
|
||
new_strugglePoint.y = fishCome.transform.position.y;
|
||
var posMidnew = (position + new_strugglePoint) / 2;
|
||
Quaternion rotation1 = Quaternion.LookRotation(fishCome.transform.position - posMid);
|
||
fishCome.transform.DORotateQuaternion(rotation1, 0.1f);
|
||
//Vector3[] path1 = new Vector3[] { fishCome.transform.position, posMidnew, new_strugglePoint };
|
||
float turnTime1 = 0;
|
||
Vector3 fishPos1 = fishCome.transform.position;
|
||
// Move the fish along the path
|
||
fishCome.transform.DOMove(new_strugglePoint, FishSwimSpeedTime)
|
||
.OnUpdate(
|
||
(() =>
|
||
{
|
||
turnTime1 += Time.deltaTime;
|
||
if (turnTime1 > 0.1f)
|
||
{
|
||
Quaternion rotationC = Quaternion.LookRotation(fishPos1 - fishCome.transform.position);
|
||
fishCome.transform.rotation = rotationC;
|
||
}
|
||
fishPos1 = fishCome.transform.position;
|
||
}));
|
||
Shock();
|
||
}
|
||
void Shock()
|
||
{
|
||
GContext.Publish(ERightState.Shock);
|
||
int _shockIndex = Random.Range(1, fishingBehaviorConf.shockCount + 1);
|
||
_cameraAnimator.SetInteger("_shockIndex", _shockIndex);
|
||
fishingRodAnimator.SetInteger("_shockIndex", _shockIndex);
|
||
_cameraAnimator.SetTrigger("_shock");
|
||
fishingRodAnimator.SetTrigger("_shock");
|
||
FishingPanel_Advanced.Instance?.ShowState(2);
|
||
}
|
||
//结束UI吃鱼
|
||
IEnumerator UIEatFish()
|
||
{
|
||
yield return new WaitForSeconds(fishingBehaviorConf.UIEatExitTime);
|
||
NotMove = false;
|
||
isShowFish = true;
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.gameObject.SetActive(true);
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
Vector3 vector;
|
||
if (FishBehaviour.Tail != null)
|
||
{
|
||
vector = FishBehaviour.Tail.position;
|
||
}
|
||
else
|
||
{
|
||
vector = _fish.transform.position;
|
||
}
|
||
fx_fishing_splashloop.transform.position = vector;
|
||
fx_fishing_splashloop.SetActive(true);
|
||
}
|
||
}
|
||
}
|
||
|
||
public void ChangelineStartPos()
|
||
{
|
||
_isChangelineStartPos = true;
|
||
ShowRod(false);
|
||
StartCoroutine(SetLineStartPos());
|
||
}
|
||
|
||
private IEnumerator ControlFishOutWater()
|
||
{
|
||
float time = fishingBehaviorConf.jumpDuration + fishingBehaviorConf.caughtFishDelayTime;
|
||
yield return new WaitForSeconds(time);
|
||
fishingRodAnimator.SetBool("_reeling", false);
|
||
_cameraAnimator.SetBool("_reeling", false);
|
||
fishingRodAnimator.SetBool("_pulling", false);
|
||
CameraPullingEnd();
|
||
fishingData.IsCaughtFish = true;
|
||
PlayCollectingEffect();
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.SetActive(false);
|
||
}
|
||
}
|
||
void CameraPullingEnd()
|
||
{
|
||
_cameraAnimator.SetBool("_pulling", false);
|
||
}
|
||
|
||
IEnumerator HideLine()
|
||
{
|
||
yield return new WaitForSeconds(fishingBehaviorConf.caughtFishHideLineTime);
|
||
RodBehaviour.fishingLineRenderer.gameObject.SetActive(false);
|
||
}
|
||
IEnumerator FailHideLine()
|
||
{
|
||
yield return new WaitForSeconds(fishingBehaviorConf.rodFailResetTime);
|
||
if (fishingData.IsShowRewardPanel)
|
||
{
|
||
RodBehaviour.fishingLineRenderer.gameObject.SetActive(false);
|
||
}
|
||
}
|
||
void IsCancelled()
|
||
{
|
||
float time = fishingBehaviorConf.rodFailResetTime;
|
||
RodBehaviour.transform.DOLocalRotateQuaternion(Quaternion.identity, time);
|
||
RodBehaviour.transform.DOLocalMove(Vector3.zero, time);
|
||
fishingRodAnimator.SetBool("_recast", false);
|
||
fishingRodAnimator.SetBool("_restart", false);
|
||
rodHandleAni.SetBool("_recast", false);
|
||
rodHandleAni.SetBool("_restart", false);
|
||
_cameraAnimator.SetBool("_recast", false);
|
||
_cameraAnimator.SetBool("_restart", false);
|
||
|
||
fishingRodAnimator.SetTrigger("_cancelled");
|
||
rodHandleAni.SetTrigger("_cancelled");
|
||
_cameraAnimator.SetTrigger("_cancelled");
|
||
}
|
||
void IsRecast(bool value)
|
||
{
|
||
if (!value)
|
||
{
|
||
_cameraAnimator.SetTrigger("_restart");
|
||
fishingRodAnimator.SetTrigger("_restart");
|
||
rodHandleAni.SetTrigger("_restart");
|
||
GContext.Publish(ERightState.Idle);
|
||
rodHandleAni.SetBool("_drawing", false);
|
||
rodHandleAni.SetTrigger("_idle");
|
||
}
|
||
else
|
||
{
|
||
fishingRodAnimator.SetTrigger("_recast");
|
||
rodHandleAni.SetTrigger("_recast");
|
||
GContext.Publish(ERightState.Throwing);
|
||
_cameraAnimator.SetTrigger("_recast");
|
||
}
|
||
fishingRodAnimator.SetBool("_throwing", false);
|
||
_cameraAnimator.SetBool("_throwing", false);
|
||
CameraToFish = false;
|
||
if (F_whitemarli_P)
|
||
{
|
||
Addressables.Release(F_whitemarli_P);
|
||
F_whitemarli_P = null;
|
||
}
|
||
if (FxChangeFish)
|
||
{
|
||
Addressables.ReleaseInstance(FxChangeFish);
|
||
FxChangeFish = null;
|
||
}
|
||
}
|
||
|
||
private IEnumerator SetLineStartPos()
|
||
{
|
||
_endLinePos = new Vector3(_lineStartPos.position.x,
|
||
fishingBehaviorConf.lineHeight,
|
||
_lineStartPos.position.z);
|
||
_lineStartPos.DOMove(_endLinePos, fishingBehaviorConf.lineMoveToTopTime);
|
||
yield return new WaitForSeconds(fishingBehaviorConf.lineMoveToTopTime + fishingBehaviorConf.lineHoldTopTime);
|
||
_endLinePos = new Vector3(0f,
|
||
fishingBehaviorConf.lineHeight,
|
||
RodBehaviour.transform.position.z + fishingBehaviorConf.reelingToPullLength - 5);
|
||
_lineStartPos.DOMove(_endLinePos, fishingBehaviorConf.lineMoveToMidTime);
|
||
}
|
||
//鱼竿播放Drawing
|
||
public void RodDrawing()
|
||
{
|
||
fishingRodAnimator.SetTrigger("_piercingExit");
|
||
fishingRodAnimator.SetTrigger("_drawing");
|
||
GContext.Publish(ERightState.Drawing);
|
||
}
|
||
public void CameraDrawing()
|
||
{
|
||
_cameraAnimator.SetTrigger("_drawing");
|
||
fishingRodAnimator.SetBool("_biting", false);
|
||
fishAnimator.SetTrigger($"_drawing0{fishingData.curFishData.ShowAnimation}");
|
||
fishAnimator.SetTrigger("_drawing");
|
||
CameraToFish = true;
|
||
}
|
||
public void Release(bool release)
|
||
{
|
||
if (release)
|
||
{
|
||
fishingRodAnimator.SetTrigger("_release");
|
||
fishingRodAnimator.SetBool("_drawing", false);
|
||
}
|
||
else
|
||
{
|
||
fishingRodAnimator.SetTrigger("_drawing");
|
||
fishingRodAnimator.SetBool("_release", false);
|
||
}
|
||
}
|
||
//bool isClickIng;
|
||
//模拟玩家操控鱼竿的体验
|
||
public void ControlFishingRodAnim(FishingStateName stateName, float fishSpeed, float nearDistance, float farDistance)
|
||
{
|
||
Vector3 dir = _fish.transform.position - transform.position;
|
||
dir.y = 0;
|
||
float angelX = Vector3.Angle(transform.right, dir);
|
||
angelX -= fishingBehaviorConf.cameraDrawingOffset;
|
||
// 判断是否按下鼠标左键
|
||
Vector2 mousePosition = Input.mousePosition;
|
||
if (Input.GetMouseButtonDown(0) && FishingPanel_Advanced.Instance != null && FishingPanel_Advanced.Instance.IsDown())
|
||
{
|
||
_cameraAnimator.SetTrigger(angelX < 0 ? "_drawL" : "_drawR");
|
||
}
|
||
|
||
if (stateName == FishingStateName.Move || stateName == FishingStateName.UIEating)
|
||
{
|
||
SimulateFish(fishSpeed, nearDistance, farDistance);
|
||
}
|
||
else if (stateName == FishingStateName.Jump)
|
||
{
|
||
fishSpeed *= JumpDistance;
|
||
SimulateFish(fishSpeed, nearDistance, farDistance);
|
||
}
|
||
else if (stateName == FishingStateName.Escape)
|
||
{
|
||
CloseBaitDoTween();
|
||
SimulateFishEscape(fishSpeed);
|
||
}
|
||
else
|
||
{
|
||
CloseBaitDoTween();
|
||
}
|
||
//控制鱼竿旋转
|
||
angelX += fishingBehaviorConf.RodRotationOffset;
|
||
float angelZ = angelX * fishingBehaviorConf.zRotationRodParam + fishingBehaviorConf.zRotationRodOffset;
|
||
float angelY = angelX * fishingBehaviorConf.yRotationRodParam + fishingBehaviorConf.yRotationRodOffset;
|
||
RodBehaviour.transform.localRotation = Quaternion.Lerp(RodBehaviour.transform.localRotation, Quaternion.Euler(0, -angelY, -angelZ), Time.deltaTime * 5);
|
||
RodBehaviour.transform.localPosition = Vector3.right * (Mathf.Sin(RodBehaviour.transform.localRotation.z) * fishingBehaviorConf.xPosRodParam + fishingBehaviorConf.xPosRodOffset);
|
||
SetCurFishEffectPos();
|
||
if (CameraToFish)
|
||
{
|
||
MoveCam();
|
||
}
|
||
}
|
||
void MoveCam()
|
||
{
|
||
var angle = GetFishPos() - fishingData.mainCamera.position;
|
||
angle.y = 0;
|
||
var camY = Vector3.Angle(Vector3.forward, angle) / _cameraMaxAngelOffset;
|
||
camY = Mathf.Clamp(camY, 0, 1);
|
||
if (angle.x < 0)
|
||
{
|
||
camY = -camY;
|
||
}
|
||
|
||
float cameraMaxAngel = _cameraMaxAngel /** offset*/;
|
||
camY *= cameraMaxAngel;
|
||
float camZ = (camY + fishingBehaviorConf.cameraDrawingOffset - 90) * fishingBehaviorConf.zAngelParam;
|
||
camZ = Mathf.Clamp(camZ, -fishingBehaviorConf.zAngelMax, fishingBehaviorConf.zAngelMax);
|
||
|
||
Quaternion rotation = Quaternion.Euler(fishingData.mainCamera.eulerAngles.x, camY, camZ);
|
||
Quaternion result = Quaternion.Lerp(fishingData.mainCamera.rotation, /*camStartRotation **/ rotation, Time.deltaTime * 10);
|
||
fishingData.mainCamera.rotation = result;
|
||
if (HandController != null)
|
||
{
|
||
Vector3 vector = fishingData.mainCamera.localEulerAngles;
|
||
vector.x *= fishingBehaviorConf.xRotationHandParam;
|
||
vector.y *= fishingBehaviorConf.yRotationHandParam;
|
||
vector.z *= fishingBehaviorConf.zRotationHandParam;
|
||
HandController.SetShoulderRota(vector);
|
||
}
|
||
}
|
||
public void SetDrawingForce(float forcePower)
|
||
{
|
||
fishingRodAnimator.SetFloat("_drawingForce", forcePower);
|
||
cameraAnimator.SetFloat("_drawingForce", forcePower);
|
||
}
|
||
|
||
public void SetFishAnimSpeed(float speed)
|
||
{
|
||
if (isJumping || isDashMove)
|
||
{
|
||
fishAnimator.speed = 1;
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.FishAnimSpeed = 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
fishAnimator.speed = speed;
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.FishAnimSpeed = speed;
|
||
}
|
||
}
|
||
}
|
||
|
||
public void RodReset()
|
||
{
|
||
fishingRodAnimator.SetBool("_biting", false);
|
||
CloseIK();
|
||
RodBehaviour.transform.localEulerAngles = Vector3.zero;
|
||
RodBehaviour.transform.localPosition = Vector3.zero;
|
||
SetRodType();
|
||
}
|
||
public void CameraReset(bool isSupplyDrop = false)
|
||
{
|
||
_cameraAnimator.SetBool("_preparing", false);
|
||
_cameraAnimator.SetBool("_shock", false);
|
||
_cameraAnimator.SetBool("_drawing", false);
|
||
if (isSupplyDrop)
|
||
{
|
||
StartCoroutine(PlayAfterpulling());
|
||
}
|
||
else
|
||
{
|
||
_cameraAnimator.SetTrigger("_preparing");
|
||
_cameraAnimator.SetTrigger("_afterpulling");
|
||
_cameraAnimator.SetTrigger("_claim");
|
||
}
|
||
}
|
||
public void PlaySupplyDropClaim()
|
||
{
|
||
_cameraAnimator.SetTrigger("_supplydropclaim");
|
||
}
|
||
IEnumerator PlayAfterpulling()
|
||
{
|
||
_cameraAnimator.SetTrigger("_supplydrop");
|
||
yield return new WaitForSeconds(fishingBehaviorConf.supplyDropAppearDelay);
|
||
_cameraAnimator.SetTrigger("_afterpulling");
|
||
_cameraAnimator.SetTrigger("_claim");
|
||
}
|
||
|
||
// 绘制钓鱼线
|
||
private void DrawFishingLine()
|
||
{
|
||
if (RodBehaviour == null)
|
||
{
|
||
return;
|
||
}
|
||
Vector3 fishPos = _bait.transform.position;
|
||
if (fishingData.IsCatchingFish || fishingData.IsDrawing || fishingData.IsShowRewardPanel)
|
||
{
|
||
fishPos = GetMouthPos();
|
||
}
|
||
int positionCount = 0;
|
||
var linePoints = new Vector3[2];
|
||
if (_isChangelineStartPos)
|
||
{
|
||
linePoints[0] = _lineStartPos.position;
|
||
linePoints[1] = fishPos;
|
||
positionCount = 2;
|
||
}
|
||
else
|
||
{
|
||
float gravityOnLine = _currentGravityOnLine;
|
||
Vector3 targetPos = fishPos;
|
||
// TODO: restore when DirtyStuck is available
|
||
// if (isStuck && curDirty != null)
|
||
if (false)
|
||
{
|
||
if (gravityOnLine > 1)
|
||
{
|
||
gravityOnLineAdd = false;
|
||
}
|
||
else if (gravityOnLine < -1)
|
||
{
|
||
gravityOnLineAdd = true;
|
||
}
|
||
if (gravityOnLineAdd)
|
||
gravityOnLine += 0.03f;
|
||
else
|
||
gravityOnLine -= 0.03f;
|
||
// TODO: restore when curDirty is available
|
||
// targetPos = curDirty.transform.position;
|
||
}
|
||
if (RodBehaviour.TopLine != null)
|
||
{
|
||
_lineStartPos.position = RodBehaviour.TopLine.position;
|
||
}
|
||
|
||
Vector3 startPos = _lineStartPos.position;
|
||
//计算钓鱼线的长度和分段数
|
||
float distance = Vector3.Distance(startPos, targetPos);
|
||
LineDistance = distance * _tables.TbGlobalConfig.LineLengthParam;
|
||
if (RodBehaviour != null && RodBehaviour.lineLength != null)
|
||
{
|
||
if (LineDistance > fishingData.MaxLinelength)
|
||
{
|
||
RodBehaviour.lineLength.text = fishingData.MaxLinelength.ToString("000");
|
||
}
|
||
else
|
||
RodBehaviour.lineLength.text = LineDistance.ToString("000");
|
||
}
|
||
int segments = Mathf.FloorToInt(distance / CalculateSegmetLenght(distance, _lineResolution));
|
||
List<Vector3> pos1 = new List<Vector3>();
|
||
if (_isLineSin)
|
||
{
|
||
int count = vector3s.Count;
|
||
for (int i = 1; i <= count; i++)
|
||
{
|
||
Vector3 vector = GetCurPos(vector3s[^i], out float zeroTime);
|
||
pos1.Add(vector);
|
||
}
|
||
pos1 = CalculateBezierPoint(pos1);
|
||
segments = pos1.Count;
|
||
}
|
||
if (segments > 0)
|
||
{
|
||
// 计算钓鱼线上的点
|
||
int addCount = 0;
|
||
segments++;
|
||
addCount = RodBehaviour.LineList.Count + 2;
|
||
linePoints = new Vector3[segments + addCount];
|
||
linePoints[0] = RodBehaviour.LineHole.position;
|
||
linePoints[1] = RodBehaviour.EndLine.position;
|
||
|
||
for (int i = 0; i < RodBehaviour.LineList.Count; i++)
|
||
{
|
||
linePoints[i + 2] = RodBehaviour.LineList[i].position;
|
||
|
||
}
|
||
linePoints[addCount] = startPos;
|
||
if (_isLineSin)
|
||
{
|
||
for (int i = 1; i < segments - 1; i++)
|
||
{
|
||
linePoints[i + addCount] = pos1[i];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (int i = 1; i < segments - 1; i++)
|
||
{
|
||
float t = i / (float)segments;
|
||
Vector3 controlPoint = Vector3.Lerp(startPos, targetPos, 0.5f) + Vector3.up * gravityOnLine;
|
||
linePoints[i + addCount] = CalculateBezierPoint(startPos, controlPoint, targetPos, t);
|
||
}
|
||
}
|
||
linePoints[segments + addCount - 2] = targetPos;
|
||
linePoints[segments + addCount - 1] = fishPos;
|
||
positionCount = segments + addCount;
|
||
}
|
||
|
||
}
|
||
if (positionCount > 0)
|
||
{
|
||
// 绘制钓鱼线
|
||
RodBehaviour.fishingLineRenderer.positionCount = positionCount;
|
||
RodBehaviour.fishingLineRenderer.SetPositions(linePoints);
|
||
}
|
||
else
|
||
{
|
||
RodBehaviour.fishingLineRenderer.positionCount = 0;
|
||
}
|
||
}
|
||
|
||
private float CalculateSegmetLenght(float distance, Vector2 lineResolution)
|
||
{
|
||
float x = Mathf.InverseLerp(1, 50, distance);
|
||
float value = Mathf.Lerp(lineResolution.x, lineResolution.y, x);
|
||
|
||
return value;
|
||
}
|
||
|
||
private List<Vector3> CalculateBezierPoint(List<Vector3> curPoints)
|
||
{
|
||
List<Vector3> points = new List<Vector3>();
|
||
Vector3 p1 = curPoints[0];
|
||
points.Add(p1);
|
||
for (int i = 1; i < curPoints.Count - 1; i++)
|
||
{
|
||
if ((p1 - curPoints[i]).magnitude > 1)
|
||
{
|
||
p1 = CalculateBezierPoint(curPoints[i - 1], curPoints[i], curPoints[i + 1], 0.4f);
|
||
points.Add(p1);
|
||
}
|
||
}
|
||
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 OnDisable()
|
||
{
|
||
CloseAllEffect();
|
||
}
|
||
public void CloseAllEffect()
|
||
{
|
||
foreach (var o in _effectDic)
|
||
{
|
||
o.Value.SetActive(false);
|
||
}
|
||
}
|
||
public void CloseSpKillEffect()
|
||
{
|
||
foreach (var modeGo in spKillFxDict.Values)
|
||
{
|
||
if (modeGo)
|
||
{
|
||
Addressables.ReleaseInstance(modeGo);
|
||
}
|
||
}
|
||
spKillFxDict.Clear();
|
||
DelDirty();
|
||
}
|
||
private void OnDestroy()
|
||
{
|
||
disposables?.Dispose();
|
||
disposables = null;
|
||
foreach (var o in _effectDic)
|
||
{
|
||
Addressables.ReleaseInstance(o.Value);
|
||
}
|
||
if (fxWaterDrop != null)
|
||
{
|
||
Addressables.ReleaseInstance(fxWaterDrop);
|
||
fxWaterDrop = null;
|
||
}
|
||
_effectDic.Clear();
|
||
Addressables.Release(rodPrefab);
|
||
Addressables.ReleaseInstance(baitAB);
|
||
if (handAB != null)
|
||
{
|
||
Addressables.ReleaseInstance(handAB);
|
||
}
|
||
if (FishBehaviour != null)
|
||
{
|
||
if (FishBehaviour.modeGo)
|
||
{
|
||
Addressables.ReleaseInstance(FishBehaviour.modeGo);
|
||
}
|
||
Addressables.Release(FishPrefab);
|
||
}
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
Addressables.ReleaseInstance(fx_fishing_splashloop);
|
||
fx_fishing_splashloop = null;
|
||
}
|
||
CloseSpKillEffect();
|
||
DestroySwimFish();
|
||
}
|
||
|
||
Vector3 GetMouthPos()
|
||
{
|
||
if (FishBehaviour == null || FishBehaviour.mouthPos == null)
|
||
{
|
||
return _fish.transform.position;
|
||
}
|
||
return FishBehaviour.mouthPos.position;
|
||
}
|
||
|
||
//刺鱼表现
|
||
public async void PiercingIndex(int index)
|
||
{
|
||
fishingRodAnimator.SetBool("_piercingExit", false);
|
||
_cameraAnimator.SetInteger("_piercingState", index);
|
||
fishingRodAnimator.SetInteger("_piercingState", index);
|
||
|
||
_ = StartCoroutine(PiercingTimeScale(index - 1));
|
||
_cameraAnimator.SetTrigger("_piercing");
|
||
fishingRodAnimator.SetTrigger("_piercing");
|
||
GContext.Publish(ERightState.Piercing);
|
||
_cameraAnimator.SetTrigger("_drawing");
|
||
await Awaiters.Seconds(fishingBehaviorConf.PiercingAnimExitTime[index - 1]);
|
||
RodDrawing();
|
||
}
|
||
|
||
void SetPulling()
|
||
{
|
||
_cameraAnimator.SetInteger("_pullingOver", fishingData.curFishData.PullingOverIndex);
|
||
}
|
||
|
||
IEnumerator PiercingTimeScale(int index)
|
||
{
|
||
float piercingState = fishingBehaviorConf.piercingTime[index];
|
||
var a = DOTween.To(() => 0.01f, x => Time.timeScale = x, 1, piercingState)
|
||
.SetEase(fishingBehaviorConf.piercingTimeScaleCurve);
|
||
yield return new WaitForSeconds(piercingState);
|
||
a.Kill();
|
||
Time.timeScale = 1;
|
||
}
|
||
|
||
public void PlayNewItem()
|
||
{
|
||
if (fishingData.fishEatDataList.Count > 0)
|
||
return;
|
||
var etNewItem = collectingData.ETNewItemFx();
|
||
if (etNewItem != null)
|
||
{
|
||
PlayNewItemFxEvent playNewItemFxEvent = new PlayNewItemFxEvent();
|
||
playNewItemFxEvent.fxName = etNewItem.FxScene[fishingData.NewIndex];
|
||
playNewItemFxEvent.audioName = etNewItem.AudioScene[fishingData.NewIndex];
|
||
playNewItemFxEvent.IsDarkness = etNewItem.IsDarkness[fishingData.NewIndex];
|
||
playNewItemFxEvent.PerformanceDelay = etNewItem.PerformanceDelay[fishingData.NewIndex];
|
||
GContext.Publish(playNewItemFxEvent);
|
||
}
|
||
}
|
||
}
|