mirror of
https://github.com/tym1116/BH3.git
synced 2025-12-12 22:44:35 +01:00
401 lines
11 KiB
C#
401 lines
11 KiB
C#
using System;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
namespace MoleMole
|
|
{
|
|
[RequireComponent(typeof(Animation))]
|
|
[ExecuteInEditMode]
|
|
public class MonoSimpleAnimation : MonoAuxObject
|
|
{
|
|
public enum TimeScaleMode
|
|
{
|
|
DoNothing = 0,
|
|
IgnoreTimeScale = 1,
|
|
UseLevelTimeScale = 2
|
|
}
|
|
|
|
[Serializable]
|
|
public class CircleTrack
|
|
{
|
|
public float radius;
|
|
|
|
public float angularSpeed;
|
|
|
|
public float startAngle;
|
|
|
|
public float elevation;
|
|
|
|
public bool isAntiClockwise;
|
|
|
|
public GameObject centerPos;
|
|
}
|
|
|
|
[Header("Set this to true and key")]
|
|
public bool useKeyedRotation;
|
|
|
|
[Header("Use animation to key this instead of transform.rotation for working constant tangent")]
|
|
public Vector3 keyedRotation;
|
|
|
|
public bool useAnimRotation;
|
|
|
|
[Header("Use keyed Radial Blur")]
|
|
public bool useKeyedRadialBlur;
|
|
|
|
public Vector2 radialBlurCenter;
|
|
|
|
public float radialBlurStrenth;
|
|
|
|
public float radialBlurScatterScale;
|
|
|
|
[Header("Use this Go postion and rotation")]
|
|
public GameObject realAnimGameObject;
|
|
|
|
[Header("Duplicate a fixed parent transform on start")]
|
|
public bool useFixedParentAnchor;
|
|
|
|
[Header("Set this to true and key")]
|
|
public bool useKeyedFOV;
|
|
|
|
[Header("Use animation to key this instead of maincamera fov")]
|
|
public float keyedFOV;
|
|
|
|
[Header("Use key Directional Light Forward")]
|
|
public bool useKeyedDirectionalLightRotation;
|
|
|
|
[Header("Use animation to key this to control directional light forward")]
|
|
public Vector3 keyedDirectionalLightRotation;
|
|
|
|
[HideInInspector]
|
|
public bool hasPushedLevelTimeScale;
|
|
|
|
[Header("Init FOV, only positive value works")]
|
|
public float initFOV = -1f;
|
|
|
|
[Header("Init Near Z Plane, only positive value works")]
|
|
public float initClipZNear = -1f;
|
|
|
|
[Header("Ignore Time Scale")]
|
|
public TimeScaleMode timeScaleMode;
|
|
|
|
[Header("Animated UI Graphics")]
|
|
public Graphic[] graphics;
|
|
|
|
[NonSerialized]
|
|
public bool selfUpdateKeyedRotation = true;
|
|
|
|
[Header("use circle track")]
|
|
public bool UseSpecificCircleTrack;
|
|
|
|
[Header("circle track parameter")]
|
|
public CircleTrack circleTrack;
|
|
|
|
private bool _hasSetCircleStartTime;
|
|
|
|
private float _circleStartTime;
|
|
|
|
private Vector3 _circleLookAtPos;
|
|
|
|
private Animation _animation;
|
|
|
|
private float _sampleTimer;
|
|
|
|
private AnimationState _animationState;
|
|
|
|
private float _lastTimeScale;
|
|
|
|
private int _levelEntityTimescalIx = -1;
|
|
|
|
public Transform ownedParent { get; private set; }
|
|
|
|
private void Awake()
|
|
{
|
|
_animation = GetComponent<Animation>();
|
|
if (timeScaleMode > TimeScaleMode.DoNothing)
|
|
{
|
|
_lastTimeScale = Singleton<LevelManager>.Instance.levelEntity.TimeScale;
|
|
_sampleTimer = 0f;
|
|
_animationState = _animation[_animation.clip.name];
|
|
}
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
if (useFixedParentAnchor)
|
|
{
|
|
if (!Application.isPlaying || ownedParent != null || base.transform.parent == null)
|
|
{
|
|
return;
|
|
}
|
|
GameObject gameObject = new GameObject();
|
|
gameObject.name = "FixedCameraAnchor";
|
|
ownedParent = gameObject.transform;
|
|
ownedParent.position = base.transform.parent.transform.position;
|
|
Vector3 forward = base.transform.parent.transform.forward;
|
|
forward.y = 0f;
|
|
ownedParent.forward = forward;
|
|
base.transform.parent = ownedParent;
|
|
base.transform.localPosition = Vector3.zero;
|
|
}
|
|
if (UseSpecificCircleTrack && circleTrack != null)
|
|
{
|
|
base.transform.localRotation = circleTrack.centerPos.transform.localRotation;
|
|
_circleLookAtPos = circleTrack.centerPos.transform.position;
|
|
}
|
|
}
|
|
|
|
public void SyncRotation()
|
|
{
|
|
if (useKeyedRotation)
|
|
{
|
|
base.transform.localRotation = Quaternion.Euler(keyedRotation);
|
|
}
|
|
}
|
|
|
|
public void SyncRadialBlur()
|
|
{
|
|
if (useKeyedRadialBlur)
|
|
{
|
|
radialBlurCenter.x = Mathf.Clamp(radialBlurCenter.x, 0f, 1f);
|
|
radialBlurCenter.y = Mathf.Clamp(radialBlurCenter.y, 0f, 1f);
|
|
radialBlurStrenth = Mathf.Clamp(radialBlurStrenth, 0f, 10f);
|
|
radialBlurScatterScale = Mathf.Clamp(radialBlurScatterScale, 0f, 2f);
|
|
}
|
|
}
|
|
|
|
public void SetOwnedParent(Transform ownedParent)
|
|
{
|
|
this.ownedParent = ownedParent;
|
|
base.transform.parent = this.ownedParent;
|
|
base.transform.localPosition = Vector3.zero;
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (Application.isPlaying && ownedParent != null)
|
|
{
|
|
UnityEngine.Object.Destroy(ownedParent.gameObject);
|
|
}
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void TimeSlow(float duration)
|
|
{
|
|
Singleton<LevelManager>.Instance.levelActor.TimeSlow(duration);
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void PushLevelTimeScale(float timescale)
|
|
{
|
|
hasPushedLevelTimeScale = true;
|
|
_levelEntityTimescalIx = Singleton<LevelManager>.Instance.levelEntity.timeScaleStack.Push(timescale);
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void PopLevelTimeScale()
|
|
{
|
|
hasPushedLevelTimeScale = false;
|
|
Singleton<LevelManager>.Instance.levelEntity.timeScaleStack.Pop(_levelEntityTimescalIx);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (selfUpdateKeyedRotation)
|
|
{
|
|
SyncRotation();
|
|
}
|
|
if (useKeyedRadialBlur)
|
|
{
|
|
SyncRadialBlur();
|
|
}
|
|
if (UseSpecificCircleTrack && circleTrack != null && Singleton<LevelManager>.Instance != null && Singleton<LevelManager>.Instance.levelEntity != null)
|
|
{
|
|
if (!_hasSetCircleStartTime)
|
|
{
|
|
_circleStartTime = Time.time;
|
|
_hasSetCircleStartTime = true;
|
|
}
|
|
float num = circleTrack.startAngle + circleTrack.angularSpeed * (Time.time - _circleStartTime) * Singleton<LevelManager>.Instance.levelEntity.TimeScale;
|
|
if (circleTrack.isAntiClockwise)
|
|
{
|
|
num *= -1f;
|
|
}
|
|
Vector3 vector = default(Vector3);
|
|
vector.z = circleTrack.radius * Mathf.Cos(num * ((float)Math.PI / 180f)) * Mathf.Cos(circleTrack.elevation * ((float)Math.PI / 180f));
|
|
vector.x = circleTrack.radius * Mathf.Sin(num * ((float)Math.PI / 180f)) * Mathf.Cos(circleTrack.elevation * ((float)Math.PI / 180f));
|
|
vector.y = circleTrack.radius * Mathf.Sin(circleTrack.elevation * ((float)Math.PI / 180f));
|
|
base.transform.localPosition = circleTrack.centerPos.transform.localPosition + vector;
|
|
base.transform.LookAt(_circleLookAtPos);
|
|
}
|
|
if (timeScaleMode == TimeScaleMode.IgnoreTimeScale)
|
|
{
|
|
_sampleTimer += Time.unscaledDeltaTime * Singleton<LevelManager>.Instance.levelEntity.TimeScale;
|
|
_animationState.time = _sampleTimer;
|
|
_animation.Sample();
|
|
}
|
|
else if (timeScaleMode == TimeScaleMode.UseLevelTimeScale)
|
|
{
|
|
float timeScale = Singleton<LevelManager>.Instance.levelEntity.TimeScale;
|
|
if (_lastTimeScale != timeScale)
|
|
{
|
|
_animationState.speed = timeScale;
|
|
}
|
|
_lastTimeScale = timeScale;
|
|
}
|
|
if (graphics.Length > 0 && _animation.isPlaying)
|
|
{
|
|
for (int i = 0; i < graphics.Length; i++)
|
|
{
|
|
graphics[i].SetAllDirty();
|
|
}
|
|
}
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void ShowCloseUpPanel(string monsterName)
|
|
{
|
|
Singleton<MainUIManager>.Instance.ShowPage(new MonsterCloseUpPageContext(monsterName));
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void HideCloseUpPanel()
|
|
{
|
|
Singleton<NotifyManager>.Instance.FireNotify(new Notify(NotifyTypes.MonsterCloseUpEnd));
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void HideGameObject(string childPath)
|
|
{
|
|
if (string.IsNullOrEmpty(childPath))
|
|
{
|
|
base.gameObject.SetActive(false);
|
|
}
|
|
else
|
|
{
|
|
base.transform.Find(childPath).gameObject.SetActive(false);
|
|
}
|
|
}
|
|
|
|
[AnimationCallback]
|
|
public void SetInLevelUIDeactive()
|
|
{
|
|
MonoInLevelUICanvas inLevelUICanvas = Singleton<MainUIManager>.Instance.GetInLevelUICanvas();
|
|
if (inLevelUICanvas != null)
|
|
{
|
|
inLevelUICanvas.SetInLevelUIActive(false);
|
|
}
|
|
}
|
|
|
|
public void SetInLevelUIActive()
|
|
{
|
|
MonoInLevelUICanvas inLevelUICanvas = Singleton<MainUIManager>.Instance.GetInLevelUICanvas();
|
|
if (inLevelUICanvas != null)
|
|
{
|
|
inLevelUICanvas.SetInLevelUIActive(true);
|
|
}
|
|
}
|
|
|
|
[AnimationCallback]
|
|
public void SetInLevelUIActiveInstant()
|
|
{
|
|
BasePageContext currentPageContext = Singleton<MainUIManager>.Instance.CurrentPageContext;
|
|
if (currentPageContext != null)
|
|
{
|
|
if (currentPageContext is InLevelMainPageContext)
|
|
{
|
|
InLevelMainPageContext inLevelMainPageContext = currentPageContext as InLevelMainPageContext;
|
|
inLevelMainPageContext.SetInLevelMainPageActive(true, true);
|
|
}
|
|
else
|
|
{
|
|
Singleton<MainUIManager>.Instance.CurrentPageContext.SetActive(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void SetInLevelUIDeactiveInstant()
|
|
{
|
|
BasePageContext currentPageContext = Singleton<MainUIManager>.Instance.CurrentPageContext;
|
|
if (currentPageContext != null)
|
|
{
|
|
if (currentPageContext is InLevelMainPageContext)
|
|
{
|
|
InLevelMainPageContext inLevelMainPageContext = currentPageContext as InLevelMainPageContext;
|
|
inLevelMainPageContext.SetInLevelMainPageActive(false, true);
|
|
}
|
|
else
|
|
{
|
|
Singleton<MainUIManager>.Instance.CurrentPageContext.SetActive(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void ActCameraShake(float shakeTime)
|
|
{
|
|
Singleton<CameraManager>.Instance.GetMainCamera().ActShakeEffect(shakeTime, 0.36f, 90f, 2, false, false);
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void EndLevel(string winMsg)
|
|
{
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void FadeIn(float fadeDuration)
|
|
{
|
|
MonoInLevelUICanvas inLevelUICanvas = Singleton<MainUIManager>.Instance.GetInLevelUICanvas();
|
|
Action fadeEndCallback = delegate
|
|
{
|
|
Singleton<EventManager>.Instance.FireEvent(new EvtLevelState(EvtLevelState.State.ExitTransition));
|
|
};
|
|
inLevelUICanvas.FadeInStageTransitPanel(fadeDuration, false, null, fadeEndCallback);
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void FadeOut(float fadeDuration)
|
|
{
|
|
MonoInLevelUICanvas inLevelUICanvas = Singleton<MainUIManager>.Instance.GetInLevelUICanvas();
|
|
Action fadeStartCallback = delegate
|
|
{
|
|
Singleton<EventManager>.Instance.FireEvent(new EvtLevelState(EvtLevelState.State.EnterTransition));
|
|
};
|
|
inLevelUICanvas.FadeOutStageTransitPanel(fadeDuration, false, fadeStartCallback);
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void SetFloorReflectionHeight(float reflectionHeight)
|
|
{
|
|
Singleton<StageManager>.Instance.GetPerpStage().GetComponent<FloorReflection>().floorHeight = reflectionHeight;
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void DebugBreak()
|
|
{
|
|
Debug.Break();
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void MainCanvasFadeIn()
|
|
{
|
|
Singleton<MainUIManager>.Instance.GetInLevelUICanvas().FadeInStageTransitPanel();
|
|
}
|
|
|
|
[AnimationCallback]
|
|
private void MainCanvasFadeOut()
|
|
{
|
|
Singleton<MainUIManager>.Instance.GetInLevelUICanvas().FadeOutStageTransitPanel();
|
|
}
|
|
|
|
public Quaternion GetLightRotation()
|
|
{
|
|
if (ownedParent == null)
|
|
{
|
|
return Quaternion.Euler(keyedDirectionalLightRotation);
|
|
}
|
|
return ownedParent.transform.rotation * Quaternion.Euler(keyedDirectionalLightRotation);
|
|
}
|
|
}
|
|
}
|