private void OnChromieHitColorZoneHandler(ChromieController chromieController, ColorZoneController colorZone)
{
if (chromieController.ChromieType == colorZone.Color)
{
ChromieCollected(chromieController, colorZone);
}
}
protected override IEnumerator<float> PowerupEffectCorutine(ChromieController cheomieControllerActivator)
{
if (cheomieControllerActivator != null)
{
SpwanerController spwanerController;
ColorZonesController colorZonesController;
ChromieController[] chromiesControllers = GameObject.FindObjectsOfType<ChromieController>();
for (int i = 0; i < chromiesControllers.Length; i++)
{
if (chromiesControllers[i].gameObject.activeSelf)
{
chromiesControllers[i].SwitchChromie(cheomieControllerActivator.ChromieDefenition);
}
}
spwanerController = GameObject.FindObjectOfType<SpwanerController>();
spwanerController.SetSpwanColorOverride(cheomieControllerActivator.ChromieType);
colorZonesController = GameObject.FindObjectOfType<ColorZonesController>();
colorZonesController.OverrideColorZonesColor(cheomieControllerActivator.ChromieDefenition);
yield return Timing.WaitForSeconds(GetDuration());
spwanerController.SetSpwanColorOverride(eChromieType.None);
colorZonesController.ResetColorZonesToOriginalColor();
}
}
private void ActivatePowerup(PowerupBase powerup, ChromieController chromieController)
{
if (!powerup.AllowMultiple)
{
foreach (PowerupBase activePowerup in _activePowerups)
{
if (activePowerup.GetType() == powerup.GetType())
{
// stop the powerup from activate, there is alrady one active!
Debug.Log("stopped powerup: " + powerup.name + " from activate!");
return;
}
}
}
PowerupBase powerupInstance = powerup.StartPowerup(chromieController);
_activePowerups.Add(powerupInstance);
if (_powerupActivationEffectprefab != null)
{
GameObject powerupEffect = Lean.LeanPool.Spawn(_powerupActivationEffectprefab, chromieController.transform.position, Quaternion.identity);
powerupEffect.GetComponent<ParticleSystem>().startColor = chromieController.ChromieDefenition.ColorValue;
Lean.LeanPool.Despawn(powerupEffect, 2.0f);
}
}
private void OnChromieCollectedHandler(ChromieController chromieController, ColorZoneController colorZone)
{
_gameplayTrackingData.CollectedChromiez++;
if (_gameplayTrackingData.ColletedColors.ContainsKey(chromieController.ChromieDefenition.ChromieColor))
{
_gameplayTrackingData.ColletedColors[chromieController.ChromieDefenition.ChromieColor] += 1;
}
else
{
_gameplayTrackingData.ColletedColors.Add(chromieController.ChromieDefenition.ChromieColor, 1);
}
if (chromieController.IsPowerup)
{
_gameplayTrackingData.CollectedPowerups++;
if (_gameplayTrackingData.CollectedPoweupsColors.ContainsKey(chromieController.ChromieDefenition.ChromieColor))
{
_gameplayTrackingData.CollectedPoweupsColors[chromieController.ChromieDefenition.ChromieColor] += 1;
}
else
{
_gameplayTrackingData.CollectedPoweupsColors.Add(chromieController.ChromieDefenition.ChromieColor, 1);
}
}
}
public void OnChromieCollectedHandler(ChromieController chromieController, ColorZoneController colorZone)
{
if (colorZone == this)
{
//TODO: Display collection animation
_colorZoneCharacter.Collected();
}
}
protected override IEnumerator<float> PowerupEffectCorutine(ChromieController cheomieControllerActivator)
{
GameplayLivesManager livesManager = GameObject.FindObjectOfType<GameplayLivesManager>();
if (livesManager != null)
{
livesManager.AddLifeSlot(NumberOfExtraLivesSlots);
}
yield return 0f;
}
protected override IEnumerator<float> PowerupEffectCorutine(ChromieController cheomieControllerActivator)
{
GameplayTimerManager timerManager = GameObject.FindObjectOfType<GameplayTimerManager>();
if (timerManager != null)
{
timerManager.AddTime(TimeToAdd);
}
yield return 0f;
}
public PowerupBase StartPowerup(ChromieController chromieController)
{
Debug.Log("start powerup: " + this.name);
PowerupBase powerupEffect = ScriptableObject.Instantiate(this);
if (powerupEffect != null)
{
Timing.RunCoroutine(powerupEffect.PlayPowerupEffect(chromieController));
}
return powerupEffect;
}
private void OnChromieCollectedHandler(ChromieController chromieController, ColorZoneController colorZone)
{
if (chromieController.IsPowerup)
{
if (chromieController.ChromieDefenition.ActivePowerup != null)
{
ActivatePowerup(chromieController.ChromieDefenition.ActivePowerup, chromieController);
}
}
}
private void OnScoreUpdateHandler(int scoreAdded, int newScore, ChromieController chromieController)
{
UpdateScoreDisplay(newScore);
if (_displayScoreIndicationOnCollection && chromieController != null)
{
Vector3 position = chromieController.transform.localPosition;
ScoreIndicatorController scoreIndicator = Lean.LeanPool.Spawn(_scoreIndicatorPrefab, position, Quaternion.identity, this.transform);
scoreIndicator.transform.position = position;
scoreIndicator.DisplayScore(scoreAdded, chromieController.ChromieDefenition.ColorValue);
}
}
protected override IEnumerator<float> PowerupEffectCorutine(ChromieController cheomieControllerActivator)
{
GameplayLivesManager livesManager = GameObject.FindObjectOfType<GameplayLivesManager>();
if (livesManager != null)
{
livesManager.SetImmune(true);
yield return Timing.WaitForSeconds(Duration);
livesManager.SetImmune(false);
}
}
private void OnChromieDespwanedHandler(ChromieController chromieController)
{
if (chromieController.gameObject == _draggedObject)
{
IDraggable draggable = _draggedObject.gameObject.GetComponent<IDraggable>();
if (draggable != null)
{
draggable.EndDrag();
}
_isDragging = false;
_draggedObject = null;
}
}
protected override IEnumerator<float> PowerupEffectCorutine(ChromieController cheomieControllerActivator)
{
GameplayPowerupsManager gameplayPowerupsManager = GameObject.FindObjectOfType<GameplayPowerupsManager>();
if (gameplayPowerupsManager != null)
{
GameplayBuffEffect buffEffect = GameplayBuffsManager.Instance.CreateBuff(BuffEffect);
gameplayPowerupsManager.UpdatePowerupSpwanInterval();
if (IsActive)
{
yield return Timing.WaitForSeconds(GetDuration());
GameplayBuffsManager.Instance.RemoveBuff(buffEffect);
gameplayPowerupsManager.UpdatePowerupSpwanInterval();
}
}
}
protected override IEnumerator<float> PowerupEffectCorutine(ChromieController cheomieControllerActivator)
{
GameplayScoreManager scoreManager = GameObject.FindObjectOfType<GameplayScoreManager>();
if (scoreManager != null)
{
GameplayBuffEffect buffEffectInstance = GameplayBuffsManager.Instance.CreateBuff(BuffEffect);
scoreManager.UpdateScoreMultiplier();
if (IsActive)
{
yield return Timing.WaitForSeconds(GetDuration());
GameplayBuffsManager.Instance.RemoveBuff(buffEffectInstance);
scoreManager.UpdateScoreMultiplier();
}
}
}
protected override IEnumerator<float> PowerupEffectCorutine(ChromieController cheomieControllerActivator)
{
float scaleValue = BuffEffect.Value * GameplayBuffsManager.GetValue(eBuffType.PowerupEffectMultiplier);
GameplayBuffEffect buffEffect = GameplayBuffsManager.Instance.CreateBuff(BuffEffect.Type, scaleValue, BuffEffect.Method);
ColorZoneController[] colorZoneControlerList = GameObject.FindObjectsOfType<ColorZoneController>();
foreach (ColorZoneController colorZone in colorZoneControlerList)
{
colorZone.UpdateScaleFactor();
}
if (IsActive)
{
GameplayBuffsManager.Instance.RemoveBuff(buffEffect);
yield return Timing.WaitForSeconds(GetDuration());
foreach (ColorZoneController colorZone in colorZoneControlerList)
{
colorZone.UpdateScaleFactor();
}
}
}
private void OnChromieCollectedHandler(ChromieController chromieController, ColorZoneController colorZone)
{
int scoreToAdd = 1;
if (_lastCollectedChromie == chromieController.ChromieType)
{
_currentComboCount++;
}
else
{
_currentComboCount = 0;
}
scoreToAdd += (_currentComboCount * _currentComboMultiplier);
scoreToAdd *= _currentScoreMultiplier;
_currentScore += scoreToAdd;
GameplayEventsDispatcher.Instance.ScoreUpdate(scoreToAdd, _currentScore, chromieController);
_lastCollectedChromie = chromieController.ChromieType;
}
public IEnumerator<float> PlayPowerupEffect(ChromieController chromieController)
{
if (ActivationEffectPrefab != null)
{
Instantiate(ActivationEffectPrefab);
}
if (DurationEffectPrefab != null)
{
if (_durationEffectInstance != null)
{
Destroy(_durationEffectInstance);
}
_durationEffectInstance = Instantiate(DurationEffectPrefab) as GameObject;
}
GameplayEventsDispatcher.SendPowerupStarted(this);
yield return Timing.WaitUntilDone(Timing.RunCoroutine(PowerupEffectCorutine(chromieController)));
Timing.KillCoroutines(this.GetHashCode().ToString());
if (_durationEffectInstance != null)
{
Destroy(_durationEffectInstance);
_durationEffectInstance = null;
}
if (FinishedEffectPrefab != null)
{
Instantiate(FinishedEffectPrefab);
}
GameplayEventsDispatcher.SendPowerupStopped(this);
}
private void ChromieCollected(ChromieController chromieController, ColorZoneController colorZone)
{
GameplayEventsDispatcher.SendChromieCollected(chromieController, colorZone);
}
public void ChromieCollected(ChromieController chromieController, ColorZoneController colorZone)
{
if (OnChromieCollected != null)
{
OnChromieCollected(chromieController, colorZone);
}
}
public void OnChromieCollectedHandler(ChromieController chromieController, ColorZoneController colorZone)
{
if (chromieController == this)
{
//TODO: do stuff when collected
}
}
public void ChromieDropped(ChromieController chromieController)
{
if (OnChromieDropped != null)
{
OnChromieDropped(chromieController);
}
}
private void OnChromieDroppedHandler(ChromieController chromieController)
{
_currentComboCount = 0;
_lastCollectedChromie = eChromieType.None;
}
public static void SendScoreUpdate(int scoreAdded, int newScore, ChromieController chromieController)
{
GameplayEventsDispatcher.Instance.ScoreUpdate(scoreAdded, newScore, chromieController);
}
private void OnChromieDroppedHandler(ChromieController chromieController)
{
if (_isActive)
{
LooseLife();
if (_hitIndicatorPrefab != null)
{
Timing.RunCoroutine(DisplayHit(chromieController.transform.position));
}
}
}
public static void SendChromieDeSpwaned(ChromieController chromieController)
{
GameplayEventsDispatcher.Instance.ChromieDeSpwaned(chromieController);
}
public static void SendChromieCollected(ChromieController chromieController, ColorZoneController colorZone)
{
GameplayEventsDispatcher.Instance.ChromieCollected(chromieController, colorZone);
}
public void ScoreUpdate(int scoreAdded, int newScore, ChromieController chromieController)
{
if (OnScoreUpdate != null)
{
OnScoreUpdate(scoreAdded, newScore, chromieController);
}
}
public void ChromieHitColorZone(ChromieController chromieController, ColorZoneController colorZone)
{
if (OnChromieHitColorZone != null)
{
OnChromieHitColorZone(chromieController, colorZone);
}
}
public void ChromieSpwaned(ChromieController cheomieController)
{
if (OnChromieSpawned != null)
{
OnChromieSpawned(cheomieController);
}
}
private void OnScoreUpdateHandler(int scoreAdded, int newScore, ChromieController chromieController)
{
_gameplayTrackingData.Score += scoreAdded;
}
