diff --git a/2024-Parcial-GrimFandango.pdf b/2024-Parcial-GrimFandango.pdf
new file mode 100644
index 0000000..d328827
Binary files /dev/null and b/2024-Parcial-GrimFandango.pdf differ
diff --git a/README.md b/README.md
index 26f6969..2d83445 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,5 @@
-## Parcial Objetos 2024 Jueves Mañana
+[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/P6bH6nET)
 
+## Parcial Objetos 2024 Jueves Mañana
+ - **Enunciado**: [2024-Parcial-GrimFandango.pdf](2024-Parcial-GrimFandango.pdf)
 
diff --git a/parcial.wlk b/parcial.wlk
index bc3bf72..1272b3c 100644
--- a/parcial.wlk
+++ b/parcial.wlk
@@ -1,2 +1,122 @@
 // Apellido y Nombre: 
+// Apellido y Nombre: 
+class Agente {
+  const deudaInicial
+  const ventas = []
+  var estrategiaDeVenta = clasico
+  
+  // 1a)
+  method venderA(paquete, alma) {
+    if (!alma.puedeCostear(paquete)) {
+      throw new DomainException(message = "El alma no puede costear el paquete")
+    }
+    ventas.add(new Venta(paquete=paquete, alma=alma)) 
+    // esta es una forma de que funcionen todos los puntos posteriores, creando un objeto venta,
+    // que registra qué paquete le fue a qué alma. El punto 4 de los paquetes
+    // predefinidos queda mejor de esta manera.
+  }  
+  // 1d)
+  method deuda() = deudaInicial - self.dineroGanado() // podría tener una deuda que se actualice también.
+  
+  // 1c)
+  method dineroGanado() = ventas.sum({ venta => venta.costo() })
+  
+  method pagoSuDeuda() = self.deuda() <= 0
+  
+  // 4)
+  method atender(alma) {
+    self.venderA(estrategiaDeVenta.paquetePara(alma), alma)
+  }
+
+  // 4c)
+  method cambiarEstrategia(estrategia) {
+    estrategiaDeVenta = estrategia
+  }
+  
+  method cantidadPaquetesVendidos() = ventas.size()
+}
+
+object departamentoDeLaMuerte {
+  const agentes = []
+  var property paquetesPredefinidos = [new Tren(basico=100), new Crucero(basico=40)] //ejemplos
+
+  // 1b)
+  method mejorAgente() = agentes.max(
+    { agente => agente.cantidadPaquetesVendidos() }
+  )
+
+  method agregarAgente(a) {
+    agentes.add(a)
+  }
+  
+  // 2)
+  method diaDeLosMuertos() {
+    self.mejorAgente().reducirDeudaInicial(50)
+    agentes.removeAll(self.agentesQueCumplieronDeuda())
+    agentes.forEach({ agente => agente.aumentarDeuda(100) })
+    // las dos líneas anteriores podrían ser un solo foreach con un if, no estaría mal, si está bien delegado.
+    // tambien con el método removeAllSuchThat
+  }
+
+  method agentesQueCumplieronDeuda() = agentes.filter({agente => agente.pagoSuDeuda()})
+}
+
+class Venta {
+  const alma
+  const paquete
+
+  method costo() = paquete.costoPara(alma) 
+}
+
+// Punto 3), paquetes:
+class Paquete {
+  const basico
+
+  method costoPara(alma) = (basico * self.cuantoReduceA(alma)).min(350)
+  method cuantoReduceA(alma)
+}
+
+class Tren inherits Paquete {
+  override method cuantoReduceA(alma) = 4
+}
+
+class Bote inherits Paquete {  
+  override method cuantoReduceA(alma) = (alma.cantAccionesBuenas() / 50).min(2)
+}
+
+class Palo inherits Paquete {
+  override method cuantoReduceA(alma) = 0.05
+  override method costoPara(alma) = basico
+}
+
+class Crucero inherits Bote {
+  override method cuantoReduceA(alma) = super(alma) * 2
+}
+
+class Alma {
+  const dinero
+  const cantAccionesBuenas
+
+  method puedeCostear(paquete) = paquete.costoPara(self) <= self.capital()
+
+  method capital() = cantAccionesBuenas + dinero
+    
+  method cantAccionesBuenas() = cantAccionesBuenas
+}
+
+
+// Estrategias punto 4:
+
+object clasico {
+  method paquetesCosteables(alma) = departamentoDeLaMuerte.paquetesPredefinidos().filter({paq => alma.puedeCostear(paq)})
+  method paquetePara(alma) = self.paquetesCosteables(alma).max( { p => p.costoPara(alma)})
+}
+object navegante {
+  method paquetePara(alma) = if (alma.cantAccionesBuenas() > 50) 
+    new Crucero(basico=alma.cantAccionesBuenas()) 
+    else new Bote(basico=alma.cantAccionesBuenas())
+}
 
+object indiferente {  
+  method paquetePara(alma) = new Palo(basico=1.randomUpTo(300))
+}
diff --git a/testExample.wtest b/testExample.wtest
index 995f8ca..bd60150 100644
--- a/testExample.wtest
+++ b/testExample.wtest
@@ -2,10 +2,57 @@
 
 import parcial.*
 
-describe "parcial" {
+describe "tests punto 5), un agente con estrategia navegante" {
+  const almaCaro = new Alma(cantAccionesBuenas=230, dinero=0)
+  const almaDelfi = new Alma(cantAccionesBuenas=50, dinero=0)
+  test "Cuando el alma tiene más de 50 acciones, le corresponde un paquete crucero" {
+    // Como el equals compara por identidad, esto no se puede hacer, que es lo ideal:
+    // assert.equals(new Crucero(basico=230), navegante.paquetePara(almaCaro))
+    // Sin embargo, lo anterior está bien en el parcial.
+    // La forma correcta de resolverlo es definiendo el método equals() en los paquetes.
+    // Por simplicidad, usamos una solución parche en este ejemplo, que le pregunta al
+    // paquete cuánto reduce para identificar si es crucero o bote
+    assert.equals(4, navegante.paquetePara(almaCaro).cuantoReduceA(almaCaro))
+  }
+
+  test "Cuando el alma tiene menos de 50 acciones, le corresponde un paquete bote" {
+    //assert.equals(new Bote(basico=50), navegante.paquetePara(almaDelfi))
+    // Ver comentarios en el test de arriba.
+    assert.equals(1, navegante.paquetePara(almaDelfi).cuantoReduceA(almaDelfi))
+  }
+
+}
+
+// Tests adicionales posibles
+
+describe "Tests de ventas" {
+  const agenteYayo = new Agente(deudaInicial=120)
+  const agenteZeta = new Agente(deudaInicial=50)
+  const crucero = new Crucero(basico=100)
+  const palo = new Palo(basico=100)
+  const almaAna = new Alma(cantAccionesBuenas=150, dinero=0)
+  const almaPepe = new Alma(cantAccionesBuenas=40, dinero=500)
+
+  test "Se calcula correctamente la deuda de un agente"{
+    assert.equals(120, agenteYayo.deuda())
+  }
+  test "Al hacer una venta se disminuye la deuda de un agente"{
+    agenteYayo.venderA(palo, almaAna)
+    assert.equals(20, agenteYayo.deuda())
+  }
+
+  test "El total ganado por un agente es la suma de los costos de los paquetes vendidos"{
+    agenteYayo.venderA(palo, almaAna)
+    agenteYayo.venderA(crucero, almaPepe)
+    assert.equals(260, agenteYayo.dineroGanado())
+  }
 
-  test "parcial" {
-    assert.equals(1, 1)
+  test "El mejor agente del departamento es el que más paquetes vendió"{
+    departamentoDeLaMuerte.agregarAgente(agenteYayo)
+    departamentoDeLaMuerte.agregarAgente(agenteZeta)
+    agenteYayo.venderA(palo, almaAna)
+    assert.equals(agenteYayo, departamentoDeLaMuerte.mejorAgente())
   }
+}
 
-}
\ No newline at end of file
+// Sería interesante tener tests de cálculos de años y costos de los paquetes.
\ No newline at end of file