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();
}
