public TweenEventArgs(ITween tween, object target, double progress) : base() { Tween = tween; Target = target; Progress = progress; }
public void AddTween(ITween tween, bool start = false) { tweens.Add(tween); if (start) { tween.Start(true); } }
public static void Launch(ITween tween) { m_instance.m_tweens.Add(tween); if (!m_instance.gameObject.activeSelf) { m_instance.gameObject.SetActive(true); m_instance.m_timer = Time.realtimeSinceStartup; } }
public TankView(Tank tank, Random random) { this.tank = tank; this.movementTween = TweenFactory.Tween(0, 1, TimeSpan.FromSeconds(0.25), EasingFunction.Discrete); this.movementTween.Repeats = Repeat.Forever; this.movementTween.YoYos = true; this.turretView = new TurretView(tank); this.dustParticles = new DustParticleSystem(random); this.smokeParticles = new MuzzleFireParticleSystem(random); }
public ButtonView( IInputManager inputManager, string textureName, Vector2 position) { this.inputManager = inputManager; this.textureName = textureName; this.position = position; this.scaleTween = TweenFactory.Tween(1, 0.9f, TimeSpan.FromSeconds(.1)); this.scaleTween.IsPaused = true; }
// Constructor public TweenEventArgs( ITween tween, TweenEvent eventType, string errorDescription = null, TweenCompletedBy completedBy = TweenCompletedBy.Undefined ) { Tween = tween; Event = eventType; CompletedBy = completedBy; Error = errorDescription; }
public static void Stop(ITween tween) { if (m_instance.m_tweens == null) { return; } if (m_instance.m_tweens.Contains(tween)) { m_instance.m_tweens.Remove(tween); } if (m_instance.m_tweens.Count == 0) { m_instance.gameObject.SetActive(false); } }
public static void InitializeTween(ITween animation) { animation.Target = null; animation.Property = null; animation.Parent = null; animation.Interpolator = new FloatInterpolator(); animation.StartValue = null; animation.EndValue = null; animation.StartValueReader = null; animation.EndValueReader = null; animation.IsDone = false; animation.Name = CreateUniqueName(); }
void FlapWings(ITween<UnityEngine.Vector3> tween){ //ZestKit.instance.stopAllTweensWithTarget (rightWing); var flapTime = Random.Range (0f, .5f); rightWing.ZKlocalEulersTo (new Vector3 (3, -125, 69), flapTime) .setFrom (new Vector3(270, 0, 0)) .setLoops(LoopType.PingPong, 1) .setEaseType(EaseType.QuartInOut) .start (); leftWing.ZKlocalEulersTo (new Vector3 (-13, -33, -134), flapTime) .setLoops(LoopType.PingPong, 1) .setCompletionHandler(FlapWings) .setEaseType(EaseType.QuartInOut) .start (); }
public KeyFrame(int rowCount, int columnCount, TimeSpan startTime, ITween tween) { this.grid = new List<List<Color>>(); for (int row = 0; row < rowCount; row++) { this.grid.Add(new List<Color>()); for (int col = 0; col < columnCount; col++) { this.grid[row].Add(new Color()); } } this.StartTime = startTime; this.Tween = tween; }
public PlayingView( SpriteBatch spriteBatch, ContentManager content, IInputManager inputManager, PlayingViewModel viewModel, ISoundManager soundManager) { this.spriteBatch = spriteBatch; this.content = content; this.viewModel = viewModel; this.doodadViews = new List<DoodadView>(); this.rotateClockwiseButton = new ButtonView( inputManager, "Images/Playing/RotateClockwise", new Vector2(Constants.ScreenWidth - 127, 428), soundManager); this.rotateClockwiseButton.Command = new RelayCommand(() => this.viewModel.Rotate(true)); this.rotateCounterClockwiseButton = new ButtonView( inputManager, "Images/Playing/RotateCounterClockwise", new Vector2(127, 428), soundManager); this.rotateCounterClockwiseButton.Command = new RelayCommand(() => this.viewModel.Rotate(false)); this.translateOutTween = TweenFactory.Tween(0, Constants.ScreenHeight, TimeSpan.FromSeconds(0.75f)); this.translateOutTween.IsPaused = true; this.translateInTween = TweenFactory.Tween(Constants.ScreenHeight, 0, TimeSpan.FromSeconds(0.75f)); this.translateInTween.IsPaused = true; this.textTween = TweenFactory.Tween(0, 1, TimeSpan.FromSeconds(0.3f)); this.textTween.Reverse(); this.textTween.IsPaused = true; this.spottedZebraButton = new ButtonView( inputManager, "Images/Playing/SpottedZebraLogo", new Vector2(Constants.ScreenWidth - 78, 36), soundManager); this.spottedZebraButton.Command = this.viewModel.OpenCompanyUrlCommand; }
/// <summary> /// Remove a tween by key /// </summary> /// <param name="key">Key to remove</param> /// <param name="stopBehavior">Stop behavior</param> /// <returns>True if removed, false if not</returns> public static bool RemoveTweenKey(object key, TweenStopBehavior stopBehavior) { if (key == null) { return(false); } bool foundOne = false; for (int i = tweens.Count - 1; i >= 0; i--) { ITween t = tweens[i]; if (t.Key == key) { t.Stop(stopBehavior); tweens.RemoveAt(i); foundOne = true; } } return(foundOne); }
public void Join(ITween tween) { Tween castedTween = tween as Tween; if (castedTween == null) { throw new ArgumentNullException($"Tried to {nameof(Join)} a null {nameof(Tween)} on {nameof(SequenceTween)}"); } bool canAdd = TweenUtils.CanAddTween(this, tween); if (!canAdd) { return; } tweenRepository.Join(castedTween); castedTween.IsNested = true; durationCalculated = false; }
private void FadeOutWithAnimation() { _targetAlpha = 0.0f; if (PreventInteractionWhenFading) { CanvasGroup.blocksRaycasts = false; CanvasGroup.interactable = false; } _tween.SafelyAbort(); _tween = CanvasGroup.TweenAlpha() .To(_targetAlpha, FadeTime) .Easing(FadeEasing) .OnComplete(OnEndedFade) .Start(); _fadingState = FadingStates.FadingOut; StartedFadingOut.SafelyInvoke(); }
public void Run(Action onComplete = null) { Stop(); _tween = CreateTween(_tweenParams.Duration) .SetEase(_tweenParams.Ease); if (_tweenParams.Delay > 0) { _tween.SetDelay(_tweenParams.Delay); } if (onComplete != null) { _tween.OnComplete(onComplete); } if (_tweenParams.Loop != TweenLoopType.None) { _tween.SetLoop(_tweenParams.LoopCount, _tweenParams.Loop); } }
public void ListenDoTween(object parameter) { string param = parameter as string; if (string.IsNullOrEmpty(param)) { Debug.LogErrorFormat("TweenManger.ListenDoTween=> parameter({0}) is not ListenDoTweenParameter", parameter.ToString()); return; } ITween foundedTween = null; if (!tweens.TryGetValue(param, out foundedTween)) { Debug.LogErrorFormat("TweenManger.ListenDoTween=> id: {0} is not founded", param); return; } foundedTween.Enabled = true; }
/// <summary> /// Fades In a Ui Transform using CanvasGroup component /// </summary> /// <param name="transform">self transform to fade in</param> /// <param name="duration">fading duration time in seconds</param> /// <param name="easeType">fading easeType</param> /// <param name="onCompleteCallback">callback on tween completion</param> /// <param name="blockRaycast">block Raycasts during tween time?</param> /// <returns>returns ITween<float> that can be used for other purposes.</returns> public static ITween <float> FadeIn(this Transform transform, float duration, EaseType easeType = EaseType.Linear, Action onCompleteCallback = null, bool blockRaycast = false) { CanvasGroup image = InitCanvasGroup(transform, blockRaycast); image.alpha = 0; ITween <float> tween = image.ZKalphaTo(1f, duration); tween.setEaseType(easeType); tween.setCompletionHandler((t) => { if (onCompleteCallback != null) { onCompleteCallback.Invoke(); } image.blocksRaycasts = true; }); tween.start(); return(tween); }
/// <summary> /// Stops the tween. /// </summary> /// <param name="stopBehavior">The behavior to use to handle the stop.</param> public void Stop(TweenStopBehavior stopBehavior) { if (state != TweenState.Stopped) { state = TweenState.Stopped; if (stopBehavior == TweenStopBehavior.Complete) { currentTime = duration; UpdateValue(); if (completionCallback != null) { completionCallback.Invoke(this); completionCallback = null; } if (continueWith != null) { continueWith.Start(); TweenFactory.AddTween(continueWith); continueWith = null; } } } }
public void Add(ITween tween) { lock (runningAndQueueLock) { if (running) { waitQueue.Enqueue(tween); return; } } // worst case at multi threading, wait lock until finish Run() but it is super rarely. lock (arrayLock) { // Ensure Capacity if (tweens.Length == tail) { Array.Resize(ref tweens, checked (tail * 2)); } tweens[tail++] = tween; } }
private void SetupComponents() { _collisionHandler = addComponent(new CollectibleCollisionHandler()); var gunSprite = Preset.Gun.Sprite; _sprite = addComponent(new Sprite(gunSprite.Icon.ToSpriteAnimation(gunSprite.Source).frames[0])); _sprite.renderLayer = Layers.Interactables; _sprite.material = new Material(); scale = new Vector2(0.5f, 0.5f); _hoverTween = this.tweenLocalScaleTo(0.5f, 0.5f) .setEaseType(EaseType.ExpoOut) .setCompletionHandler(_ => Hover(2f)); _hoverTween.start(); _mover = addComponent(new Mover()); // Delay pickup (debug) Core.schedule(0.5f, _ => SetupPickupHitbox()); //Collision _collisionHitbox = addComponent(new CircleCollider(4)); Flags.setFlagExclusive(ref _collisionHitbox.collidesWithLayers, Layers.MapObstacles); }
public static ITween <Vector3> SlideIn(this Transform transform, float duration, EaseType easeType = EaseType.Linear, Action onCompleteCallback = null, bool deactiveOnComplete = false, bool blockRaycast = false, slideDirection direction = slideDirection.up) { CanvasGroup image = InitCanvasGroup(transform, blockRaycast); var xOffset = Screen.width; var yOffset = Screen.height; var startPos = transform.position; switch (direction) { case slideDirection.left: transform.position += new Vector3(-xOffset, 0f); break; case slideDirection.right: transform.position += new Vector3(xOffset, 0f); break; case slideDirection.up: transform.position += new Vector3(0, yOffset); break; case slideDirection.down: transform.position += new Vector3(0, -yOffset); break; } ITween <Vector3> tween = transform.ZKpositionTo(startPos, duration); FillOutTween(transform, easeType, onCompleteCallback, deactiveOnComplete, image, tween); return(tween); }
public void Init(ITween tween) { _tweener = tween as Tweener <Color, ColorHelper>; }
public TweenAction setInterpolation(ITween interp) { this.m_interpolation = interp; return this; }
public void reset() { m_target = null; m_reverse = false; m_interpolation = null; restart(); }
public TweenAction(float duration, ITween interpolation, Action<float> onUpdate) { this.m_duration = duration; this.m_interpolation = interpolation; this.m_onUpdate = onUpdate; }
// PRAGMA MARK - Interface public void AddTween(ITween t) { _tweens.Add(t); }
public TweenInfo(Component component, string memberName, ITween tween) { this.Component = component; this.MemberName = memberName; this.Tween = tween; }
public void RemoveTween(ITween tween) { tweens.Remove(tween); }
public override void Froze() { base.Froze(); _myRainbow?.GetComponent <ParticleSystem>()?.Pause(); ITween.Pause(MyHero.gameObject); }
public virtual void AddTween(ITween tween) { Tweens.Add(tween); }
public void Push(ITween tween) { m_Active.Add(tween); }
private static Vector4 LerpVector4(ITween<Vector4> t, Vector4 start, Vector4 end, float progress) { return Vector4.Lerp(start, end, progress); }
public virtual void RemoveTween(ITween tween) { Tweens.Remove(tween); }
void IUpdatable.update() { updateFloat(); CollisionResult collisionResult; // Collision of the raft with the player var playerComponent = _playerEntity.getComponent <PlayerComponent>(); var vel = playerComponent.Velocity * Time.deltaTime; if (_playerEntity.getComponent <BoxCollider>().collidesWith(_raftCollider, vel, out collisionResult)) { _playerEntity.transform.position += (vel - collisionResult.minimumTranslationVector) * Vector2.UnitY; if (_playerOnTop <= 0) { _impactTween = this.tween("_impact", 5.0f, 0.5f).setEaseType(EaseType.Punch); _impactTween.start(); } playerComponent.ForcedGround = true; playerComponent.platformerObject.velocity.Y = 0.0f; _playerOnTop = 10; } else if (_playerOnTop > 0) { _playerOnTop--; } // Collision of the left barrier with the player if (_playerEntity.getComponent <BoxCollider>().collidesWith(_leftBarrierCollider, vel, out collisionResult)) { _playerEntity.transform.position += (vel - collisionResult.minimumTranslationVector) * Vector2.UnitX; playerComponent.platformerObject.velocity.X = 0.0f; } // Collision of the right barrier with the player if (_rightBarrierCollider.enabled && _playerEntity.getComponent <BoxCollider>().collidesWith(_rightBarrierCollider, vel, out collisionResult)) { _playerEntity.transform.position += (vel - collisionResult.minimumTranslationVector) * Vector2.UnitX; playerComponent.platformerObject.velocity.X = 0.0f; } // Collision with the bag vel = Vector2.UnitY; if (_bagEntity.getComponent <BoxCollider>().collidesWith(_raftCollider, vel, out collisionResult)) { _bagEntity.transform.position += (vel - collisionResult.minimumTranslationVector) * Vector2.UnitY; _bagEntity.getComponent <PlatformerObject>().velocity.Y = 0.0f; } if (Core.getGlobalManager <SystemManager>().getSwitch("picked_up_bag") && !_stopRaft) { var movementVector = -40.0f * Time.deltaTime * Vector2.UnitX; _position += movementVector; if (!_rightBarrierCollider.enabled || Core.getGlobalManager <SystemManager>().getSwitch("replace_raft_right_barrier")) { Core.getGlobalManager <SystemManager>().setSwitch("replace_raft_right_barrier", false); var x = _playerEntity.transform.position.X - _position.X + _playerEntity.getComponent <BoxCollider>().width / 2; _rightBarrierCollider.localOffset = new Vector2(x, -_rightBarrierCollider.height / 2); _rightBarrierCollider.enabled = true; } } if (_position.X <= 480) { _stopRaft = true; Core.getGlobalManager <SystemManager>().setSwitch("make_it_rain", true); } }
/// <summary> /// Remove a tween /// </summary> /// <param name="tween">Tween to remove</param> /// <param name="stopBehavior">Stop behavior</param> /// <returns>True if removed, false if not</returns> public static bool RemoveTween(ITween tween, TweenStopBehavior stopBehavior) { tween.Stop(stopBehavior); return tweens.Remove(tween); }
private void OnComplete(ITween <float> obj) { this.Complete?.Invoke(); }
private static Vector2 LerpVector2(ITween<Vector2> t, Vector2 start, Vector2 end, float progress) { return Vector2.Lerp(start, end, progress); }
private static Quaternion LerpQuaternion(ITween<Quaternion> t, Quaternion start, Quaternion end, float progress) { return Quaternion.Lerp(start, end, progress); }
public TweenEventArgs(ITween tween, object target) : base() { Progress = double.NaN; }
private void UpdateColorLocal(ITween <Color> tween) { _spriteRenderer.color = tween.CurrentValue; }
private void RemoveTweenHandlers(ITween tween) { System.Diagnostics.Debug.WriteLine("tweeen: " + tween + ", " + (tween == null)); tween.Progress += new TweenEventHandler(CurrentTween_Progress); tween.Complete += new TweenEventHandler(CurrentTween_Complete); }
private void MakeFly() { MyHero.Body.isKinematic = true; ITween.MoveTo(MyHero.gameObject, new Vector3(0, 1, 0), TimeAnimation); _objectToShake = MyHero.transform.GetChild(0).transform; }
public Parallel(ITween first, ITween second) : base(Math.Max(first.Duration, second.Duration)) { this.first = first; this.second = second; }
public override void Unfroze() { base.Unfroze(); _myRainbow?.GetComponent <ParticleSystem>()?.Play(); ITween.Resume(MyHero.gameObject); }
public void Initialize(TweenGlobalManager globalManager, ITween tween) { this.globalManager = globalManager; this.TweenState = TweenStates.Paused; this.CurrentTween = tween; }
private static float LerpFloat(ITween<float> t, float start, float end, float progress) { return start + (end - start) * progress; }
public virtual void RecycleSelf() { this.TweenState = TweenStates.Complete; this.CurrentTween = null; }
private static Vector3 LerpVector3(ITween<Vector3> t, Vector3 start, Vector3 end, float progress) { return Vector3.Lerp(start, end, progress); }
public Loop(ITween timer, int times = -1) : base((times < 0) ? double.MaxValue : times * timer.Duration) { this.timer = timer; }
private static Color LerpColor(ITween<Color> t, Color start, Color end, float progress) { return Color.Lerp(start, end, progress); }
// Let a tween overwrite others public void Overwrite(ITween tween) { foreach (var tweenGroup in _groups) { tweenGroup.Overwrite(tween); } }
public static T Append <T>(this T self, ITween item) where T : ITweener { self.AppendInternal(item); return(self); }
public TweenData(Control mTweenTarget) { m_tweenTarget = mTweenTarget; m_tween = new Linear(); m_targetPoint = new Point(); }