void PlayMulti(int indexOfAnimation, float speed, float blendDuration)
{
animation = animationList[indexOfAnimation];
animationParameters = animation.GetParameters();
animationParameters.BlendDuration = blendDuration;
animationParameters.PlaybackSpeed = speed;
animationParameters.PlaybackMode = AnimationPlaybackMode.Loop;
animation.Play(animationParameters);
InterruptibleWait(((1000.0f / FPS) * (animation.GetFrameCount())) / Math.Abs(speed));
}
private void Start()
{
flare = GetComponent<LensFlare>();
startPos = transform.position;
starMat = GetComponent<Renderer>().material;
trailMat = GetComponent<TrailRenderer>().material;
starMat.SetFloat("_Transparency", 0.0f);
trailMat.SetFloat("_Transparency", 0.0f);
flare.brightness = minFlareBrightness;
tr = gameObject.GetComponent<TrailRenderer>();
origTrailTime = tr.time;
maxValues = new AnimationParameters() { scale = maxScale, starTransparency = 1.0f, trailTransparency = 1.0f, flareBrightness = maxFlareBrightness };
minValues = new AnimationParameters() { scale = minScale, starTransparency = 0.0f, trailTransparency = 0.0f, flareBrightness = minFlareBrightness };
}
protected override void SimpleInit()
{
AnimationComponent animComponent;
if (!ObjectPrivate.TryGetFirstComponent <AnimationComponent>(out animComponent))
{
Log.Write(LogLevel.Error, "SimpleAnimation.Init", "Object must have an animation added at edit time for SimpleAnimation to work");
return;
}
animation = animComponent.DefaultAnimation;
if (!string.IsNullOrWhiteSpace(RangeA))
{
string[] frames = RangeA.Split(new char[] { ':', ',' }, StringSplitOptions.RemoveEmptyEntries);
if (frames.Length != 2 ||
!int.TryParse(frames[0].Trim(), out RangeAStart) ||
!int.TryParse(frames[1].Trim(), out RangeAEnd))
{
SimpleLog(LogLevel.Error, "Invalid RangeA parameter: '" + RangeA + "'. Should be two integers separated by a colon, ex 0:10");
RangeAStart = RangeAEnd = 0;
}
}
if (!string.IsNullOrWhiteSpace(RangeA))
{
string[] frames = RangeB.Split(new char[] { ':', ',' }, StringSplitOptions.RemoveEmptyEntries);
if (frames.Length != 2 ||
!int.TryParse(frames[0].Trim(), out RangeBStart) ||
!int.TryParse(frames[1].Trim(), out RangeBEnd))
{
SimpleLog(LogLevel.Error, "Invalid RangeB parameter: '" + RangeB + "'. Should be two integers separated by a colon, ex 0:10");
RangeBStart = RangeBEnd = 0;
}
}
initialAnimationParameters = animation.GetParameters();
Subscribe(null);
if (EnableEvent != "")
{
SubscribeToAll(EnableEvent, Subscribe);
}
if (DisableEvent != "")
{
SubscribeToAll(DisableEvent, Unsubscribe);
}
}
public override void Init()
{
AnimationComponent animComponent;
if (!ObjectPrivate.TryGetFirstComponent <AnimationComponent>(out animComponent))
{
Log.Write(LogLevel.Error, "SimpleAnimation.Init", "Object must have an animation added at edit time for SimpleAnimation to work");
return;
}
animation = animComponent.DefaultAnimation;
initialAnimationParameters = animation.GetParameters();
Log.Write("Subscring To: " + PlayEvent);
SubscribeToScriptEvent(PlayEvent, PlayAnimation);
SubscribeToScriptEvent(StopEvent, StopAnimation);
}
public void Close()
{
HorizonTeleporter.SetEnabled(false);
HorizonTeleporter.SetPrompt("Closed");
AnimationParameters ap = anim_close.GetParameters();
ap.PlaybackMode = AnimationPlaybackMode.PlayOnce;
anim_close.Play(ap);
Timer.Create(2.0, () =>
{
foreach (MeshComponent mesh in meshes)
{
mesh.SetIsVisible(false);
}
anim_open.Reset();
anim_close.Reset();
});
}
private void PlayAnimationEvent(int AnimationNumber, ScriptEventData data)
{
//Log.Write("Playing Animation Number: " + AnimationNumber + " Animation: " + AnimationEvent[AnimationNumber]);
int firstFrame = Int32.Parse(startFrame[AnimationNumber]);
//Log.Write("firstFrame: " + firstFrame);
int lastFrame = Int32.Parse(endFrame[AnimationNumber]);
//Log.Write("lastFrame: " + lastFrame);
float NumberOfFrames = lastFrame - firstFrame;
//Log.Write("NumberOfFrames: " + NumberOfFrames);
float AnimationTimeToComplete = NumberOfFrames / 30.0f;
//Log.Write("AnimationTimeToComplete: " + AnimationTimeToComplete);
AnimationParameters animationParameters = initialAnimationParameters;
if (PlaybackType[AnimationNumber].Contains("oop"))
{
animationParameters.PlaybackMode = AnimationPlaybackMode.Loop;
}
if (PlaybackType[AnimationNumber].Contains("ong"))
{
animationParameters.PlaybackMode = AnimationPlaybackMode.PingPong;
}
if (PlaybackType[AnimationNumber].Contains("nce"))
{
animationParameters.PlaybackMode = AnimationPlaybackMode.PlayOnce;
}
float fltPlaybackSpeed = float.Parse(AnimationSpeed[AnimationNumber]);
animationParameters.PlaybackSpeed = Math.Abs(fltPlaybackSpeed) * Math.Sign(lastFrame - firstFrame);
int intBlendDuration = Int32.Parse(BlendDuration[AnimationNumber]);
if (intBlendDuration > 0)
{
animationParameters.BlendDuration = Int32.Parse(BlendDuration[AnimationNumber]);
}
//Log.Write("PlaybackSpeed: " + animationParameters.PlaybackSpeed);
if (animationParameters.PlaybackSpeed > 0.0f)
{
animationParameters.RangeStartFrame = firstFrame;
animationParameters.RangeEndFrame = lastFrame;
}
else
{
// Backwards playback uses negative playback speed but start frame still less than end frame
animationParameters.RangeStartFrame = lastFrame;
animationParameters.RangeEndFrame = firstFrame;
}
animationParameters.ClampToRange = true;
float TimeAdjust = 1.0f / fltPlaybackSpeed;
//Log.Write("Type Length: " + PlaybackType[AnimationNumber].Length);
//Log.Write("Number: " + PlaybackType[AnimationNumber].Substring(4, PlaybackType[AnimationNumber].Length - 4));
if (PlaybackType[AnimationNumber].Contains("oop"))
{
//you can say loop5 and it will loop 5 times
if (PlaybackType[AnimationNumber].Length > 4)
{
int loopNum = Int32.Parse(PlaybackType[AnimationNumber].Substring(4, PlaybackType[AnimationNumber].Length - 4));
int i = 0;
do
{
animation.Play(animationParameters);
//Log.Write("TimeAdjust: " + TimeAdjust);
Wait(TimeSpan.FromMilliseconds(AnimationTimeToComplete * 1000 * TimeAdjust));
i++;
} while (i < loopNum);
}
else
{
//loop indefinitely
animationParameters.PlaybackMode = AnimationPlaybackMode.Loop;
animation.Play(animationParameters);
}
}
else
{
//PlayOnce
animation.Play(animationParameters);
//Log.Write("TimeAdjust: " + TimeAdjust);
Wait(TimeSpan.FromMilliseconds(AnimationTimeToComplete * 1000 * TimeAdjust));
}
if (killAnimation)
{
animation.Reset();
killAnimation = false;
}
else
{
string DoneEvent = AnimationDoneEvent[AnimationNumber];
SendToAll(DoneEvent, data.Data);
//Log.Write("Sent Done Event: " + DoneEvent);
}
}
public override void Init()
{
if (!ObjectPrivate.TryGetFirstComponent <AnimationComponent>(out animComponent))
{
Log.Write(LogLevel.Error, "NPCAnimation.Init", "Object must have an animation added at edit time for NPCAnimation to work");
return;
}
animation = animComponent.DefaultAnimation;
initialAnimationParameters = animation.GetParameters();
//SubscribeToAll("Kill", KillAnimation);
if (EnableEvent != "")
{
Log.Write("Enable Event was not null: " + EnableEvent);
SubscribeToAll(EnableEvent, Subscribe);
}
else
{
Subscribe(null); //executes it by passing null data
SubscribeToAll(prefix + "0", N0);
SubscribeToAll(prefix + "1", N1);
SubscribeToAll(prefix + "2", N2);
SubscribeToAll(prefix + "3", N3);
SubscribeToAll(prefix + "4", N4);
SubscribeToAll(prefix + "5", N5);
SubscribeToAll(prefix + "6", N6);
SubscribeToAll(prefix + "7", N7);
SubscribeToAll(prefix + "8", N8);
SubscribeToAll(prefix + "9", N9);
SubscribeToAll(prefix + "A", A);
SubscribeToAll(prefix + "B", B);
SubscribeToAll(prefix + "C", C);
SubscribeToAll(prefix + "D", D);
SubscribeToAll(prefix + "E", E);
SubscribeToAll(prefix + "F", F);
SubscribeToAll(prefix + "G", G);
SubscribeToAll(prefix + "H", H);
SubscribeToAll(prefix + "I", I);
SubscribeToAll(prefix + "J", J);
SubscribeToAll(prefix + "K", K);
SubscribeToAll(prefix + "L", L);
SubscribeToAll(prefix + "M", M);
SubscribeToAll(prefix + "N", N);
SubscribeToAll(prefix + "O", O);
SubscribeToAll(prefix + "P", P);
SubscribeToAll(prefix + "Q", Q);
SubscribeToAll(prefix + "R", R);
SubscribeToAll(prefix + "S", S);
SubscribeToAll(prefix + "T", T);
SubscribeToAll(prefix + "U", U);
SubscribeToAll(prefix + "V", V);
SubscribeToAll(prefix + "W", W);
SubscribeToAll(prefix + "X", X);
SubscribeToAll(prefix + "Y", Y);
SubscribeToAll(prefix + "Z", Z);
}
if (DisableEvent != "")
{
SubscribeToAll(DisableEvent, Unsubscribe);
}
}
void Start()
{
thisMesh = GetComponent <MeshFilter>().mesh;
thisAnimationParameters = GetComponent <AnimationParameters>();
ren = GetComponent <Renderer>();
}
//Runs an attack and then returns the combat left so that it can be fed back in with correct timings
AttackResults[] StartAnimations(AttackResults[] Attacks, AnimationParameters Left, AnimationParameters Right)
{
if (Attacks[0].Unit == Left.Unit)
{
Left.AnimationObject.GetComponent <Animator>().SetTrigger("Start");
Right.Unit.Stats[(int)RPGClass.Stat.HitPoints].dynamicValue -= Attacks[0].DamageDealt;
Right.Unit.Stats[(int)RPGClass.Stat.StressPoints].dynamicValue += (Attacks[0].DamageDealt - (Right.Unit.Stats[(int)RPGClass.Stat.Willpower].dynamicValue / 2));
//print(Right.Unit.Stats[(int)RPGClass.Stat.StressPoints].dynamicValue);
Right.Unit.ClampHP();
Right.Unit.ClampStress();
if (Right.Unit.Stats[(int)RPGClass.Stat.HitPoints].dynamicValue <= 0)
{
if (Right.Unit.FodderCharacter)
{
Right.Unit.Die();
}
else
{
Right.Unit.DeathsDoor(Right.Unit.Stats[(int)RPGClass.Stat.Constitution].dynamicValue,
Right.Unit.Stats[(int)RPGClass.Stat.Luck].dynamicValue,
Right.Unit.Stats[(int)RPGClass.Stat.HitPoints].dynamicValue,
Right.Unit.Stats[(int)RPGClass.Stat.HitPoints].staticValue);
}
}
}
else
{
Right.AnimationObject.GetComponent <Animator>().SetTrigger("Start");
Left.Unit.Stats[(int)RPGClass.Stat.HitPoints].dynamicValue -= Attacks[0].DamageDealt;
Left.Unit.Stats[(int)RPGClass.Stat.StressPoints].dynamicValue += (Attacks[0].DamageDealt - (Left.Unit.Stats[(int)RPGClass.Stat.Willpower].dynamicValue / 2));
//print(Left.Unit.Stats[(int)RPGClass.Stat.StressPoints].dynamicValue);
Left.Unit.ClampHP();
Left.Unit.ClampStress();
if (Left.Unit.Stats[(int)RPGClass.Stat.HitPoints].dynamicValue <= 0)
{
if (Left.Unit.FodderCharacter)
{
Left.Unit.Die();
}
else
{
Left.Unit.DeathsDoor(Left.Unit.Stats[(int)RPGClass.Stat.Constitution].dynamicValue,
Left.Unit.Stats[(int)RPGClass.Stat.Luck].dynamicValue,
Left.Unit.Stats[(int)RPGClass.Stat.HitPoints].dynamicValue,
Left.Unit.Stats[(int)RPGClass.Stat.HitPoints].staticValue);
}
}
}
List <AttackResults> Reduced = new List <AttackResults> {
};
for (int i = 1; i < Attacks.Length; i++)
{
Reduced.Add(Attacks[i]);
}
return(Reduced.ToArray());
}
private void Subscribe(ScriptEventData sed)
{
if (unsubscribePlay == null)
{
unsubscribePlay = SubscribeToAll(PlayEvent, (data) =>
{
if (ResetOnPlay)
{
animation.JumpToFrame(initialAnimationParameters.PlaybackSpeed > 0.0f? 0 : animation.GetFrameCount() - 1);
}
animation.Play(initialAnimationParameters);
});
}
if (unsubscribePause == null)
{
unsubscribePause = SubscribeToAll(PauseEvent, (data) =>
{
animation.Pause();
});
}
if (unsubscribeA == null)
{
unsubscribeA = SubscribeToAll(PlayRangeAEvent, (data) =>
{
AnimationParameters animationParameters = initialAnimationParameters;
animationParameters.PlaybackSpeed = Math.Abs(animationParameters.PlaybackSpeed) * Math.Sign(RangeAEnd - RangeAStart);
if (animationParameters.PlaybackSpeed > 0.0f)
{
animationParameters.RangeStartFrame = RangeAStart;
animationParameters.RangeEndFrame = RangeAEnd;
}
else
{
// Backwards playback uses negative playback speed but start frame still less than end frame
animationParameters.RangeStartFrame = RangeAEnd;
animationParameters.RangeEndFrame = RangeAStart;
}
animationParameters.ClampToRange = true;
if (ResetOnPlay)
{
animation.JumpToFrame(RangeAStart);
}
animation.Play(animationParameters);
});
}
if (unsubscribeB == null)
{
unsubscribeB = SubscribeToAll(PlayRangeBEvent, (data) =>
{
AnimationParameters animationParameters = initialAnimationParameters;
animationParameters.PlaybackSpeed = Math.Abs(animationParameters.PlaybackSpeed) * Math.Sign(RangeBEnd - RangeBStart);
if (animationParameters.PlaybackSpeed > 0.0f)
{
animationParameters.RangeStartFrame = RangeBStart;
animationParameters.RangeEndFrame = RangeBEnd;
}
else
{
// Backwards playback uses negative playback speed but start frame still less than end frame
animationParameters.RangeStartFrame = RangeBEnd;
animationParameters.RangeEndFrame = RangeBStart;
}
animationParameters.ClampToRange = true;
if (ResetOnPlay)
{
animation.JumpToFrame(RangeBStart);
}
animation.Play(animationParameters);
});
}
}
private void PlayAnimationEvent(int AnimationNumber, ScriptEventData data)
{
Log.Write("Playing Animation Number: " + AnimationNumber + " Animation: " + AnimationEvent[AnimationNumber]);
int firstFrame = Int32.Parse(startFrame[AnimationNumber]);
Log.Write("firstFrame: " + firstFrame);
int lastFrame = Int32.Parse(endFrame[AnimationNumber]);
Log.Write("lastFrame: " + lastFrame);
float NumberOfFrames = lastFrame - firstFrame;
Log.Write("NumberOfFrames: " + NumberOfFrames);
float AnimationTimeToComplete = NumberOfFrames / 30.0f;
Log.Write("AnimationTimeToComplete: " + AnimationTimeToComplete);
AnimationParameters animationParameters = initialAnimationParameters;
if (PlaybackType[AnimationNumber].Contains("oop"))
{
animationParameters.PlaybackMode = AnimationPlaybackMode.PlayOnce;
}
if (PlaybackType[AnimationNumber].Contains("ong"))
{
animationParameters.PlaybackMode = AnimationPlaybackMode.PingPong;
}
if (PlaybackType[AnimationNumber].Contains("nce"))
{
animationParameters.PlaybackMode = AnimationPlaybackMode.PlayOnce;
}
float fltPlaybackSpeed = float.Parse(AnimationSpeed[AnimationNumber]);
animationParameters.PlaybackSpeed = Math.Abs(fltPlaybackSpeed) * Math.Sign(lastFrame - firstFrame);
int intBlendDuration = Int32.Parse(BlendDuration[AnimationNumber]);
if (intBlendDuration > 0)
{
animationParameters.BlendDuration = Int32.Parse(BlendDuration[AnimationNumber]);
}
Log.Write("PlaybackSpeed: " + animationParameters.PlaybackSpeed);
if (animationParameters.PlaybackSpeed > 0.0f)
{
animationParameters.RangeStartFrame = firstFrame;
animationParameters.RangeEndFrame = lastFrame;
}
else
{
// Backwards playback uses negative playback speed but start frame still less than end frame
animationParameters.RangeStartFrame = lastFrame;
animationParameters.RangeEndFrame = firstFrame;
}
animationParameters.ClampToRange = true;
float TimeAdjust = 1.0f / fltPlaybackSpeed;
float timeDelay = AnimationTimeToComplete * 1000 * TimeAdjust - delay;
Log.Write("Type Length: " + PlaybackType[AnimationNumber].Length);
Log.Write("Number: " + PlaybackType[AnimationNumber].Substring(4, PlaybackType[AnimationNumber].Length - 4));
int i = 0;
if (PlaybackType[AnimationNumber].Contains("oop"))
{
do
{
animation.Play(animationParameters);
//Log.Write("TimeAdjust: " + TimeAdjust);
CurrentPosition = CurrentPosition + EndPosition[AnimationNumber];
Wait(TimeSpan.FromMilliseconds(timeDelay));
//Log.Write("CurPos: " + CurrentPosition);
animComponent.SetPosition(CurrentPosition);
animation.Reset(animationParameters);
//Wait(TimeSpan.FromMilliseconds(1000));
i++;
} while (i < 5);
}
else
{
animation.Play(animationParameters);
Log.Write("TimeAdjust: " + TimeAdjust);
Wait(TimeSpan.FromMilliseconds(AnimationTimeToComplete * 1000 * TimeAdjust));
}
string DoneEvent = AnimationDoneEvent[AnimationNumber];
SendToAll(DoneEvent, data.Data);
Log.Write("Sent Done Event: " + DoneEvent);
}
private void UpdateAnimations(float t, AnimationParameters fromParameters, AnimationParameters toParameters)
{
transform.localScale = Vector3.Lerp(fromParameters.scale, toParameters.scale, t);
starMat.SetFloat("_Transparency", Mathf.Lerp(fromParameters.starTransparency, toParameters.starTransparency, t));
trailMat.SetFloat("_Transparency", Mathf.Lerp(fromParameters.trailTransparency, toParameters.trailTransparency, t));
flare.brightness = Mathf.Lerp(fromParameters.flareBrightness, toParameters.flareBrightness, t);
}
