Cambios en general

adminProyectiles.wlk

@@ -21,12 +21,13 @@ object administradorDeProyectiles {
     // Genera un nuevo proyectil en la posición y tipo especificado
     method generarProyectil(posicion, tipoProyectil) {
         var nombreParaProyectil = self.nombre()
-        nombreParaProyectil = new Proyectil(position = posicion, tipoProyectil = tipoProyectil)
+        nombreParaProyectil = new Proyectil(position = posicion, proyectil = tipoProyectil)
         proyectiles.add(nombreParaProyectil)
         self.sumarProyectil()
         game.addVisual(nombreParaProyectil)
-        nombreParaProyectil.combinar()
+        game.schedule(50, {nombreParaProyectil.combinar()})
         try nombreParaProyectil.colisionar() catch e "YA NO EXISTE PROYECTIL"
+
     }
 
     // Mueve cada proyectil en la lista
@@ -39,10 +40,6 @@ object administradorDeProyectiles {
         proyectiles.forEach({ proyectil => proyectil.colisionar() })
     }
 
-    method combinarProyectiles() {
-        proyectiles.forEach({ proyectil => proyectil.combinar() })
-    }
-
     // Elimina un proyectil de la lista
     method destruirProyectil(proyectil) {
         proyectiles.remove(proyectil)

administradorDeEnemigos.wlk

@@ -96,13 +96,13 @@ class Linea{
     method text() = cantEnemigos.toString()
 
 
-    var property cantEnemigos =0
+    var property cantEnemigos = 0
 
     method reset(){
         cantEnemigos = 0
     }
 
-    method tieneEnemigos()= cantEnemigos > 0
+    method tieneEnemigos() = (cantEnemigos > 0)
 
     method aumentarCant() {
         cantEnemigos+=1

casa.wlk

@@ -23,14 +23,15 @@ object casa {
 
   method recibirDanio(fila) {
     vida -= 1
-    if (administradorDeEnemigos.hayEnemigoFila(fila)){
-    administradorDeEnemigos.enemigos().filter( { enemigo => enemigo.position().y() == fila } ).forEach({ enemigo => enemigo.matarSlime() })
-    }
     // elimina enemigos de la misma fila
     self.sonidoDanio().volume(0.3)
     if (vida <= 0) {
-      pantalla.nuevoEstado(derrota)
-      administradorDeJuego.terminarJuego()
+        pantalla.nuevoEstado(derrota)
+        administradorDeJuego.terminarJuego()
+    }
+    else if (administradorDeEnemigos.hayEnemigoFila(fila)){
+        const enemigosEnFila = administradorDeEnemigos.enemigos().filter({ enemigo => enemigo.position().y() == fila })
+        enemigosEnFila.forEach({ enemigo => enemigo.matarSlime() })
     }
   }
 

cursor.wlk

@@ -38,7 +38,7 @@ object cursor {
     method recibeDanioEnemigo(_danio,proyectil){}
     method combinarProyectil(_tipo){return false}
     method matarSlime(){return false}
-    method tipoProyectil()=false
+    method proyectil()=false
     method cambiarAccion(accionNueva){}
     method tipo()=descartable
 }

magos.wlk

@@ -28,8 +28,6 @@ class Mago {
 
   method recibeDanioEnemigo(_danio,proyectil) { return false }
 
-  method combinarProyectil(_tipo){return false}
-
   method recibeDanioMago(_danio,enemigo) {
     self.vida(self.vida() - _danio)
     enemigo.cambiarAccion(enemigo.tipo().atacar())
@@ -58,31 +56,23 @@ class Mago {
   method matarSlime(){}
   method cambiarAccion(accionNueva){}
   method tipo()=descartable
+  method proyectil() = false
+  method mejorar(){}
 }
 
 
 
 class MagoQueDispara inherits Mago{
   const proyectilBase
-  var property tipoProyectil=proyectilBase
 
   override method disparar(){
-    if (self.enemigoEnSuFila()) {
-      const posicionProyectil = new MutablePosition(x = self.position().x() + 1, y = self.position().y())
-      administradorDeProyectiles.generarProyectil(posicionProyectil, tipoProyectil)
-      tipoProyectil=proyectilBase
+    const hayEnemigo = self.enemigoEnSuFila()
+    if (hayEnemigo) {
+      const posicionProyectil = new MutablePosition(x = self.position().x(), y = self.position().y())
+      administradorDeProyectiles.generarProyectil(posicionProyectil, proyectilBase)
     }
-
   }
 
-  override method combinarProyectil(otroTipo){
-        if (tipoProyectil.condicionParaCombinarse(otroTipo) && tipoProyectil.puedeCombinarse()){
-            tipoProyectil = tipoProyectil.combinar()
-            return true
-            }
-        return tipoProyectil.condicionParaCombinarse(otroTipo) && tipoProyectil.puedeCombinarse()
-    }
-
    method enemigoEnSuFila() = administradorDeEnemigos.hayEnemigoFila(self.position().y())
 }
 

proyectil.wlk

@@ -12,11 +12,11 @@ import administradorDeEnemigos.administradorDeEnemigos
 // ===============================
 class Proyectil {
     // Propiedades
-    var property tipoProyectil
-    const position = new MutablePosition()
-    const property danio = tipoProyectil.danio()
+    var property proyectil
+    var position
+    const property danio = proyectil.danio()
     var frame = 0
-    var imagen = tipoProyectil.imagenes().get(0)
+    var imagen = proyectil.imagenes().get(0)
 
     // Métodos públicos
     method position() = position
@@ -26,7 +26,7 @@ class Proyectil {
 
     // Método de movimiento
     method mover() {
-        imagen=tipoProyectil.imagenes().get(0)
+        imagen=proyectil.imagenes().get(0)
         frame=1
         position.goRight(1)
         if (self.llegueAlFinal() || self.verificarEnemigosEnfrente()) { self.eliminar() }
@@ -35,34 +35,32 @@ class Proyectil {
     // Método que revisa si llego al final
     method llegueAlFinal() = position.x() >= 14
     // Método de colisión
-    method colisionar() {tipoProyectil.colisionar().apply(self)}
+    method colisionar() {proyectil.colisionar().apply(self)}
 
     method combinar(){
-        const posicionEnFrente = new MutablePosition(x = position.x(), y = position.y())
+        const posicionEnFrente = new MutablePosition(x = position.x()+1, y = position.y())
 
-        const objetosEnPosicion = game.getObjectsIn(self.position()) + game.getObjectsIn(posicionEnFrente)
+        const objetosEnPosicion = game.getObjectsIn(posicionEnFrente)
 
-        const hayColision =  objetosEnPosicion.any({ objeto => objeto != self && objeto.combinarProyectil(self.tipoProyectil())}) //aparentemente wollok tiene lazy evaluation, chad wollok ;)
-        if (tipoProyectil.puedeCombinarse() &&  hayColision ) {
+        const proyACombinar =  objetosEnPosicion.any({objeto => self.proyectil().puedeCombinarse() &&  objeto.proyectil() == self.proyectil()}) //aparentemente wollok tiene lazy evaluation, chad wollok ;)
+
+        if (proyACombinar) {
+            objetosEnPosicion.forEach({objeto => objeto.mejorar()})
             self.eliminar()
         }
     }
 
-    method combinarProyectil(otroTipo){
-        if (tipoProyectil.condicionParaCombinarse(otroTipo) && tipoProyectil.puedeCombinarse()){
-            tipoProyectil = tipoProyectil.combinar()
-            return true
-            }
-        return tipoProyectil.condicionParaCombinarse(otroTipo) && tipoProyectil.puedeCombinarse()
+    method mejorar(){
+        proyectil = self.proyectil().mejora()
     }
 
     // Métodos para recibir daño
-    method recibeDanioEnemigo(_danio,proyectil){}
-    method recibeDanioMago(_danio,enemigo) {tipoProyectil.recibeDanioMago(_danio, enemigo)}
+    method recibeDanioEnemigo(_danio,proy){}
+    method recibeDanioMago(_danio,enemigo) {proyectil.recibeDanioMago(_danio, enemigo)}
 
     // Método para destruir el proyectil
     method destruirse() {
-        if (tipoProyectil.destruirse()) { self.eliminar()}
+        if (proyectil.destruirse()) { self.eliminar()}
     }
 
     // Método para eliminar el proyectil
@@ -74,7 +72,7 @@ class Proyectil {
     method verificarEnemigosEnfrente() = !administradorDeEnemigos.enemigos().any({enemigo => enemigo.position().y() == self.position().y() && enemigo.position().x() >= self.position().x()-2})
 
     method cambiarFrame() {
-        imagen=tipoProyectil.imagenes().get(frame)
+        imagen=proyectil.imagenes().get(frame)
         if(frame<2) {frame+=1}
     }
     method matarSlime(){}
@@ -94,17 +92,17 @@ object proyectilNormal {
     const property imagenes = ["p.proyectilFuego - frame1.png", "p.proyectilFuego - frame2.png", "p.proyectilFuego - frame3.png"]
     method danio() = 40
     method destruirse() = true
-    method combinar() = proyectilPenetrante
     method puedeCombinarse() = true
+    method mejora() = proyectilPenetrante
 
-    method puedeCombinarseConNormal() = true
-    method puedeCombinarseConPenetrante() = false
-    method condicionParaCombinarse(otroTipo) = otroTipo.puedeCombinarseConNormal()
     method colisionar() ={proyectil=>
         const posicionEnFrente = new MutablePosition(x = proyectil.position().x() + 1, y = proyectil.position().y())
         const objetosEnPosicion = game.getObjectsIn(proyectil.position()) + game.getObjectsIn(posicionEnFrente)
         objetosEnPosicion.forEach({objeto =>objeto.recibeDanioEnemigo(proyectil.danio(),proyectil)})
     }
+
+
+
     method recibeDanioMago(danio,enemigo) ={enemigo=>}
 }
 
@@ -118,11 +116,9 @@ object proyectilPenetrante {
     method danio() = 45
     method destruirse() = false
 
-    method combinar() = superProyectil
     method puedeCombinarse() = true
-    method puedeCombinarseConNormal() = false
-    method puedeCombinarseConPenetrante() = true
-    method condicionParaCombinarse(otroTipo) = otroTipo.puedeCombinarseConPenetrante()
+    method mejora() = superProyectil
+
     method colisionar() = proyectilNormal.colisionar()
     method recibeDanioMago(_danio,enemigo)=proyectilNormal.recibeDanioMago(_danio, enemigo)
 }
@@ -134,11 +130,8 @@ object superProyectil {
     const property imagenes = ["p.superProyectil-1.png", "p.superProyectil-2.png", "p.superProyectil-3.png"]
     method danio() = 100
     method destruirse() = false
-    method combinar() = self
     method puedeCombinarse() = false
-    method puedeCombinarseConNormal() = false
-    method puedeCombinarseConPenetrante() = false
-    method condicionParaCombinarse(otroTipo)=false
+    method mejora() = self
     method colisionar() = proyectilNormal.colisionar()
     method recibeDanioMago(_danio,enemigo)=proyectilNormal.recibeDanioMago(_danio, enemigo)
 }
@@ -147,11 +140,8 @@ object proyectilDeStop{
     const property imagenes = ["p.proyectilDeStop-frame1.png", "p.proyectilDeStop-frame2.png", "p.proyectilDeStop-frame3.png"]
     method danio() = 20
     method destruirse() = true
-    method combinar() = self
     method puedeCombinarse() = false
-    method puedeCombinarseConNormal() = false
-    method puedeCombinarseConPenetrante() = false
-    method condicionParaCombinarse(otroTipo)=false
+    method mejora() = self
     method colisionar() ={proyectil=>
         const posicionEnFrente = new MutablePosition(x = proyectil.position().x() + 1, y = proyectil.position().y())
         const objetosEnPosicion = game.getObjectsIn(proyectil.position()) + game.getObjectsIn(posicionEnFrente)

puntaje.wlk

@@ -9,7 +9,7 @@ import administradorDeMagos.*
 // Puntaje: Manejo de puntos
 // ===============================
 object puntaje {
-	const puntajeInicial = 200
+	const puntajeInicial = 20000 //200
 
 	var property puntos = puntajeInicial
 

slime.wlk

@@ -82,7 +82,8 @@ class Slime {
         administradorDeEnemigos.eliminarEnemigo(self)
     }
 
-    method tipoProyectil() = false
+    method proyectil() = false
+    method mejorar(){}
 }
 // ===============================
 // Tipos de Slime: Variantes
@@ -124,7 +125,8 @@ class Tipo{
 
             if (slime.sinVida() || slime.llegoACasa()) {
                 if (slime.llegoACasa()) {
-                    casa.recibirDanio(slime.position().y())
+                    const fila =  slime.position().y()
+                    casa.recibirDanio(fila)
                 } 
                 slime.eliminar()
             }
@@ -208,10 +210,12 @@ object slimeAgil inherits Tipo(danio=50, vida=200, imagen="s.slimeAgil_01.png",i
     method cambiarDeCarril()={
         slime=>
             const newPosicionY = (slime.position().y()+((-1).randomUpTo(2))).max(0).min(4)
-            const newPosicion= new MutablePosition(x = slime.position().x(), y = newPosicionY )//
-            if(game.getObjectsIn(newPosicion).isEmpty()){
+            const newPosicion = new MutablePosition(x = slime.position().x(), y = newPosicionY )//
+            const oldPoscionY = slime.position().y()
+            const objetos = game.getObjectsIn(newPosicion)
+            if(objetos.all({objeto => objeto.sePuedeSuperponer()})){
                 administradorDeEnemigos.aumentarLinea(newPosicionY)  
-                administradorDeEnemigos.decrementarLinea(slime.position().y())  
+                administradorDeEnemigos.decrementarLinea(oldPoscionY)  
                 slime.position(newPosicion)
             }
     }