772 lines
26 KiB
C#
772 lines
26 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 UnityEngine;
|
||
using UnityEngine.AddressableAssets;
|
||
using Random = UnityEngine.Random;
|
||
public partial class FishingBehaviorB : MonoBehaviour
|
||
{
|
||
|
||
#region 进出水面
|
||
float OldFishPos = -3f;
|
||
float jumpoutMaxCD = 0.2f;
|
||
float jumpoutCD = 0f;
|
||
public void JumpWater()
|
||
{
|
||
if (jumpoutCD > jumpoutMaxCD)
|
||
{
|
||
jumpoutCD = 0;
|
||
float newFishPos = GetFishPos().y;
|
||
if ((newFishPos - _waterHeight) * (OldFishPos - _waterHeight) < 0)
|
||
{
|
||
//进出水面
|
||
if (newFishPos > _waterHeight - 0.00001f)
|
||
{
|
||
Vector3 vector = _fish.transform.position;
|
||
vector.y = _waterHeight;
|
||
if (fx_fishing_water != null)
|
||
{
|
||
fx_fishing_water.transform.position = vector;
|
||
fx_fishing_water.gameObject.SetActive(false);
|
||
fx_fishing_water.gameObject.SetActive(true);
|
||
}
|
||
else if (fx_fishing_jumpout != null)
|
||
{
|
||
fx_fishing_jumpout.transform.position = vector;
|
||
fx_fishing_jumpout.gameObject.SetActive(false);
|
||
fx_fishing_jumpout.gameObject.SetActive(true);
|
||
}
|
||
//播音效
|
||
GContext.Publish(new EventFishingSound(SoundType.audio_fishing_jumpout));
|
||
}
|
||
else if (newFishPos < _waterHeight + 0.00001f)
|
||
{
|
||
Vector3 vector = _fish.transform.position;
|
||
vector.y = _waterHeight;
|
||
//进水面
|
||
if (fx_fishing_water != null)
|
||
{
|
||
fx_fishing_water.transform.position = vector;
|
||
fx_fishing_water.gameObject.SetActive(false);
|
||
fx_fishing_water.gameObject.SetActive(true);
|
||
}
|
||
else if (fx_fishing_jumpinto != null)
|
||
{
|
||
fx_fishing_jumpinto.transform.position = vector;
|
||
fx_fishing_jumpinto.gameObject.SetActive(false);
|
||
fx_fishing_jumpinto.gameObject.SetActive(true);
|
||
}
|
||
//播音效
|
||
GContext.Publish(new EventFishingSound(SoundType.audio_fishing_jumpinto));
|
||
|
||
}
|
||
}
|
||
OldFishPos = newFishPos;
|
||
}
|
||
jumpoutCD += Time.deltaTime;
|
||
}
|
||
#endregion 进出水面
|
||
|
||
//跳跃相关
|
||
bool isJumping = false;
|
||
float JumpDistance = 1;
|
||
GameObject fx_fishing_water;
|
||
GameObject fxHeadFishSkill;
|
||
GameObject fxFishJumpWaterSkill;
|
||
GameObject fxFishStruggleSkill;
|
||
GameObject fxAppendFishSkill;
|
||
public async void PlayFxFishSkill(IFishSpSkillData fishSpSkillData)
|
||
{
|
||
string fxFish = "";
|
||
string fxFishJumpWater = "";
|
||
string fxFishStruggle = "";
|
||
switch (fishSpSkillData.fishSkill.PerformanceType)
|
||
{
|
||
case FishPerformanceType.Jump:
|
||
//技能表现
|
||
fxFish = fishSpSkillData.FxFishJump();
|
||
fxFishJumpWater = fishSpSkillData.FxFishJumpWater();
|
||
break;
|
||
//case FishPerformanceType.Dash:
|
||
// break;
|
||
case FishPerformanceType.Struggle:
|
||
fxFishStruggle = fishSpSkillData.FxFishStruggle();
|
||
break;
|
||
}
|
||
string rootFx = fishSpSkillData.FxFishSkillAppend();
|
||
string fxWater = fishSpSkillData.FxWater();
|
||
if (!string.IsNullOrEmpty(fxWater) && fx_fishing_water == null)
|
||
{
|
||
fx_fishing_water = await Addressables.InstantiateAsync(fxWater, transform, true).Task;
|
||
fx_fishing_water?.SetActive(false);
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(fxFishJumpWater) && fxFishJumpWaterSkill == null)
|
||
{
|
||
fxFishJumpWaterSkill = await Addressables.InstantiateAsync(fxFishJumpWater, transform).Task;
|
||
}
|
||
if (!string.IsNullOrEmpty(fxFishStruggle) && fxFishStruggleSkill == null && FishBehaviour != null)
|
||
{
|
||
fxFishStruggleSkill = await Addressables.InstantiateAsync(fxFishStruggle, FishBehaviour.transform).Task;
|
||
}
|
||
if (!string.IsNullOrEmpty(fxFish) && fxHeadFishSkill == null && FishBehaviour != null && FishBehaviour.Head != null)
|
||
{
|
||
fxHeadFishSkill = await Addressables.InstantiateAsync(fxFish, FishBehaviour.Head).Task;
|
||
}
|
||
if (!string.IsNullOrEmpty(rootFx) && fxAppendFishSkill == null && FishBehaviour != null && FishBehaviour.Head != null)
|
||
{
|
||
fxAppendFishSkill = await Addressables.InstantiateAsync(rootFx, FishBehaviour.Head).Task;
|
||
}
|
||
fxHeadFishSkill?.SetActive(false);
|
||
fxHeadFishSkill?.SetActive(true);
|
||
fxAppendFishSkill?.SetActive(false);
|
||
fxAppendFishSkill?.SetActive(true);
|
||
fxFishStruggleSkill?.SetActive(false);
|
||
fxFishStruggleSkill?.SetActive(true);
|
||
fxFishJumpWaterSkill?.SetActive(true);
|
||
}
|
||
|
||
public void StopFxFishSkill()
|
||
{
|
||
fxHeadFishSkill?.SetActive(false);
|
||
}
|
||
public void SkillRelease()
|
||
{
|
||
if (fxHeadFishSkill != null)
|
||
{
|
||
Addressables.ReleaseInstance(fxHeadFishSkill);
|
||
fxHeadFishSkill = null;
|
||
}
|
||
|
||
if (fxAppendFishSkill != null)
|
||
{
|
||
Addressables.ReleaseInstance(fxAppendFishSkill);
|
||
fxAppendFishSkill = null;
|
||
}
|
||
if (fx_fishing_water != null)
|
||
{
|
||
Addressables.ReleaseInstance(fx_fishing_water);
|
||
fx_fishing_water = null;
|
||
}
|
||
if (fxFishStruggleSkill != null)
|
||
{
|
||
Addressables.ReleaseInstance(fxFishStruggleSkill);
|
||
fxFishStruggleSkill = null;
|
||
}
|
||
if (fxFishJumpWaterSkill != null)
|
||
{
|
||
Addressables.ReleaseInstance(fxFishJumpWaterSkill);
|
||
fxFishJumpWaterSkill = null;
|
||
}
|
||
}
|
||
public async void PlayJump()
|
||
{
|
||
FishData curFishData = fishingData.curFishData;
|
||
isJumping = true;
|
||
fishAnimator.SetTrigger($"_jumping0{fishingData.FishJump.AnimatorState}");
|
||
fishAnimator.SetTrigger("_jumping");
|
||
fishAnimator.SetTrigger($"_drawing0{curFishData.ShowAnimation}");
|
||
if (FishBehaviour != null)
|
||
{
|
||
FishBehaviour.SetSkillInt(fishingData.FishJump.SkillIndex);
|
||
FishBehaviour.SetTrigger("Skill");
|
||
}
|
||
FishJump fishJump = fishingData.FishJump;
|
||
if (fishJump != null)
|
||
{
|
||
_ = StartCoroutine(PlayerJumpOutDelay(fishJump.FxJumpOutDelay, fishJump.JumpDistance));
|
||
_ = StartCoroutine(PlayerJumpIntoDelay(fishJump.FxJumpIntoDelay));
|
||
float jumpEndTime = fishJump.JumpEndTime;
|
||
await Awaiters.Seconds(jumpEndTime);
|
||
}
|
||
isJumping = false;
|
||
JumpDistance = 1;
|
||
if (fishingData.FishJump == null)
|
||
return;
|
||
if (fxFishJumpWaterSkill != null)
|
||
{
|
||
fxFishJumpWaterSkill.SetActive(true);
|
||
}
|
||
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.transform.localScale = Vector3.one * fishingData.curFishData.SlashFxScale;
|
||
fx_fishing_splashloop.SetActive(true);
|
||
}
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.transform.localScale = Vector3.one * fishingData.curFishData.SlashFxScale;
|
||
fx_fishing_splashwaveloop.SetActive(true);
|
||
}
|
||
}
|
||
IEnumerator PlayerJumpOutDelay(float fxJumpOutDelay, float jumpDistance)
|
||
{
|
||
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.transform.DOScale(Vector3.zero, fxJumpOutDelay).SetEase(Ease.Linear);
|
||
}
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.transform.DOScale(Vector3.zero, fxJumpOutDelay).SetEase(Ease.Linear);
|
||
}
|
||
yield return new WaitForSeconds(fxJumpOutDelay);
|
||
GContext.Publish(new EventFishingSound(SoundType.HPEvent));
|
||
CloseBaitDoTween();
|
||
JumpDistance = jumpDistance;
|
||
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.SetActive(false);
|
||
}
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.SetActive(false);
|
||
}
|
||
|
||
if (fxFishJumpWaterSkill != null)
|
||
{
|
||
fxFishJumpWaterSkill.SetActive(false);
|
||
}
|
||
}
|
||
IEnumerator PlayerJumpIntoDelay(float fxJumpIntoDelay)
|
||
{
|
||
yield return new WaitForSeconds(fxJumpIntoDelay);
|
||
GContext.Publish(new EventFishingSound(SoundType.HPEvent));
|
||
CloseBaitDoTween();
|
||
JumpDistance = 1;
|
||
}
|
||
public void StartSplashloopScale()
|
||
{
|
||
Vector3 localScale = Vector3.one * fishingData.curFishData.SlashFxScale * 1.5f;
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.transform.DOKill();
|
||
fx_fishing_splashloop.transform.localScale = localScale;
|
||
}
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.transform.DOKill();
|
||
fx_fishing_splashwaveloop.transform.localScale = localScale;
|
||
}
|
||
if (fishingData.superDashSpSkillData != null)
|
||
{
|
||
HideSpSkillFx("dashFx");
|
||
HideSpSkillFx("dashWaterFx");
|
||
}
|
||
}
|
||
public void EndSplashloopScale()
|
||
{
|
||
Vector3 localScale = Vector3.one * fishingData.curFishData.SlashFxScale;
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.transform.DOKill();
|
||
fx_fishing_splashloop.transform.DOScale(localScale, 1).SetEase(Ease.Linear);
|
||
}
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.transform.DOKill();
|
||
fx_fishing_splashwaveloop.transform.DOScale(localScale, 1).SetEase(Ease.Linear);
|
||
}
|
||
}
|
||
//====跳跃相关
|
||
//=====================鱼移动算法挪位置
|
||
private float timer = 1f;
|
||
float dashTime = 0f;
|
||
|
||
private float moveTimer = 0f;
|
||
private Vector3 _strugglePoint;
|
||
|
||
private Vector3 _startPos;
|
||
private Vector3 _curStartPos;
|
||
Tweener baitDoTween;
|
||
//X轴偏移
|
||
float _nearDistance = 1;
|
||
float _farDistance = 1;
|
||
float distance = 1;
|
||
float fishSpeed = 1;
|
||
public bool Far => _fish.transform.position.z >= _farDistance;
|
||
void SetBaitStartPos()
|
||
{
|
||
_nearDistance = _fishSwimAreaZNear;
|
||
_nearDistance = Mathf.Clamp(_nearDistance, _fishSwimAreaZNear, _fishSwimAreaZFar);
|
||
_farDistance = _fishSwimAreaZFar;
|
||
_farDistance = Mathf.Clamp(_farDistance, _fishSwimAreaZNear, _fishSwimAreaZFar);
|
||
_startPos = _fish.transform.position;
|
||
_curStartPos = _startPos;
|
||
|
||
float z = Random.Range(_nearDistance, _farDistance);
|
||
_strugglePoint = GeneratePoint(z, 0) / 2;
|
||
timer = 10;
|
||
}
|
||
public async void OnFail(float z, float speed)
|
||
{
|
||
EscapeFish(z);
|
||
var targetPos = Vector3.Lerp(_curStartPos, _strugglePoint, fishSpeed / distance);
|
||
_fish.transform.DOMove(targetPos, 1);
|
||
await Awaiters.Seconds(1);
|
||
GetFish.gameObject.SetActive(false);
|
||
if (fx_fishing_splashloop != null)
|
||
{
|
||
fx_fishing_splashloop.SetActive(false);
|
||
}
|
||
if (fx_fishing_splashwaveloop != null)
|
||
{
|
||
fx_fishing_splashwaveloop.SetActive(false);
|
||
}
|
||
}
|
||
//往安全区域外移动
|
||
public void EscapeFish(float z)
|
||
{
|
||
moveTimer = 0;
|
||
_strugglePoint.z = z;
|
||
_strugglePoint.x = 0;
|
||
_curStartPos = _fish.transform.position;
|
||
distance = Vector3.Distance(_curStartPos, _strugglePoint);
|
||
FishTurn();
|
||
}
|
||
void SimulateFishEscape(float fishSpeed)
|
||
{
|
||
moveTimer += Time.deltaTime * fishSpeed;
|
||
|
||
if (moveTimer / distance < 1)
|
||
{
|
||
_fish.transform.position = Vector3.Lerp(_curStartPos, _strugglePoint, moveTimer / distance);
|
||
Debug.Log("moveTimer / distance:" + _strugglePoint);
|
||
}
|
||
}
|
||
//停止正常的移动，贝塞尔DoTween
|
||
public void CloseBaitDoTween()
|
||
{
|
||
if (baitDoTween != null)
|
||
{
|
||
baitDoTween.Kill();
|
||
baitDoTween = null;
|
||
timer = 10;
|
||
}
|
||
}
|
||
float dashSpeedInc;
|
||
public void DashStayTime(float dashSpeedInc)
|
||
{
|
||
IsPrepareDash = false;
|
||
SetFishDash();
|
||
dashTime = 0;
|
||
timer = 10;
|
||
this.dashSpeedInc = dashSpeedInc;
|
||
}
|
||
void SetFishDash()
|
||
{
|
||
fishingData.DashStay = GetFishDash();
|
||
if (FishBehaviour != null && fishingData.DashStay != null)
|
||
{
|
||
FishBehaviour.SetSkillInt(fishingData.DashStay.SkillIndex);
|
||
}
|
||
dashPrepareTime = 0;
|
||
}
|
||
public void SetStruggle()
|
||
{
|
||
if (FishBehaviour != null && fishingData.FishStruggle != null)
|
||
{
|
||
FishBehaviour.SetSkillInt(fishingData.FishStruggle.SkillIndex);
|
||
FishBehaviour.SetTrigger("Skill");
|
||
}
|
||
}
|
||
|
||
|
||
public void StartMoveFish()
|
||
{
|
||
timer = 10;
|
||
}
|
||
|
||
//能随时修改速度的移动轨迹
|
||
void SimulateFish(float curFishSpeed, float nearDistance, float farDistance)
|
||
{
|
||
fishSpeed = curFishSpeed;
|
||
if (NotMove)
|
||
{
|
||
CloseBaitDoTween();
|
||
return;
|
||
}
|
||
_nearDistance = nearDistance * (_fishSwimAreaZFar - _fishSwimAreaZNear) + _fishSwimAreaZNear;
|
||
_nearDistance = Mathf.Clamp(_nearDistance, _fishSwimAreaZNear, _fishSwimAreaZFar);
|
||
_farDistance = farDistance * (_fishSwimAreaZFar - _fishSwimAreaZNear) + _fishSwimAreaZFar;
|
||
_farDistance = Mathf.Clamp(_farDistance, _fishSwimAreaZNear, _fishSwimAreaZFar);
|
||
timer += Time.deltaTime;
|
||
float rangeTimer = Random.Range(5f, 10f);
|
||
if (fishingData.superDashSpSkillData != null && IsPrepareDash && dashPrepareTime > 0)
|
||
{
|
||
dashPrepareTime -= Time.deltaTime;
|
||
if (dashPrepareTime <= 0)
|
||
{
|
||
timer = 10;
|
||
}
|
||
}
|
||
if (timer > rangeTimer || Vector3.Distance(_fish.transform.position, _strugglePoint) < 1)
|
||
{
|
||
CloseBaitDoTween();
|
||
float escapeDistanceMag = GContext.container.Resolve<PlayerData>().GrtEscapeDistanceMag();
|
||
if (fishingData.DashStay != null)
|
||
{
|
||
if (!DashMove())
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
isDashMove = false;
|
||
float z = Random.Range(_nearDistance, _farDistance);
|
||
if (fishingData.MaxZEscape > 0.001f)
|
||
{
|
||
z = fishingData.MaxZEscape * escapeDistanceMag;
|
||
}
|
||
_strugglePoint = GeneratePoint(z, _fish.transform.position.x);
|
||
}
|
||
timer = 0;
|
||
moveTimer = 0;
|
||
_strugglePoint.y = GetFishUnderwaterOffset();
|
||
if (fishingData.MaxYEscape > 0.001f)
|
||
{
|
||
_strugglePoint.y = fishingData.MaxYEscape * escapeDistanceMag;
|
||
}
|
||
if (fishingData.MaxZEscape > 0.001f)
|
||
{
|
||
_strugglePoint.z = fishingData.MaxZEscape * escapeDistanceMag;
|
||
if (_strugglePoint.z < _fishSwimAreaZFar)
|
||
{
|
||
_strugglePoint.z = _fishSwimAreaZFar;
|
||
}
|
||
if (fishingData.DashStayTime <= 0 &&
|
||
!isJumping &&
|
||
_fish.transform.position.z < _strugglePoint.z - 5)
|
||
{
|
||
_strugglePoint.x = 0;
|
||
}
|
||
if (fishingData.NextPointEMin > 0.001f && fishingData.NextPointEMax > 0.001f)
|
||
{
|
||
_strugglePoint.z = _fish.transform.position.z + Random.Range(fishingData.NextPointEMin, fishingData.NextPointEMax);
|
||
}
|
||
}
|
||
_curStartPos = _fish.transform.position;
|
||
_curStartPos.y = GetFishUnderwaterOffset();
|
||
distance = Vector3.Distance(_curStartPos, _strugglePoint);
|
||
//开始转向
|
||
FishTurn();
|
||
|
||
Vector3 offset = _strugglePoint - _curStartPos;
|
||
Vector3 mid = (_strugglePoint + _curStartPos) / 2;
|
||
float x;
|
||
if (Math.Abs(offset.x) > Math.Abs(offset.z))
|
||
{
|
||
x = offset.x * Random.Range(0, 0.25f);
|
||
mid.z += offset.x * Random.Range(-0.25f, 0.25f);
|
||
}
|
||
else
|
||
{
|
||
//z轴比较长
|
||
x = offset.z * Random.Range(0, 0.25f);
|
||
mid.z += offset.z * Random.Range(-0.25f, 0.25f);
|
||
}
|
||
if (mid.x * x > 0)
|
||
{
|
||
mid.x -= x;
|
||
}
|
||
else
|
||
{
|
||
mid.x += x;
|
||
}
|
||
|
||
float turnTime = 0;
|
||
Vector3 fishPos = _fish.transform.position;
|
||
Vector3[] path = new Vector3[] { _curStartPos, mid, _strugglePoint };// GetBezierCurvePoints(_curStartPos, mid, _strugglePoint, 10);
|
||
baitDoTween = _fish.transform.DOPath(path, fishSpeed, PathType.CatmullRom).SetSpeedBased(true)
|
||
.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;
|
||
}));
|
||
if (fishingData.DashStayTime > 0.001f)
|
||
{
|
||
baitDoTween.SetEase(Ease.OutCubic);
|
||
}
|
||
else
|
||
{
|
||
baitDoTween.SetEase(Ease.Linear);
|
||
}
|
||
}
|
||
}
|
||
public void FishTurn()
|
||
{
|
||
FishingPanel_Advanced.Instance?.SetFishIconDir(_fish.transform.position.x > _strugglePoint.x);
|
||
|
||
Quaternion rotation = Quaternion.LookRotation(_fish.transform.position - _strugglePoint);
|
||
_fish.transform.DORotateQuaternion(rotation, GetTurnTime())/*.SetEase(Ease.InOutSine);*/;
|
||
}
|
||
Vector3 GeneratePoint(float z, float curX)
|
||
{
|
||
float x1 = (_fishSwimAreaXFar - _fishSwimAreaXNear) / (_fishSwimAreaZFar - _fishSwimAreaZNear) * (z - _fishSwimAreaZNear) + _fishSwimAreaXNear;
|
||
//float x = Random.Range(_fishSwimAreaXNear, x1);
|
||
float min = curX - x1;
|
||
float max = curX + x1;
|
||
if (min < -x1)
|
||
{
|
||
min = -x1;
|
||
}
|
||
if (max > x1)
|
||
{
|
||
max = x1;
|
||
}
|
||
float x = Random.Range(min, max);
|
||
return new Vector3(x, 0, z);
|
||
}
|
||
bool isDashMove;
|
||
|
||
|
||
bool DashMove()
|
||
{
|
||
fx_fishing_splashloopreeling.SetActive(false);
|
||
string dashPerformanceFx = "";
|
||
if (fishingData.fishSpSkillData != null)
|
||
{
|
||
dashPerformanceFx = fishingData.fishSpSkillData.DashPerformanceFx();
|
||
}
|
||
if (!isDashMove)
|
||
{
|
||
isDashMove = true;
|
||
StartSplashloopScale();
|
||
FishBehaviour.SetTrigger("Skill");
|
||
if (!string.IsNullOrEmpty(dashPerformanceFx))
|
||
{
|
||
LoadEffectNoMove(dashPerformanceFx, transform);
|
||
}
|
||
}
|
||
dashTime += Time.deltaTime;
|
||
if (dashTime < fishingData.DashStayTime)
|
||
{
|
||
DOTween.Kill("FishSkillStaminaParam");
|
||
fishingData.FishSkillStaminaState = 3;
|
||
fishingData.FishSkillStaminaParam = 1 - dashTime / fishingData.DashStayTime;
|
||
if (fishingData.superDashSpSkillData != null)
|
||
{
|
||
HideSpSkillFx("dashFx");
|
||
HideSpSkillFx("dashWaterFx");
|
||
}
|
||
return false;
|
||
}
|
||
if (!string.IsNullOrEmpty(dashPerformanceFx))
|
||
{
|
||
LoadEffectNoMove(dashPerformanceFx, false);
|
||
}
|
||
isDashMove = false;
|
||
EndSplashloopScale();
|
||
if (fishingData.DashStayTime < 0)
|
||
{
|
||
fishingData.DashStay = null;
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
fishingData.FishSkillStaminaState = 2;
|
||
fishingData.FishSkillStaminaParam = 1;
|
||
if (fishingData.superDashSpSkillData != null)
|
||
{
|
||
if (!IsPrepareDash)
|
||
{
|
||
IsPrepareDash = true;
|
||
SetFishDash();
|
||
}
|
||
else
|
||
{
|
||
IsPrepareDash = false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
SetFishDash();
|
||
}
|
||
}
|
||
if (FishBehaviour)
|
||
{
|
||
FishBehaviour.PlaySwim01();
|
||
}
|
||
DOTween.To(() => fishingData.FishSkillStaminaParam,
|
||
x => fishingData.FishSkillStaminaParam = x, 0, Random.Range(5f, 10f)).SetId("FishSkillStaminaParam");
|
||
if (fishingData.fishSpSkillData != null)
|
||
{
|
||
string dashFx = fishingData.fishSpSkillData.FxDash();
|
||
if (!string.IsNullOrEmpty(dashFx))
|
||
{
|
||
PlaySpSkillFx("dashFx", dashFx);
|
||
}
|
||
if (!IsPrepareDash)
|
||
{
|
||
//播放 DashWaterFx;
|
||
string dashWaterFx = fishingData.fishSpSkillData.DashWaterFx();
|
||
if (!string.IsNullOrEmpty(dashWaterFx))
|
||
{
|
||
PlaySpSkillFx("dashWaterFx", dashWaterFx, FishBehaviour.Tail);
|
||
}
|
||
}
|
||
}
|
||
if (fishingData.superDashSpSkillData == null || IsPrepareDash)
|
||
{
|
||
_strugglePoint = DashPoint(_fish.transform.position.x);
|
||
}
|
||
|
||
if (fishingData.superDashSpSkillData != null && IsPrepareDash)
|
||
{
|
||
fishSpeed /= dashSpeedInc;
|
||
dashPrepareTime = fishingData.superDashSpSkillData.GetDashPrepareTime(fishingData.DashStay.SkillIndex - 1);
|
||
dashTime = fishingData.DashStayTime;
|
||
}
|
||
else
|
||
{
|
||
if (fishingData.superDashSpSkillData != null)
|
||
{
|
||
MapData mapData = _tables.TbMapData.GetOrDefault(fishingData.MapId);
|
||
fishSpeed *= mapData.EscapeSpeedMag;
|
||
}
|
||
dashTime = 0;
|
||
}
|
||
GContext.Publish(new EventFishingSound(SoundType.audio_fishing_dash));
|
||
fx_fishing_splashloopreeling.SetActive(true);
|
||
return true;
|
||
}
|
||
FishDash GetFishDash()
|
||
{
|
||
List<int> animationTypeList = fishingData.curFishData.AnimationTypeList;
|
||
if (animationTypeList.Count <= 1)
|
||
{
|
||
return _tables.TbFishDash.GetOrDefault(animationTypeList[0]);
|
||
}
|
||
List<FishDash> fishDashes = new List<FishDash>();
|
||
int weight = 0;
|
||
foreach (var item in animationTypeList)
|
||
{
|
||
FishDash fishDash = _tables.TbFishDash.GetOrDefault(item);
|
||
if (fishDash != null)
|
||
{
|
||
fishDashes.Add(fishDash);
|
||
weight += fishDash.Weight;
|
||
}
|
||
}
|
||
if (fishDashes.Count == 1)
|
||
{
|
||
return fishDashes[0];
|
||
}
|
||
int random = Random.Range(0, weight);
|
||
foreach (var item in fishDashes)
|
||
{
|
||
random -= item.Weight;
|
||
if (random <= 0)
|
||
{
|
||
return item;
|
||
}
|
||
}
|
||
Debug.LogError("Not FishDash FishDataID =" + fishingData.curFishData.ID);
|
||
return null;
|
||
}
|
||
bool IsPrepareDash = false;
|
||
float dashPrepareTime;
|
||
Vector3 DashPoint(float curX)
|
||
{
|
||
float near = _nearDistance;
|
||
float far = _farDistance;
|
||
|
||
if (fishingData.superDashSpSkillData != null)
|
||
{
|
||
var super = fishingData.superDashSpSkillData;
|
||
int chargeCount = super.ChargeCount;
|
||
float posz = super.PosZChange * chargeCount;
|
||
near = super.PosZInit[0] + posz;
|
||
far = super.PosZInit[1] + posz;
|
||
super.AddChargeCount();
|
||
chargeCount = super.ChargeCount;
|
||
fishSpeed *= (1 + super.DashSpeedChange * chargeCount);
|
||
fishingData.StrugglingPower += super.StrengthChange;
|
||
}
|
||
float z = Random.Range(near, far);
|
||
float x1 = (_fishSwimAreaXFar - _fishSwimAreaXNear) / (_farDistance - _nearDistance) * (z - _nearDistance) + _fishSwimAreaXNear;
|
||
|
||
float nextPointNear = x1 * fishingData.NextPointMin;
|
||
float nextPointFar = x1 * fishingData.NextPointMax;
|
||
float point = Random.Range(nextPointNear, nextPointFar);
|
||
|
||
float x = point;
|
||
if (curX > 0)
|
||
{
|
||
x = -point;
|
||
}
|
||
return new Vector3(x, 0, z);
|
||
}
|
||
|
||
Dictionary<string, GameObject> spKillFxDict = new Dictionary<string, GameObject>();
|
||
public void HideSpSkillFx(string key)
|
||
{
|
||
if (spKillFxDict.TryGetValue(key, out GameObject fx))
|
||
{
|
||
if (fx != null)
|
||
{
|
||
fx.SetActive(false);
|
||
}
|
||
}
|
||
}
|
||
public async void PlaySandStorm(float delay, SandStorm sandStorm)
|
||
{
|
||
await Task.Delay((int)(delay * 1000));
|
||
var fx = await PlaySpSkillFx("sandStormFx", sandStorm.JumpFx, transform);
|
||
if (fx != null)
|
||
{
|
||
fx.SetActive(false);
|
||
fx.SetActive(true);
|
||
}
|
||
}
|
||
|
||
public async Task<GameObject> PlaySpSkillFx(string key, string fxName, Transform parent = null)
|
||
{
|
||
if (!spKillFxDict.TryGetValue(key, out GameObject fx))
|
||
{
|
||
spKillFxDict[key] = null;
|
||
if (key == "struggleFx")
|
||
{
|
||
parent = FishBehaviour.Neck;
|
||
}
|
||
if (parent == null)
|
||
{
|
||
parent = FishBehaviour.Root;
|
||
}
|
||
fx = await Addressables.InstantiateAsync(fxName, parent).Task;
|
||
if (fx == null)
|
||
{
|
||
return null;
|
||
}
|
||
spKillFxDict[key] = fx;
|
||
}
|
||
else
|
||
{
|
||
fx = spKillFxDict[key];
|
||
}
|
||
if (fx != null)
|
||
{
|
||
fx.SetActive(true);
|
||
}
|
||
return fx;
|
||
}
|
||
}
|