public override void OnEnter()
{
if (!effect.IsNone && effect.Value != null)
{
Effect effectPrefab = effect.Value.GetComponent <Effect>();
EffectUtils.PlayEffect(effectPrefab, position.Value, rotation.Value, parent.Value != null ? parent.Value.transform : null);
}
Finish();
}
public override void OnSyncedUpdate()
{
base.OnSyncedUpdate();
if (!m_RunSyncedUpdate)
{
return;
}
// Read delta time.
FP deltaTime = TrueSyncManager.deltaTimeMain;
// Update timers.
UpdateTimers(deltaTime);
// Handle actions.
bool buttonDown = TrueSyncInput.HasByte(m_ButtonDownCode);
if (buttonDown && (m_Timer == FP.Zero))
{
int tick = TrueSyncManager.ticksMain;
if (!m_EffectTicks.Contains(tick))
{
if (m_Pivot != null)
{
EffectUtils.PlayEffect(m_Effect, m_Pivot);
}
m_EffectTicks.Add(tick);
}
m_Timer = m_Cooldown;
}
// Clear effect ticks cache.
for (int index = 0; index < m_EffectTicks.Count; ++index)
{
int tick = m_EffectTicks[index];
if (TrueSyncManager.IsTickOutOfRollbackMain(tick))
{
m_EffectTicks.RemoveAt(index);
index = -1;
}
}
}
protected override void OnKickOff()
{
base.OnKickOff();
int currentTick = TrueSyncManager.ticksMain;
if (!m_KickOffEffectsTicks.Contains(currentTick))
{
EffectUtils.PlayEffect(m_KickOffEffect, midfieldPosition, Quaternion.identity);
SfxPlayer.PlayMain(m_KickOffSfx);
m_KickOffEffectsTicks.Add(currentTick);
}
}
// LOGIC
public void Teleport(int i_HoleIndex, TSVector2 i_Position, TSVector2 i_OutForce, FP i_Delay, Effect i_InEffect = null, Effect i_OutEffect = null)
{
if (m_Teleporting)
{
return;
}
int tick = TrueSyncManager.ticksMain;
// Play effect.
if (m_TeleportRequestTick != tick)
{
EffectUtils.PlayEffect(i_InEffect, currentPosition);
}
// Cache rigidbody data and set it kinematic.
if (m_Rigidbody != null)
{
m_CachedMass = m_Rigidbody.mass;
m_CachedKinematic = m_Rigidbody.isKinematic;
m_Rigidbody.isKinematic = true;
}
// Setup class variables.
m_EnteringHoleIndex = i_HoleIndex;
m_Teleporting = true;
m_Timer = FP.Zero;
m_TeleportRequestTick = tick;
m_Delay = i_Delay;
m_OutForce = i_OutForce;
m_RespawnPosition = i_Position;
m_OutEffect = i_OutEffect;
// If no delay, teleport instant.
if (i_Delay == FP.Zero)
{
Respawn();
}
}
// INTERNALS
private void Respawn()
{
int tick = TrueSyncManager.ticksMain;
// If rigidbody, re-config it. Move otherwise.
if (m_Rigidbody != null)
{
m_Rigidbody.isKinematic = m_CachedKinematic;
m_Rigidbody.mass = m_CachedMass;
m_Rigidbody.MovePosition(m_RespawnPosition);
m_Rigidbody.AddForce(m_OutForce);
}
else
{
tsTransform2D.position = m_RespawnPosition;
}
// Play Effect.
if (!m_OutEffectTicks.Contains(tick))
{
Effect outEffect = m_OutEffect;
EffectUtils.PlayEffect(outEffect, currentPosition);
m_OutEffectTicks.Add(tick);
}
// Clear class variables.
m_EnteringHoleIndex = -1;
m_TeleportTick = 0;
m_Teleporting = false;
m_Timer = FP.Zero;
m_Delay = FP.Zero;
m_OutForce = TSVector2.zero;
m_RespawnPosition = TSVector2.zero;
m_OutEffect = null;
m_TeleportRequestTick = 0;
}
public override void OnSyncedCollisionExit(TSCollision2D i_Collision)
{
if (m_HitEffectTimer == 0f)
{
if (!i_Collision.collider.CompareTag(Tags.s_Ball))
{
if (m_DurationTimer > 0f)
{
EffectUtils.PlayEffect(m_HitEffect, transform.position, transform.rotation);
m_HitEffectTimer = m_HitEffectInterval;
}
}
else
{
EffectUtils.PlayEffect(m_BallHitEffect, transform.position, transform.rotation);
m_HitEffectTimer = m_HitEffectInterval;
}
}
}
// EVENTS
private void Teleport()
{
if (m_TargetsCache.Count < 1 || m_RespawnPointsCache.Count < 1)
{
return;
}
Collider2D target = m_TargetsCache[0];
m_TargetsCache.RemoveAt(0);
RespawnPoint respawnPoint = m_RespawnPointsCache[0];
m_RespawnPointsCache.RemoveAt(0);
if (target != null && respawnPoint != null && respawnPoint.transform != null)
{
target.transform.position = respawnPoint.transform.position;
Rigidbody2D rb2d = target.GetComponent <Rigidbody2D>();
if (rb2d != null)
{
rb2d.isKinematic = false;
rb2d.velocity = Vector2.zero;
Vector2 forceDirection = respawnPoint.forceDirection;
forceDirection.Normalize();
if (Mathf.Abs(respawnPoint.errorAngle) > Mathf.Epsilon)
{
float randomError = Random.Range(-respawnPoint.errorAngle, respawnPoint.errorAngle);
forceDirection = forceDirection.Rotate(randomError);
}
Vector2 outForce = forceDirection * respawnPoint.forceIntensity;
rb2d.AddForce(outForce);
}
EffectUtils.PlayEffect(m_OutEffect, respawnPoint.transform.position);
RaisePostHoleOccuredEvent(target);
}
}
protected override void OnKickOff()
{
base.OnKickOff();
int currentTick = TrueSyncManager.ticksMain;
if (!m_KickOffEffectsTicks.Contains(currentTick))
{
// Play effects.
EffectUtils.PlayEffect(m_KickOffEffect, midfieldPosition, Quaternion.identity);
SfxPlayer.PlayMain(m_KickOffSfx);
m_KickOffEffectsTicks.Add(currentTick);
}
// Enable energy recovery.
SetEnergyRecoveryEnabled(true);
}
public override void OnSyncedCollisionExit(TSCollision2D i_Collision)
{
if (i_Collision.gameObject.CompareTag(Tags.s_Character))
{
if (m_HitEffectTimer == 0f)
{
EffectUtils.PlayEffect(m_CharacterHitEffect, transform.position, transform.rotation);
m_HitEffectTimer = m_HitEffectInterval;
}
}
else
{
if (m_HitEffectTimer == 0f)
{
EffectUtils.PlayEffect(m_HitEffect, transform.position, transform.rotation);
m_HitEffectTimer = m_HitEffectInterval;
}
}
}
public override void OnSyncedCollisionEnter(TSCollision2D i_Collision)
{
int tick = TrueSyncManager.ticksMain;
// Apply forces.
TSRigidBody2D rigidbody2D = i_Collision.gameObject.GetComponent <TSRigidBody2D>();
if (rigidbody2D != null)
{
// Clear velocity.
rigidbody2D.velocity = TSVector2.zero;
// Add bounce force.
TSVector2 otherPosition = rigidbody2D.position;
TSVector2 myPostion = tsTransform2D.position;
TSVector2 direction = otherPosition - myPostion;
direction.Normalize();
TSVector2 force = direction * m_Force;
rigidbody2D.AddForce(force);
}
// Play effect.
if (!m_EffectTicks.Contains(tick))
{
m_Animator.SetTrigger("Hit");
EffectUtils.PlayEffect(m_Effect, transform);
m_EffectTicks.Add(tick);
}
}
void Update()
{
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, m_Threshold, m_LayerMask);
if (colliders == null)
{
return;
}
for (int colliderIndex = 0; colliderIndex < colliders.Length; ++colliderIndex)
{
Collider2D collider = colliders[colliderIndex];
if (m_Manager == null || !m_Manager.IsValidCollision(collider))
{
continue;
}
Vector2 colliderPosition = collider.transform.position;
Vector2 myPosition = transform.position;
Vector2 positionDelta = colliderPosition - myPosition;
float distance2 = positionDelta.sqrMagnitude;
if (distance2 < m_Threshold * m_Threshold)
{
RespawnPoint respawnPoint = GetRandomRespawnPoint();
if (respawnPoint == null || respawnPoint.transform == null)
{
continue;
}
Transform otherTransform = collider.transform;
// Snap to my position.
otherTransform.position = transform.position;
// Make the object kinematic.
Rigidbody2D rb2d = otherTransform.GetComponent <Rigidbody2D>();
if (rb2d != null)
{
rb2d.isKinematic = true;
rb2d.velocity = Vector2.zero;
}
RaisePreHoleOccuredEvent(collider);
m_RespawnPointsCache.Add(respawnPoint);
m_TargetsCache.Add(collider);
EffectUtils.PlayEffect(m_InEffect, transform.position);
if (m_RespawnTime == 0f)
{
Teleport();
}
else
{
Invoke("Teleport", m_RespawnTime);
}
}
}
}
public override void OnSyncedUpdate()
{
base.OnSyncedUpdate();
if (!m_RunSyncedUpdate)
{
return;
}
// Read delta time.
FP deltaTime = TrueSyncManager.deltaTimeMain;
int currentTick = TrueSyncManager.ticksMain;
// Update timers.
UpdateTimers(deltaTime);
// Handle kick.
bool kickRequested = TrueSyncInput.HasByte(m_ButtonDownCode);
bool cooldownOk = (m_CooldownTimer == FP.Zero);
bool energyAvailable = (m_Energy != null && m_Energy.CanSpend(m_EnergyCost));
if (kickRequested && m_KickTickRequest == 0 && energyAvailable && cooldownOk)
{
// Cache kick tick request.
m_KickTickRequest = currentTick + m_KickTickDelay;
// Consume energy
if (m_Energy != null)
{
m_Energy.Consume(m_EnergyCost);
}
}
if ((m_KickTickRequest > 0) && (m_KickTickRequest == currentTick))
{
m_KickTickRequest = 0;
bool kick = Kick(m_KickLayerMask, m_KickForce, deltaTime, m_KickInvertVelocity);
bool tackle = Kick(m_TackleLayerMask, m_TackleForce, deltaTime, m_TackleInvertVelocity);
bool kickedAnything = kick || tackle;
if (kickedAnything || m_PlayEffectWhenNothingIsHit)
{
int tick = TrueSyncManager.ticksMain;
if (!m_EffectTicks.Contains(tick))
{
if (m_EffectPivot != null)
{
EffectUtils.PlayEffect(m_Effect, m_EffectPivot);
}
m_EffectTicks.Add(tick);
}
}
if (!kickedAnything)
{
m_CooldownTimer = FP.Zero;
}
else
{
m_CooldownTimer = m_Cooldown;
}
}
// Clear effect ticks cache.
for (int index = 0; index < m_EffectTicks.Count; ++index)
{
int tick = m_EffectTicks[index];
if (TrueSyncManager.IsTickOutOfRollbackMain(tick))
{
m_EffectTicks.RemoveAt(index);
index = -1;
}
}
}