private IEnumerable <IPoolable> InstantiateBullet(InteractiveData interactiveData, UnityAction onInteractHandler)
{
var bullet = Instantiate(bulletPrefab);
bullet.name = "bullet";
bullet.GetComponent <ISetData <InteractiveData> >().SetData(interactiveData);
bullet.GetComponent <ISubscribedInteract>().OnInteracted.Subscribe(onInteractHandler);
var poolable = new Poolable(bullet);
poolable.OnFloated.Subscribe
(
() =>
{
spriteRenderer.sprite = withoutBullet;
bullet.transform.position = transform.position;
bullet.transform.rotation = transform.rotation;
var rigitbody = bullet.GetComponent <Rigidbody2D>();
rigitbody.velocity = Vector2.zero;
rigitbody.AddForce(accelerate);
StartCoroutine(CoroutineT.Single
(
() => spriteRenderer.sprite = withBullet, shootingReload / 2)
);
}
);
yield return(poolable);
}
private void Shoot()
{
bulletsPool.PoolObject();
for (int i = 1; i < bulletCount; i++)
{
CoroutineT.Single(bulletsPool.PoolObject, i * shootingTime).Start(this);
}
}
public void DenyAt(MonoBehaviour coroutineSource, float time, UnityAction denyActions = null)
{
state++;
CoroutineT.Single(() =>
{
RemoveState();
denyActions?.Invoke();
}, time).Start(coroutineSource);
}
public void Repool()
{
scaleAnimation.Show();
StartCoroutine(CoroutineT.Single
(
() => gameObject.SetActive(false),
damagedTime
));
}
public void Interact(PlayerCharacterLogic playerCharacter)
{
playerCharacter.CanGetDamage.Update();
CoroutineT.Single
(
() => playerCharacter
.Damage(999999, DamageType.magic)
.AddColorBy(Color.red, 1), 0.2f
).Start(this);
}
public void Close()
{
IsShowing = false;
transform.localScale = Scale;
count = (int)Mathf.Round(closeTransition / time);
vectorSpeed = Scale / count;
CoroutineT.For(RemoveSpeed, count, time, () => gameObject.SetActive(false)).Start(this);
}
public void Show()
{
IsShowing = true;
transform.localScale = Vector3.zero;
count = (int)Mathf.Round(openTransition / time);
vectorSpeed = Scale / count;
gameObject.SetActive(true);
CoroutineT.For(AddSpeed, count, time).Start(this);
}
public void Interact(PlayerCharacterLogic playerCharacter)
{
dragCount = touchedDragedCount;
CoroutineT.WhileBefore
(
() => damageEntity.Attack(playerCharacter),
() => TrapClosed,
damagedTime
).Start(playerCharacter);
}
private IEnumerator AsyncLoadScene(float delay)
{
var asyncOperator = SceneManager.LoadSceneAsync((int)scene);
asyncOperator.allowSceneActivation = false;
while (asyncOperator.progress < .9f)
{
yield return(null);
}
CoroutineT.Single(() => asyncOperator.allowSceneActivation = true, delay).Start(this);
}
public void OnPointerClick(PointerEventData eventData)
{
if (!draged)
{
clickedCount++;
if (clickedCount <= 2)
{
CoroutineT.Single(CheckClick, clickDelay).Start(this);
}
}
}
private void Awake()
{
transform = GetComponent <Transform>();
score = DB.Data.Score;
score.UpdateScore();
subscriber = score.OnDataChanged.Subscribe(SetData);
addingScore = ScoreBy1Time / 2;
CoroutineT.InfiniteBefore(AddScore, frequencyOfAddingScore).Start(this);
CoroutineT.InfiniteBefore(UpdateScore, frequencyOfUpdatingScore).Start(this);
CoroutineT.InfiniteBefore(IncreaseScoreBy1Time, 10).Start(this);
}
public void CoroutineDamaging(Collider2D collider2D, float damage, DamageType damageType, float time, UnityAction action = null)
{
CoroutineT.WhileBefore
(
() =>
{
if (CanGetDamage)
{
Damage(damage, damageType);
action?.Invoke();
}
},
() => this.collider2D.IsTouching(collider2D),
time
).Start(this);
}
public void CoroutineDamaging(int count, float damage, DamageType damageType, float time, UnityAction action = null)
{
CoroutineT.ForBefore
(
() =>
{
if (CanGetDamage)
{
Damage(damage, damageType);
action?.Invoke();
}
},
count,
time
).Start(this);
}
public void Interact(Transform playerTransform, Rigidbody2D playerRigitBody, PlayerControl control)
{
if (!Locked)
{
Locked = true;
Hitted = true;
OnHitted.Invoke();
CoroutineT.WhileBefore
(
() => control.LockTransformBy(transform, time),
() => gameObject.activeInHierarchy && Hitted,
time,
() => Locked = false
).Start(control);
}
}
private IEnumerable <IPoolable> InstansiateWave()
{
var wave = Instantiate(wavePrefab);
wave.name = "Wave";
waveTransform = wave.GetComponent <Transform>();
var poolable = new Poolable(wave);
poolable.OnFloated
.Subscribe
(
() => CoroutineT.Single(() => wave.SetActive(false), waveLivingTime)
.Start(this)
);
yield return(poolable);
}
public void ReflectPause()
{
if (IsPouse)
{
Time.timeScale = 1;
StartCoroutine(CoroutineT.Single
(
() =>
{
IsPouse = false;
PauseChanged();
}, 0.1f
));
}
else
{
Time.timeScale = 0;
IsPouse = true;
PauseChanged();
}
}
private void Shoot()
{
float time = 0.0f;
bulletsPool.PoolObject();
for (int i = 1; i < bulletsPool.Length; i++)
{
if (i + 1 < bulletsPool.Length)
{
time += i % countIn1Queue == 0 ? timeBetweenQueues : reloadingTimeBetweenShoots;
}
else
{
time += reloadingTimeBetweenShoots;
}
CoroutineT.Single(bulletsPool.PoolObject, time).Start(this);
}
CoroutineT.Single(OnReloadingStart.Invoke, time).Start(this);
}
private IEnumerable <IPoolable> InstantiateRay(InteractiveData interactiveData)
{
var ray = Instantiate(rayPrefab, transform.position, transform.rotation);
ray.name = "Lazer Ray";
var rayComponent = ray.GetComponent <LazerRay>();
rayComponent.SetData(interactiveData);
ray.GetComponent <ILinkWithShower>().EffectShower = EffectShower;
var poolable = new Poolable(ray);
poolable.OnFloated.Subscribe
(
() =>
{
ray.transform.position = transform.position;
ray.transform.rotation = transform.rotation;
float y = movingObject.Speed.y;
movingObject.Speed = movingObject.Speed.Change(y: 0);
movingObject.UpdateSpeedAndDelta();
rayComponent.StartCoroutine(CoroutineT.Single
(
() =>
{
ray.SetActive(false);
movingObject.Speed = movingObject.Speed.Change(y: y);
movingObject.UpdateSpeedAndDelta();
},
rayLivingTime
));
}
);
yield return(poolable);
}
private void MoveBack()
{
hookCollider.enabled = false;
hookRigidBody.velocity = Vector2.zero;
CoroutineT.WhileBefore
(
() => hookTransform.position = Vector3.MoveTowards(hookPosition, position, speed),
() => distanceHook.magnitude > 0.1f,
0,
() =>
{
hookTransform.localEulerAngles = Vector3.zero;
if (hookComponent.Hitted)
{
gameObject.SetActive(false);
}
movingObject.Speed = movingObject.Speed.Change(y: ySpeed);
}
).Start(this);
}
public void Interact(Transform playerTransform, Rigidbody2D playerRigitBody, PlayerControl control)
{
playerRigitBody.gravityScale = 0;
effectClosing.Play();
CoroutineT.WhileBefore
(
() =>
{
control.BlockPlayerAt(damagedTime);
control.LockTransformBy(transform, damagedTime);
},
() => TrapClosed,
damagedTime + Time.fixedDeltaTime,
() =>
{
playerRigitBody.gravityScale = control.WallGravityScale;
playerRigitBody.velocity = Vector2.zero;
effectClosing.Stop();
Dispose();
}
).Start(control);
}
private void Start()
{
CoroutineT.InfiniteBefore(Animate, animatedTime).Start(this);
}
public void Repool()
{
accelerate = (transform.position.x < 0 ? 1 : -1) * Mathf.Abs(accelerate);
StopAllCoroutines();
CoroutineT.InfiniteBefore(Shoot, reloadTime).Start(this);
}
public void Interact()
{
StopAllCoroutines();
StartCoroutine(CoroutineT.Single(Explode, hittedActiveTime));
}
private void Start()
{
PrepareParalax();
CoroutineT.Infinite(NormilizeParalax, 1).Start(this);
}
public void Repool()
{
rigidbody2D.constraints = RigidbodyConstraints2D.FreezeRotation;
StartCoroutine(CoroutineT.Single(Explode, activeTime.Randomize(3)));
}
private void ShowShieldAt(float time)
{
shield.SetActive(true);
CoroutineT.Single(() => shield.SetActive(false), time).Start(this);
}
public void Interact()
{
spriteRenderer.sprite = activeMine;
StartCoroutine(CoroutineT.Single(Explode, activeTime.Randomize(1.4f)));
}
public void Repool()
{
StopAllCoroutines();
StartCoroutine(CoroutineT.Single(Shoot, 2));
}
public void Repool()
{
accelerate.x = (transform.position.x < 0 ? 1 : -1) * Mathf.Abs(accelerate.x);
StopAllCoroutines();
CoroutineT.InfiniteBefore(arrowsPool.PoolObject, reloadTime).Start(this);
}
public void Repool()
{
StopAllCoroutines();
CoroutineT.Infinite(raysPool.PoolObject, reloadingTime).Start(this);
}
