Esempio n. 1
0
 void DoThings()
 {
     nextAvailable = Time.timeSinceLevelLoad + cooldown;
     OnSwing?.Invoke();
 }
Esempio n. 2
0
        protected override void PostConstruct()
        {
            base.PostConstruct();

            var manager = OnPlayerChange
                          .Select(p => p.AnimationManager)
                          .OfType <IAnimationStateManager>();

            var states = manager
                         .Select(m => m.FindStates(StatesPath).ToObservable())
                         .Switch();

            var seeker = manager
                         .Select(m => m.FindSeekableAnimator(SeekerPath).ToObservable())
                         .Switch();

            var blender = manager
                          .Select(m => AnimationBlend.Bind(m.FindBlender).ToObservable())
                          .Switch();

            var conflictingInputs = OnArm.Select(_ => ConflictingInputs.Freeze());

            var disposed = Disposed.Where(identity);

            // Change animation.
            OnArm
            .Select(_ => seeker.TakeUntil(OnDisarm))
            .Switch()
            .TakeUntil(disposed)
            .Subscribe(s => s.Animation = SwingAnimation, this);

            // Change animation state.
            OnArm
            .Select(_ => states)
            .Switch()
            .TakeUntil(disposed)
            .Do(_ => Logger.LogDebug("Entering armed state."))
            .Subscribe(s => s.State = SwingState, this);

            OnArm
            .Select(_ => OnDisarm)
            .Switch()
            .Select(_ => states)
            .Switch()
            .TakeUntil(disposed)
            .Do(_ => Logger.LogDebug("Exiting armed state."))
            .Subscribe(s => s.State = IdleState, this);

            // Lock view rotation.
            conflictingInputs
            .Do(_ => Logger.LogDebug("Deactivating conflicting view controls."))
            .Do(i => i.Iter(v => v.Deactivate()))
            .Select(v => OnDisarm.Select(_ => v))
            .Switch()
            .Do(_ => Logger.LogDebug("Activating conflicting view controls."))
            .Do(i => i.Iter(v => v.Activate()))
            .TakeUntil(disposed)
            .Subscribe(this);

            var minPos = AnimationRange.Min;
            var maxPos = AnimationRange.Max > AnimationRange.Min
                ? AnimationRange.Max
                : Animation.Map(a => a.Length).IfNone(1f);

            Logger.LogDebug($"Using animation range: {minPos} - {maxPos}.");

            // Handle swing motion.
            OnSwing.Select(v => v * (maxPos - minPos) + minPos)
            .SelectMany(v => seeker, (v, s) => (v, s))
            .TakeUntil(disposed)
            .Do(t => Logger.LogDebug("Changing animation position: {}.", t.v))
            .Subscribe(t => t.s.Position = t.v, this);

            // Blend/unblend holding animation.
            OnArm
            .Select(_ => blender.TakeUntil(OnDisarm))
            .Switch()
            .Do(_ => Logger.LogDebug("Overriding default animation: '{}'.", Animation))
            .TakeUntil(disposed)
            .Subscribe(b => b.Unblend(AnimationTransition), this);

            OnArm
            .Select(_ => OnDisarm)
            .Switch()
            .Select(_ => blender)
            .Switch()
            .Do(_ => Logger.LogDebug("Restoring default animation: '{}'.", Animation))
            .TakeUntil(disposed)
            .Subscribe(
                b => Animation.Iter(a => b.Blend(a, transition: AnimationTransition)),
                this);
        }