void CleanUp()
{
try
{
VictoryScreen.Get().ContinueEvents();
} catch
{
}
try
{
VictoryScreen.Get().m_hitbox.TriggerRelease();
} catch
{
}
try
{
EndGameScreen.Get().ContinueEvents();
} catch
{
}
try
{
EndGameScreen.Get().m_hitbox.TriggerRelease();
} catch
{
}
try
{
WelcomeQuests.Get().m_clickCatcher.TriggerRelease();
} catch
{
}
}
public void RestartGame()
{
Debug.Log("Starting game...");
Time.timeScale = 1;
VictoryScreen.SetActive(false);
GameOverScreen.SetActive(false);
Money = GetComponent <ConfiguraionLoader>().DefaultMoney;
Lives = GetComponent <ConfiguraionLoader>().DefaultLives;
foreach (Transform child in EnemiesParent.transform)
{
GameObject.Destroy(child.gameObject);
}
foreach (Transform child in ProjectileParent.transform)
{
GameObject.Destroy(child.gameObject);
}
foreach (Transform child in TowersParent.transform)
{
GameObject.Destroy(child.gameObject);
}
GetComponent <WaveController>().ResetGame();
}
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// CreateVictoryScreen()
//----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
public void CreateVictoryScreen()
{
if (level1IsActive == true)
{
_level1.Destroy();
_level1.Remove();
}
if (level2IsActive == true)
{
_level2.Destroy();
_level2.Remove();
}
if (Globals.levelBossIsActive == true)
{
_levelBoss.Destroy();
_levelBoss.Remove();
}
stopMusic();
_victoryscreen = new VictoryScreen();
AddChild(_victoryscreen);
}
// Start is called before the first frame update
void Start()
{
victoryComponent = GetComponent <VictoryScreen>();
dialogue = GetComponent <FungusDialogue>();
AccuseSFX = this.transform.Find("AccuseSFX").GetComponent <AudioSource>();
HintSFX = this.transform.Find("HintSFX").GetComponent <AudioSource>();
}
private void CheckIfWon()
{
if (player.Col == data.End.Col && player.Row == data.End.Row)
{
VictoryScreen SW = new VictoryScreen();
SW.ShowDialog();
}
}
void Start()
{
hud = hudPanel.GetComponent <HUDScript>();
blackFadeScreen = blackScreenPanel.GetComponent <BlackFadeScreen>();
victoryScreen = victoryScreenPanel.GetComponent <VictoryScreen>();
gameOverScreen = gameOverPanel.GetComponent <GameOverScreen>();
pauseMenu = pausePanel.GetComponent <PauseMenu>();
}
private void Start()
{
victoryScreen = FindObjectOfType <VictoryScreen>();
#region Assertions
Assert.IsNotNull(animator);
Assert.IsNotNull(victoryScreen);
#endregion
}
public GamePlayState(Game game, Level level, CarAttributes carAttribs, VictoryScreen victoryScreen, GameOverScreen gameOverScreen)
: base(game)
{
this.level = level;
this.carAttributes = carAttribs;
this.victoryScreen = victoryScreen;
this.gameOverScreen = gameOverScreen;
Initialize();
}
/*
* Método: private void GameIsOver()
*
* Función: finalizar juego
*
* Descripción: Verifica si el juego ha terminado, ya sea con una victoria
* o con una derrota. Si el juego ha terminado, guarda la puntuación final
* del jugador y detiene el reloj de actualizaciones del juego.
*/
private void GameIsOver()
{
if (GameData.gameOver)
{
GameData.gameStart = false;
//el jugador ha ganado
if (GameData.victory)
{
/*Aplicar multiplier basado en el tiempo que tomo para completar
* el juego y las vidas restantes del jugador.*/
score += (score * 10 / time) * hp;
txtScore.Text = "SCORE: " + score;
VictoryScreen.BackgroundImage = Resources.VictoryImg;
VictoryScreen.BackgroundImageLayout = ImageLayout.Stretch;
VictoryScreen.Height = (int)(Height * 0.65);
VictoryScreen.Width = (int)(Width * 0.80);
VictoryScreen.Top = (int)(Height * 0.20);
VictoryScreen.Left = (int)(Width * 0.08);
VictoryScreen.Show();
}
//el jugador ha perdido
else
{
GameOverScreen.BackgroundImage = Resources.GameOverImg;
GameOverScreen.BackgroundImageLayout = ImageLayout.Stretch;
GameOverScreen.Height = (int)(Height * 0.5);
GameOverScreen.Width = (int)(Width * 0.8);
GameOverScreen.Top = (int)(Height * 0.25);
GameOverScreen.Left = (int)(Width * 0.08);
GameOverScreen.Show();
}
//detener relojes
secondsTimer.Stop();
gameTimer.Stop();
//guardar puntuación
Score s = new Score(score, playahata.username);
ScoreDAO.AddScore(s);
}
}
public void GameOver(EndCondition endCondition)
{
Time.timeScale = 0f;
if (endCondition == EndCondition.Victory)
{
Text[] info = VictoryScreen.GetComponentsInChildren <Text>();
info[0].text = string.Format("{0:00}:{1:00}", totalTime / 60, totalTime % 60);
info[1].text = totalGameOvers.ToString();
totalTime = 0f;
totalGameOvers = 0;
VictoryScreen.SetActive(true);
}
else if (endCondition == EndCondition.Defeat)
{
DefeatScreen.SetActive(true);
}
}
void Start()
{
//load the player data if exists and passes it to the PlayerManager
playerInfo = new PlayerInfo();
PlayerManager.SetPlayerInfo(playerInfo);
splashScreen = FindObjectOfType <SplashScreenHandler>();
pauseScreen = FindObjectOfType <PauseScreen>();
victoryScreen = FindObjectOfType <VictoryScreen>();
musicHandler = FindObjectOfType <MusicHandler>();
if (pauseScreen)
{
pauseScreen.SetActive(false);
}
if (victoryScreen)
{
victoryScreen.gameObject.SetActive(false);
}
gameActive = true;
debug = false;
}
void OnTriggerEnter(Collider other)
{
if (other.tag == "firstCoin")
{
coinCounter++;
Destroy(other.gameObject);
}
if (other.tag == "secondCoin")
{
coinCounter++;
Destroy(other.gameObject);
SceneManager.LoadScene("Level2", LoadSceneMode.Single);
}
// Om vi plockar upp vinnar-myntet...
if (other.tag == "WinnerCoin")
{
coinCounter++;
// Sätt igång vinn skärmen
VictoryScreen.Show();
}
}
private void Awake()
{
instance = this;
}
public PlayerView(GameLogic game)
{
this.Game = game;
this.EventManager = game.EventManager;
menuClock = new GameClock();
menuClock.Start();
/**
* Initialize Graphics Subsystem
**/
RenderForm = new Form();
RenderForm.ClientSize = new Size(Game.World.Width, Game.World.Height);
RenderForm.Text = "Alien Invasion v1.0";
RenderForm.BackColor = Color.Empty;
RenderForm.KeyPreview = true;
RenderForm.FormBorderStyle = FormBorderStyle.FixedSingle; // Disable resizing of window
RenderForm.MaximizeBox = false; // Disable maximizing
RenderForm.Leave += (s, e) => {
this.RenderForm.Focus(); // When RenderForm loses focus player input won't be processed correctly
};
extractor = new Extractor(game);
Renderer = new Graphics.Renderer(RenderForm, extractor);
Renderer.StartRender();
rendererLoaders.Add(new TextureLoader(Renderer));
rendererLoaders.Add(new MeshLoader(Renderer));
rendererLoaders.Add(new EffectLoader(Renderer));
foreach (var rendererLoader in rendererLoaders)
{
game.ResourceManager.AddLoader(rendererLoader);
}
game.ResourceManager.AddLoader(new MaterialLoader(game.ResourceManager));
/**
* Initialize Input Subsystem
**/
gameController = new GameController(EventManager, game);
RenderForm.KeyDown += new KeyEventHandler(gameController.OnKeyDown);
RenderForm.KeyUp += new KeyEventHandler(gameController.OnKeyUp);
/**
* Initialize Audio Subsystem
**/
audioPlayer = new FmodAudioPlayer(@"./data/audio/");
audioPlayer.LoadFile("audio.fev");
audioPlayer.IsPaused = false;
/**
* Initialize GUI
**/
mainMenuControl = new GameMainMenu(EventManager);
mainMenuControl.Location = new Point(
(RenderForm.ClientSize.Width - mainMenuControl.Width) / 2,
(RenderForm.ClientSize.Height - mainMenuControl.Height) / 2);
RenderForm.Controls.Add(mainMenuControl);
highscoreControl = new HighscoreScreen(EventManager);
highscoreControl.Location = new Point(
(RenderForm.ClientSize.Width - highscoreControl.Width) / 2,
(RenderForm.ClientSize.Height - highscoreControl.Height) / 2);
RenderForm.Controls.Add(highscoreControl);
creditsControl = new Credits(EventManager);
creditsControl.Location = new Point(
(RenderForm.ClientSize.Width - creditsControl.Width) / 2,
(RenderForm.ClientSize.Height - creditsControl.Height) / 2);
RenderForm.Controls.Add(creditsControl);
pauseControl = new PauseScreen();
pauseControl.Location = new Point(
(RenderForm.ClientSize.Width - pauseControl.Width) / 2,
(RenderForm.ClientSize.Height / 2) - pauseControl.Height);
RenderForm.Controls.Add(pauseControl);
victoryControl = new VictoryScreen(EventManager);
victoryControl.Location = new Point(
(RenderForm.ClientSize.Width - victoryControl.Width) / 2,
(RenderForm.ClientSize.Height / 2) - (victoryControl.Height / 2));
RenderForm.Controls.Add(victoryControl);
gameOverControl = new DefeatScreen(EventManager);
gameOverControl.Location = new Point(
(RenderForm.ClientSize.Width - gameOverControl.Width) / 2,
(RenderForm.ClientSize.Height / 2) - (gameOverControl.Height / 2));
RenderForm.Controls.Add(gameOverControl);
hud = new Hud(EventManager);
hud.Location = new Point(RenderForm.ClientSize.Width - hud.Width, 0);
RenderForm.Controls.Add(hud);
numOfGcCollectedObjects = new int[GC.MaxGeneration];
registerGameEventListeners();
}
void Awake()
{
instance = (VictoryScreen)Singleton.Setup(this, instance);
}
void Update()
{
if (!EndGame && !GameWon)
{
Inputs();
CountSoldiers();
Collider2D HitCollider = Physics2D.OverlapCircle(transform.position, Radius, layerMask);
if (!GameOver)
{
GameOver = GameObject.FindGameObjectWithTag("GameOverScreen");
}
else if (GameOver)
{
GameOver.SetActive(false);
}
if (!VictoryScreen)
{
VictoryScreen = GameObject.FindGameObjectWithTag("VictoryScreen");
}
else if (VictoryScreen)
{
VictoryScreen.SetActive(false);
}
if (!TooManySoldierScreen)
{
TooManySoldierScreen = GameObject.FindGameObjectWithTag("SoldierFull");
}
else if (TooManySoldierScreen)
{
TooManySoldierScreen.SetActive(false);
}
if (!Dropoff)
{
Dropoff = GameObject.FindObjectOfType <DropoffSound>();
}
if (!Pickup)
{
Pickup = GameObject.FindObjectOfType <PickupSound>();
}
if (HitCollider != null && HitCollider?.tag == "Hospital" && GameManager.Instance.SoldierCounter > 0)
{
//Dropoff.Play();
if (!GameWon)
{
Dropoff.Dropoff.Play();
}
GameManager.Instance.RescuedCounter += GameManager.Instance.SoldierCounter;
GameManager.Instance.SoldierCounter = 0;
}
if (HitCollider?.tag == "InjuredSoldier" && GameManager.Instance.SoldierCounter < 3)
{
//Pickup.Play();
Pickup.Pickup.Play();
Destroy(HitCollider.gameObject);
GameManager.Instance.SoldierCounter++;
}
else if (HitCollider?.tag == "InjuredSoldier" && GameManager.Instance.SoldierCounter >= 3)
{
TooManySoldierScreen.SetActive(true);
}
if (HitCollider?.tag != "InjuredSoldier" && GameManager.Instance.SoldierCounter >= 3)
{
TooManySoldierScreen.SetActive(false);
}
if (HitCollider?.tag == "Tree")
{
EndGame = true;
HeliAnim.SetBool("Explosion", true);
GameOver.SetActive(true);
}
if (GameManager.Instance.RescuedCounter == SM.TotalSoldiers && SM.Continued == false)
{
//Debug.Log("Game won");
GameWon = true;
Dropoff.Dropoff.Stop();
VictoryScreen.SetActive(true);
}
if (EndGame || GameWon)
{
GameManager.Instance.Audio.Stop();
HeliSound.Stop();
}
}
}
public void Victory()
{
Debug.Log("Victory!");
Time.timeScale = 0;
VictoryScreen.SetActive(true);
}
public void turnManager()
{
if (turnIndex >= turnQueueLength)
{
turnIndex = 0;
}
/////////////////
// VICTORY !!! //
/////////////////
if (state == BattleState.WON)
{
//////////////////////////////////////////
// Configure the victory screen here... //
//////////////////////////////////////////
if (Input.GetKeyUp(KeyCode.Return))
{
player_properties.updateStats(true);
SceneManager.LoadScene("SampleScene");
}
Debug.Log(victoryScreen.transform.position);
}
/// *** THIS BLOCK WILL DECIDE WHO WILL GO NEXT... ***
/// *** THIS WILL CHANGE LATER ONCE OTHER PARTY MEMBERS ARE ADDED ***
if (state == BattleState.DECIDETURN)
{
if (turnQueue[turnIndex].name == "Final_Jerry_Battle")
{
state = BattleState.PLAYERPARTYTURNSTART;
}
else
{
state = BattleState.ENEMYPARTYTURN;
}
if (enemy_properties.getSize() < 1)
{
state = BattleState.WON;
Vector3 victoryScreenPos = new Vector3(player.transform.position.x + 13f, player.transform.position.y - 4f);
victoryScreen = Instantiate(victoryScreen, victoryScreenPos, Quaternion.identity);
victoryScreen_properties = victoryScreen.GetComponent <VictoryScreen>();
configureVictoryScreen();
}
}
/***************************************************
*******************#PLAYER TURN#********************
****************************************************/
else if (state == BattleState.PLAYERPARTYTURNSTART)
{
Vector3 playerNamePos = new Vector3(playerName.transform.position.x + 3f, playerName.transform.position.y, 0f);
cursor = UI_properties.insCursor(playerNamePos);
state = BattleState.PLAYERPARTYTURN;
}
else if (state == BattleState.PLAYERPARTYTURN)
{
if (Input.GetKeyUp(KeyCode.Return))
{
Vector3 abilityListPos = new Vector3(playerName.transform.position.x + 5.8f, playerName.transform.position.y - 1.38f, 0f);
abilityList = UI_properties.insAbilityMenu(abilityListPos);
cursor.transform.position = initButtons()[0];
state = BattleState.PARTYSELECTACTION;
buttonArr = initButtons();
}
}
else if (state == BattleState.PARTYSELECTACTION)
{
changeActionSelection(cursor, buttonArr, initEnemyArray()[0]);
}
else if (state == BattleState.PARTYSELECTENEMY)
{
changeEnemySelection(cursor, initEnemyArray(), BattleState.PARTYATTACKSTART);
player_initial_start_time = Time.time;
player_travel_length = Vector3.Distance(player.transform.position, initEnemyArray()[buttonSelectIndex]);
}
else if (state == BattleState.PARTYATTACKSTART)
{
// ***PLAYER MOVES TOWARDS THE ENEMY***
move(player, player_original_position, travel_to, player_initial_start_time, player_travel_length);
player_properties.setAllAnimFalseBut("walk_right");
if (player.transform.position == travel_to)
{
player_properties.setAllAnimFalseBut("attack");
state = BattleState.PARTYATTACKING;
enemyChosen_properties.takeDamage(player_properties.getAttack());
}
}
else if (state == BattleState.PARTYATTACKING)
{
if (Math.Round(player_properties.getNormTime(), 2) > 0.55 && displayDamage)
{
floating_damage_number.insDam(enemyChosen, enemyChosen_properties.getDamageTaken());
displayDamage = false;
if (enemyChosen_properties.getHealth() <= 0)
{
killEnemy(enemyChosen);
}
}
if (!player_properties.getAnimState())
{
state = BattleState.PARTYATTACKEND;
player_initial_start_time = Time.time;
player_properties.setAllAnimFalseBut("walk_left");
}
}
else if (state == BattleState.PARTYATTACKEND)
{
///////////////////////////////////////
// I HATE THAT I HAVE TO USE THIS... //
///////////////////////////////////////
displayDamage = true;
// ***PLAYER MOVES BACK TO ORIGINAL SPOT*** //
move(player, travel_to, player_original_position, player_initial_start_time, player_travel_length);
if (player.transform.position == player_original_position)
{
player_properties.setAllAnimFalseBut("idle");
state = BattleState.DECIDETURN;
turnIndex++;
}
}
else if (state == BattleState.PARTYSELECTITEM)
{
if (Input.GetKeyUp(KeyCode.Return))
{
state = BattleState.DECIDETURN;
Destroy(cursor);
Destroy(abilityList);
turnIndex++;
}
}
/***************************************************
****************************************************
****************************************************/
/***************************************************
*******************#ENEMY TURN#********************
***************************************************/
else if (state == BattleState.ENEMYPARTYTURN)
{
currentEnemy = turnQueue[turnIndex];
currentEnemy_properties = currentEnemy.GetComponent <BattleEnemy>();
enemy_original_position = currentEnemy.transform.position;
enemy_travel_length = Vector3.Distance(currentEnemy.transform.position, player.transform.position);
state = BattleState.ENEMYSELECTACTION;
}
else if (state == BattleState.ENEMYSELECTACTION)
{
// **I'll put enemy abilites here later... but for now...**
state = BattleState.ENEMYATTACKSTART;
Vector3 modPlayerPos = player.transform.position;
enemy_attack_pos = new Vector3(modPlayerPos.x + 0.2f, modPlayerPos.y - 2.8f);
enemy_initial_start_time = Time.time;
}
else if (state == BattleState.ENEMYATTACKSTART)
{
move(currentEnemy, enemy_original_position, enemy_attack_pos, enemy_initial_start_time, enemy_travel_length);
if (currentEnemy.transform.position == enemy_attack_pos)
{
player_properties.takeDamage(currentEnemy_properties.getAttack());
floating_damage_number.insDam(player, player_properties.getDamageTaken());
state = BattleState.ENEMYATTACKEND;
enemy_initial_start_time = Time.time;
}
}
else if (state == BattleState.ENEMYATTACKEND)
{
move(currentEnemy, enemy_attack_pos, enemy_original_position, enemy_initial_start_time, enemy_travel_length);
if (currentEnemy.transform.position == enemy_original_position)
{
state = BattleState.DECIDETURN;
turnIndex++;
}
}
/***************************************************
****************************************************
****************************************************/
}
public void SetVictoryScreenText(string text)
{
VictoryScreen.SetClearingTimeText(text);
}
// Start is called before the first frame update
void Start()
{
victoryComponent = GetComponent <VictoryScreen>();
}
public void Victory()
{
Cursor.visible = true;
Time.timeScale = 0;
VictoryScreen.SetActive(true);
}
