Tarea 1 - Entrega Parcial 2

README.md

@@ -3,6 +3,8 @@
 Final Reality is a simplified clone of the renowned game, Final Fantasy. Its main purpose is to
 serve as an educational tool, teaching foundational programming concepts.
 
+this game will be selling more than final fantasy...
+
 This README is yours to complete it. Take this opportunity to describe your contributions, the
 design decisions you've made, and any other information you deem necessary.
 

src/main/scala/model/controller/Controller.scala

@@ -0,0 +1,14 @@
+package model.controller
+
+
+class Controller {
+  // tuve problemas con mi licencia de intellij, lo solucione hoy y no me dio tiempo a terminar esta parte
+  // si arreglé varias cosas que no estaban del  buenas en la entrega parcial 1
+  // el cuerpo docente ya esta al tanto de la situacion
+
+
+
+
+
+}
+

src/main/scala/model/nonplayable/Enemy.scala

@@ -0,0 +1,33 @@
+package model.nonplayable
+import model.nonplayable.NonPlayable
+
+// Enemy class represents a non-playable entity that is an enemy
+class Enemy(name: String, weight: Int,
+            attack: Int, life: Int,
+            defence: Int) extends NonPlayable {
+
+  // Method to return the name of the enemy
+  def sayName(): String = {
+    name
+  }
+
+  // Method to return the weight of the enemy
+  def sayWeight(): Int = {
+    weight
+  }
+
+  // Method to return the attack power of the enemy
+  def sayAttack(): Int = {
+    attack
+  }
+
+  // Method to return the life points of the enemy
+  def sayLife(): Int = {
+    life
+  }
+
+  // Method to return the defence points of the enemy
+  def sayDefence(): Int = {
+    defence
+  }
+}

src/main/scala/model/nonplayable/MagicWeapon.scala

@@ -0,0 +1,35 @@
+package model.nonplayable
+import model.nonplayable.NonPlayable
+import model.playable.APlayable
+
+// MagicWeapon class represents a non-playable entity that is a magic weapon
+class MagicWeapon(name: String, weight: Int,
+                  attack: Int, mana: Int,
+                  owner: APlayable) extends NonPlayable {
+
+  // Method to return the mana points required to use the magic weapon
+  def sayMana(): Int ={
+    mana
+  }
+
+  // Method to return the name of the magic weapon
+  def sayName(): String = {
+    name
+  }
+
+  // Method to return the weight of the magic weapon
+  def sayWeight(): Int = {
+    weight
+  }
+
+  // Method to return the attack power of the magic weapon
+  def sayAttack(): Int = {
+    attack
+  }
+
+  // Method to return the owner character of the magic weapon
+  def sayOwner(): APlayable = {
+    owner
+  }
+}
+

src/main/scala/model/nonplayable/NonPlayable.scala

@@ -0,0 +1,14 @@
+package model.nonplayable
+
+// Trait to represent non-playable entities
+trait NonPlayable {
+  // Abstract method to get the name of the non-playable entity
+  def sayName(): String
+
+  // Abstract method to get the weight of the non-playable entity
+  def sayWeight(): Int
+
+  // Abstract method to get the attack power of the non-playable entity
+  def sayAttack(): Int
+}
+

src/main/scala/model/nonplayable/Weapon.scala

@@ -0,0 +1,28 @@
+package model.nonplayable
+import model.nonplayable.NonPlayable
+import model.playable.APlayable
+
+// Weapon class represents a non-playable entity that is a weapon
+class Weapon(name: String, weight: Int,
+             attack: Int, owner: Character) extends NonPlayable {
+
+  // Method to return the owner character of the weapon
+  def sayOwner(): Character = {
+    owner
+  }
+
+  // Method to return the name of the weapon
+  def sayName(): String = {
+    name
+  }
+
+  // Method to return the weight of the weapon
+  def sayWeight(): Int = {
+    weight
+  }
+
+  // Method to return the attack power of the weapon
+  def sayAttack(): Int = {
+    attack
+  }
+}

src/main/scala/model/party/Party.scala

@@ -0,0 +1,27 @@
+package model.party
+
+import model.playable.{APlayable}
+
+import scala.collection.mutable.Map
+
+// Party class to manage a group of playable characters
+class Party {
+  // Map to store the allies in the party, keyed by their kind/type
+  val allies: Map[String, APlayable] = Map()
+
+  // Method to add a playable character to the party
+  def addPlayable(pj: APlayable): Unit = {
+    allies.put(pj.sayKind(), pj) // Adds the playable character to the allies map with their kind as the key
+  }
+
+  // Method to check if the party is defeated
+  def isDefeated: Boolean = {
+    if (allies.isEmpty) {
+      // Print a message if the party is empty
+      true // The party is considered defeated if it's empty
+    } else {
+      // The party is considered defeated if all allies have 0 life points
+      allies.values.forall(_.sayLife() == 0)
+    }
+  }
+}

src/main/scala/model/playable/APlayable.scala

@@ -0,0 +1,42 @@
+package model.playable
+import model.playable.Playable
+abstract class APlayable(val name: String, var life: Int,
+                         val defence: Int, val weight: Int,
+                         var kind: String, var weapon: Boolean, val mana: Int) extends Playable {
+
+  // Method to return the name of the character
+  def sayName(): String = {
+    name
+  }
+
+  // Method to return the life points of the character
+  def sayLife(): Int = {
+    life
+  }
+
+  // Method to return the defense points of the character
+  def sayDefence(): Int = {
+    defence
+  }
+
+  // Method to return the weight of the character
+  def sayWeight(): Int = {
+    weight
+  }
+
+  // Method to return the kind/type of the character
+  def sayKind(): String = {
+    kind
+  }
+
+  // Method to check if the character has a weapon
+  def havWeapon(): Boolean = {
+    weapon
+  }
+  def sayMana(): Int = {
+    mana
+  }
+
+
+}
+

src/main/scala/model/playable/Character.scala

@@ -0,0 +1,25 @@
+package model.playable
+import model.playable.Playable
+import model.playable.APlayable
+// Character class extends the Playable trait
+class Paladin(name:String) extends APlayable(name,100,50,50,"Paladin",false,0) {
+
+}
+class Guerrero(name:String) extends APlayable(name,120,80,40,"Guerrero",false,0) {
+
+}
+class Ninja(name:String) extends APlayable(name,50,80,20,"Ninja",false,0) {
+
+}
+class MagoNegro(name:String) extends APlayable(name,100,100,120,"MagoNegro",false,50) {
+
+}
+
+class MagoBlanco(name:String) extends APlayable(name,50,150,100,"MagoBlanco",false,80) {
+
+} // Override equals method to compare two characters based on their attributes
+
+
+
+
+

src/main/scala/model/playable/MagicCharacter.scala

@@ -0,0 +1,4 @@
+package model.playable
+import model.playable.APlayable
+
+// MagicCharacter class extends the Playable trait

src/main/scala/model/playable/Playable.scala

@@ -0,0 +1,22 @@
+package model.playable
+
+trait Playable {
+  // Abstract method to get the name of the playable entity
+  def sayName(): String
+
+  // Abstract method to get the life points of the playable entity
+  def sayLife(): Int
+
+  // Abstract method to get the defense points of the playable entity
+  def sayDefence(): Int
+
+  // Abstract method to get the weight of the playable entity
+  def sayWeight(): Int
+
+  // Abstract method to get the kind/type of the playable entity
+  def sayKind(): String
+
+  // Abstract method to check if the playable entity has a weapon
+  def havWeapon(): Boolean
+
+}

src/test/scala/PartyTest.scala

@@ -0,0 +1,48 @@
+import munit.FunSuite
+import model.party.Party
+import model.playable.{APlayable,Paladin,Guerrero,Ninja,MagoBlanco,MagoNegro}
+import model.nonplayable.{Enemy, MagicWeapon, Weapon}
+class PartyTest extends FunSuite {
+  var Team1: Party = _ // We declare a variable Team1 of type Party
+  var Cristiano: APlayable = _ // We declare a variable Cristiano of type Playable
+  var Alexis: APlayable = _ // We declare a variable Alexis of type Playable
+
+
+  override def beforeEach(context: BeforeEach): Unit = {
+    Team1 = new Party() // Creates a new instance of the Party class and assigns it to the variable Team1.
+    // Creates a new instance of the Character class with the specified parameters:
+    Cristiano = new Paladin("Cristiano")
+
+    // Creates a new instance of the MagicCharacter class with the specified parameters:
+    Alexis = new MagoBlanco("Alexis")// - Kind: Mago Blanco // - Weapon: false
+
+  }
+  test("addCharacter") { // Test the method to add a character
+    Team1.addPlayable(Cristiano) // Add the character Cristiano
+    val expected: Map[String, APlayable] = Map("Paladin" -> Cristiano) // The expected variable will be a map with the type and name of the character
+    assertEquals(Team1.allies.toMap, expected) // Compare the result with the Map
+  }
+
+  test("isEmpty") { // Test if the team is initially empty
+    var state: Boolean = Team1.isDefeated // Create a variable 'state' that stores the result of checking if a party is defeated
+    assertEquals(state, true) // Compare the results
+  }
+  test("isDefeat") { // Test if a party is defeated or not
+    Cristiano.life = 0
+    Team1.addPlayable(Cristiano) // Add a character with zero health
+    Alexis.life = 0
+    Team1.addPlayable(Alexis) // Add a magic character with zero health
+    assertEquals(Team1.isDefeated, true) // Check if they are defeated or not (a team with no health is defeated) -> true
+  }
+  test("isNotDefeat") { // Test if a party is not defeated
+    Team1.addPlayable(Cristiano) // Add a character with zero health
+    Alexis = new MagoBlanco("Alexis")
+    Team1.addPlayable(Alexis) // Add that living character
+    assertEquals(Team1.isDefeated, false) // Check that the team is alive (false)
+  }
+
+
+
+
+
+}

src/test/scala/nonplayable/EnemyTest.scala

@@ -0,0 +1,76 @@
+package nonplayable
+
+import model.nonplayable.Enemy
+import munit.FunSuite
+class EnemyTest extends FunSuite {
+  var Neymar: Enemy = _ // We declare a variable Neymar of type Enemy
+  var Bale: Enemy = _ // We declare a variable Bale of type Enemy
+
+  override def beforeEach(context: BeforeEach): Unit = {
+    // Creates a new instance of the Enemy class with the specified parameters:
+    Neymar = new Enemy("Neymar", 60, 90, 70, 30) // -Name : Neymar // - Weight: 60 // - Attack: 90 // - Life: 70 // - Defence: 30
+    // Creates a new instance of the Enemy class with the specified parameters:
+    Bale = new Enemy("Bale", 70, 85, 75, 50) // -Name : Bale // - Weight: 70 // - Attack: 85 // - Life: 75 // - Defence: 50
+
+  }
+
+  test("equalsEnemyName") { // Test if the returned name value for an enemy matches the expected value
+    var name: String = Neymar.sayName() // Retrieve the name value of the enemy Neymar and store it in the 'name' variable
+    var expected: String = "Neymar" // Define the expected name value
+    assertEquals(name, expected) // Compare the actual name value with the expected value
+  }
+
+  test("NotEqualsEnemyName") { // Test if the name values of two different enemies are not equal
+    var name1: String = Neymar.sayName() // Retrieve the name value of the enemy Neymar and store it in the 'name1' variable
+    var name2: String = Bale.sayName() // Retrieve the name value of the enemy Bale and store it in the 'name2' variable
+    assertNotEquals(name1, name2) // Assert that the name values of Neymar and Bale are not equal
+  }
+
+  test("equalsWeight") { // Test if the returned weight value for an enemy matches the expected value
+    var weight = Neymar.sayWeight() // Retrieve the weight value of the enemy Neymar and store it in the 'weight' variable
+    var expected: Int = 60 // Define the expected weight value
+    assertEquals(weight, expected) // Compare the actual weight value with the expected value
+  }
+
+  test("NotEqualsWeight") { // Test if the weight values of two different enemies are not equal
+    var weight1 = Neymar.sayWeight() // Retrieve the weight value of the enemy Neymar and store it in the 'weight1' variable
+    var weight2 = Bale.sayWeight() // Retrieve the weight value of the enemy Bale and store it in the 'weight2' variable
+    assertNotEquals(weight1, weight2) // Assert that the weight values of Neymar and Bale are not equal
+  }
+
+  test("equalsAttack") { // Test if the returned attack value for an enemy matches the expected value
+    var attack = Neymar.sayAttack() // Retrieve the attack value of the enemy Neymar and store it in the 'attack' variable
+    var expected: Int = 90 // Define the expected attack value
+    assertEquals(attack, expected) // Compare the actual attack value with the expected value
+  }
+
+  test("NotEqualsAttack") { // Test if the attack values of two different enemies are not equal
+    var attack1 = Neymar.sayAttack() // Retrieve the attack value of the enemy Neymar and store it in the 'attack1' variable
+    var attack2 = Bale.sayAttack() // Retrieve the attack value of the enemy Bale and store it in the 'attack2' variable
+    assertNotEquals(attack1, attack2) // Assert that the attack values of Neymar and Bale are not equal
+  }
+
+  test("equalsLife") { // Test if the returned life value for an enemy matches the expected value
+    var life = Neymar.sayLife() // Retrieve the life value of the enemy Neymar and store it in the 'life' variable
+    var expected: Int = 70 // Define the expected life value
+    assertEquals(life, expected) // Compare the actual life value with the expected value
+  }
+
+  test("NotEqualsLife") { // Test if the life values of two different enemies are not equal
+    var life1 = Neymar.sayLife() // Retrieve the life value of the enemy Neymar and store it in the 'life1' variable
+    var life2 = Bale.sayLife() // Retrieve the life value of the enemy Bale and store it in the 'life2' variable
+    assertNotEquals(life1, life2) // Assert that the life values of Neymar and Bale are not equal
+  }
+
+  test("equalsDefence") { // Test if the returned defense value for an enemy matches the expected value
+    var defense = Neymar.sayDefence() // Retrieve the defense value of the enemy Neymar and store it in the 'defense' variable
+    var expected: Int = 30 // Define the expected defense value
+    assertEquals(defense, expected) // Compare the actual defense value with the expected value
+  }
+
+  test("NotEqualsDefence") { // Test if the defense values of two different enemies are not equal
+    var defense1 = Neymar.sayDefence() // Retrieve the defense value of the enemy Neymar and store it in the 'defense1' variable
+    var defense2 = Bale.sayDefence() // Retrieve the de
+
+  }
+}