//Проверка команды
private void CheckTeam(TeamController teamController)
{
if (teamController.IsCanContinue())
{
GameOverEvent?.Invoke(this, new GameEventArgs($"{teamController.Team.Name} team - 5 players are injured"));
}
}
void OnCollisionEnter(Collision collision)
{
// Check if the player was hit.
if (Deadly && collision.collider.gameObject.CompareTag("Player"))
{
// If the player is a minifig or a brick, do an explosion.
var minifigController = collision.collider.GetComponent <MinifigController>();
if (minifigController)
{
minifigController.Explode();
}
else
{
var brick = collision.collider.GetComponentInParent <Brick>();
if (brick)
{
BrickExploder.ExplodeConnectedBricks(brick);
}
}
GameOverEvent evt = Events.GameOverEvent;
evt.Win = false;
EventManager.Broadcast(evt);
}
// Turn on gravity and make non-deadly.
m_RigidBody.useGravity = true;
Deadly = false;
}
void onGameOver(GameOverEvent gameOver)
{
NonDiegeticUI.SetActive(false);
playerStatistics.SetIsCompleted(gameOver.IsCompleted);
ResolutionScreen.SetActive(true);
ResolutionScreen.GetComponentInChildren <ResolutionSetup>().SetUpResolutionScreen();
}
void GameOver(GameOverEvent e)
{
G.Sys.dataMaster.BigCoins += _runBigCoin;
G.Sys.dataMaster.Distance += _runScore;
_runScore = 0;
if (_runJump > G.Sys.dataMaster.RunJump)
{
G.Sys.dataMaster.RunJump = _runJump;
}
_runJump = 0;
if (_runCoin > G.Sys.dataMaster.RunCoins)
{
G.Sys.dataMaster.RunCoins = _runCoin;
}
_runCoin = 0;
if (_runBigCoin > G.Sys.dataMaster.RunBigCoins)
{
G.Sys.dataMaster.RunBigCoins = _runBigCoin;
}
_runBigCoin = 0;
if (_runPowerUp > G.Sys.dataMaster.RunPowerUp)
{
G.Sys.dataMaster.RunPowerUp = _runPowerUp;
}
_runPowerUp = 0;
}
protected void Awake()
{
gameObject.SetActive(false);
// Set up listeners
GameOverEvent.RegisterListener(GameOver);
}
public static void GameOver()
{
if (GameOverEvent != null)
{
GameOverEvent.Invoke();
}
}
// Start is called before the first frame update
void Start()
{
playerControllable = GameObject.FindGameObjectWithTag(GeneralVariables.PlayerTag).GetComponent <Controllable>();
animator = GetComponentInChildren <Animator>();
GameOverEvent.AddListener(onGameOver);
ResolutionScreenSetup.OnLoadCheckpoint += onLoadCheckpoint;
}
//생성자==================================================================
public Game(Rectangle rectangle, Random random)
{
PlayerLife = 2;
enemyList = new List <Enemy>();
enemyBullet = new List <Bullet>();
playerBullet = new List <Bullet>();
enemyScore = new List <EnemyDie>();
dieEffect = new List <DieEffect>();
wave = 0;
gameScore = 0;
enemyShootDelay = 0;
enemyShootDelayMax = 10;
drawGameScore = new Point(20, 20);
CilentRect = rectangle;
this.random = random;
stars = new Stars(random, CilentRect);
player = new Player(new Point(350, 800), CilentRect);
enemyani = 0;
frameskip = 0;
frameskipMax = 3;
moveDirectionEnemy = 1;
NextWave();
GameOver += new GameOverEvent(Game_GameOver);
DrawLine = false;
}
private void Start()
{
if (this.livesRemaining == 0)
{
this.livesRemaining = GameConstants.MaxLives - 1; // -1 because don't have extra life yet
}
Logger.Log("LIVES AT START:" + this.livesRemaining);
EventManager.AddItemCollectedListener(CollectItem);
EventManager.AddCreatureKilledListener(KillCreature);
EventManager.AddPowerUpListener(CollectItem);
EventManager.AddPlayerDiedListener(LoseLife);
EventManager.AddNextRoomListener(NextRoom);
EventManager.AddRoomVisitedListener(RoomVisited);
// display an initially transparent blank screen when first started
// (will be used if player loses a life)
GameObject background = GameObject.FindGameObjectWithTag(GameConstants.BLANKSCREENBACKGROUND);
if (background != null)
{
this.blankScreen = background.GetComponent <Image>();
Color color = this.blankScreen.color;
color.a = 0f; // transparent
this.blankScreen.color = color;
}
this.gameOverEvent = new GameOverEvent();
EventManager.AddGameOverInvoker(this);
//Debug.Log("Start gamestate: " + Dump());
}
void GameOver(GameOverEvent eventTest)
{
/*EventController.Instance.UnSubscribe<GoWestEvent>(GoWest);
* EventController.Instance.UnSubscribe<GoEastEvent>(GoEast);
* EventController.Instance.UnSubscribe<GoNorthEvent>(GoNorth);
* EventController.Instance.UnSubscribe<GoSouthEvent>(GoSouth);*/
}
public void GameOver()
{
isGameOver = true;
GameOverEvent?.Invoke();
Time.timeScale = 0f;
}
public static string ToEvent(this GameOverEvent gameOverEvent)
{
JObject delta = new JObject();
delta[nameof(GameOverEvent)] = JsonConvert.SerializeObject(gameOverEvent);
return(delta.ToString());
}
protected void OnDestroy()
{
GameOverEvent.UnregisterListener(GameOver);
GameWonEvent.UnregisterListener(GameWon);
GameStartEvent.UnregisterListener(GameStart);
MenuEvent.UnregisterListener(Menu);
}
private void LogEvent(GameOverEvent e)
{
if (e.LoggingLevel <= LoggingLevel)
{
Debug.Log(e.Description);
}
}
void Handle(GameOverEvent e)
{
constraint.ForEachGameObject((egoComponent, gameStateComponent) => {
gameStateComponent.myGameState = GameStateComponent.GameState.GameOver;
Time.timeScale = 0;
});
}
void GameOverEventHandler(GameOverEvent e)
{
paused = true;
gameOver = true;
FindObjectOfType <InGameUIController>().OnGameEnd();
}
private void onGameOverEvent(GameOverEvent e)
{
if (playerType == PlayerType.P1)
{
if (e.playerWon == PlayerType.P1)
{
onUpdateUserStatsToServer(true);
}
else
{
onUpdateUserStatsToServer(false);
}
}
else if (playerType == PlayerType.P2)
{
if (e.playerWon == PlayerType.P2)
{
onUpdateUserStatsToServer(true);
}
else
{
onUpdateUserStatsToServer(false);
}
}
}
void OnGameOver(GameOverEvent e)
{
float time = Time.time - _startTime;
var chunkDatas = G.Sys.chunkSpawner.allDatas();
_sumCoin += e.RunCoin;
_runCount++;
_sumRunTime += time;
if (e.RunScore > _distanceMax)
{
_distanceMax = e.RunScore;
}
Dictionary <string, object> UserProperties = new Dictionary <string, object>();
UserProperties.Add("RJump", _jumpCount);
UserProperties.Add("Rhole", chunkDatas.holesCount);
UserProperties.Add("RDistanceMax", e.RunScore);
UserProperties.Add("RChunkDeath", G.Sys.chunkSpawner.currentChunkID());
UserProperties.Add("RCoins", e.RunCoin);
UserProperties.Add("RCheat", e.RunCoin / e.RunScore);
UserProperties.Add("RRing", chunkDatas.ringCount);
UserProperties.Add("RTRun", time);
UserProperties.Add("RArms", chunkDatas.armCount);
UserProperties.Add("RFps", _frames / time);
_amplitude.logEvent("EndRun", UserProperties);
}
IEnumerator Slowdown(bool isSadDay)
{
if (isSadDay)
{
while (Time.timeScale > 0f)
{
Time.timeScale = Mathf.Clamp(Time.timeScale - m_fSlowdown * Time.fixedDeltaTime, 0f, 1f);
grayscale.scale = 1f - Time.timeScale;
yield return(null);
}
}
float Alpha = 0f;
while (Alpha < 1f)
{
Alpha += Time.fixedDeltaTime;
if (isSadDay)
{
grayscale.rampOffset = -Alpha;
}
else
{
grayscale.rampOffset = Alpha;
}
yield return(null);
}
grayscale.rampOffset = isSadDay ? -1f : 0f;
GameOverEvent.Send(!isSadDay);
grayscale.rampOffset = 0f;
grayscale.scale = 0f;
}
void OnGameOver(GameOverEvent evt)
{
// Disable input when the game is over.
m_MinifigController.SetInputEnabled(false);
// If we have won, turn to the camera and do a little celebration!
if (evt.Win)
{
m_MinifigController.TurnTo(Camera.main.transform.position);
var randomCelebration = Random.Range(0, 3);
switch (randomCelebration)
{
case 0:
{
m_MinifigController.PlaySpecialAnimation(MinifigControllerPUN.SpecialAnimation.AirGuitar);
break;
}
case 1:
{
m_MinifigController.PlaySpecialAnimation(MinifigControllerPUN.SpecialAnimation.Flexing);
break;
}
case 2:
{
m_MinifigController.PlaySpecialAnimation(MinifigControllerPUN.SpecialAnimation.Dance);
break;
}
}
}
}
public static GameOverEvent Caculate(List <GameSeat> seates, List <KeyValuePair <long, List <int> > > poolsSeats, out int winSeat)
{
List <KeyValuePair <int, CardCombination> > seatRand = new List <KeyValuePair <int, CardCombination> >();
foreach (var seat in seates)
{
if (seat.IsInGame())
{
seatRand.Add(new KeyValuePair <int, CardCombination>(seat.SeatNum, seat.Combination));
}
}
seatRand.Sort((x, y) =>
{
if (x.Value == null)
{
return(-1);
}
return(x.Value.CompareTo(y.Value));
});
seatRand.Reverse();
winSeat = seatRand.First().Key;
List <WinnerCoinsPool> poolWinners = new List <WinnerCoinsPool>();
foreach (var onePool in poolsSeats)
{
int winseat = GetPoolWinner(seatRand, onePool.Value);
poolWinners.Add(new WinnerCoinsPool(winseat, onePool.Key));
}
List <int> winners = GetWinners(seates, poolWinners);
var playerCards = GetHandCards(seates);
GameOverEvent gameOver = new GameOverEvent(winners, poolWinners, playerCards);
return(gameOver);
}
private void ProcessGameOverEvent(GameOverEvent gameOverEvent)
{
if (!IsGameOffline)
{
return;
}
string winnerName = null;
var losers = gameOverEvent.losers.ToList();
if (!losers.Contains(battle.Player1.ID))
{
winnerName = battle.Player1.Name;
}
else if (!losers.Contains(battle.Player2.ID))
{
winnerName = battle.Player2.Name;
}
var message = new GameOver
{
Reason = Cz.Cuni.Mff.Fruiton.Dto.GameOver.Types.Reason.Standard,
WinnerLogin = winnerName,
GameRewards = new GameRewards()
};
GameOver(message);
}
protected void Update()
{
if (m_Active)
{
// Emit particles.
if (m_ParticleSystem)
{
var emissionCollider = m_EmissionColliders[m_EmissionColliderDistribution[Random.Range(0, m_EmissionColliderWeightSum)]];
var colliderType = emissionCollider.GetType();
if (emissionCollider)
{
m_ParticleSystem.transform.position = emissionCollider.transform.position;
m_ParticleSystem.transform.rotation = emissionCollider.transform.rotation;
var particleShapeMoule = m_ParticleSystem.shape;
if (colliderType == typeof(BoxCollider))
{
var boxCollider = (BoxCollider)emissionCollider;
particleShapeMoule.shapeType = ParticleSystemShapeType.BoxShell;
particleShapeMoule.position = boxCollider.center;
particleShapeMoule.scale = Quaternion.Euler(90.0f, 0.0f, 0.0f) * boxCollider.size;
}
else if (colliderType == typeof(SphereCollider))
{
var sphereCollider = (SphereCollider)emissionCollider;
particleShapeMoule.shapeType = ParticleSystemShapeType.Sphere;
particleShapeMoule.radiusThickness = 0.0f;
particleShapeMoule.position = sphereCollider.center;
particleShapeMoule.radius = sphereCollider.radius;
}
m_Emitted += m_EmissionRate * Time.deltaTime;
var emit = Mathf.FloorToInt(m_Emitted);
m_ParticleSystem.Emit(emit);
m_Emitted -= emit;
}
}
// Check if colliding with player.
if (m_ActiveColliders.Count > 0)
{
if (m_MinifigController)
{
m_MinifigController.Explode();
}
GameOverEvent evt = Events.GameOverEvent;
evt.Win = false;
EventManager.Broadcast(evt);
}
if (!audioStarted)
{
PlayAudio(true);
audioStarted = true;
}
}
}
private void GameOver(GameOverEvent myEvent)
{
TransitionTo <GameOverState>();
Time.timeScale = 0;
GameObject.Destroy((myEvent).objToDestroy);
Context.gameOverText.SetActive(true);
}
public void GameOver()
{
// TODO: Reset Timescale on reload.
Time.timeScale = 0f;
GameOverEvent?.Invoke();
}
private void OnTriggerEnter(Collider other)
{
if (other.tag == "Ball")
{
GameOverEvent e = new GameOverEvent();
_EventBus.Publish <GameOverEvent>(e);
}
}
private void OnDestroy()
{
AlarmTriggered.ClearListeners();
CameraTriggered.ClearListeners();
CollectablePickedupEvent.ClearListeners();
GameOverEvent.ClearListeners();
AlarmStateChanged.ClearListeners();
ShowDialogueEvent.ClearListeners();
}
// Cette méthode affiche le gameOver lorsque l'evenement GameOverEvent se présente
public void HandleGameOverEvent(Object sender, GameOverEvent e)
{
this.Invoke(() => {
panel2.Visible = true;
panel3.Visible = false;
jeu = null;
});
}
void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Player"))
{
GameOverEvent evt = Events.GameOverEvent;
evt.Win = false;
EventManager.Broadcast(evt);
}
}
private void OnGameOverEvent(GameOverEvent arg)
{
StopCoroutine(timerCoroutine);
hUDView.TimeSurvivedTxt.text = hUDView.TimeScoreTxt.text;
hUDView.BackButton.gameObject.SetActive(true);
StartCoroutine(UITweener.FadeCanvasGroup(hUDView.BlackScreenGroup, 0f, 1f, 1f));
}
//what to do when the game is lost
void GameOver()
{
//end the game
IsGameActive = false;
//Reveal The Word
WordToGuess.Reveal();
// invoke the event only if someone listens to it (not Null)
GameOverEvent?.Invoke(this, false);
}
// Méthode qui définit l'evenement GameOverEvent
protected virtual void OnGameOverEvent(GameOverEvent e)
{
EventHandler<GameOverEvent> handler = YouGameOverEvent;
if (handler != null)
{
handler(this, e);
}
}
