Marge con main

src/Library/Domain/GameList.cs

@@ -61,15 +61,11 @@ public Player FindOpponentOfDisplayName(string playerDisplayName)
         return null;
     }
 
-    public Game FindGame(string playerDisplayName)
+    public Game FindGameByPlayerDisplayName(string playerDisplayName)
     {
         foreach ( Game game in games)
         {
-            if (playerDisplayName == game.Player1.DisplayName)
-            {
-                return game; 
-            }
-            else if (playerDisplayName == game.Player2.DisplayName)
+             if (game.Player1.DisplayName == playerDisplayName || game.Player2.DisplayName == playerDisplayName)
             {
                 return game;
             }

src/Library/Domain/Item/CompleteCure.cs

@@ -0,0 +1,18 @@
+namespace ClassLibrary
+{
+    public class CuraTotal : Item
+    {
+        public CuraTotal() : base("Cura total") { }
+
+        public override string ApplyEffect(Pokemon pokemon)
+        {
+            if (pokemon == null)
+            {
+                return "No hay un Pokémon activo para curar.";
+            }
+
+            pokemon.HealthPoints = 100; 
+            return $"{pokemon.Name} ha sido curado completamente.";
+        }
+    }
+}

src/Library/Domain/Item/Item.cs

@@ -0,0 +1,23 @@
+namespace ClassLibrary;
+
+public class Item
+{
+    public string Name { get;  }
+
+    public Item(string name)
+    {
+        this.Name = name;
+    }
+    /// <summary>
+    /// Aplica el efecto del ítem en el Pokémon especificado.
+    /// Este método será sobrescrito por las subclases.
+    /// </summary>
+    /// <param name="pokemon">El Pokémon al que se le aplicará el efecto.</param>
+    /// <returns>Un mensaje con el resultado de aplicar el efecto.</returns>
+    public virtual string ApplyEffect(Pokemon pokemon)
+    {
+        return $"{Name} no tiene ningún efecto.";
+    }
+}
+
+

src/Library/Domain/Item/Revive.cs

@@ -0,0 +1,25 @@
+namespace ClassLibrary
+{
+    public class Revivir : Item
+    {
+        private const int ReviveHealth = 50;
+
+        public Revivir() : base("Revivir") { }
+
+        public override string ApplyEffect(Pokemon pokemon)
+        {
+            if (pokemon == null)
+            {
+                return "No hay un Pokémon para revivir.";
+            }
+
+            if (pokemon.HealthPoints > 0)
+            {
+                return $"{pokemon.Name} no puede ser revivido.";
+            }
+
+            pokemon.HealthPoints = ReviveHealth;
+            return $"{pokemon.Name} ha sido revivido con {ReviveHealth} puntos de vida.";
+        }
+    }
+}   

src/Library/Domain/Item/SuperPocion.cs

@@ -0,0 +1,23 @@
+namespace ClassLibrary
+{
+    public class SuperPocion : Item
+    {
+        private const int HealingAmount = 70;
+
+        public SuperPocion() : base("Super pocion") { }
+
+        public override string ApplyEffect(Pokemon pokemon)
+        {
+            if (pokemon == null)
+            {
+                return "No hay un Pokémon activo para curar.";
+            }
+
+            int previousHealth = pokemon.HealthPoints;
+            pokemon.HealthPoints += HealingAmount;
+            int healthRestored = pokemon.HealthPoints - previousHealth;
+
+            return $"{pokemon.Name} ha recuperado {healthRestored} puntos de vida.";
+        }
+    }
+}

src/Library/Domain/Moves/Move.cs

@@ -0,0 +1,39 @@
+namespace ClassLibrary;
+
+public abstract class Move
+{
+    /// <summary>
+    /// Nombre del movimiento. 
+    /// </summary>
+    public string Name { get; set; }
+
+    /// <summary>
+    /// Valor del ataque del movimiento.
+    /// </summary>
+    public int AttackValue { get; set; }
+
+    /// <summary>
+    /// El valor de precisión define la probabilidad de que el ataque se ejecute. 
+    /// </summary>
+    public double Accuracy { get; set; }
+
+    /// <summary>
+    /// Constructor de la clase.
+    /// </summary>
+    /// <param name="name">El nombre del movimiento.</param>
+    /// <param name="attackValue">El valor de ataque del movimiento.</param>
+    public Move(string name, int attackValue, double accuracy)
+    {
+        this.Name = name;
+        this.AttackValue = attackValue;
+        this.Accuracy = accuracy;
+    }
+
+    /// <summary>
+    /// Método para aplicar el ataque considerando ambos pokemones.
+    /// </summary>
+    /// <param name="attacker">El pokemon que está atacando.</param>
+    /// <param name="target">El pokemon que está siendo atacado.</param>
+    ///
+    public abstract void ExecuteMove(Pokemon attacker, Pokemon target, double criticalHit);
+}

src/Library/Domain/Moves/MoveBurn.cs

@@ -0,0 +1,46 @@
+namespace ClassLibrary;
+
+
+/// <summary>
+/// La clase <c>MoveSleep</c> tiene la responsabilidad de almacenar y gestionar los valores de ataque, su nombre, y método de ejecución de un movimiento especial.
+/// Esto sigue el principio de responsabilidad única (SRP) ya que su única función es representar los atributos de un movimiento en el juego.
+/// </summary>
+/// 
+public class MoveBurn: Move
+{
+    /// <summary>
+    /// Constructor de la clase <c>MoveBurn</c>. Inicializa los valores de nombre, ataque, defensa y curación.
+    /// Esto sigue el principio de Liskov Substitution Principle (LSP) porque permite que cualquier clase derivada de <c>MoveSleep</c> (si la hubiera) 
+    /// pueda sustituirse sin alterar el comportamiento de la lógica del juego.
+    /// </summary>
+    /// <param name="name">El nombre del movimiento.</param>
+    /// <param name="attackValue">El valor de ataque del movimiento.</param>
+
+    public MoveBurn(string name, int attackValue, double accuracy): base(name, attackValue, accuracy) 
+    {
+        this.Name = name;
+        this.AttackValue = attackValue;
+        this.Accuracy = accuracy;
+
+    }
+
+    /// <summary>
+    /// Método para aplicar el ataque del <c>IMove</c> en particular, considerando ambos pokemones.
+    /// </summary>
+    /// <param name="attacker">El pokemon que está atacando.</param>
+    /// <param name="target">El pokemon que está siendo atacado.</param>
+    ///
+    public override void ExecuteMove(Pokemon attacker, Pokemon target, double criticalHit)
+    {
+        //Aplica el ataque común
+        if (this.AttackValue > 0)
+        {
+            double typeEffectiveness = PokemonType.GetEffectiveness(attacker.Type, target.Type);
+            int calculatedDamage = (int)((this.AttackValue * typeEffectiveness)*(criticalHit));
+            target.HealthPoints -= calculatedDamage;
+        }
+
+        //Aplica al pokemon ataque de quemado
+        target.IsPoisoned= true;
+    }
+}

src/Library/Domain/Moves/MoveNormal.cs

@@ -0,0 +1,29 @@
+namespace ClassLibrary
+{
+    /// <summary>
+    /// La clase <c>NormalMove</c> tiene la responsabilidad de almacenar y gestionar los valores de ataque, su nombre, y método de ejecución de un movimiento común.
+    /// Esto sigue el principio de responsabilidad única (SRP) ya que su única función es representar los atributos de un movimiento en el juego.
+    /// </summary>
+    public class MoveNormal: Move
+    {
+        public MoveNormal(string name, int attackValue, double accuracy): base(name, attackValue, accuracy) 
+        {
+            this.Name = name;
+            this.AttackValue = attackValue;
+        }
+
+        /// <summary>
+        /// Método para aplicar el ataque considerando ambos pokemones.
+        /// </summary>
+        /// <param name="attacker">El pokemon que está atacando.</param>
+        /// <param name="target">El pokemon que está siendo atacado.</param>
+        ///
+        public override void ExecuteMove(Pokemon attacker, Pokemon target, double criticalHit)
+        {
+            double typeEffectiveness = PokemonType.GetEffectiveness(attacker.Type, target.Type);
+            int calculatedDamage = (int)((this.AttackValue * typeEffectiveness)*(criticalHit));
+
+            target.HealthPoints -= calculatedDamage;
+        }
+    }
+} 

src/Library/Domain/Moves/MoveParalize.cs

@@ -0,0 +1,48 @@
+namespace ClassLibrary;
+
+/// <summary>
+/// La clase <c>MoveParalize</c> tiene la responsabilidad de almacenar y gestionar los valores de ataque, su nombre, y método de ejecución de un movimiento especial.
+/// Esto sigue el principio de responsabilidad única (SRP) ya que su única función es representar los atributos de un movimiento en el juego.
+/// </summary>
+/// 
+public class MoveParalize: Move
+{
+    /// <summary>
+    /// Constructor de la clase <c>MoveParalize</c>. Inicializa los valores de nombre, ataque, defensa y curación.
+    /// Esto sigue el principio de Liskov Substitution Principle (LSP) porque permite que cualquier clase derivada de <c>Move</c> (si la hubiera) 
+    /// pueda sustituirse sin alterar el comportamiento de la lógica del juego.
+    /// </summary>
+    /// <param name="name">El nombre del movimiento.</param>
+    /// <param name="attackValue">El valor de ataque del movimiento.</param>
+
+    public MoveParalize(string name, int attackValue, double accuracy): base(name, attackValue, accuracy) 
+    {
+        this.Name = name;
+        this.AttackValue = attackValue;
+        this.Accuracy = accuracy;
+
+    }
+
+    /// <summary>
+    /// Método para aplicar el ataque del <c>IMove</c> en particular, considerando ambos pokemones.
+    /// </summary>
+    /// <param name="attacker">El pokemon que está atacando.</param>
+    /// <param name="target">El pokemon que está siendo atacado.</param>
+    ///
+    public override void ExecuteMove(Pokemon attacker, Pokemon target, double criticalHit)
+    {
+        //Aplica el ataque común
+        if (this.AttackValue > 0)
+        {
+            double typeEffectiveness = PokemonType.GetEffectiveness(attacker.Type, target.Type);
+            int calculatedDamage = (int)((this.AttackValue * typeEffectiveness)*(criticalHit));
+            target.HealthPoints -= calculatedDamage;
+        }
+
+        //Aplica al pokemon ataque de paralizar
+        if (!target.IsParalyzed)
+        {
+            target.IsParalyzed = true;
+        }
+    }
+}

src/Library/Domain/Moves/MovePoison.cs

@@ -0,0 +1,46 @@
+namespace ClassLibrary;
+
+
+/// <summary>
+/// La clase <c>MovePoison</c> tiene la responsabilidad de almacenar y gestionar los valores de ataque, su nombre, y método de ejecución de un movimiento especial.
+/// Esto sigue el principio de responsabilidad única (SRP) ya que su única función es representar los atributos de un movimiento en el juego.
+/// </summary>
+/// 
+public class MovePoison: Move
+{
+    /// <summary>
+    /// Constructor de la clase <c>MovePoison</c>. Inicializa los valores de nombre, ataque, defensa y curación.
+    /// Esto sigue el principio de Liskov Substitution Principle (LSP) porque permite que cualquier clase derivada de <c>MoveSleep</c> (si la hubiera) 
+    /// pueda sustituirse sin alterar el comportamiento de la lógica del juego.
+    /// </summary>
+    /// <param name="name">El nombre del movimiento.</param>
+    /// <param name="attackValue">El valor de ataque del movimiento.</param>
+
+    public MovePoison(string name, int attackValue, double accuracy): base(name, attackValue, accuracy) 
+    {
+        this.Name = name;
+        this.AttackValue = attackValue;
+        this.Accuracy = accuracy;
+
+    }
+
+    /// <summary>
+    /// Método para aplicar el ataque del <c>IMove</c> en particular, considerando ambos pokemones.
+    /// </summary>
+    /// <param name="attacker">El pokemon que está atacando.</param>
+    /// <param name="target">El pokemon que está siendo atacado.</param>
+    ///
+    public override void ExecuteMove(Pokemon attacker, Pokemon target, double criticalHit)
+    {
+        //Aplica el ataque común
+        if (this.AttackValue > 0)
+        {
+            double typeEffectiveness = PokemonType.GetEffectiveness(attacker.Type, target.Type);
+            int calculatedDamage = (int)((this.AttackValue * typeEffectiveness)*(criticalHit));
+            target.HealthPoints -= calculatedDamage;
+        }
+
+        //Aplica al pokemon ataque de envenenado
+        target.IsPoisoned= true;
+    }
+}