protected virtual void Update()
{
try
{
if (_currentBaseControlHandler != null)
{
while (!_currentBaseControlHandler.Update())
{
BaseControlHandler poppedHandler = _controlHandlers.Pop();
poppedHandler.Dispose();
Logger.Info("Popped handler: " + poppedHandler.ToString());
TryActivateCurrentControlHandler(poppedHandler);
}
// after we updated the control handler, we now want to notify all stack members (excluding the current handler/peek) that an update
// has occurred. This is necessary in case stacked handlers need to react to actions, for example: melee attack is interrupted by wall jump handler
for (int i = _controlHandlers.Count - 2; i >= 0; i--)
{
_controlHandlers[i].OnAfterStackPeekUpdate();
}
}
}
catch (Exception err)
{
Logger.Error("Game object " + this.name + " misses default control handler.", err);
throw;
}
}
/// <summary>
/// Pushes the control handler.
/// </summary>
/// <param name="controlHandler">The control handler.</param>
public void PushControlHandler(BaseControlHandler controlHandler)
{
Logger.Info("Pushing handler: " + controlHandler.ToString());
_controlHandlers.Push(controlHandler);
TryActivateCurrentControlHandler(_currentBaseControlHandler);
}
public DamageResult AddDamage()
{
if (_currentPowerUpItem.HasValue)
{
_orderedPowerUpInventory.Remove(_currentPowerUpItem.Value);
_currentPowerUpControlHandler.Dispose();
_gameManager.player.RemoveControlHandler(_currentPowerUpControlHandler);
_currentPowerUpControlHandler = null;
_currentPowerUpItem = null;
Logger.Info("Added damage, removed power up item. " + this.ToString());
return(DamageResult.LostItem);
}
else
{
if (_powerMeter == 1)
{
_powerMeter = 0; // TODO (Roman): notify player for rendering...
_gameManager.player.ExchangeControlHandler(0, new BadHealthPlayerControlHandler(_gameManager.player));
Logger.Info("Added damage, reduced power meter. " + this.ToString());
return(DamageResult.LostPower);
}
else
{
// player died
Logger.Info("Added damage, respawn. " + this.ToString());
// TODO (Roman): this should be somewhere else - this is just test code
GameObject deathParticles = ObjectPoolingManager.Instance.GetObject(GameManager.instance.gameSettings.pooledObjects.defaultPlayerDeathParticlePrefab.prefab.name);
deathParticles.transform.position = _gameManager.player.gameObject.transform.position;
_gameManager.player.Respawn();
return(DamageResult.IsDead);
}
}
}
public void InsertControlHandlerBeforeCurrent(BaseControlHandler controlHandler)
{
var index = Mathf.Max(0, _controlHandlers.Count - 1);
Logger.Info("Inserting handler: " + controlHandler.ToString() + " at index " + index);
_controlHandlers.Insert(index, controlHandler);
}
public override bool TryActivate(BaseControlHandler previousControlHandler)
{
PlayerController.PlayerState |= PlayerState.Invincible;
_blinkTimer.Reset();
return(true);
}
/// <summary>
/// Resets the control handlers.
/// </summary>
/// <param name="controlHandler">The control handler.</param>
public void ResetControlHandlers(BaseControlHandler controlHandler)
{
Logger.Info("Resetting character control handlers.");
for (int i = _controlHandlers.Count - 1; i >= 0; i--)
{
Logger.Info("Removing handler: " + _controlHandlers[i].ToString());
_controlHandlers[i].Dispose();
_controlHandlers.RemoveAt(i);
}
_currentBaseControlHandler = null;
PushControlHandler(controlHandler);
}
public void InsertControlHandler(int index, BaseControlHandler controlHandler)
{
Logger.Info("Inserting handler: " + controlHandler.ToString() + " at index " + index);
if (index >= _controlHandlers.Count)
{
PushControlHandler(controlHandler);
}
else
{
_controlHandlers.Insert(index, controlHandler);
}
}
private void TryActivateCurrentControlHandler(BaseControlHandler previousControlHandler)
{
_currentBaseControlHandler = _controlHandlers.Peek();
while (_currentBaseControlHandler != null &&
!_currentBaseControlHandler.TryActivate(previousControlHandler))
{
previousControlHandler = _controlHandlers.Pop();
Logger.Info("Popped handler: " + previousControlHandler.ToString());
previousControlHandler.Dispose();
_currentBaseControlHandler = _controlHandlers.Peek();
}
}
/// <summary>
/// Exchanges the control handler.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="controlHandler">The control handler.</param>
public void ExchangeControlHandler(int index, BaseControlHandler controlHandler)
{
Logger.Info("Exchanging handler " + _controlHandlers[index].ToString() + " (index: " + index + ") with " + controlHandler.ToString());
if (_controlHandlers[index] == _currentBaseControlHandler)
{
BaseControlHandler poppedHandler = _controlHandlers.Exchange(index, controlHandler);
poppedHandler.Dispose();
TryActivateCurrentControlHandler(poppedHandler);
}
else
{
_controlHandlers.Exchange(index, controlHandler);
}
}
public override bool TryActivate(BaseControlHandler previousControlHandler)
{
var targetPosition = _enemyController.gameObject.transform.position
+ new Vector3(
_ballisticTrajectorySettings.EndPosition.x * _moveDirectionFactor,
_ballisticTrajectorySettings.EndPosition.y,
_enemyController.gameObject.transform.position.z);
_velocity = DynamicsUtility.GetBallisticVelocity(
targetPosition,
_enemyController.gameObject.transform.position,
_ballisticTrajectorySettings.Angle,
_ballisticTrajectorySettings.ProjectileGravity);
return(true);
}
/// <summary>
/// Removes the control handler.
/// </summary>
/// <param name="controlHandler">The control handler.</param>
public void RemoveControlHandler(BaseControlHandler controlHandler)
{
Logger.Info("Removing handler: " + controlHandler.ToString());
if (controlHandler == _currentBaseControlHandler)
{
BaseControlHandler poppedHandler = _controlHandlers.Pop();
poppedHandler.Dispose();
TryActivateCurrentControlHandler(poppedHandler);
}
else
{
_controlHandlers.Remove(controlHandler);
controlHandler.Dispose();
}
}
public override bool TryActivate(BaseControlHandler previousControlHandler)
{
PlayerController.PlayerState |= PlayerState.Invincible;
PlayerController.PlayerState |= PlayerState.EnemyContactKnockback;
_blinkTimer.Reset();
_distancePerSecond = (1f / PlayerController.DamageSettings.KnockbackDuration)
* PlayerController.DamageSettings.KnockbackDistance;
if (PlayerController.IsFacingRight())
{
_distancePerSecond *= -1f;
}
return(true);
}
public override bool TryActivate(BaseControlHandler previousControlHandler)
{
PlayerController.PlayerState |= PlayerState.Invincible;
PlayerController.PlayerState |= PlayerState.Locked;
if (_playerTranslationVector.HasValue)
{
_translateTransformAction = TranslateTransformAction.Start(
PlayerController.transform.position,
PlayerController.transform.position + _playerTranslationVector.Value,
Duration,
_playerTranslationEasingType,
GameManager.Instance.Easing);
}
ResetOverrideEndTime();
return(true);
}
public override bool TryActivate(BaseControlHandler previousControlHandler)
{
WallJumpEvaluationControlHandler wallJumpEvaluationControlHandler = previousControlHandler as WallJumpEvaluationControlHandler;
if (wallJumpEvaluationControlHandler == null)
{
Logger.Info("Wall Jump Control Handler can not be activated because previous control handler is null.");
return(false);
}
else if (wallJumpEvaluationControlHandler.HasDetached)
{
Logger.Info("Wall Jump Control Handler can not be activated because wall jump evaluation control handler has detached.");
return(false);
}
_playerController.isAttachedToWall = true;
return(base.TryActivate(previousControlHandler));
}
public override bool TryActivate(BaseControlHandler previousControlHandler)
{
PlayerController.PlayerState |= PlayerState.Sliding;
_startTime = Time.time;
_distancePerSecond = (1f / PlayerController.SlideSettings.Duration)
* PlayerController.SlideSettings.Distance;
HorizontalAxisOverride = new AxisState(1f);
if (!PlayerController.IsFacingRight())
{
HorizontalAxisOverride.Value = -1f;
_distancePerSecond *= -1f;
}
return(true);
}
public void KillPlayer()
{
if (_currentPowerUpItem.HasValue)
{
_orderedPowerUpInventory.Remove(_currentPowerUpItem.Value);
_currentPowerUpControlHandler.Dispose();
_gameManager.player.RemoveControlHandler(_currentPowerUpControlHandler);
_currentPowerUpControlHandler = null;
_currentPowerUpItem = null;
Logger.Info("Added damage, removed power up item. " + this.ToString());
}
// player died
Logger.Info("Added damage, respawn. " + this.ToString());
// TODO (Roman): this should be somewhere else - this is just test code
GameObject deathParticles = ObjectPoolingManager.Instance.GetObject(GameManager.instance.gameSettings.pooledObjects.defaultPlayerDeathParticlePrefab.prefab.name);
deathParticles.transform.position = _gameManager.player.gameObject.transform.position;
_gameManager.player.Respawn();
}
public void ApplyPowerUpItem(PowerUpType powerUpType)
{
if (powerUpType == PowerUpType.Basic)
{
_powerMeter = 1;
_gameManager.player.ExchangeControlHandler(0, new GoodHealthPlayerControlHandler(_gameManager.player));
Logger.Info("Added basic power up. " + this.ToString());
}
else
{
if (_powerMeter != 1)
{
// when getting a non basic power up, we want to set the power meter to 1 so we automatically go back to that state in case we lose the
// power up.
_powerMeter = 1;
_gameManager.player.ExchangeControlHandler(0, new GoodHealthPlayerControlHandler(_gameManager.player));
Logger.Info("Added basic power up. " + this.ToString());
}
if (!_currentPowerUpItem.HasValue || _currentPowerUpItem.Value != powerUpType)
{
if (_currentPowerUpItem.HasValue)
{
_gameManager.player.RemoveControlHandler(_currentPowerUpControlHandler);
}
switch (powerUpType)
{
case PowerUpType.Floater:
_currentPowerUpControlHandler = new PowerUpFloaterControlHandler(_gameManager.player, _gameManager.gameSettings.powerUpSettings);
break;
case PowerUpType.DoubleJump:
_currentPowerUpControlHandler = new PowerUpDoubleJumpControlHandler(_gameManager.player);
break;
case PowerUpType.SpinMeleeAttack:
_currentPowerUpControlHandler = new PowerUpSpinMeleeAttackControlHandler(_gameManager.player);
break;
case PowerUpType.JetPack:
_currentPowerUpControlHandler = new PowerUpJetPackControlHandler(_gameManager.player, 30f, _gameManager.gameSettings.powerUpSettings);
break;
case PowerUpType.Gun:
_currentPowerUpControlHandler = new PowerUpGunControlHandler(_gameManager.player, -1f, _gameManager.gameSettings.powerUpSettings);
break;
}
_gameManager.player.PushControlHandler(_currentPowerUpControlHandler);
_currentPowerUpItem = powerUpType;
if (!_orderedPowerUpInventory.Contains(powerUpType))
{
_orderedPowerUpInventory.Add(powerUpType);
_orderedPowerUpInventory.Sort();
}
Logger.Info("Added " + powerUpType.ToString() + " power up. " + this.ToString());
}
}
}
public override bool TryActivate(BaseControlHandler previousControlHandler)
{
PlayerController.PlayerState |= PlayerState.ClimbingLadderTop;
return(true);
}
public void ExchangeActiveControlHandler(BaseControlHandler controlHandler)
{
ExchangeControlHandler(_controlHandlers.Count - 1, controlHandler);
}
/// <summary>
/// This method is called from the BaseCharacterController control handler stack in order to evaluate whether the
/// top stack element can be activated or not. By default this method always returns true but can be overridden
/// for special purposes or chained control handlers.
/// </summary>
/// <param name="previousControlHandler">The last active control handler.</param>
/// <returns>true if activation was successful; false if not.</returns>
public virtual bool TryActivate(BaseControlHandler previousControlHandler)
{
Logger.Trace("Activated control handler: " + ToString());
return(true);
}
