//constructor
public override void Init(PowerUp powerUp)
{
base.Init(powerUp);
SlowDown slowDown = powerUp as SlowDown;
timeToSet = slowDown.timeToSet;
}
public void Update()
{
if (_currentSlowdown != null)
{
_currentSlowdown.Duration -= Time.deltaTime * (1 / (1 - Time.timeScale));
UpdateTimeDisplayCallback.Invoke(_currentSlowdown.DurationProcentage);
if (_currentSlowdown.Duration < 0)
{
EnableTimeDisplayCallback.Invoke(false);
RestTimeScale();
_currentSlowdown = null;
}
}
}
protected override void OnActivate()
{
this.menu = new OrderBlockerMenu(this.context, this.menuManager, this.context.AssemblyEventManager);
this.drawInfo = new DrawBlockInfo(this.context.Renderer, this.menu);
this.oosBlock = new OutOfScreenBlock(this.menu);
this.zoomBlock = new ZoomBlock(this.menu);
this.spamBlock = new SpamBlock(this.menu);
this.notSelectedBlock = new NotSelectedBlock(this.menu);
this.slowDown = new SlowDown(this.menu);
this.blockTooFastReaction = new BlockTooFastReaction(this.menu);
Player.OnExecuteOrder += this.OnExecuteOrder;
Player.OnExecuteOrder += this.OnExecuteOrderAPM;
this.context.AssemblyEventManager.ForceBlockerResubscribe += this.ForceBlockerResubscribe;
}
internal void QueueSlowdown(float timeScale, float duration)
{
if (_currentSlowdown != null)
{
_currentSlowdown.TimeScale = timeScale;
_currentSlowdown.SetDuration(duration);
}
else
{
_currentSlowdown = new SlowDown(duration, timeScale);
}
SetNewTimeScale(_currentSlowdown.TimeScale);
EnableTimeDisplayCallback.Invoke(true);
UpdateTimeDisplayCallback.Invoke(_currentSlowdown.DurationProcentage);
}
IEnumerator CreatePowerUps()
{
var random = new System.Random();
int randNum;
while (Application.isPlaying)
{
if (!delay.IsDelayed)
{
randNum = random.Next(5);
if (randNum == 0)
{
print("Creating powerup");
var powerUp = Instantiate(PowerUp);
randNum = random.Next(5);
Ability ability = null;
switch (randNum)
{
case 0:
ability = new SpeedUp(gameBall, this);
break;
case 1:
ability = new SlowDown(gameBall, this);
break;
case 2:
ability = new Grow(leftPaddle, rightPaddle, gameBall);
break;
case 3:
ability = new Shrink(leftPaddle, rightPaddle, gameBall);
break;
case 4:
ability = new ChangeDirection(gameBall);
break;
}
var position = new Vector3((float)random.NextDouble() * 6 - 3, (float)random.NextDouble() * 6 - 3, 0);
powerUp.Init(ability, position);
PowerUpsOnField.Add(powerUp);
powerUp.GameManager = this;
}
}
yield return(new WaitForSeconds(1f));
}
}
protected override void Awake()
{
base.Awake();
Range = 10f;
Damage = 10;
UpgradeCosts = new List <int> {
100, 300, 400
};
UpgradeScaleChanges = new List <Vector3> {
new Vector3(0.1f, 0.1f, 0.1f), new Vector3(0.2f, 0.2f, 0.2f), new Vector3(0.35f, 0.35f, 0.35f)
};
upgradeBoost = new UpgradeBoost(10, 10, 10);
SellCosts = new List <int> {
50, 100, 300, 550
};
slowDown = new SlowDown(5, 0.5f);
BugTag = "Enemy";
RotationSpeed = 5f;
FireRate = 0.5f;
}
void SetDefaultValues()
{
this.slowDownPickUp = new SlowDown();
this.flashPickUp = new Flash();
this.slowFallingPickup = new SlowFalling();
this.pickUpsList = new List <PickUp>()
{
slowDownPickUp,
flashPickUp,
slowFallingPickup
};
this.pickUpsProbabilities = new List <float>
{
0.8f, //grenade
0.05f, //Slow Down
0.05f, //Flash
0.1f //Slow Falling
};
}
/// <summary>
/// Coroutine function that calls logic when a player picks up slowdown.
/// </summary>
/// <param name="target">Player that did not pickup slowdown</param>
/// <param name="slowDown">Slow down data class</param>
/// <returns>Enumerator to be used by coroutines</returns>
IEnumerator activateSlowDown(Player target, SlowDown slowDown)
{
//Show picked up
slowDown.gameObject.GetComponent<Animator>().SetTrigger("pickupHit");
slowDown.gameObject.GetComponent<Animator>().SetTrigger("hide");
//Don't trigger collider again
slowDown.gameObject.GetComponent<Collider2D>().enabled = false;
//Check if there is a slowdown icon on the player
var slowDownIconOnPlayerAnimator = target.gameObject.transform.Find("SlowDownIcon").gameObject.GetComponent<Animator>();
slowDownIconOnPlayerAnimator.SetTrigger("fadein");
//Slow down picked up logic
target.speed -= slowDown.flatSpeedReduction;
yield return new WaitForSeconds(slowDown.speedRecutionDuration - slowDown.speedRecutionWarningDuration);
//Show user slowdown is almost up
slowDownIconOnPlayerAnimator.SetTrigger("activeFinishing");
yield return new WaitForSeconds(slowDown.speedRecutionWarningDuration);
target.speed += slowDown.flatSpeedReduction;
}
public PowerUp getPowerUp(PowerUpList chosenPowerUpID)
{
PowerUp chosenPowerUp = null;
switch (chosenPowerUpID) {
case PowerUpList.SlowDown:
chosenPowerUp = new SlowDown(10);
break;
case PowerUpList.SpeedUp:
chosenPowerUp = new SpeedUp(10);
break;
case PowerUpList.Warp:
chosenPowerUp = new Warp(10);
break;
case PowerUpList.IceyPlayer:
chosenPowerUp = new IceyPlayer(10);
break;
case PowerUpList.ObjectSpawnPowerUp:
chosenPowerUp = new ObjectSpawnPowerUp(10);
break;
case PowerUpList.Pull:
chosenPowerUp = new Pull(10);
break;
case PowerUpList.Push:
chosenPowerUp = new Push(10);
break;
case PowerUpList.Bigger:
chosenPowerUp = new Bigger(10);
break;
case PowerUpList.Smaller:
chosenPowerUp = new Smaller(10);
break;
case PowerUpList.OrbitingShield:
chosenPowerUp = new OrbitingShield(10);
break;
}
return chosenPowerUp;
}
void Start()
{
_lowSpeed = speed * 0.1f;
_curSpeed = speed;
_slowDown = GetComponent <SlowDown>();
}
public void ClearQueue()
{
_currentSlowdown = null;
EnableTimeDisplayCallback.Invoke(false);
RestTimeScale();
}
public void AddPowerup(PowerupType type)
{
if (powerups.ContainsKey(type) && type != PowerupType.ULTIMATE)
{
powerups[type].AddTime();
return;
}
// usuwanie steerblock powerupa
if (type != PowerupType.STEERBLOCK && powerups.ContainsKey(PowerupType.STEERBLOCK))
{
SteerBlock sb = (SteerBlock)powerups[PowerupType.STEERBLOCK];
sb.PowerupEnd(this);
powerups.Remove(PowerupType.STEERBLOCK);
}
Powerup thePowerup = null;
// Tutaj w switch przydalo by sie ogarniac priorytet powerupow
// np jak masz slowa to sie nie da speedup -> powerupy sie anuluja?
switch (type)
{
case PowerupType.SPEEDUP:
{
if (powerups.ContainsKey(PowerupType.SLOWDOWN))
{
powerups.Remove(PowerupType.SLOWDOWN);
}
Speedup powerup = new Speedup();
SpeedupData sd;
if (powerupsData.ContainsKey(PowerupType.SPEEDUP))
{
sd = (SpeedupData)powerupsData[PowerupType.SPEEDUP];
}
else
{
sd = Resources.Load <SpeedupData>("ScriptableData/SpeedupData");
powerupsData.Add(PowerupType.SPEEDUP, sd);
}
powerup.speedupData = sd;
powerup.AddTime();
powerups.Add(PowerupType.SPEEDUP, powerup);
thePowerup = powerup;
break;
}
case PowerupType.SLOWDOWN:
{
if (powerups.ContainsKey(PowerupType.SPEEDUP))
{
powerups.Remove(PowerupType.SPEEDUP);
}
SlowDown powerup = new SlowDown();
SlowDownData sd;
if (powerupsData.ContainsKey(PowerupType.SLOWDOWN))
{
sd = (SlowDownData)powerupsData[PowerupType.SLOWDOWN];
}
else
{
sd = Resources.Load <SlowDownData>("ScriptableData/SlowdownData");
powerupsData.Add(PowerupType.SLOWDOWN, sd);
}
powerup.slowDownData = sd;
powerup.AddTime();
powerups.Add(PowerupType.SLOWDOWN, powerup);
thePowerup = powerup;
break;
}
case PowerupType.STEERBLOCK:
{
SteerBlock powerup = new SteerBlock();
SteerBlockData sd;
if (powerupsData.ContainsKey(PowerupType.STEERBLOCK))
{
sd = (SteerBlockData)powerupsData[PowerupType.STEERBLOCK];
}
else
{
sd = Resources.Load <SteerBlockData>("ScriptableData/SteerBlockData");
powerupsData.Add(PowerupType.STEERBLOCK, sd);
}
powerup.steerBlockData = sd;
powerup.AddTime();
powerups.Add(PowerupType.STEERBLOCK, powerup);
thePowerup = powerup;
break;
}
case PowerupType.GHOST:
{
Ghost powerup = new Ghost();
GhostData gd;
if (powerupsData.ContainsKey(PowerupType.GHOST))
{
gd = (GhostData)powerupsData[PowerupType.GHOST];
}
else
{
gd = Resources.Load <GhostData>("ScriptableData/GhostData");
powerupsData.Add(PowerupType.GHOST, gd);
}
powerup.ghostData = gd;
powerup.AddTime();
powerups.Add(PowerupType.GHOST, powerup);
thePowerup = powerup;
break;
}
case PowerupType.ULTIMATE:
{
powerups.Remove(PowerupType.ULTIMATE);
Ultimate powerup = new Ultimate();
UltimateData ud;
if (powerupsData.ContainsKey(PowerupType.ULTIMATE))
{
ud = (UltimateData)powerupsData[PowerupType.ULTIMATE];
}
else
{
ud = Resources.Load <UltimateData>("ScriptableData/UltimateData");
powerupsData.Add(PowerupType.ULTIMATE, ud);
}
powerup.ultimateData = ud;
powerup.AddTime();
powerups.Add(PowerupType.ULTIMATE, powerup);
thePowerup = powerup;
break;
}
case PowerupType.SHIELD:
{
thePowerup = new Shield();
break;
}
default:
Debug.LogError("Unknown PowerupType");
return;
}
thePowerup.PowerupStart(this);
GameManager.Instance.AddPowerupScore();
}
private void Awake()
{
instance = this;
}
