/// <summary>
/// Adds a child animation to be activated after the specified duration
/// after current EventToken's animation completes.
/// </summary>
/// <param name="child"></param>
public void AddChildAnimator(IAnimator child, TimeSpan? timespan)
{
if (!_Children.ContainsKey(child))
{
_Children.Add(child, timespan);
}
}
/// <summary>
/// Adds a child animation to be activated when the current
/// EventToken's animation completes.
/// </summary>
/// <param name="child"></param>
public void AddChildAnimator(IAnimator child)
{
if (!_Children.ContainsKey(child))
{
_Children.Add(child, null);
}
}
void Awake()
{
m_Animator = m_Player.GetComponent<IAnimator> ();
m_PlayerController = m_Player.GetComponent<PlayerController> ();
m_InputSource = GetComponent<InputJoyStick> ();
m_InputSource.SetController (m_Animator, m_PlayerController);
}
public Menu(IAnimator<Vector2> InAnimator, IAnimator<Vector2> OutAnimator)
{
Buttons = new List<IButton>();
OutVectorAnimator = OutAnimator;
InVectorAnimator = InAnimator;
}
public static IObservable <float> Play(float[] path, IAnimator animator)
{
return(Play(path, animator, DefaultScheduler));
}
public static UniTask ToMaterialPropertyFloat(this IAnimator <float> animator, Renderer renderer, string name, CancellationToken cancellationToken = default, SkipToken skipToken = default, IScheduler scheduler = default)
{
CheckAlive(renderer);
return(Anime.Play(animator, new MaterialPropertyFloatTranslator(renderer, name), scheduler, CancellationTokenSource.CreateLinkedTokenSource(renderer.GetCancellationTokenOnDestroy(), cancellationToken).Token, skipToken));
}
public static IObservable <float> PlayIn(float from, float inEnd, float to, IAnimator inAnimator)
{
return(PlayIn(from, inEnd, to, inAnimator, DefaultScheduler));
}
public static IObservable <float> PlayInOut(float from, float inEnd, float outStart, float to, IAnimator inAnimator, IAnimator outAnimator)
{
return(PlayInOut(from, inEnd, outStart, to, inAnimator, outAnimator, DefaultScheduler));
}
public static IObservable <float> PlayRelative(float from, float relative, IAnimator animator, IScheduler scheduler)
{
return(Play(from, from + relative, animator, scheduler));
}
public static IObservable <float> PlayRelative(this IObservable <float> self, float relative, IAnimator animator)
{
return(PlayRelative(self, relative, animator, DefaultScheduler));
}
protected void Awake()
{
m_Animator = null;
m_CurrentAnimatorFrame = 0;
m_AntecedentAnimatorFrame = 0;
m_FrameCount = 0;
m_TurnSpeed = 15;
m_MoveDir = transform.forward;
m_OnTrimToGround = false;
m_GroundPosition = Vector3.zero;
m_FallSpeed = 0.005f;
m_GravityFact = 0.98f;
m_GravityFrameCount = 0;
m_AnimationSpeed = m_ConstantAnimationSpeed;
}
private void Inject(IAnimator animator)
{
this.animator = animator;
}
public static async UniTask Play <T>(IAnimator <T> animator, ITranslator <T> translator, IScheduler scheduler = default, CancellationToken cancellationToken = default)
{
await PlayInternal(animator, translator, scheduler, cancellationToken);
}
public static UniTask ToProgress <T>(this IAnimator <T> animator, IProgress <T> progress, CancellationToken cancellationToken = default, IScheduler scheduler = default) => Anime.Play(animator, new ProgressTranslator <T>(progress), scheduler, cancellationToken);
public static UniTask ToLocalPosition(this IAnimator <Vector3> animator, Component component, CancellationToken cancellationToken = default, IScheduler scheduler = default) => Anime.Play(animator, new LocalPositionTranslator(component.transform), scheduler, cancellationToken);
public static UniTask ToGlobalRotation(this IAnimator <Quaternion> animator, Component component, CancellationToken cancellationToken = default, IScheduler scheduler = default) => Anime.Play(animator, new GlobalRotationTranslator(component.transform), scheduler, cancellationToken);
public static UniTask ToLocalScaleZ(this IAnimator <float> animator, Component component, CancellationToken cancellationToken = default, IScheduler scheduler = default) => Anime.Play(animator, new LocalScaleXTranslator(component.transform, 2), scheduler, cancellationToken);
public static UniTask ToLocalScaleY(this IAnimator <float> animator, GameObject gameObject, CancellationToken cancellationToken = default, IScheduler scheduler = default) => Anime.Play(animator, new LocalScaleXTranslator(gameObject.transform, 1), scheduler, cancellationToken);
private SceneObject unitSprite(IGrouping <Vector2D, CombatantInfo> hex, IEnumerable <PlayerInfo> players)
{
var polygons = new List <PolygonData>();
IAnimator animator = null;
var hexTransform = Matrix4.CreateTranslation(hexX(hex.Key), hexY(hex.Key), 0);
var unitSelected = (this.currentUnit != null && this.currentUnit.Position == hex.Key);
var unit = unitSelected ? this.currentUnit : biggestStack(hex);
var unitSprite = GalaxyTextures.Get.Sprite(unit.Design.ImagePath);
var alpha = players.All(x => unit.CloakedFor(x) || x == unit.Owner) ? 0.65 : 1;
var unitDrawable = new PolygonData(
CombatantZ,
new SpriteData(hexTransform, unitSprite.Id, Color.FromArgb((int)(alpha * 255), unit.Owner.Color), null),
SpriteHelpers.UnitRect(unitSprite).ToList()
);
if (unitSelected)
{
animator = new OscillatingAlpha(
unitDrawable,
AnimationPeriod,
0.6,
x => (x + 0.4) * alpha,
unit.Owner.Color);
}
polygons.Add(unitDrawable);
var otherUnits = hex.Where(x => x != unit).Select(x => x.Owner).Distinct().ToList();
for (int i = 0; i < otherUnits.Count; i++)
{
polygons.Add(new PolygonData(
CombatantZ,
new SpriteData(
Matrix4.CreateScale(0.2f, 0.2f, 1) * Matrix4.CreateTranslation(0.5f, 0.2f * i + 0.5f, 0) * hexTransform,
GalaxyTextures.Get.FleetIndicator.Id,
otherUnits[i].Color,
null
),
SpriteHelpers.UnitRect(GalaxyTextures.Get.FleetIndicator).ToList()
));
}
var formatter = new ThousandsFormatter();
polygons.AddRange(
TextRenderUtil.Get.BufferText(formatter.Format(unit.Count), -1, 0, CombatantZ, 1 / Layers).
Select(layer =>
new PolygonData(
layer.Key,
new SpriteData( //TODO(v0.9) text as sprite data? should be SDF
Matrix4.CreateScale(0.2f, 0.2f, 1) * Matrix4.CreateTranslation(0.5f, -0.5f, 0) * hexTransform,
TextRenderUtil.Get.TextureId,
Color.Gray,
null
),
layer.Value.ToList()
)
));
return(new SceneObject(polygons, animator: animator));
}
public static IObservable <float> PlayRelative(float from, float relative, IAnimator animator)
{
return(PlayRelative(from, relative, animator, DefaultScheduler));
}
public static IObservable <float> Play(this IObservable <float> self, float from, float to, IAnimator animator, IScheduler scheduler)
{
return(self.Concat(Play(from, to, animator, scheduler)));
}
public static IObservable <float> PlayRelative(this IObservable <float> self, float from, float relative, IAnimator animator, IScheduler scheduler)
{
return(self.Concat(Play(from, from + relative, animator, scheduler)));
}
public static IObservable <float> Play(this IObservable <float> self, float from, float[] path, IAnimator animator)
{
return(Play(self, from, path, animator, DefaultScheduler));
}
public static IObservable <float> PlayRelative(this IObservable <float> self, float relative, IAnimator animator, IScheduler scheduler)
{
return(self.Select(x => Play(x, x + relative, animator, scheduler)).Switch());
}
public static IObservable <float> Play(this IObservable <float> self, float from, float[] path, IAnimator animator, IScheduler scheduler)
{
var merged = new float[path.Length + 1];
merged[0] = from;
Array.Copy(path, 0, merged, 1, path.Length);
return(self.Concat(Play(merged, animator, scheduler)));
}
public static IObservable <float> PlayOut(float from, float outStart, float to, IAnimator outAnimator, IScheduler scheduler)
{
var velocity = outAnimator.CalcStartVelocity(Mathf.Abs(to - outStart));
var linearAnimator = Easing.Linear(velocity);
var compositeAnimator = new CompositeAnimator(new[]
{
Tuple.Create(linearAnimator, Mathf.Abs(outStart - from)),
Tuple.Create(outAnimator, Mathf.Abs(to - outStart)),
});
return(Play(new[] { from, outStart, to }, compositeAnimator, scheduler));
}
public static IObservable <float> Play(float from, float to, IAnimator animator, IScheduler scheduler)
{
return(PlayInternal(animator, Mathf.Abs(from - to), scheduler)
.Select(x => Mathf.LerpUnclamped(from, to, x)));
}
public static IObservable <float> PlayInOut(float from, float inEnd, float outStart, float to, IAnimator inAnimator, IAnimator outAnimator, IScheduler scheduler)
{
var inVelocity = inAnimator.CalcFinishVelocity(Mathf.Abs(inEnd - from)).PerSecond;
var outVelocity = outAnimator.CalcStartVelocity(Mathf.Abs(to - outStart)).PerSecond;
IAnimator linearAnimator;
if (Math.Abs(inVelocity - outVelocity) < EqualDelta)
{
linearAnimator = Motion.Uniform((float)((inVelocity + outVelocity) / 2.0));
}
else
{
var accel = (outVelocity * outVelocity - inVelocity * inVelocity) / (2.0f * Mathf.Abs(outStart - inEnd));
linearAnimator = Motion.Acceleration((float)accel, (float)inVelocity);
}
var compositeAnimator = new CompositeAnimator(new[]
{
Tuple.Create(inAnimator, Mathf.Abs(inEnd - from)),
Tuple.Create(linearAnimator, Mathf.Abs(outStart - inEnd)),
Tuple.Create(outAnimator, Mathf.Abs(to - outStart)),
});
return(Play(new[] { from, inEnd, outStart, to }, compositeAnimator, scheduler));
}
public static UniTask ToGlobalPositionY(this IAnimator <float> animator, Component component, CancellationToken cancellationToken = default, IScheduler scheduler = default) => Anime.Play(animator, new GlobalPositionXTranslator(component.transform, 1), scheduler, cancellationToken);
public static IObservable <float> Play(float from, float to, IAnimator animator)
{
return(Play(from, to, animator, DefaultScheduler));
}
public static UniTask ToLocalPosition(this IAnimator <Vector2> animator, GameObject gameObject, CancellationToken cancellationToken = default, IScheduler scheduler = default) => Anime.Play(animator, new LocalPositionTranslator(gameObject.transform), scheduler, cancellationToken);
public void SetController(IAnimator animatorController, MonoBehaviour playerController)
{
m_AnimatorController = animatorController;
m_PlayerController = playerController as PlayerController;
}
public static IObservable <float> Play(this IObservable <float> self, float[] path, IAnimator animator, IScheduler scheduler)
{
return(self.Select(x =>
{
var merged = new float[path.Length + 1];
merged[0] = x;
Array.Copy(path, 0, merged, 1, path.Length);
return Observable.Return(x).Concat(Play(merged, animator, scheduler));
}).Switch());
}
public static IObservable <float> Play(this IObservable <float> self, float to, IAnimator animator)
{
return(Play(self, to, animator, DefaultScheduler));
}
public static UniTask ToGlobalPositionZ(this IAnimator <float> animator, GameObject gameObject, CancellationToken cancellationToken = default, IScheduler scheduler = default) => Anime.Play(animator, new GlobalPositionXTranslator(gameObject.transform, 2), scheduler, cancellationToken);
/// <summary>
/// Helper method to simplify check
/// </summary>
/// <param name="animator"></param>
/// <returns></returns>
bool isAnimating(IAnimator animator) {
if (animator == null) {
return false;
}
return animator.hasNext;
}
public static IObservable <float> Play(this IObservable <float> self, float to, IAnimator animator, IScheduler scheduler)
{
var hot = self.Publish().RefCount();
return(Observable.Merge(hot, hot.ContinueWith(x => Play(x, to, animator, scheduler))));
}
