diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XCameraSoloComponent.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XCameraSoloComponent.cs | 277 |
1 files changed, 277 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XCameraSoloComponent.cs b/Client/Assets/Scripts/XMainClient/XCameraSoloComponent.cs new file mode 100644 index 00000000..b4d52220 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XCameraSoloComponent.cs @@ -0,0 +1,277 @@ +using System;
+using UnityEngine;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XCameraSoloComponent : XComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XCameraSoloComponent.uuID;
+ }
+ }
+
+ public XCameraSoloComponent.XCameraSoloState SoloState
+ {
+ get
+ {
+ return this._solo_state;
+ }
+ }
+
+ public float SoloInitAngle
+ {
+ get
+ {
+ return this._init_angle;
+ }
+ }
+
+ public XEntity Target
+ {
+ get
+ {
+ return this._target;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("Camera_Solo_Effect");
+
+ private XCameraEx _camera_host = null;
+
+ private XCameraMotionData _motion = new XCameraMotionData();
+
+ private XEmpty _anchor = null;
+
+ private XEntity _target = null;
+
+ private float _rotate_y = 0f;
+
+ private float _init_angle = 0f;
+
+ private float _base_angle = 0f;
+
+ private float _targetRadius = 0f;
+
+ private bool _first_execute = false;
+
+ private Vector3 _base_direction = Vector3.forward;
+
+ private Vector3 _base_position = Vector3.zero;
+
+ private Vector3 _base_location = Vector3.zero;
+
+ private Vector3 _last_location = Vector3.zero;
+
+ private XCameraSoloComponent.XCameraSoloState _solo_state = XCameraSoloComponent.XCameraSoloState.Stop;
+
+ public enum XCameraSoloState
+ {
+ Prepared,
+ Triggered,
+ Executing,
+ Stop
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ this._motion.AutoSync_At_Begin = true;
+ this._motion.Coordinate = CameraMotionSpace.World;
+ this._motion.Follow_Position = true;
+ this._motion.LookAt_Target = false;
+ this._motion.At = 0f;
+ this._motion.Motion = "Animation/Main_Camera/Main_Camera_Idle";
+ this._camera_host = (this._host as XCameraEx);
+ this._solo_state = XCameraSoloComponent.XCameraSoloState.Stop;
+ this._anchor = XSingleton<XEntityMgr>.singleton.CreateEmpty();
+ }
+
+ public override void OnDetachFromHost()
+ {
+ this._camera_host = null;
+ base.OnDetachFromHost();
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.RegisterEvent(XEventDefine.XEvent_CameraSolo, new XComponent.XEventHandler(this.OnSolo));
+ }
+
+ protected bool OnSolo(XEventArgs e)
+ {
+ bool flag = !XCameraEx.OperationH || XSingleton<XOperationData>.singleton.OffSolo;
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ XCameraSoloEventArgs xcameraSoloEventArgs = e as XCameraSoloEventArgs;
+ this._target = xcameraSoloEventArgs.Target;
+ bool flag2 = !XEntity.ValideEntity(this._target);
+ if (flag2)
+ {
+ result = true;
+ }
+ else
+ {
+ Vector3 position = this._target.EngineObject.Position;
+ this._last_location = position;
+ this._targetRadius = this._target.Radius;
+ this._base_position = XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position;
+ this._base_position.y = XSingleton<XScene>.singleton.TerrainY(position);
+ this._base_direction = XSingleton<XCommon>.singleton.Horizontal(this._target.EngineObject.Position - this._base_position);
+ this._base_angle = XSingleton<XCommon>.singleton.AngleToFloat(this._base_direction);
+ this._base_location = this._camera_host.CameraTrans.position;
+ this._init_angle = this._base_angle;
+ this.CalibrateAnchor(this._init_angle);
+ this._solo_state = XCameraSoloComponent.XCameraSoloState.Prepared;
+ this.Start();
+ result = true;
+ }
+ }
+ return result;
+ }
+
+ public void Start()
+ {
+ this._first_execute = true;
+ XCameraMotionEventArgs @event = XEventPool<XCameraMotionEventArgs>.GetEvent();
+ @event.Motion = this._motion;
+ @event.Target = this._anchor;
+ @event.Trigger = "ToSolo";
+ @event.Firer = this._camera_host;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ bool flag = this._target != null && this._target.IsBoss;
+ if (flag)
+ {
+ XSingleton<XAudioMgr>.singleton.PlayBGM("Audio/mapambience/bossnew");
+ }
+ }
+
+ public void Go()
+ {
+ this._solo_state = XCameraSoloComponent.XCameraSoloState.Triggered;
+ }
+
+ public override void Update(float fDeltaT)
+ {
+ XCameraSoloComponent.XCameraSoloState solo_state = this._solo_state;
+ if (solo_state != XCameraSoloComponent.XCameraSoloState.Triggered)
+ {
+ if (solo_state == XCameraSoloComponent.XCameraSoloState.Executing)
+ {
+ bool flag = XEntity.ValideEntity(this._target);
+ if (flag)
+ {
+ this.Execution(this._target.RadiusCenter, fDeltaT);
+ this._last_location = this._target.RadiusCenter;
+ }
+ else
+ {
+ bool flag2 = XSingleton<XSceneMgr>.singleton.Is1V1Scene();
+ if (flag2)
+ {
+ this.Execution(this._last_location, fDeltaT);
+ }
+ else
+ {
+ this.Stop();
+ }
+ }
+ }
+ }
+ else
+ {
+ bool rootReady = this._camera_host.RootReady;
+ if (rootReady)
+ {
+ this._solo_state = XCameraSoloComponent.XCameraSoloState.Executing;
+ }
+ }
+ }
+
+ private void Execution(Vector3 position, float fDeltaT)
+ {
+ bool first_execute = this._first_execute;
+ if (first_execute)
+ {
+ this._base_position = XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position;
+ this._first_execute = false;
+ }
+ else
+ {
+ Vector3 vector = XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position - this._base_position;
+ Vector3 vector2 = Vector3.Project(vector, this._base_direction);
+ Vector3 vector3 = Vector3.Project(vector, Vector3.up);
+ Vector3 vector4 = Vector3.Project(vector, Vector3.Cross(this._base_direction, Vector3.up));
+ float num = (Vector3.Angle(vector2, this._base_direction) > 90f) ? 6f : 3f;
+ this._base_position += vector2 * Mathf.Min(1f, num * fDeltaT);
+ this._base_position += vector3 * Mathf.Min(1f, 2f * fDeltaT);
+ this._base_position += vector4 * Mathf.Min(1f, 2f * fDeltaT);
+ }
+ Vector3 vector5 = XSingleton<XCommon>.singleton.Horizontal(position - this._base_position);
+ float num2 = Vector3.Angle(vector5, this._base_direction);
+ bool flag = XSingleton<XCommon>.singleton.Clockwise(this._base_direction, vector5);
+ if (flag)
+ {
+ num2 = -num2;
+ }
+ this._base_angle += (0f - num2) * Mathf.Min(1f, this.Palstance(position) * fDeltaT);
+ this._base_direction = XSingleton<XCommon>.singleton.FloatToAngle(this._base_angle);
+ float num3 = XSingleton<XCommon>.singleton.AngleToFloat(this._base_direction);
+ this._rotate_y = num3 - this._init_angle;
+ this._camera_host.YRotateExBarely(this._rotate_y);
+ this.CalibrateAnchor(num3);
+ }
+
+ public override void PostUpdate(float fDeltaT)
+ {
+ bool flag = this._solo_state == XCameraSoloComponent.XCameraSoloState.Executing;
+ if (flag)
+ {
+ Vector3 eulerAngles = this._camera_host.CameraTrans.rotation.eulerAngles;
+ Vector3 vector = Quaternion.Euler(eulerAngles) * Vector3.forward;
+ this._camera_host.Offset += (this._camera_host.TargetOffset - this._camera_host.Offset) * Mathf.Min(1f, fDeltaT * 4f);
+ this._base_location = this._camera_host.Anchor - vector * this._camera_host.Offset;
+ }
+ }
+
+ private float Palstance(Vector3 targetPosition)
+ {
+ Vector3 vector = targetPosition - this._base_position;
+ vector.y = 0f;
+ float num = vector.magnitude - this._targetRadius - XSingleton<XEntityMgr>.singleton.Player.Radius;
+ float num2 = 2f;
+ float num3 = 4f;
+ return (num > num3) ? num2 : ((num > 0f) ? (Mathf.Sin(num / num3 * 1.57079637f) * num2) : 0f);
+ }
+
+ private void CalibrateAnchor(float y)
+ {
+ this._anchor.EngineObject.Position = this._base_position;
+ this._anchor.EngineObject.Rotation = Quaternion.Euler(0f, y, 0f);
+ }
+
+ public void Stop()
+ {
+ bool flag = this._camera_host == null || this._solo_state == XCameraSoloComponent.XCameraSoloState.Stop;
+ if (!flag)
+ {
+ this._target = null;
+ this._solo_state = XCameraSoloComponent.XCameraSoloState.Stop;
+ XCameraMotionEndEventArgs @event = XEventPool<XCameraMotionEndEventArgs>.GetEvent();
+ @event.Firer = this._camera_host;
+ @event.Target = this._anchor;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ this._camera_host.AdjustRoot();
+ this._camera_host.TargetOffset = this._camera_host.DefaultOffset;
+ }
+ }
+ }
+}
|