public void OnPoolSpawned()
{
float duration;
//if (!ParticleC== null) {
// duration = ParticleC.lifetime + ParticleC.lifetimeOffset;
//}
if (_particle != null)
{
duration = _particle.main.duration;
}
else
{
duration = _defaultDuration;
}
_lerp.RestartLerp(0, 1, duration);
if (_unscaled)
{
TimeManager.StartUnscaled(UpdateLight());
}
else
{
TimeManager.StartTask(UpdateLight());
}
}
public void Animate()
{
if (!_animatingColor && _spriteRender != null)
{
TimeManager.StartTask(DamageTween());
}
}
public IEnumerator PlayAnimation()
{
StartTween();
bool flipped = false;
while (true)
{
UpdateTween();
if (Tween.Active)
{
yield return(null);
continue;
}
if (Repeat == PixelComrades.Tween.TweenRepeat.PingPong)
{
if (!flipped)
{
flipped = true;
Tween.Flip();
continue;
}
}
break;
}
if (_chain != null)
{
yield return(TimeManager.StartTask(_chain.PlayAnimation(), _chain.Tween.UnScaled));
}
}
public void OnPoolSpawned()
{
for (int i = 0; i < _entity.Renderers.Length; i++)
{
_entity.Renderers[i].material.SetFloat("_DissolveAmount", 0);
}
TimeManager.StartTask(FadeInItem());
}
public void ReloadWeapon()
{
if (_current == null || _state != State.None)
{
return;
}
TimeManager.StartTask(LoadWeaponProcess(), false);
}
public override void Play()
{
if (_task != null)
{
TimeManager.Cancel(_task);
}
_task = TimeManager.StartTask(PlayAnimation(), UnScaled, Finish);
}
public override void OnComplete()
{
_floating = NewPrefab.GetComponent <UIFloatingText>();
if (_icon != null)
{
_floating._icon.overrideSprite = _icon;
}
_floating.RectTransform.SetParent(_parent);
_floating.RectTransform.SetAsLastSibling();
TimeManager.StartTask(SetTargetText());
}
void OnEnable()
{
if (_unscaled)
{
TimeManager.StartUnscaled(Despawn());
}
else
{
TimeManager.StartTask(Despawn());
}
}
private void CheckRepeat()
{
resttime = originaltime;
if (repeat == Tween.TweenRepeat.PingPong)
{
SwitchTargets();
}
if (repeat == Tween.TweenRepeat.PingPong || repeat == Tween.TweenRepeat.Loop)
{
TimeManager.StartTask(Animate());
}
}
private IEnumerator Test3(float extraWait)
{
yield return(1);
yield return(extraWait);
yield return(new Task[] {
TimeManager.StartTask(Test(2)), TimeManager.StartTask(Test(4))
});
Log(extraWait, 3);
}
private void ProcessVertices(Vector3[] verts, Color[] colors, Vector3 velocity)
{
if (verts == null || colors == null)
{
Debug.Log("no verts");
return;
}
velocity = Vector3.ClampMagnitude(velocity, _maxForceMagnitude);
CheckParticles();
var vertexMulti = Mathf.Clamp(_maxParticles / verts.Length, 1, 2);
var emitCount = Mathf.Clamp(verts.Length * vertexMulti, 100, _maxParticles);
//_particleSystem.main.maxParticles = _maxParticles;
_particleSystem.Emit(emitCount);
var currentParticlesCount = _particleSystem.GetParticles(_particles);
//if (currentParticlesCount != emitCount && !Application.isPlaying) {
// Debug.LogError(string.Format("Particle count {0} emit {1}", currentParticlesCount, emitCount));
//}
var vertexStep = verts.Length / _maxParticles;
if (vertexStep < 1)
{
vertexStep = 1;
}
var vertIndex = 0;
float jitter = _extraForce.Get();
float posJitter = 0;
//var octaves = 1;
for (int i = 0; i < currentParticlesCount; i++)
{
var spherePos = UnityEngine.Random.insideUnitSphere;
_particles[i].position = verts[vertIndex] + spherePos * posJitter; //targetTr.TransformPoint(verts[vertIndex]); //verts[vertIndex];//
_particles[i].startColor = colors[vertIndex];
var noiseOffset = Mathf.PerlinNoise(_particles[i].position.x, _particles[i].position.y); //Perlin.Fbm(verts[vertIndex], octaves);
_particles[i].velocity = velocity + spherePos * jitter * noiseOffset;
_particles[i].angularVelocity3D = velocity + spherePos * jitter * noiseOffset;
vertIndex += vertexStep;
if (vertIndex >= verts.Length)
{
//octaves++;
vertIndex = 0;
posJitter += _particleSystem.main.startSize.Evaluate(0.5f);
jitter += _extraForce.Get();
}
}
_particleSystem.SetParticles(_particles, emitCount);
if (Application.isPlaying)
{
TimeManager.StartTask(DespawnParticles());
}
}
public override void Stop()
{
if (_inMotion)
{
return;
}
if (Physics.SphereCast(_context.transform.position + Vector3.up * .75f, _context.Radius, Vector3.up,
out FloorHit, _nativeCapsuleHeight * .25f))
{
return;
}
TimeManager.StartTask(StandUp());
}
public override void OnInspectorGUI()
{
var script = (TimeManager)target;
_expandedList = EditorGUILayout.Foldout(_expandedList, "Tasks");
if (_expandedList)
{
for (int i = 0; i < TimeManager.ActiveCount; i++)
{
if (i > MaxList)
{
break;
}
var current = script[i];
if (current == null)
{
continue;
}
var taskDisplay = string.Format("{0}: {1} Scale {2} Curr {3} Wait {4}",
current.Routine.ToString(), current.Mode, !current.Unscaled, current.Current.ToString("F2"), current.WaitFor);
if (GUILayout.Button(taskDisplay))
{
script.CancelInternal(current);
}
}
}
if (GUILayout.Button("Cancel All"))
{
script.CancelAll();
}
if (GUILayout.Button("Check Editor"))
{
script.ForceEditorCheck();
Debug.Log(TimeManager.ActiveCount + " " + EditorApplication.update.GetInvocationList().Length);
foreach (var del in EditorApplication.update.GetInvocationList())
{
if (del.Target == null)
{
continue;
}
Debug.Log(del.Target.GetType());
}
}
if (GUILayout.Button("Test"))
{
TimeManager.StartTask(Test3(1.5f));
}
EditorGUILayout.LabelField(string.Format("Scale {0} Fixed {1} Time {2} TimeUn {3}",
TimeManager.TimeScale, TimeManager.FixedDelta, TimeManager.Time, TimeManager.TimeUnscaled));
base.OnInspectorGUI();
}
public void ChangeAction(ActionConfig newActionConfig)
{
if (_current != null && newActionConfig != null)
{
TimeManager.StartTask(SwapWeapons(newActionConfig));
}
else if (_current != null && newActionConfig == null)
{
TimeManager.StartTask(LowerWeapon(true));
}
else
{
SetupUsable(newActionConfig);
TimeManager.StartTask(RaiseWeapon());
}
}
public override void Play()
{
if (_matBlocks == null)
{
SetMatBlocks();
}
_index++;
if (_index >= _shaderTargets.Length)
{
_index = 0;
}
if (_task != null)
{
TimeManager.Cancel(_task);
}
_task = TimeManager.StartTask(PlayAnimation(), _unscaled, Finish);
}
private void UpdateRoutine()
{
_current = 0;
if (Routine == null || !Routine.MoveNext() || Finished)
{
Finished = true;
return;
}
if (Routine == null)
{
Debug.LogError(Routine.ToString() + " hit null");
return;
}
if (Routine.Current == null)
{
_waitFor = 1;
_mode = UpdateMode.Frame;
return;
}
var yieldCommand = Routine.Current;
if (yieldCommand is int)
{
_waitFor = (int)yieldCommand;
_mode = UpdateMode.Frame;
return;
}
if (yieldCommand is float)
{
_waitFor = (float)yieldCommand;
_mode = UpdateMode.Time;
return;
}
IEnumerator routine = yieldCommand as IEnumerator;
Task waitTask;
if (routine != null)
{
waitTask = TimeManager.StartTask(routine, Unscaled);
}
else
{
waitTask = yieldCommand as Task;
}
if (waitTask != null)
{
_mode = UpdateMode.Task;
waitTask.OnFinish += WatchedTaskFinished;
_waitFor = 0;
return;
}
var taskArray = yieldCommand as IList <Task>;
if (taskArray != null)
{
_mode = UpdateMode.Task;
for (int i = 0; i < taskArray.Count; i++)
{
taskArray[i].OnFinish += WatchedTaskFinished;
}
_waitFor = taskArray.Count - 1;
return;
}
Debug.LogError(string.Format("Unexpected yield type: {0} in {1}", yieldCommand.GetType(), Routine.ToString()));
Finished = true;
}
void OnBecameInvisible()
{
_visible = false;
TimeManager.StartTask(CheckVisibleStatus());
}
public override void OnComplete()
{
_floating = NewPrefab.GetComponent <FloatingText>();
TimeManager.StartTask(SetTargetText());
}
public static void StartCharge(float lerpTime)
{
TimeManager.StartTask(main.Charge(lerpTime));
}
public void OnPoolSpawned()
{
transform.rotation *= Quaternion.Euler(0, 0, Random.Range(-360, 360));
TimeManager.StartTask(WaitForDespawn());
}
private void Play()
{
TimeManager.StartTask(PlayAnimation(), _unscaled);
}
public void StartText(string text, float duration, Vector3 end, Color color)
{
TimeManager.StartTask(SetTargetText(text, duration, end, color));
}
public void Handle(DamageEvent arg)
{
var entity = this.GetEntity();
TimeManager.StartTask(PauseMovementForDamage(entity, entity.Get <AnimatorData>(), _damageClip));
}
public void PauseForClip(string clip)
{
var entity = this.GetEntity();
TimeManager.StartTask(PauseMovementForDamage(entity, entity.Get <AnimatorData>(), clip));
}
public void StartTimer()
{
TimeManager.StartTask(WaitTimer(), Unscaled);
}
public static void StopCharge()
{
TimeManager.StartTask(main.Fade());
}
public void TypeWriterText(string displayText, float speed, bool unscaled, System.Action onComplete)
{
TimeManager.StartTask(DisplayText(displayText, speed), unscaled, onComplete);
}
public override void Enter()
{
TimeManager.StartTask(SitDown());
}
