protected override void Update()
{
base.Update();
if (IsActive)
{
transform.Rotate(0, 0, -_input.GetRotation() * _rotationSpeed * Time.deltaTime);
Rigidbody.AddForce(transform.up * _movingForce * _input.GetMovement());
if (_input.ActionButtonPressed())
{
if (_timeFromLastShot > _shotDelay)
{
var laser = _laserSpawner.Spawn() as Laser;
if (laser != null)
{
laser.Setup(_weapon.transform.position, transform.rotation);
SignalsManager.Broadcast("PlayAudio", "laser");
}
_timeFromLastShot = 0f;
}
else
{
_timeFromLastShot += Time.deltaTime;
}
}
else
{
_timeFromLastShot = float.MaxValue;
}
}
}
protected override void OnDestroy()
{
base.OnDestroy();
SignalsManager.Unregister(_hitTopBoundSignal.Name, OnHitBoundsAction);
SignalsManager.Unregister(_hitBottomBoundSignal.Name, OnHitBoundsAction);
}
public override void OnExit()
{
base.OnExit();
SignalsManager.Unregister(_levelSignal.Name, OnLevelChange);
SignalsManager.Unregister(_scoreSignal.Name, OnScoreChanged);
}
public void BlowUp()
{
GameController.Instance.GameSession.AddScorePoints(_value);
SignalsManager.Broadcast(_audioSignal.Name, "splash");
EffectsManager.Instance.Play(GameConfiguration.Instance.PopSettings.BlowUpEffect, _value, transform.position);
Deactivate();
}
private void OnTriggerEnter(Collider otherCollider)
{
var pathLine = otherCollider.GetComponent <Line>();
if (pathLine != null)
{
_currentLine = pathLine;
return;
}
var platform = otherCollider.GetComponent <Platform>();
if (platform != null)
{
_isOnPlatform = true;
ProcessPlatform(platform);
return;
}
var pickup = otherCollider.GetComponent <Pickup>();
if (pickup != null)
{
pickup.Trigger();
return;
}
var fallZone = otherCollider.GetComponent <FallZone>();
if (fallZone != null && !_isOnPlatform)
{
ProcessFall();
SignalsManager.Broadcast(_stateSignal.Name, GameState.End.ToString());
}
}
public override void Trigger()
{
base.Trigger();
SignalsManager.Broadcast(_audioSignal.Name, _sound);
GameController.Instance.GameSession.ApplyMultiplier(_multiplier);
Debug.Log("Trigger Multiplier");
}
public void Activate()
{
_isActive = true;
_time = Time.time;
ApplyStartSpeed(GameController.Instance.GameSession.Level);
SignalsManager.Register(_levelSignal.Name, OnLevelChange);
}
public void Trigger()
{
if (GameController.Instance.GameState == GameState.Play)
{
_animator.SetTrigger("React");
SignalsManager.Broadcast(_audioSignal.Name, _soundName);
}
}
public override void OnEnter()
{
base.OnEnter();
this.WaitForSeconds(_waitTime, () =>
{
SignalsManager.Broadcast(_stateChangeSignal.Name, GameState.Start.ToString());
});
}
private void PlayHitEffects(Vector3 hitPoint)
{
var hitEffect = _effectsPool.GetNext();
hitEffect.transform.position = hitPoint;
this.WaitForSeconds(hitEffect.main.duration, () => _effectsPool.Return(hitEffect));
SignalsManager.Broadcast(_playAudioSignal.Name, "ball_hit");
}
public override void OnEnter()
{
base.OnEnter();
UpdateLevel(GameController.Instance.GameSession.Level, GameController.Instance.GameSession.Score);
SignalsManager.Register(_levelSignal.Name, OnLevelChange);
SignalsManager.Register(_scoreSignal.Name, OnScoreChanged);
}
public override void OnExit()
{
base.OnExit();
_livesViewController.Unsubscribe();
SignalsManager.Unregister(_levelSignal.Name, OnLevelChange);
SignalsManager.Unregister(_scoreSignal.Name, OnScoreChanged);
}
public void PlayDestroyEffect(Vector3 hitPoint)
{
if (!_destroyEffectPlayed)
{
Instantiate(_ballView.DestroyEffect, hitPoint, Quaternion.identity, transform.parent);
SignalsManager.Broadcast(_playAudioSignal.Name, "ball_destroy");
_destroyEffectPlayed = true;
}
}
public override void Trigger()
{
_renderer.enabled = false;
_splashMaterial.color = GameConfiguration.GetColor(_color);
_particleSystem.Play();
SignalsManager.Broadcast(_audioSignal.Name, _sound);
GameController.Instance.GameSession.ApplyColor(_color);
Debug.Log("Trigger Color");
}
protected override void Awake()
{
base.Awake();
_networkManager = GetComponent <NetworkManager>();
_networkManager.StartMatch(OnMatchCreate, OnMatchList);
SignalsManager.Register(_hitTopBoundSignal.Name, OnHitBoundsAction);
SignalsManager.Register(_hitBottomBoundSignal.Name, OnHitBoundsAction);
}
public override void OnExit()
{
base.OnExit();
InputEventProvider.Instance.PointerDown -= OnPointerDown;
InputEventProvider.Instance.PointerUp -= OnPointerUp;
_showTutorialTask.Stop();
_tutorial.DOPause();
NotificationManager.HideAll();
SignalsManager.Unregister("CurrentScoreChanged", UpdateScoreValue);
}
private void OnHitRacketAction()
{
_hitsCount++;
SignalsManager.Broadcast(_scoreChangeSignal.Name, _hitsCount);
if (_hitsCount % GameConfiguration.Instance.RacketSizeDecreaseRate == 0)
{
DecreaseRacketSize(_topRacket);
DecreaseRacketSize(_bottomRacket);
SignalsManager.Broadcast(_racketsSizeChangeSignal.Name);
}
}
private void StartGame()
{
_asteroidsSpawner.RestartSpawn();
var spaceShip = _shipSpawner.Spawn() as Ship;
if (spaceShip != null)
{
spaceShip.Setup(ShipSettings.Instance);
}
SignalsManager.Broadcast(_gameStartedSignal.Name);
}
private void Shoot(Cell cell)
{
_isActive = false;
_firstPop.Move(cell, () =>
{
cell.Attach(_firstPop);
cell.React();
cell.Merge();
});
SignalsManager.Broadcast(_audioSignal.Name, "shoot");
Reload();
}
protected override void OnContactHandlerEntered(SpaceObject spaceObject)
{
if (spaceObject.Type == SpaceObjectType.Asteroid)
{
return;
}
if (spaceObject.Type == SpaceObjectType.Laser)
{
SignalsManager.Broadcast(_destroyedSignal.Name, _scorePoints);
SignalsManager.Broadcast("PlayAudio", "destroyed");
Deactivate();
}
}
public void AddScorePoints(int scorePoints)
{
Score += scorePoints;
SignalsManager.Broadcast(_scoreSignal.Name, Score);
var level = GameConfiguration.GetLevelByScore(Score);
if (level > Level)
{
Level = level;
SignalsManager.Broadcast(_levelSignal.Name, level);
SaveLevelAndScore();
}
}
protected override void Awake()
{
base.Awake();
_topRacket = Instantiate(_racketPrefab, RacketRoot);
_topRacket.Setup(RacketType.Top);
_bottomRacket = Instantiate(_racketPrefab, RacketRoot);
_bottomRacket.Setup(RacketType.Bottom);
SignalsManager.Register(_hitRacketSignal.Name, OnHitRacketAction);
SignalsManager.Register(_hitTopBoundSignal.Name, OnHitBoundsAction);
SignalsManager.Register(_hitBottomBoundSignal.Name, OnHitBoundsAction);
}
public void Enhance(int level)
{
var value = _value;
for (var i = 1; i < level; i++)
{
value *= 2;
}
GameController.Instance.GameSession.AddScorePoints(value);
Setup(value);
SignalsManager.Broadcast(_audioSignal.Name, "merge");
EffectsManager.Instance.Play(GameConfiguration.Instance.PopSettings.MergeEffect, _value, transform.position);
}
public void ApplyColor(string color)
{
if (color != Color)
{
Color = color;
_ball.ApplyColor(color);
_path.ApplyColor(color);
SignalsManager.Broadcast(_colorSignal.Name, color);
}
else
{
Lives++;
SignalsManager.Broadcast(_livesSignal.Name, Lives);
}
}
public override void OnEnter()
{
base.OnEnter();
_livesViewController.Subscribe();
_livesViewController.UpdateLives(GameController.Instance.GameSession.Lives);
_level.text = string.Format(LocalizationManager.GetString("Level"), GameController.Instance.GameSession.Level);
_score.text = GameController.Instance.GameSession.Score.ToString();
UpdateLevelProgress(GameController.Instance.GameSession.Score);
SignalsManager.Register(_levelSignal.Name, OnLevelChange);
SignalsManager.Register(_scoreSignal.Name, OnScoreChanged);
}
public void OnShipDestroyed()
{
_shipSpawner.Flush();
_lives--;
if (_lives > 0)
{
SignalsManager.Broadcast(_livesCountChangedSignal.Name, _lives);
this.WaitForSeconds(GameConfiguration.Instance.DelayBetweenSessions, StartGame);
}
else
{
GameController.Instance.SetState(GameState.GameOver);
}
}
public void IncreaseScore()
{
++CurrentScore;
//Use variable from configuration here
if (CurrentScore % 10 == 0)
{
SignalsManager.Broadcast("PassedLineSection");
}
if (BestScore > 0)
{
if (CurrentScore > BestScore)
{
SignalsManager.Broadcast("BestScoreBeaten");
}
}
}
public void SubtractLive(bool all = false)
{
if (all)
{
Lives = 0;
}
else
{
Lives--;
}
if (Lives > 0)
{
SignalsManager.Broadcast(_livesSignal.Name, Lives);
}
else
{
_ball.BlowUp();
GameController.Instance.SetState(GameState.End);
}
}
public override void OnEnter()
{
base.OnEnter();
_bestScoreShown = false;
_tutorial.alpha = 0f;
UpdateScoreValue(0);
SignalsManager.Register("CurrentScoreChanged", UpdateScoreValue);
_showTutorialTask = new WaitTask(this, GameController.Instance.Settings.ActivationTime, () =>
{
if (InputEventProvider.Instance.PointersCount == 0)
{
ShowTutorial();
}
});
_showTutorialTask.Start();
InputEventProvider.Instance.PointerDown += OnPointerDown;
InputEventProvider.Instance.PointerUp += OnPointerUp;
}
private void OnCollisionEnter(Collision otherCollision)
{
var hitPoint = otherCollision.contacts[0].point;
var racket = otherCollision.gameObject.GetComponentInParent <Racket>();
if (racket != null)
{
var hitFactor = CalculateHitFactor(transform.position, otherCollision.transform.position, otherCollision.collider.bounds.size.x);
racket.React(hitFactor);
if (racket.Type == RacketType.Top)
{
_rigidbody.velocity = new Vector2(hitFactor, -1).normalized *_bouncingSpeed;
}
else if (racket.Type == RacketType.Bottom)
{
_rigidbody.velocity = new Vector2(hitFactor, 1).normalized *_bouncingSpeed;
}
SignalsManager.Broadcast(_hitRacketSignal.Name);
}
else
{
var bound = otherCollision.gameObject.GetComponent <Bound>();
if (bound != null)
{
if (HitVerticalBounds(bound.Type))
{
PlayDestroyEffect(hitPoint);
Destroy(gameObject);
return;
}
}
}
PlayHitEffects(hitPoint);
}
