public void PlayPowerupEffect(EPowerUp powerup, int version = 0, bool play = true)
{
switch (powerup)
{
case EPowerUp.Multiball:
PlayEffect(this.systems.multiball, play);
break;
case EPowerUp.CatchNThrow:
PlayEffect(this.systems.catchNThrow, play);
break;
case EPowerUp.Freeze:
PlayFreezeEffect(version, play);
break;
case EPowerUp.CircleShield:
PlayEffect(this.systems.shield, play);
break;
case EPowerUp.Shrink:
PlayEffect(this.systems.shrink, play);
break;
}
}
public void PlayerPowerUpCollision(GameObject player, PowerUp powerUp)
{
PlayerController playerController;
// If player is not cached, cache them
if (!playerDictionary.TryGetValue(player, out playerController))
{
playerController = player.GetComponent <PlayerController>();
playerDictionary.Add(player, playerController);
}
if (playerController.GetCurrentPowerUp() != EPowerUp.None)
{
playerController.RemovePowerUp();
}
EPowerUp powerUpType = powerUp.GetPowerUpType();
Color powerUpShieldColor = powerUpManager.GetPowerUpShieldColor(powerUpType);
playerController.ReceivePowerUp(powerUpType, powerUpShieldColor);
if (powerUpType == EPowerUp.CircleShield) //need to have a list of powerups that reference a secondary shield
{
playerController.EnableSecondaryShield(true);
}
else if (powerUpType == EPowerUp.Multiball)
{
multiBallInPlay = true;
}
else if (powerUpType == EPowerUp.Shrink)
{
ETeam team = playerController.GetTeamNumber();
ETeam opTeam = GetOpposingTeam(team);
ShrinkTeam(opTeam);
playerController.RemovePowerUp();
}
}
void OnEnable()
{
if (powerUpType == EPowerUp.Random)
{
instanceType = powerups[rng.Next(0, powerups.Length)];
UpdateSprite();
}
}
public void ReceivePowerUp(EPowerUp powerUp, Color powerUpColor)
{
if (powerupParticleController)
{
powerupParticleController.PlayPowerupEffect(powerUp, 0, true);
}
audioSource.PlayOneShot(gameManagerInstance.GetPowerupPickupSound(powerUp));
hasPowerUp = true;
currPowerUp = powerUp;
}
private void OnCollisionEnter2D(Collision2D collision)
{
if (!isInvincible)
{
if (collision.gameObject.layer == LayerMask.NameToLayer("Ball") && collision.otherCollider.CompareTag("Player"))
{
if (gameManagerInstance != null || GameManager.TryGetInstance(out gameManagerInstance))
{
gameManagerInstance.BallPlayerCollision(gameObject, collision);
}
}
if (collision.gameObject.layer == LayerMask.NameToLayer("Player"))
{
if (gameManagerInstance != null || GameManager.TryGetInstance(out gameManagerInstance))
{
PlayerController otherPlayer = collision.gameObject.GetComponent <PlayerController>();
if (team != otherPlayer.team)
{
EPowerUp otherPlayerPowUp = otherPlayer.GetCurrentPowerUp();
if (otherPlayerPowUp == EPowerUp.Freeze)
{
powerupParticleController.PlayPowerupEffect(EPowerUp.Freeze, 1, true);
audioSource.PlayOneShot(gameManagerInstance.GetPowerupUsedSound(EPowerUp.Freeze));
isFrozen = true;
rigid.gravityScale = 0.0f;
rigid.velocity = new Vector3(0, 0, 0);
sprite.color = freezeColor;
otherPlayer.RemovePowerUp();
gameManagerInstance.FreezePlayer(this);
if (remainingFreezeTime <= 0)
{
isFrozen = false;
powerupParticleController.PlayPowerupEffect(EPowerUp.Freeze, 1, false);
}
}
if (!isShrunken)
{
audioSource.PlayOneShot(gameManagerInstance.GetCharacterBumpSFX(chosenCharacter));
Rigidbody2D body = gameObject.GetComponent <Rigidbody2D>();
body.velocity = otherPlayer.GetPreviousVelocity() * -boingFactor;
}
Rumble(1.25f);
}
}
}
if (collision.gameObject.layer == LayerMask.NameToLayer("Ground"))
{
if (gameManagerInstance != null || GameManager.TryGetInstance(out gameManagerInstance))
{
audioSource.PlayOneShot(gameManagerInstance.GetCharacterBumpSFX(chosenCharacter), 1f);
}
}
}
}
public void RemovePowerUp()
{
//if (powerupParticle && powerupParticle.isPlaying)
//{
// powerupParticle.Stop();
//}
if (powerupParticleController)
{
powerupParticleController.StopPowerupEffect(currPowerUp, 0);
}
hasPowerUp = false;
EnableSecondaryShield(false);
currPowerUp = EPowerUp.None;
}
public void BallShieldCollision(GameObject shield, Ball ball)
{
PlayerController playerController;
// check if the player is cached / cache it
if (!playerDictionary.TryGetValue(shield, out playerController))
{
playerController = shield.GetComponent <Shield>().GetPlayer();
if (playerController == null)
{
return;
}
playerDictionary.Add(shield, playerController);
}
playerController.Rumble();
EPowerUp currentPowerUp = playerController.GetCurrentPowerUp();
if (currentPowerUp != EPowerUp.None)
{
switch (currentPowerUp)
{
case EPowerUp.Multiball:
if (!ball.GetTempStatus() && balls.Count <= powerUpManager.GetMaxBalls() - powerUpManager.GetBallSpawnCount())
{
playerController.PlayPowerupUsedSound();
playerController.RemovePowerUp();
SpawnMultipleBalls(ball);
multiBallInPlay = false;
}
break;
case EPowerUp.CatchNThrow:
playerController.PlayPowerupUsedSound();
playerController.RemovePowerUp();
playerController.SetBallHeld(ball);
ball.SetHeld(true);
ball.transform.SetParent(playerController.GetShieldTransform());
StartCoroutine(DropBallCoroutine(playerController, ball));
break;
}
}
// The last player to touch the ball
ball.SetLastTouchedBy(playerController);
}
public AudioClip GetPowerUpUsedSound(EPowerUp powerUp)
{
switch (powerUp)
{
case EPowerUp.CatchNThrow:
return(catchNThrowUsed);
case EPowerUp.CircleShield:
return(circleShieldUsed);
//case EPowerUp.Freeze:
// return freezeUsed;
case EPowerUp.Multiball:
return(multiballUsed);
default: //EPowerUp.Shrink
return(shrinkUsed);
}
}
public AudioClip GetPowerUpPickUpSound(EPowerUp powerup)
{
switch (powerup)
{
case EPowerUp.CatchNThrow:
return(catchNThrowPickedUp);
case EPowerUp.CircleShield:
return(circleShieldPickedup);
//case EPowerUp.Freeze:
// return freezePickedUp;
case EPowerUp.Multiball:
return(multiballPickedUp);
default: // EPowerUp.Shrink:
return(shrinkPickedUp);
}
}
void Awake()
{
if (powerUpType == EPowerUp.Random)
{
uint len = 0;
rng = new System.Random();
foreach (weight w in weights)
{
if (w.type == EPowerUp.Random || w.type == EPowerUp.None)
{
Debug.LogError("Powerup weight type of " + w.type.ToString(), gameObject);
continue;
}
len += w.probability;
}
powerups = new EPowerUp[len];
foreach (weight w in weights)
{
if (w.type == EPowerUp.Random || w.type == EPowerUp.None)
{
continue;
}
for (int i = 0; i < w.probability; i++)
{
powerups[--len] = w.type;
}
}
if (runTrials)
{
Trial();
}
}
else
{
instanceType = powerUpType;
UpdateSprite();
}
}
public RuntimeAnimatorController GetPowerUpAC(EPowerUp ePowerUp)
{
switch (ePowerUp)
{
case EPowerUp.Multiball:
return(multiBallAC);
case EPowerUp.CatchNThrow:
return(catchNThrowAC);
case EPowerUp.CircleShield:
return(circleShieldAC);
case EPowerUp.Freeze:
return(freezeAC);
case EPowerUp.Shrink:
return(shrinkAC);
default:
return(null);
}
}
public Sprite GetPowerUpSprite(EPowerUp ePowerUp)
{
switch (ePowerUp)
{
case EPowerUp.Multiball:
return(multiBallSprite);
case EPowerUp.CatchNThrow:
return(catchNThrowSprite);
case EPowerUp.CircleShield:
return(circleShieldSprite);
case EPowerUp.Freeze:
return(freezeSprite);
case EPowerUp.Shrink:
return(shrinkSprite);
default:
return(null);
}
}
public Color GetPowerUpShieldColor(EPowerUp ePowerUp)
{
switch (ePowerUp)
{
case EPowerUp.Multiball:
return(multiBallShieldColor);
case EPowerUp.CatchNThrow:
return(catchNThrowShieldColor);
case EPowerUp.CircleShield:
return(circleShieldShieldColor);
case EPowerUp.Freeze:
return(freezeShieldColor);
case EPowerUp.Shrink:
return(shrinkShieldColor);
default:
return(Color.white);
}
}
public AudioClip GetPowerupPickupSound(EPowerUp powerUp)
{
return(soundStorage.GetPowerUpPickUpSound(powerUp));
}
public Sprite GetPowerUpSprite(EPowerUp powerup)
{
return(powerUpManager.GetPowerUpSprite(powerup));
}
public RuntimeAnimatorController GetPowerUpAC(EPowerUp powerup)
{
return(powerUpManager.GetPowerUpAC(powerup));
}
public Color GetPowerUpShieldColor(EPowerUp powerup)
{
return(powerUpManager.GetPowerUpShieldColor(powerup));
}
public AudioClip GetPowerupUsedSound(EPowerUp powerUp)
{
return(soundStorage.GetPowerUpUsedSound(powerUp));
}
/// <summary>
/// Randomly applies some type of powerup
/// </summary>
private static string HandleMystery(Player pPlayer)
{
const int chance_ammo = 5;
const int chance_health = 10;
const int chance_speed = 20;
const int chance_shield = 30;
const int chance_receive_damage = 40;
//todo: general method for weighted random
const int chance_effect_half_speed = 50;
const int chance_effect_double_damage = 60;
const int chance_effect_half_damage = 70;
float random = Random.Range(0, chance_effect_half_damage);
//Debug.Log($"random = {random}");
if (DebugData.TestPlayerEffect != EPlayerEffect.None)
{
switch (DebugData.TestPlayerEffect)
{
case EPlayerEffect.None:
break;
case EPlayerEffect.DoubleSpeed:
break;
case EPlayerEffect.HalfSpeed:
break;
case EPlayerEffect.Shield:
break;
case EPlayerEffect.DoubleDamage:
random = chance_effect_double_damage;
break;
case EPlayerEffect.HalfDamage:
break;
default:
break;
}
random -= 1;
}
EPowerUp type = EPowerUp.None;
if (random < chance_ammo)
{
type = EPowerUp.Ammo;
}
else if (random < chance_health)
{
type = EPowerUp.Health;
}
else if (random < chance_speed)
{
type = EPowerUp.Speed;
}
else if (random < chance_shield)
{
type = EPowerUp.Shield;
}
else if (random < chance_receive_damage)
{
pPlayer.Stats.AddHealth(-20);
pPlayer.PlaySound(ESound.Item_Powerup_ReceiveDamage);
return("- health");
}
else if (random < chance_effect_half_speed)
{
pPlayer.Stats.StatsEffect.ApplyEffect(EPlayerEffect.HalfSpeed, 5);
pPlayer.PlaySound(ESound.Item_Powerup_Slow);
return("- speed");
}
else if (random < chance_effect_double_damage)
{
pPlayer.Stats.StatsEffect.ApplyEffect(EPlayerEffect.DoubleDamage, 5);
pPlayer.PlaySound(ESound.Item_Powerup_DoubleDamage);
return("+ damage");
}
else if (random < chance_effect_half_damage)
{
pPlayer.Stats.StatsEffect.ApplyEffect(EPlayerEffect.HalfDamage, 5);
pPlayer.PlaySound(ESound.Item_Powerup_HalfDamage);
return("- damage");
}
return(ApplyPowerup(Brainiacs.Instance.ItemManager.GetPowerupConfig(type), pPlayer));
}
internal PowerUpConfig GetPowerupConfig(EPowerUp pPowerUp)
{
return(PowerUps.Find(a => a.Type == pPowerUp));
}
public void StopPowerupEffect(EPowerUp powerup, int version = 0)
{
PlayPowerupEffect(powerup, version, false);
}
