Attila. Condiciones de victoria y derrota

Una vez construida las mecánicas básicas del juego llego el momento de programar las condiciones de victoria y derrota. De hecho son aquellas condiciones que nos hacen progresar dentro del nivel de juego y avanzar si conseguimos superar el nivel y acceder al siguiente nivel.

Este enfoque necesita gestionar el movimiento del caballo en la escena del juego así como programar las mecánica del menú de niveles que hasta ahora era un composición de imágenes estáticas antes de entrar en el nivel de prueba.

Basándonos en la mecánica del juego:

1. Recogemos las propiedades del ejército.
2. El caballo de mueve a una casilla disponible.
3. Destruimos la casilla de origen.
4. Se produce un evento en función de la casilla destino.
5. Actualizamos las propiedades del ejército.
6. Mostramos las nuevas casillas disponibles.

Consideraciones:

1. Si la casilla destino es un objetivo la descontamos.
2. Si la casilla es final pero aún quedan casillas objetivo por destruir no podemos avanzar.
3. Si no quedan casillas objetivo y estamos en una casilla final… ejecutamos el evento y si es superado terminados el nivel.

Sobre esta mecánica hay que tener en cuenta dos situaciones distintas. En cualquier casilla se debe poder ver cuál es el balance del movimiento del caballo sobre la casilla y como afecta a la composición del ejército. En las casillas donde se supone que hay una contienda entre romanos y hunos (pueblo, ciudad, objetivo, casilla de ejército) debemos mostrar, además, el resultado de la contienda.

Puede darse el caso que en cualquier batalla, si nuestros recursos no son suficientes, que seamos derrotados y debamos volver a iniciar el nivel desde la posición inicial. En caso de ganar la batalla, recibiremos la compensación de esa casilla y seguiremos avanzando.

Para gestionar estas condiciones trabajaremos en primer lugar con la clase MovePlayer donde dejamos preparada la función para gestionar los eventos. Ahora sólo es necesario distinguir en función del tipo la casilla destino del jugador y actuar en consecuencia. Si conseguimos terminar el nivel, será necesario, también, salvar la información en el archivo de configuración y avanzar de nivel.

 public void ProcessEvents()  
   {  
     //Update values  
     if (GameObject.Find(destination).GetComponent<GameCell>().objective == true)  
     {  
       Objective();  
     }  
     if (GameObject.Find(destination).GetComponent<GameCell>().final == true)  
     {  
       Final();  
     }  
     if ((GameObject.Find(destination).GetComponent<GameCell>().final == false) && (GameObject.Find(destination).GetComponent<GameCell>().objective == false))  
     {  
       int nType = GlobalInfo.gridStage[GameObject.Find(destination).GetComponent<GameCell>().num - 1].type;  
       // Is Town OR City OR Army  
       if (nType == 4 || nType == 5 || nType == 6 )  
       {  
         GameObject.Find("GameManager").GetComponent<GameManager>().ShowBattleResult();  
       }  
       Normal();  
     }  
     //Events  
     if (GlobalInfo.objectivesNum == 0)  
     {  
       if (GlobalInfo.finalNum == 0)  
       {  
         //Good job!  
         GlobalInfo.maxStageCompleted = GlobalInfo.actualStage;  
         PlayerInfo loadedData = DataSaver.loadData<PlayerInfo>(GlobalInfo.configFile, "txt");  
         loadedData.actualStage = GlobalInfo.actualStage;  
         loadedData.maxStageCompleted = GlobalInfo.maxStageCompleted;  
         loadedData.troops = GlobalInfo.troops;  
         loadedData.weapons = GlobalInfo.weapons;  
         loadedData.water = GlobalInfo.water;  
         loadedData.food = GlobalInfo.food;  
         loadedData.gold = GlobalInfo.gold;  
         loadedData.score = GlobalInfo.gold;  
         DataSaver.saveData(loadedData, GlobalInfo.configFile, "txt");  
         if (GlobalInfo.maxStageCompleted == GlobalInfo.maxStagesGame)  
         {  
           //Game Finish  
           SceneManager.LoadScene("Winner");  
         }  
         else  
         {  
           //Next stage  
           StartCoroutine(NextLevel());            
         }          
       }  
     }  
     if (GlobalInfo.movementsNum == 0)  
     {  
       //Game over;  
     }  
     ShowInfo();  
     GlobalInfo.isPlayerMoving = false;  
   }  
   public void Objective()  
   {  
     GlobalInfo.score = GlobalInfo.score + 100;  
     GameObject.Find(destination).GetComponent<GameCell>().UpdateValues();  
     GlobalInfo.objectivesNum--;  
     GameObject.Find("GameManager").GetComponent<GameManager>().ShowBattleResult();  
   }  
   public void Final()  
   {  
     GlobalInfo.score = GlobalInfo.score + 1000;  
     if (GlobalInfo.objectivesNum == 0)  
     {  
       GameObject.Find(destination).GetComponent<GameCell>().UpdateValues();  
       GlobalInfo.finalNum--;  
       GameObject.Find("GameManager").GetComponent<GameManager>().ShowBattleResult();  
     }      
   }  
   public void Normal()  
   {  
     GameObject.Find(destination).GetComponent<GameCell>().UpdateValues();  
     GlobalInfo.score = GlobalInfo.score + 10;  
   }  
   IEnumerator NextLevel()  
   {  
     yield return new WaitUntil(() => GlobalInfo.isShowingInfo == false);  
     GlobalInfo.actualStage++;  
     SceneManager.LoadScene("Attila");  
   }  

Así mismo debemos controlar el número de objetivos por conseguir antes de ejecutar el evento de la casilla final. Esto nos permite además incluir otra pieza en la estrategia del jugador. Mientras no ataquemos la casilla final la podemos utilizar como pivote para movernos entre otras casillas ya que esta no será destruida al pasar por ella. También las casillas de tipo montaña nos permites hacer esta función ya que tampoco serán destruidas al pasar por ellas. Estas características especiales nos permitirán modular la estrategia para resolver cada nivel y graduar y a tener más piezas para modelar la dificultad de los diferentes niveles del juego.

La segunda parte del proceso consiste en mostrar las cajas de dialogo para mostrar la información cuando es requerida o al entrar en una casilla que produce una batalla. Para ello se ha creado unas cajas de dialogo en el canvas para mostrar la información.