private void PlaybackEventTrigger(EventEntity evt, PlayDirection direction)
{
if (direction == PlayDirection.Forward)
{
switch (evt)
{
case EffectKindEvent effectKind:
{
var effect = m_currentEffects[effectKind.EffectIndex] = effectKind.Effect;
if (effect == null)
{
m_audioController.RemoveEffect(effectKind.EffectIndex);
}
else
{
m_audioController.SetEffect(effectKind.EffectIndex, CurrentQuarterNodeDuration, effect, 1.0f);
}
}
break;
// TODO(local): left/right lasers separate + allow both independent if needed
case LaserFilterGainEvent filterGain: laserGain = filterGain.Gain; break;
case LaserFilterKindEvent filterKind:
{
m_audioController.SetEffect(6, CurrentQuarterNodeDuration, currentLaserEffectDef = filterKind.Effect, m_audioController.GetEffectMix(6));
}
break;
case SlamVolumeEvent pars: m_slamSample.Volume = pars.Volume * SLAM_VOLUME_MOD; break;
}
}
}
public AnimationWrapper(Animation anim, string statename, PlayDirection direction)
: this(direction)
{
this.animation = anim;
this.animationState = anim[statename];
this.stateName = statename;
}
public void PlayAnimationDirector(xpAnimController animator_object, PlayDirection pd_dir = PlayDirection.pd_Forward)
{
if (animator_object != null)
{
animator_object.PlayDirection = pd_dir;
animator_object.Play();
}
}
private void PlaybackEventTrigger(ChartEvent evt, PlayDirection direction)
{
if (direction == PlayDirection.Forward)
{
switch (evt)
{
case EffectKindEvent effectKind:
{
var effect = m_currentEffects[effectKind.EffectIndex] = effectKind.Effect;
if (effect == null)
{
m_audioController.RemoveEffect(effectKind.EffectIndex);
}
else
{
m_audioController.SetEffect(effectKind.EffectIndex, CurrentQuarterNodeDuration, effect, 1.0f);
}
}
break;
case LaserApplicationEvent app: m_highwayControl.LaserApplication = app.Application; break;
// TODO(local): left/right lasers separate + allow both independent if needed
case LaserFilterGainEvent filterGain: laserGain = filterGain.Gain; break;
case LaserFilterKindEvent filterKind:
{
m_audioController.SetEffect(6, CurrentQuarterNodeDuration, currentLaserEffectDef = filterKind.Effect, m_audioController.GetEffectMix(6));
}
break;
case LaserParamsEvent pars:
{
if (pars.LaserIndex.HasFlag(LaserIndex.Left))
{
m_highwayControl.LeftLaserParams = pars.Params;
}
if (pars.LaserIndex.HasFlag(LaserIndex.Right))
{
m_highwayControl.RightLaserParams = pars.Params;
}
}
break;
case SlamVolumeEvent pars: m_slamSample.Volume = pars.Volume; break;
}
}
switch (evt)
{
case SpinImpulseEvent spin: m_highwayControl.ApplySpin(spin.Params, spin.AbsolutePosition); break;
case SwingImpulseEvent swing: m_highwayControl.ApplySwing(swing.Params, swing.AbsolutePosition); break;
case WobbleImpulseEvent wobble: m_highwayControl.ApplyWobble(wobble.Params, wobble.AbsolutePosition); break;
}
}
public void Play(PlayDirection direction)
{
amountPerDelta = Mathf.Abs(AmountPerDelta);
if (direction.Equals(PlayDirection.Reverse))
{
amountPerDelta = -AmountPerDelta;
}
enabled = true;
Update();
}
public AnimationWrapper(ModuleAnimateGeneric mod, PlayDirection direction) : this(direction)
{
Animation[] partAnims = mod.part.FindModelAnimators(mod.animationName);
if (partAnims.Length > 0)
{
this.module = mod;
this.animation = partAnims[0];
this.animationState = this.animation[mod.animationName];
this.stateName = mod.animationName;
}
}
public void ResetForPlaying(PlayDirection direction)
{
if (direction.Equals(PlayDirection.Forward))
{
ResetForForwardPlaying();
return;
}
if (direction.Equals(PlayDirection.Reverse))
{
ResetForReversePlaying();
return;
}
}
public AnimationWrapper(ModuleAnimateGeneric mod, PlayDirection direction)
: this(direction)
{
Animation[] partAnims = mod.part.FindModelAnimators(mod.animationName);
if (partAnims.Length > 0)
{
this.module = mod;
this.animation = partAnims[0];
this.animationState = this.animation[mod.animationName];
this.stateName = mod.animationName;
}
}
public void ResetTime(PlayDirection dir, float rate, float delay)
{
playDirection = dir;
for (int i = 0; i < m_Rates.Length; i++)
{
m_Rates[i] = rate;
}
for (int i = 0; i < m_Delays.Length; i++)
{
m_Delays[i] = -delay;
}
}
void RecordAll()
{
_enabledRecord = enabled;
_normalizedTimeRecord = _normalizedTime;
_directionRecord = direction;
if (_animations != null)
{
foreach (var anim in _animations)
{
anim?.Record();
}
}
}
private void RecordAll()
{
m_EnableRecord = enabled;
m_NormalizedTimeRecord = NormalizedTime;
m_DirectionRecord = playDirection;
if (m_Animations == null)
{
return;
}
for (int i = 0; i < m_Animations.Count; i++)
{
m_Animations[i]?.Record();
}
}
public void Press(PlayDirection dir)
{
if (dir == PlayDirection.Forward)
{
helper.Play(PlayDirection.Forward, PlayMode.Play, null);
}
else
{
helper.Play(PlayDirection.Reverse, PlayMode.Play, Idle);
}
PlayPrepare(State.Press, null);
foreach (var c in children)
{
c.Press(dir);
}
}
public void Play(PlayDirection dir, PlayMode mode, Action callback, float delay = 0)
{
bool isForward = dir == PlayDirection.Forward;
switch (mode)
{
case PlayMode.Replay:
ResetTime(dir, isForward ? 0 : 1, delay);
break;
case PlayMode.Skip:
ResetTime(dir, isForward ? 1 : 0, 0);
break;
}
onFinished = callback;
playDirection = dir;
isPlaying = true;
}
private void PlaybackVisualEventTrigger(EventEntity evt, PlayDirection direction)
{
if (direction == PlayDirection.Forward)
{
switch (evt)
{
case LaserApplicationEvent app: m_highwayControl.LaserApplication = app.Application; break;
case LaserParamsEvent pars:
{
if (pars.LaserIndex.HasFlag(LaserIndex.Left))
{
m_highwayControl.LeftLaserParams = pars.Params;
}
if (pars.LaserIndex.HasFlag(LaserIndex.Right))
{
m_highwayControl.RightLaserParams = pars.Params;
}
}
break;
}
}
}
public AnimationWrapper(Animation anim, string statename, PlayDirection direction) : this(direction)
{
this.animation = anim;
this.animationState = anim[statename];
this.stateName = statename;
}
private AnimationWrapper(PlayDirection direction)
{
this.startDirection = direction;
}
} // PlayTimeRange
// ----------------------------------------------------------------------
public PlayTimeRange(DateTime start, DateTime end, PlayDirection direction = PlayDirection.Forward) :
base(start, end)
{
this.direction = direction;
} // PlayTimeRange
protected override void OnUpdate()
{
#if UNITY_EDITOR
if (_dragging)
{
return;
}
#endif
float deltaTime =
#if UNITY_EDITOR
!Application.isPlaying ? UnityExtensions.Editor.EditorApplicationKit.deltaTime :
#endif
(timeMode == TimeMode.Normal ? Time.deltaTime : Time.unscaledDeltaTime);
while (enabled && deltaTime > Mathf.Epsilon)
{
if (direction == PlayDirection.Forward)
{
if (wrapMode == WrapMode.Clamp && _normalizedTime == 1f)
{
normalizedTime = 1f;
return;
}
float time = _normalizedTime * _duration + deltaTime;
if (time < _duration)
{
normalizedTime = time / _duration;
return;
}
deltaTime = time - _duration;
normalizedTime = 1f;
if (wrapMode == WrapMode.PingPong)
{
direction = PlayDirection.Back;
}
else if (wrapMode == WrapMode.Loop)
{
_normalizedTime = 0f;
}
if ((arrivedAction & ArrivedAction.StopOnForwardArrived) == ArrivedAction.StopOnForwardArrived)
{
enabled = false;
}
_onForwardArrived?.Invoke();
}
else
{
if (wrapMode == WrapMode.Clamp && _normalizedTime == 0f)
{
normalizedTime = 0f;
return;
}
float time = _normalizedTime * _duration - deltaTime;
if (time > 0f)
{
normalizedTime = time / _duration;
return;
}
deltaTime = -time;
normalizedTime = 0f;
if (wrapMode == WrapMode.PingPong)
{
direction = PlayDirection.Forward;
}
else if (wrapMode == WrapMode.Loop)
{
_normalizedTime = 1f;
}
if ((arrivedAction & ArrivedAction.StopOnBackArrived) == ArrivedAction.StopOnBackArrived)
{
enabled = false;
}
_onBackArrived?.Invoke();
}
}
}
/// <summary>
/// 设置反向播放（Unity 事件序列化辅助）
/// </summary>
public void SetDirectionBack()
{
direction = PlayDirection.Back;
}
protected override void OnUpdate()
{
if (m_Duration == 0)
{
return;
}
#if UNITY_EDITOR
if (m_Dragging)
{
return;
}
#endif
float deltaTime =
#if UNITY_EDITOR
!Application.isPlaying ? GameEntry.DeltaTimeInEditor :
#endif
(m_TimeMode == TimeMode.Normal ? Time.deltaTime : Time.unscaledDeltaTime);
while (enabled && deltaTime > Mathf.Epsilon)
{
if (playDirection == PlayDirection.Forward)
{
if (m_WrapMode == WrapMode.Clamp && NormalizedTime == 1f)
{
NormalizedTime = 1f;
return;
}
float time = NormalizedTime * m_Duration + deltaTime;
if (time < m_Duration)
{
NormalizedTime = time / m_Duration;
return;
}
deltaTime = time - m_Duration;
NormalizedTime = 1f;
if (m_WrapMode == WrapMode.PingPong)
{
playDirection = PlayDirection.Backward;
}
else if (m_WrapMode == WrapMode.Loop)
{
NormalizedTime = 0f;
}
if ((m_ArrivedAction & ArrivedAction.StopOnForwardArrived) == ArrivedAction.StopOnForwardArrived)
{
enabled = false;
}
m_OnForwardArrived?.Invoke();
}
else
{
if (m_WrapMode == WrapMode.Clamp && NormalizedTime == 0f)
{
NormalizedTime = 0f;
return;
}
float time = NormalizedTime * m_Duration - deltaTime;
if (time > 0f)
{
NormalizedTime = time / m_Duration;
return;
}
deltaTime = -time;
NormalizedTime = 0f;
if (m_WrapMode == WrapMode.PingPong)
{
playDirection = PlayDirection.Forward;
}
else if (m_WrapMode == WrapMode.Loop)
{
NormalizedTime = 1f;
}
if ((m_ArrivedAction & ArrivedAction.StopOnBackArrived) == ArrivedAction.StopOnBackArrived)
{
enabled = false;
}
m_OnBackwardArrived?.Invoke();
}
}
}
public void ReverseDirection()
{
playDirection = playDirection == PlayDirection.Forward ? PlayDirection.Backward : PlayDirection.Forward;
}
public void Play(PlayDirection dir = PlayDirection.Forward)
{
mAmountPerDelta = (dir == PlayDirection.Reverse)? -Mathf.Abs(amountPerDelta): Mathf.Abs(amountPerDelta);
enabled = true;
Update();
}
/// <summary>
/// Event-bindable wrapper around Direction and Play members to
/// start playing the animation in the forward direction
/// </summary>
public void PlayForward()
{
this.playDirection = PlayDirection.Forward;
this.Play();
}
// ----------------------------------------------------------------------
public PlayTimeRange( DateTime start, DateTime end, PlayDirection direction = PlayDirection.Forward )
: base(start, end)
{
this.direction = direction;
}
public void BackEnable()
{
enabled = true;
direction = PlayDirection.Back;
}
public void ForwardEnable()
{
enabled = true;
direction = PlayDirection.Forward;
}
public void Play(PlayDirection dir, PlayMode mode = PlayMode.Play, Action callback = null, float delay = 0)
{
helper.Play(dir, mode, callback, delay);
isPlaying = helper.isPlaying;
}
/// <summary>
/// 设置正向播放（Unity 事件序列化辅助）
/// </summary>
public void SetDirectionForward()
{
direction = PlayDirection.Forward;
}
private AnimationWrapper(PlayDirection direction)
{
this.startDirection = direction;
}
public void SetDirectionBackward()
{
playDirection = PlayDirection.Backward;
}
// ----------------------------------------------------------------------
public void RevertDirection()
{
direction = direction == PlayDirection.Forward ? PlayDirection.Backward : PlayDirection.Forward;
}
public void RePlay(PlayDirection dir = PlayDirection.Forward)
{
ResetTimeBeforePlay();
Play(dir);
}
// ----------------------------------------------------------------------
public PlayTimeRange( IPlayTimeRange copy )
: base(copy)
{
direction = copy.Direction;
}
public SetDirectionCommand(MainGameModtroller mgmUnderControl, PlayDirection newDirection) : base(mgmUnderControl)
{
_newDirection = newDirection;
}
/// <summary>
/// Event-bindable wrapper around Direction and Play members to
/// start playing the animation in the reverse direction
/// </summary>
public void PlayReverse()
{
this.playDirection = PlayDirection.Reverse;
this.Play();
}
public override void SetupUndoData()
{
_oldDirection = _mgmUnderControl._direction;
}
// Token: 0x06002B05 RID: 11013 RVA: 0x00470B78 File Offset: 0x0046ED78
public void Play(PlayDirection dir = PlayDirection.Forward)
{
this.mAmountPerDelta = ((dir != PlayDirection.Reverse) ? Mathf.Abs(this.amountPerDelta) : (-Mathf.Abs(this.amountPerDelta)));
base.enabled = true;
this.Update();
}
/// <summary>
/// 颠倒播放方向
/// </summary>
public void ReverseDirection()
{
direction = direction == PlayDirection.Forward ? PlayDirection.Back : PlayDirection.Forward;
}