[WIP] Treballant en el jefe. Organitzant codi (Ha deixat de funcionar quasi tot)

[FIX] Els warps reutilitzats mantenien l'estat anterior
[NEW] Funcio distancia(a, b)

data/abad.lua

@@ -104,7 +104,7 @@ function abad:draw()
         if ((abad.x+abad.y)%12)==0 then abad.stairs_flip=not abad.stairs_flip end 
         local msg = "-- "..abad.x.." "..abad.y
         if flip then msg = "FLIP"..abad.x.." "..abad.y end
-        msg_print(0,35,msg,true)
+        -- msg_print(0,35,msg,true)
     end
     if (abad.respawning==0) or (math.floor(abad.respawning/15)%2==0) then
         draw.surf(abad.frame*abad.w,0,abad.w,abad.h,x,y,abad.w,abad.h,flip)
@@ -133,7 +133,7 @@ end
 
 
 function abad_hurt(howmuch)
-    howmuch = 0
+    -- howmuch = 0
     if abad.hurting == 0 and abad.respawning==0 then
         sound.play(audio_abad_hit)
         abad.energia=abad.energia-howmuch

data/fireball.lua

@@ -110,10 +110,11 @@ function fireball.update()
             if collision(fireball,abad) then
                 if fireball.power==1 and abad.update~=abad_state_crouch then
                     abad_hurt(1)
+                    fireball.hab=-1
                 elseif fireball.power==2 then
                     abad_hurt(2)                
+                    fireball.hab=-1
                 end
-                fireball.hab=-1
             end
         else
             fireball.hab=-1

data/game.lua

@@ -14,7 +14,7 @@ require "zombie"
 require "score"
 -- require "switches"
 require "trigger"
-require "imp"
+require "imp2"
 require "fireball"
 require "bar_meter"
 

data/helpers.lua

@@ -4,6 +4,13 @@ local shine_pos  = 0
 local map_backup = {}
 local actors_backup = {}
 
+function distancia(a, b)
+    local dx = (a.x-b.x)
+    local dy = (a.y-b.y)
+    local r = math.sqrt(dx*dx+dy*dy)
+    return r
+end
+
 function collision(a, b)
     return     (a.x+a.bb.x+a.bb.w >= b.x+b.bb.x) 
            and (a.x+a.bb.x <= b.x+b.bb.x+b.bb.w) 

data/imp.lua

@@ -58,7 +58,7 @@ function imp.new(_hab, _x, _y)
        fight_mode_cooldown=1500, -- cicles fins al canvi de mode
        -- super_cooldown=2000,      -- cicles fins a Super actiu
        super_cooldown=200,      -- cicles fins a Super actiu
-       shot_cooldown=500,        -- cicles fina a poder disparar   
+       shot_cooldown=100,        -- cicles fina a poder disparar   
        hot_points={},      -- llista de punts del mapa on anar
        target={},          -- següent punt on anar
        old_target={},      -- target anterior
@@ -69,6 +69,7 @@ function imp.new(_hab, _x, _y)
        analisis={},        -- Resultat de la informació extreta de l'entorn
        old_action="-",
        invencible=false,
+       invencible_time=50,
        flip_wait=100,      -- Temps per a forçar un flip
        super_wait=200,
        zoom=1,
@@ -207,9 +208,9 @@ if DEBUG_FN_NAME then print("fight") end
     }
     self.paths[4] = {
         {next=1, actions={{action="jump" , event="target"}}},
-        --{next=5, actions={{action="right", event="target"}}},
+        {next=5, actions={{action="right", event="target"}}},
-        --{next=6, actions={{action="right", event="target"}}},
+        {next=6, actions={{action="right", event="target"}}},
-        --{next=8, actions={{action="jump" , event="target"}}},
+        {next=8, actions={{action="jump" , event="target"}}},
     }
     self.paths[5] = {
         {next=4, actions={{action="left" , event="target"}}},
@@ -268,9 +269,7 @@ end
 
 function imp:draw()
     local scr_x, scr_y = viewp:screen_coords( self.x, self.y )
-    if self.invencible then
+
-        -- pal.subpal(5,15)
-    end
     
     if self.update==self.state_super then
         for col=13,15 do
@@ -289,6 +288,9 @@ function imp:draw()
         for col=13,15 do pal.subpal(col) end
         --draw.surf(96, 32, self.w, self.h, scr_x, scr_y, self.w, self.h, self.flip)
     else
+        if self.invencible then
+            pal.subpal(5,1)
+        end
         draw.surf((self.frame&7)*self.w, (self.frame>>cxr2)*self.h, self.w, self.h, scr_x, scr_y, self.w, self.h, self.flip)
         pal.subpal(5)
     end
@@ -319,10 +321,10 @@ function imp:hit()
 if DEBUG_FN_NAME then print("hit") end
     if not self.invencible then
         self.energia = self.energia -1
-        --if self:distancia(abad)<100 then
+        if distancia(self, abad)<50 and self.invencible_time<=0 then
-            -- self.invencible = true
+            self.invencible = true
-            -- self.invencible_time = 50
+            self.invencible_time = 50
-        --end
+        end
     end
     if self.energia==1 then self.can_warp=true end
     if self.energia <= 0 then 
@@ -614,11 +616,11 @@ if DEBUG_FN_NAME then print("shot") end
         flip=true 
         x_ini = self.x-4
     end
-    local hab, tx, ty, off_x, off_y = coords.world_to_tile(x_ini,self.y+(self.h/2))
+    local hab, tx, ty, off_x, off_y = coords.world_to_tile(x_ini,self.y+(self.h/4))
     fireball.init(hab, tx, ty, flip, off_x, off_y)
     sound.play(audio_hit)
     
-    self.shot_cooldown = 500
+    self.shot_cooldown = 100
 end
 
 function imp:do_flip(actor)
@@ -634,6 +636,7 @@ if DEBUG_FN_NAME then print("reduce_cooldown") end
     self.super_cooldown = self.super_cooldown -1
     self.shot_cooldown = self.shot_cooldown -1
     self.flip_wait = self.flip_wait -1
+    self.invencible_time = self.invencible_time -1
 end
 
 function imp:reset_fight_mode_cooldown( value )
@@ -868,9 +871,7 @@ if DEBUG_FN_NAME then print("analyze_env") end
     -- end
     
     -- Distancia fins a l'abad
-    dx = (self.x-abad.x)
+    local r = distancia(self,abad)
-    dy = (self.y-abad.y)
-    r = math.sqrt(dx*dx+dy*dy)
     -- msg_print(10,20,r,true)
     self.analisis.can_chase_abad = false
     if r<=100 then 
@@ -1030,6 +1031,7 @@ end
 function imp:actualitzar_comportament()
 if DEBUG_FN_NAME then print("actualitzar_comportament") end
     self:reduce_cooldown()
+    if self.invencible_time<=0 then self.invencible=false end
     -- if self.update==imp.state_jumping or self.update==imp.state_falling then
     --     -- self:think()
     --     -- self:move()

data/imp2.lua

@@ -0,0 +1,661 @@
+imp = {}
+
+local DEBUG_FN_NAME = false
+
+function imp.reset()
+    imp.hit=imp.hit
+    imp.update=imp.update
+    imp.draw=imp.draw
+    imp.hab=abad.hab
+    imp.enabled=false
+    imp.counter=500
+end
+
+-- function imp.new(_hab, _x, _y)
+--     local world_x, world_y = coords.room_to_world(_hab,_x,_y)
+--     _fight_modes={"chase","away","super","end_super","shot"}
+--     for i,v in ipairs(_fight_modes) do _fight_modes[v] = i end
+--   
+--     return { name="imp",
+--        hab=_hab,
+--        x=world_x, y=world_y,
+--        w=32, h=32,
+--        flip=true, 
+--        frame=28,
+--        wait=0,
+--        vides=1,
+--        energia=21,
+--        max_energia=21,
+--        falling=0,
+--        step=0,
+--        hurting=0,
+--        jumpfwd=false,
+--        step_length=1,
+--        vmove_space=1,
+--        max_jump_height=24,
+--        jump_height=0,
+--        jump_in_half_block=0,
+--        jump_in_half_block_used = false,
+--        -- max_shoot_cooldown=24,
+--        shot_power=1,
+--        shot_num_shots=1,
+--        shoot_cooldown=25,
+--        anim={28,29,28,30},
+--        bb={x=8,y=0,w=16,h=32},
+--        -- scene_intro=false,
+--        -- scene_object=false,
+--        enabled=true,
+--        disable_reason="",
+--        can_warp=false,
+--        -- Atributs de jefe
+--        movement_type="",         -- Mode de moviment {pattern, free}
+--        action="",                -- Acció a realitzar en el "pad"
+--        movement="",              -- Cap on es mou independentment de si està "flipat"
+--        fight_modes=_fight_modes, -- mode de lluita (Llevar?)
+--        fight_mode="stop",        -- mode de lluita actiu 
+--        fight_mode_cooldown=1500, -- cicles fins al canvi de mode
+--        -- super_cooldown=2000,      -- cicles fins a Super actiu
+--        super_cooldown=200,      -- cicles fins a Super actiu
+--        shot_cooldown=100,        -- cicles fina a poder disparar   
+--        hot_points={},      -- llista de punts del mapa on anar
+--        target={},          -- següent punt on anar
+--        old_target={},      -- target anterior
+--        paths={},           -- Llista de "camins" a fer des d'un hot_point
+--        path={},            -- Cami actiu
+--        path_curr_action=1, -- Index d'acció dins del cami actiu
+--        action_event="",    -- Event d'acció que ha passat
+--        analisis={},        -- Resultat de la informació extreta de l'entorn
+--        old_action="-",
+--        invencible=false,
+--        invencible_time=50,
+--        flip_wait=100,      -- Temps per a forçar un flip
+--        super_wait=200,
+--        zoom=1,
+--        super_pal={[13]=13,[14]=14,[15]=15},
+--        super_fired = false,
+--        -- direccio=imp.direccio,
+--        draw=imp.draw,
+--        hit=imp.hit,
+--        do_jump=imp.do_jump,
+--        jump=imp.jump,
+--        state_jumping=imp.state_jumping,
+--        update=imp.state_normal,
+--        land=imp.land,
+--        advance=imp.advance,
+--        -- Funcions de jefe
+--        fight=imp.fight, -- Inicialització per al combat. Crea el punts, carrega els paths, etc. 
+--        -- chase=imp.chase,
+--        -- away=imp.away,
+--        move=imp.move,   -- Determina el següent moviment a fer (dreta, esq, bot, etc...)
+--        super=imp.super, -- Activa el mode super poder
+--        state_super=imp.state_super, -- Entra en estat super poder
+--        shot=imp.shot,   -- Dispara
+--        do_flip=imp.do_flip, -- Orienta a l'imp cap a l'actor
+--        -- mode_controller=imp.mode_controller,
+--        reduce_cooldown=imp.reduce_cooldown, -- Decrementa els cooldown
+--        reset_fight_mode_cooldown=imp.reset_fight_mode_cooldown, -- Asignar un valor a fight_mode_cooldown (per a mantindre una coherència cada volta que es crida)
+--        controller_input=imp.controller_input, -- Traduir l'accio en moviment
+--        actualitzar_comportament=imp.actualitzar_comportament, -- "Pensar" que fer
+--        analyze_env=imp.analyze_env, -- Analitza l'entorn a vore que està pasant
+--        
+--        path_reset=imp.path_reset,             -- Elimina el path actiu
+--        path_next_action=imp.path_next_action, -- Següent acció del path actiu
+--        path_action=imp.path_action,           -- Acció actual del path actiu
+--        
+--        pattern_movement=imp.pattern_movement,       -- Pasar a mode de moviment per patró
+--        pattern_next_action=imp.pattern_next_action, -- Següent acció en mode pattern
+--        pattern_next_target=imp.pattern_next_target, -- Següent target en mode pattern
+--        pattern_recovery=imp.pattern_recovery,       -- Si per algun motiu perd el mode pattern recuperar-lo
+--        
+--        -- Al afegir pattern_recovery el moviment lliure no te sentit (ni es gasta en este moment), se queda ara per si de cas
+--        free_movement=imp.free_movement,       -- Pasar a mode de moviment lliure
+--        free_next_action=imp.free_next_action, -- Següent acció en mode lliure
+--        free_next_target=imp.free_next_target, -- Següent target en mode free
+--        
+--        super_ready=imp.super_ready,
+--        super_movement=imp.super_movement,
+--        super_next_action=imp.super_next_action,
+--        super_next_target=imp.super_next_target,
+--        
+--        next_action=imp.next_action,  -- Següent acció en qualsevol mode de moviment
+--        next_target=imp.next_target,  -- Següent target en qualsevol mode de moviment
+--        
+--        -- imp.enabled=false
+--        -- imp.counter=500
+--     }
+-- end
+-- 
+
+function imp.new(_hab,_x,_y)
+    local world_x, world_y = coords.room_to_world(_hab,_x,_y)
+    return {
+        -- Venia de caco
+        name="imp",
+        hab=_hab,
+        x=world_x, y=world_y,
+        w=32, h=32,
+        flip=true,
+        frame=28,
+        wait=0,
+        step=0,
+        can_warp=true,
+        warping=false,
+        shrink=1,
+        d_shrink=1,
+        angle=0,
+        d_angle=15,
+        hit=imp.hit,
+        update=imp.update_normal,
+        draw=imp.draw,
+        jumpfwd=false,
+        dying=false,
+        death_time=40,
+        anim={28,29,28,30}, -- seqüencia de frames
+        bb={x=8,y=0,w=16,h=32},
+        enabled= true,
+        disable_reason="",
+        -- Ve de imp1
+        energia=21,
+        max_energia=21,
+        actions={no_action=0, up=1, down=2, left=4, right=8, jump=16, shot=32, super=64},
+        moods={stop=0, chase=1, avoid=2, neutral=4},
+        mood=0, --anterior fight_mode
+        timers={mood=150,target=150, shot=25, super=200, flip_wait=50}, --anterior *_cooldown
+        move_types={free=0, pattern=1, super=2},
+        move_type=1, -- anterior movement_type
+        paths={},           -- Llista de "camins" a fer des d'un hot_point
+        -- paths_active = 0, -- Número de path seleccionat
+        pattern={}, -- Instruccions per a moviment per patró, anterior path
+        pattern_point=1, -- anterior path_curr_action
+        target={}, -- Punt al que anar
+        shot_target=nil, -- a qui disparar
+        analisis = {}, -- memoria per a guardar el resultat de l'analisis
+        hot_points={},      -- llista de punts del mapa on anar
+        step_length=1,
+        falling = 0,
+        -- funcions
+        next_frame = imp.staying_next_frame, -- funcio de seleccio del frame
+        choose_mood = imp.choose_mood,
+        analyze_env = imp.analyze_env,
+        choose_target = imp.choose_target,
+        choose_action = imp.choose_action,
+        do_flip = imp.do_flip,
+        colisions = imp.colisions,
+        fight = imp.fight,
+        create_hot_points = imp.create_hot_points,
+        load_pattern_paths= imp.load_pattern_paths,
+        free_movement = imp.free_movement,
+        pattern_movement = imp.pattern_movement,
+        next_action = imp.next_action,
+        pattern_next_action = imp.pattern_next_action,
+        moure = imp.state_normal,
+        controller_input = imp.controller_input,
+        reduce_timers = imp.reduce_timers,
+        reset_mood_timer = imp.reset_mood_timer,
+        path_reset = imp.path_reset,
+        next_target = imp.next_target,
+        free_next_target = imp.free_next_target,
+        pattern_next_target = imp.pattern_next_target,
+        super_next_target = imp.super_next_target,
+        pattern_recovery = imp.pattern_recovery,
+        land = imp.land,
+        shot = imp.shot,
+        _moure=imp._moure, -- temporal debug
+        advance=imp.advance,
+        
+    }
+end
+
+function imp:draw() --OK
+    local scr_x, scr_y = viewp:screen_coords( self.x, self.y )
+
+    -- Modo super
+    if self.moure==self.state_super then
+        -- rotar paleta
+        for col=13,15 do
+            local newc = self.super_pal[col]
+            if self.super_wait%6 == 0 then
+                newc = newc+1
+                if newc>15 then newc=13 end
+            end
+            pal.subpal(col,newc)
+            self.super_pal[col]=newc
+        end
+        -- pintar
+        draw.surf(96, 32, self.w, self.h, 
+                  scr_x, scr_y-self.h*(self.zoom-1), 
+                  self.w*self.zoom, self.h*self.zoom, 
+                  self.flip)
+        -- restaurar paleta
+        for col=13,15 do pal.subpal(col) end
+    else
+    -- Modo normal
+        if self.invencible then
+            pal.subpal(5,1)
+        end
+        draw.surf((self.frame&7)*self.w, (self.frame>>cxr2)*self.h, self.w, self.h, scr_x, scr_y, self.w, self.h, self.flip)
+        pal.subpal(5)
+    end
+end
+
+function imp:hit() -- OK
+if DEBUG_FN_NAME then print("hit") end
+    if not self.invencible then
+        self.energia = self.energia -1
+        if distancia(self, abad)<50 and self.invencible_time<=0 then
+            self.invencible = true
+            self.invencible_time = 50
+        end
+    end
+    
+    if self.energia==1 then self.can_warp=true end
+    
+    if self.energia <= 0 then 
+        self.energia = 0
+        -- self.enabled = false
+        print("END BOSS")
+        
+        if self.can_warp then self.warping=true end
+        self.shrink=1
+        self.angle=0
+        self.dying=true
+        -- calcular velocitat per al warp
+        local warp_time = self.death_time/3
+        self.d_angle = 720 / warp_time; -- 720 = 2 voltes
+        self.d_shrink = self.shrink / warp_time
+    end
+end
+
+function imp:update_hit()
+    if not self.enabled then return end
+    -- Que pasa quan "mor"
+end
+
+function imp:update_normal()
+    self:reduce_timers()
+    
+    -- Ajustar mood (emocions)
+    self:choose_mood()
+    
+    -- analisis
+    self:analyze_env()
+    
+    -- decisio
+    self:choose_target()
+    self:choose_action()
+    
+    -- moviment
+    self:controller_input()
+    self:moure()
+    
+    -- Logica per a selecció de frame
+    self:next_frame()
+    
+    -- colisions en personatges
+    self:colisions()
+end
+
+-- imp.next_frame()
+function imp:walking_next_frame()
+    -- Selecció de frame
+    if self.wait==6 then
+        self.wait=0
+        self.step=(self.step+1)%4
+        self.frame=self.anim[self.step+1]
+    end
+    
+    -- Orientar
+    self:do_flip()
+    
+    -- Aguantar el flip
+    if self.timers.flip_wait<=0 then 
+        if self.mood==self.moods.chase then
+            self:do_flip(abad)
+        else
+            self:do_flip(self.target)
+        end
+    end
+end
+
+function imp:jumping_next_frame()
+    self.frame=30
+end
+
+function imp:falling_next_frame()
+    self.frame=30
+end
+
+function imp:staying_next_frame()
+    self.frame=28
+end
+
+function imp:super_next_frame()
+    self.frame=11
+end
+-- /imp.next_frame()
+
+
+-- imp.move()
+function walking_move()
+    -- comprovar colsions en l'entorn en cas de moure
+    
+    -- moure el personatge
+end
+
+function jumping_move()
+
+end
+
+function falling_move()
+
+end
+
+function staying_move()
+
+end
+
+function super_move()
+
+end
+-- /imp.move()
+
+function imp:do_flip( actor )
+    actor = actor or self.target
+    -- enllaçat a actor
+    if actor.x<self.x then self.flip=true else self.flip=false end
+end
+
+function imp:colisions()
+    if empty_table(self.target) then return end
+    if collision(self, self.target) then 
+    end
+end
+
+function imp:analyze_env() --OK
+    if self.mood==self.moods.stop then return end
+if DEBUG_FN_NAME then print("analyze_env") end
+    -- Distancia fins a l'abad
+    local r = distancia(self,abad)
+    -- msg_print(10,20,r,true)
+    self.analisis.can_chase_abad = false
+    if r<=100 then 
+        self.analisis.can_chase_abad=true 
+    end
+    
+    -- Els dos punts de cintura per a saber si es pot escalar
+    local x1_check = self.x+self.bb.x
+    local x2_check = self.x+self.bb.x+self.bb.w
+    local y_check  = self.y+self.bb.h-4
+    local tile_type1, tile_code1= arc_check_tile(x1_check,y_check)
+    local tile_type2, tile_code2= arc_check_tile(x2_check,y_check)
+    self.analisis.can_climb = false
+    if tile_type1~=tiletype.void or tile_type2~=tiletype.void then
+        self.analisis.can_climb = true
+    end
+    
+    -- Abad a tir
+    self.analisis.can_shot = false
+    if h_collision(self,abad) then self.analisis.can_shot=true end
+    
+    -- Super preparat
+    self.analisis.can_super = false
+    if self.timers.super<=0 then self.analisis.can_super=true end
+    
+    -- Acces a la zona central (només si el super està preparat)
+    x1_check = self.x+self.bb.x
+    x2_check = self.x+self.bb.x+self.bb.w
+    y_check  = self.y+self.bb.h
+    self.analisis.can_go_altar = false
+    local hab1, tx1, ty1 = coords.world_to_tile(x1_check, y_check)
+    local hab2, tx2, ty2 = coords.world_to_tile(x2_check, y_check)
+    if (hab1==44 and tx1==6 and ty1==4) or (hab2==44 and tx2==7 and ty2==4)
+       or (hab1==45 and tx1==7 and ty1==3) or (hab2==45 and tx2==8 and ty2==3)then
+        if self.analisis.can_super then self.analisis.can_go_altar = true end
+    end
+
+    -- Cau al següent moviment?
+    self.analisis.going_to_fall = false
+    local step_length = self.step_length
+    if self.movement==self.actions.left then step_length = -step_length end
+    local tile_type1, tile_code1= arc_check_tile(x1_check+self.step_length,y_check)
+    local tile_type2, tile_code2= arc_check_tile(x2_check+self.step_length,y_check)
+    if tile_type1==tiletype.void and tile_type2==tiletype.void then
+        self.analisis.going_to_fall = true
+    end
+    
+    -- Ha arribat a destí
+    self.analisis.target_reached = false
+    if not empty_table(self.target) then
+        -- Target reached
+        if collision(self, self.target) then self.analisis.target_reached=true end
+    end
+end
+
+
+-- ///////////////////////////////////////////////////////////
+
+function imp:path_reset() --OK
+if DEBUG_FN_NAME then print("path_reset") end
+    self.path={}
+    self.path_point=0;
+end
+
+function imp:reset_target_timer( value ) -- OK
+if DEBUG_FN_NAME then print("reset_target_timer") end
+    value = value or 150
+    self.timers.target = value
+    return value
+end
+
+function imp:pattern_get_next_path()
+if DEBUG_FN_NAME then print("pattern_get_next_path") end
+    -- obtindre uno dels possibles camins des del target en el que està
+    -- Si el camí s'ha acabat estarà en el punt self.path.target
+    local next_path_idx = math.random(#self.paths[self.path.target])
+        
+    self.path = self.paths[self.path.target][next_path_idx]
+    self.path_point = 1
+end
+
+function imp:create_hot_points() --OK
+    self.hot_points[1] = point.new(44, 5, 1,  0, 8,"P1")
+    self.hot_points[2] = point.new(45, 8, 1,  0, 8,"P2")
+    self.hot_points[3] = point.new(44,12, 5,  8, 0,"P3")
+    self.hot_points[4] = point.new(54, 5, 4, -8, 0,"P4")
+    self.hot_points[5] = point.new(54,12, 4,  8, 0,"P5")
+    self.hot_points[6] = point.new(55, 8, 4,  8, 0,"P6")
+    self.hot_points[7] = point.new(55, 8, 0,  0, 0,"P7")
+    self.hot_points[8] = point.new(54, 5, 0,  0, 0,"P8")
+    self.hot_points[9] = point.new(54, 9, 1,  0, 0,"P9")
+    self.hot_points[10] = point.new(55,4, 1, 0, 0,"P10")
+    -- self.hot_points[11] = abad
+    -- self.hot_points[11] = point.new(45, 1, 5, 8, 0,"altar-R")
+    -- self.hot_points[12] = point.new(44,11, 5, 0, 0,"altar-L")
+end
+
+function imp:load_pattern_paths() --OK
+    self.paths[1] = { 
+        {target=3, actions= {{action="right"  , event="prefall"},
+                           {action="jumpfwd", event="land"},
+                           {action="right"  , event="target"}}},
+        {target=4, actions= {{action="right"  , event="land"},
+                           {action="left"   , event="target"}}},
+        {target=4, actions= {{action="right"  , event="prefall"},
+                            {action="jumpfwd", event="land"},
+                            {action="left"   , event="target"}}},
+        {target=10, actions= {{action="right" , event="prefall"},
+                           {action="jumpfwd", event="land"},
+                           {action="right"  , event="target"}}},
+        {target=6, actions= {{action="right"  , event="prefall"},
+                           {action="jumpfwd", event="land"},
+                           {action="right"  , event="target"}}},
+        {target=5, actions= {{action="right"  , event="prefall"},
+                           {action="jumpfwd", event="land"},
+                           {action="right"  , event="land"},
+                           {action="left"   , event="target"}}},
+        {target=5, actions= {{action="right"  , event="target"}}}
+    }
+    self.paths[2] = {
+        {target=3, actions= {{action="left"   , event="prefall"},
+                           {action="jumpfwd", event="land"},
+                           {action="left"   , event="target"}}},
+        {target=6, actions= {{action="left"   , event="land"},
+                           {action="right"  , event="target"}}},
+        {target=6, actions= {{action="left"   , event="prefall"},
+                           {action="jumpfwd", event="land"},
+                           {action="right"  , event="target"}}},
+        {target=9, actions= {{action="left"   , event="prefall"},
+                           {action="jumpfwd", event="land"},
+                           {action="left"   , event="target"}}},
+        {target=4, actions= {{action="left"   , event="prefall"},
+                           {action="jumpfwd", event="land"},
+                           {action="left"   , event="target"}}},
+        {target=5, actions= {{action="left"   , event="prefall"},
+                           {action="jumpfwd", event="land"},
+                           {action="left"   , event="land"},
+                           {action="right"  , event="target"}}},
+        {target=5, actions= {{action="left"   , event="target"}}}
+    }
+    self.paths[3] = {
+        {target=1, actions={{action="left"   , event="prefall"},
+                          {action="jumpfwd", event="land"},
+                          {action="left"   , event="prefall"},
+                          {action="jump"   , event="target"}}},
+        {target=2, actions={{action="right"  , event="prefall"},
+                          {action="jumpfwd", event="land"},
+                          {action="right"  , event="prefall"},
+                          {action="jump"   , event="target"}}},
+        {target=4, actions={{action="left"   , event="prefall"},
+                          {action="jumpfwd", event="land"},
+                          {action="right"  , event="land"},
+                          {action="left"   , event="target"}}},
+        {target=5, actions={{action="left"   , event="land"},
+                          {action="right"  , event="target"}}},
+        {target=6, actions={{action="left"   , event="land"},
+                          {action="right"  , event="target"}}}
+    }
+    self.paths[4] = {
+        {target=1, actions={{action="jump" , event="target"}}},
+        {target=5, actions={{action="right", event="target"}}},
+        {target=6, actions={{action="right", event="target"}}},
+        {target=8, actions={{action="jump" , event="target"}}},
+    }
+    self.paths[5] = {
+        {target=4, actions={{action="left" , event="target"}}},
+        {target=6, actions={{action="right", event="target"}}}
+    }
+    self.paths[6] = {
+        {target=2, actions={{action="jump", event="target"}}},
+        {target=5, actions={{action="left", event="target"}}},
+        {target=7, actions={{action="jump", event="target"}}},
+        {target=4, actions={{action="left", event="target"}}}
+    }
+    self.paths[7] = {
+        {target=5, actions={{action="left"   , event="prefall"},
+                          {action="jumpfwd", event="land"},
+                          {action="left"   , event="target"}}},
+        {target=10,actions={{action="left"   , event="prefall"},
+                          {action="jumpfwd", event="land"},
+                          {action="left"   , event="target"}}},
+        {target=2, actions={{action="jump"   , event="target"}}}
+    }
+    self.paths[8] = {
+        {target=5, actions={{action="right"   , event="prefall"},
+                         {action="jumpfwd" , event="land"},
+                         {action="right"   , event="target"}}},
+        {target=9, actions={{action="right"   , event="prefall"},
+                          {action="jumpfwd" , event="land"},
+                          {action="right"   , event="target"}}},
+        {target=1, actions={{action="jump"    , event="target"}}}
+    }
+    self.paths[9] = {
+        {target=5, actions={{action="right"   , event="target"}}},
+        {target=1, actions={{action="left"   , event="prefall"},
+                          {action="jumpfwd" , event="land"},
+                          {action="left"   , event="prefall"},
+                          {action="jump"    , event="target"}}},
+        {target=4, actions={{action="left"    , event="target"}}}
+    }
+    self.paths[10] = {
+        {target=5, actions={{action="left"    , event="target"}}},
+        {target=2, actions={{action="right"    , event="prefall"},
+                          {action="jumpfwd" , event="land"},
+                          {action="right"    , event="prefall"},
+                          {action="jump"    , event="target"}}},
+        {target=6, actions={{action="right"   , event="target"}}}
+    }
+    self.paths[11] = {
+        {target=4, actions={{action="left", event="target"}}}
+    }
+    self.paths[12] = {
+        {target=6, actions={{action="right", event="target"}}}
+    }
+
+end
+
+function imp:fight() -- OK
+if DEBUG_FN_NAME then print("fight") end
+    self:create_hot_points()
+    self:load_pattern_paths()
+    
+    self.target = self.hot_points[6]
+    self.pattern = {next=6, actions={{action="right",event="target"}}}
+
+    self.shot_target = abad
+
+    self.mood=self.moods.chase
+    self:pattern_movement()
+end
+
+function imp:reduce_timers()
+    if self.mood==self.moods.stop then return end
+if DEBUG_FN_NAME then print("reduce_timers") end
+    
+    for key, val in pairs(self.timers) do
+        self.timers[key] = val - 1
+        if (val-1)<0 then self.timers[key] = 0 end
+    end
+end
+
+function imp:shot(actor)
+if DEBUG_FN_NAME then print("shot") end
+    -- self.fight_mode = self.fight_modes["shot"]
+    -- self:reset_fight_mode_cooldown(1)
+    self:do_flip(abad)
+    self.flip_wait=100
+    -- print("FIREBALL!!")
+    
+    local flip = false
+    local x_ini = self.x+self.bb.x+self.bb.w+4
+    if self.x>abad.x then 
+        flip=true 
+        x_ini = self.x-4
+    end
+    local hab, tx, ty, off_x, off_y = coords.world_to_tile(x_ini,self.y+(self.h/4))
+    fireball.init(hab, tx, ty, flip, off_x, off_y)
+    sound.play(audio_hit)
+    
+    self.shot_cooldown = 100
+end
+
+-- function imp:actualitzar_comportament()
+-- if DEBUG_FN_NAME then print("actualitzar_comportament") end
+--     self:reduce_cooldown()
+--     if self.invencible_time<=0 then self.invencible=false end
+--     -- if self.update==imp.state_jumping or self.update==imp.state_falling then
+--     --     -- self:think()
+--     --     -- self:move()
+--     -- end
+--     self:analyze_env()
+--     if self.moure==imp.state_walking or self.update==imp.state_normal then
+--         self:move()
+--     end
+--     self:controller_input() 
+-- end
+
+require "imp_mood"
+require "imp_action"
+require "imp_target"
+require "imp_movement"
+require "imp_states"
+require "imp_super"

data/imp_action.lua

@@ -0,0 +1,162 @@
+
+function imp:choose_action() -- antic imp:move
+    if self.mood==self.moods.stop then return self.mood end
+if DEBUG_FN_NAME then print("choose_action "..self.mood) end
+    local next_action = self.actions.no_action
+
+    -- Si no te ganes de fer res, no moure
+    if self.mood==self.moods.stop then return self.actions.no_action end
+
+    if self.analisis.going_to_fall  then self.action_event="prefall" end
+    if self.analisis.target_reached then self.action_event="target" end
+    if self.analisis.can_go_altar   then self:super_ready() end
+    -- if self.fight_mode == self.fight_modes["super"]     then self.action_event="super" end
+    -- if self.fight_mode == self.fight_modes["end_super"] then self.action_event="end_super" end
+
+    next_action = self:next_action()
+    
+    if self.analisis.target_reached and next_action=="super" then
+        -- print("Super READY!")
+        self.action_event = "super_ready"
+        -- next_action = self:next_action()
+        self:super()
+    end
+    
+    if self.old_action~=next_action then 
+        self.old_action=next_action
+        -- print(self.old_action)
+    end
+    
+    self.action = next_action
+
+    return next_action
+end
+
+function imp:next_action()
+    local next_action = self.actions.no_action
+    
+    -- Si el blanc està a tir
+    if self.timers.shot<=0 then
+        if h_collision(self, self.shot_target) then
+            next_action = self.actions.shot
+        end
+    end
+
+    if next_action==self.actions.no_action then
+        if self.move_type==self.move_types.free then
+            -- msg_print(10,20,"FREE",true)
+            next_action = self:free_next_action()
+        elseif self.move_type==self.move_types.pattern then
+            -- msg_print(10,20,"PATTERN "..self.action_event,true)
+            next_action=self:pattern_next_action()
+        elseif self.move_type==self.move_types.super then
+            -- msg_print(10,20,"SUPER "..self.action_event,true)
+        end
+    end
+
+    return next_action
+end
+
+function imp:free_next_action()
+if DEBUG_FN_NAME then print("free_next_action") end
+    -- Moviment horitzontal
+    if self.target.x+self.target.bb.x>=self.x+self.bb.x then
+        action="right"
+    elseif self.target.x+self.target.bb.x<self.x+self.bb.x then
+        action="left"
+    end
+    
+    -- Els dos punts de baix pero un poc mes alt que el piso
+    local x1_check = self.x+self.bb.x
+    local x2_check = self.x+self.bb.x+self.bb.w
+    local y_check  = self.y+self.bb.h-4
+    -- Tiles on esta
+    local tile_type1, tile_code1= arc_check_tile(x1_check,y_check)
+    local tile_type2, tile_code2= arc_check_tile(x2_check,y_check)
+    
+    -- debug
+    local scr_x1, scr_y = viewp:screen_coords( x1_check, y_check )
+    local scr_x2, scr_y = viewp:screen_coords( x2_check, y_check )
+    draw.rect(scr_x1,scr_y,scr_x2-scr_x1,8,2)
+    -- /debug
+    
+    --Comprovar si está en target
+    if collision(self, self.target) then 
+        self:reset_mood_timer()
+
+        -- Buscar quin es el target
+        local idx = 1
+        for i=1,#self.hot_points do
+            if self.target==self.hot_points[i] then 
+                idx= i 
+                -- print("TARGET ID= "..self.target.id.." HOT POINT IDX= "..i.." Reached")
+            end
+        end
+        
+        -- Canviar a moviment per patro
+        self.path={next=idx, actions={}}
+        action = self:path_next_action()
+    -- elseif half_collision(self, self.target) 
+    --        and tile_type1==tiletype.void  
+    --        and tile_type2==tiletype.void then -- and (self.y>self.target.y or self.y<self.target.y) ) then -- afegir que no hi haja tile per a escalar 
+    --     -- print("Next Target 2 "..tile_type1.." "..tile_code1)
+    -- elseif tile_type1~=tiletype.void 
+    --        or tile_type2~=tiletype.void then
+    --     action="jump"
+    end
+    
+    return action
+end
+
+function imp:pattern_next_action()
+if DEBUG_FN_NAME then print("pattern_next_action") end
+    local pattern_event = self.pattern.actions[self.pattern_point].event
+
+    -- Si no s'ha donat l'event mantindre el moviment
+    if self.action_event~=pattern_event then
+        action = self.actions[self.pattern.actions[self.pattern_point].action]
+    else
+    -- Si s'ha donat l'event avançar el punter del path
+        -- Si no queden accions carregar el següent path
+        if self.pattern_point<#self.pattern.actions then 
+            self:pattern_get_next_path() 
+            self.pattern_point = 0
+        end
+        
+        -- En el path
+        self.pattern_point = self.pattern_point + 1
+        action = self:pattern_action()
+    end
+    self.action_event = ""; -- Action_event processat
+    return action
+end
+
+function imp:pattern_action()
+if DEBUG_FN_NAME then print("pattern_action") end
+    return self.actions[self.path.actions[self.pattern_point].action]
+end
+
+
+
+function imp:_moure( foo, name )
+    name = name or "anonymous"
+    print("_moure= "..name)
+    self.moure = foo
+end
+
+
+
+
+-- function imp:path_next_action()
+-- if not DEBUG_FN_NAME then print("path_next_action "..from) end
+--     if #self.paths[self.path.target]>0 then
+--         -- self:pattern_movement()
+--         self:reset_target_timer()
+--         self:next_target()
+--         action = self:path_action()
+--     else
+--         action = self:pattern_recovery()
+--         print("PNA Recovery "..action)
+--     end
+--     return action
+-- end

data/imp_mood.lua

@@ -0,0 +1,14 @@
+function imp:choose_mood()
+    if self.mood==self.moods.stop then return end
+    if self.timers.mood<=0 then
+        self.mood=self.moods[math.random(2)+1] -- chase o avoid
+        self:reset_mood_timer()
+    end
+end
+
+function imp:reset_mood_timer( value ) -- OK
+if DEBUG_FN_NAME then print("reset_mood_timer") end
+    value = value or 150
+    self.timers.mood = value
+    return value
+end

data/imp_movement.lua

@@ -0,0 +1,98 @@
+-------------------------------------------------------------------
+-- // FREE MOVEMENT
+
+function imp:free_movement() --OK
+if DEBUG_FN_NAME then print("free_movement") end
+    self.move_type = self.move_types.free
+    print("Free")
+end
+
+-------------------------------------------------------------------
+-- // PATTERN MOVEMENT
+
+function imp:pattern_movement() --OK
+if DEBUG_FN_NAME then print("pattern_movement") end
+    self.movement_type = "pattern"
+    -- print("Pattern")
+end
+
+function imp:pattern_recovery() -- OK
+-- print("Pattern recovery")
+    self:pattern_movement() -- Canviar a moviment per patró
+    self:path_reset()       -- Borrar les instruccions pendents
+    
+    -- Situar-se en el mapa respecte als punts de recuperació (els tres punts del pis)
+    local x_after_4 = false
+    local x_after_5 = false
+    local x_after_6 = false
+    local y_upper_4 = false
+    local y_upper_5 = false
+    local y_upper_6 = false
+    
+    if self.hot_points[4].x<self.x then x_after_4 = true end
+    if self.hot_points[5].x<self.x then x_after_5 = true end
+    if self.hot_points[6].x<self.x then x_after_6 = true end
+    -- Comparar en el punt dels peus
+    if self.hot_points[4].y>self.y+self.h then y_upper_4 = true end
+    if self.hot_points[5].y>self.y+self.h then y_upper_5 = true end
+    if self.hot_points[6].y>self.y+self.h then y_upper_6 = true end
+
+    -- Seleccionar les instruccions segons la posicio
+    if not y_upper_5 then
+        -- target 5
+        self.target = self.hot_points[5]
+        if not x_after_5 then
+            -- right target
+            self.path = {next=5, actions={{action="right",event="target"}}}
+        else
+            -- left target
+            self.path = {next=5, actions={{action="left",event="target"}}}
+        end
+    else
+        if x_after_5 then
+            --target 4
+            self.target = self.hot_points[4]
+            -- left target
+            self.path = {next=4, actions={{action="left",event="target"}}}
+        else
+            --target 6
+            self.target = self.hot_points[6]
+            -- right target
+            self.path = {next=6, actions={{action="right",event="target"}}}
+        end
+    end
+    
+    -- Tornar l'acció a fer
+    return self.actions[self.path.actions[1].action]
+end
+
+function imp:pattern_next_target()
+if DEBUG_FN_NAME then print("pattern_next_target") end
+    self.target = self.hot_points[self.path.next]
+end
+
+-------------------------------
+-- imp.controller_input()
+--
+-- Traduir a una entrada de pad
+-------------------------------
+function imp:controller_input()
+if DEBUG_FN_NAME then print("controller_input") end
+
+print(self.action)
+--To Do: JumpFWD
+    if self.action == self.actions.right or self.action == self.actions.left then
+        self.movement = self.action
+        -- self.moure=imp.state_walking
+        self:_moure(imp.state_walking, "state_walking (movement)")
+    elseif self.action == self.actions.jump then
+        -- self:do_jump()
+    elseif self.action == "jumpfwd" then
+        -- self:do_jump(true)
+    elseif self.action == self.actions.shot then
+        -- self:shot()
+    elseif self.action == self.actions.super then
+        -- self.moure=imp.state_super
+    end
+    self.action = self.actions.no_action
+end

data/imp_states.lua

@@ -0,0 +1,203 @@
+function imp:do_jump ( jumpfwd )
+if DEBUG_FN_NAME then print("do_jump") end
+-- msg_print(0,0,"do_jump",true)
+    -- Inicialització de fer el salt
+    jumpfwd = jumpfwd or false
+    self.jump_height = 0
+    -- self.moure=imp.state_jumping
+    self:_moure(imp.state_jumping,"state_jumping (states)")
+    self.step=0
+    self.jumpfwd=jumpfwd
+    self.action=""
+end
+
+function imp:state_jumping()
+    if self.mood==self.moods.stop then return self.mood end
+if DEBUG_FN_NAME then print("state_jumping") end
+    -- msg_print(0,0,"state_jumping",true)
+    -- ??
+    self.wait=self.wait+1
+    self.wait=0
+
+    -- Pujar o caure
+    if self.jump_height<self.max_jump_height then
+        -- Comprovar que pasa en l'aire
+        self:jump()
+    else
+        -- Canviar a mode caure
+        -- self.moure=imp.state_falling
+        self:_moure(imp.state_falling,"state_falling (states)")
+    end
+    self.step=self.step+1
+
+    -- cap endavant?
+    if self.jumpfwd then self:advance() end
+end
+
+function imp:jump()
+if DEBUG_FN_NAME then print("jump") end
+-- msg_print(0,0,"jump",true)
+    local vspace = self.vmove_space
+    -- Els dos punts de dalt del personatge
+    local x1_check = self.x+self.bb.x
+    local x2_check = self.x+self.bb.x+self.bb.w
+    local y_check = self.y-vspace; -- posicio de dalt
+    
+    -- Comprovar on està pegant
+    local tile1_hit_type= arc_check_tile(x1_check, y_check )
+    local tile2_hit_type= arc_check_tile(x2_check, y_check)
+    local not_block_tile = tile1_hit_type ~= tiletype.block and tile2_hit_type ~= tiletype.block
+    
+    -- Fer l'acció que correspon
+    if not_block_tile then
+        -- Ascendir
+        self.y=self.y-vspace
+    else
+        -- Si es un bloc permetre gastar l'espai no pintat
+        local tile1_hit = arc_get_tile(x1_check, y_check )
+        local tile2_hit = arc_get_tile(x2_check, y_check)
+        local half_block1 = mapa_is_half_block_tile(map_to_editor_tile(tile1_hit))
+        local half_block2 = mapa_is_half_block_tile(map_to_editor_tile(tile2_hit))
+        local full_block1 = tile1_hit_type == tiletype.block and not half_block1
+        local full_block2 = tile2_hit_type == tiletype.block and not half_block2
+        local full_block = full_block1 and full_block2
+        local half_block = half_block1 or half_block2
+        -- Si ninguno dels tiles tocats es un block complet
+        -- i almenys un dels tiles tocats es mig tile
+        -- permetre continuar en el salt
+        if not full_block and half_block then
+            if self.jump_in_half_block==0 and not self.jump_in_half_block_used then
+                self.jump_in_half_block = arcade_config.tiles_height / 2
+            end
+            if self.jump_in_half_block>0 then
+                self.y=self.y-vspace
+                self.jump_in_half_block = self.jump_in_half_block-1
+                self.jump_in_half_block_used = true
+            end
+        end
+    end
+    
+    -- Registrar el desplaçament
+    self.jump_height = self.jump_height+1
+end
+
+function imp:state_walking()
+    if self.mood==self.moods.stop then return end
+if not DEBUG_FN_NAME then print("state_walking") end
+-- msg_print(16,48,"state_walking",true)
+
+    -- Limitar la velocitat de moviment
+    self.wait=self.wait+1
+    
+    -- Funció de selecció de frame
+    self.next_frame = imp.walking_next_frame
+    
+    -- Comprovar dos punts de contacte del personatge en el piso a vore si cau
+    local x1_check = self.x+self.bb.x
+    local x2_check = x1_check+self.bb.w
+    local y_check = self.y+self.bb.h; -- base del personatge
+    local tile1 = arc_check_tile(x1_check,y_check)
+    local tile2 = arc_check_tile(x2_check,y_check)
+    if tile1==tiletype.void and tile2==tiletype.void then
+        -- si no hi ha piso, caure
+        -- self.moure=imp.state_falling
+        self:_moure(imp.state_falling, "state_falling (states)")
+        return
+    end
+    
+    self:advance()
+end
+
+function imp:state_falling()
+if DEBUG_FN_NAME then print("state_falling") end
+-- msg_print(16,16,"state_falling",true)
+
+    self.frame=30
+    self.wait=self.wait+1
+    
+    -- Si toca terra canviar el mode
+    if self:land() then
+        -- self.moure=imp.state_normal
+        self:_moure(imp.state_normal,"state_normal (states)")
+        return
+    end    
+    
+    -- Seguir caiguent
+    self.y=self.y+1
+    self.jump_height = self.jump_height-1
+    self.falling=self.falling+1
+    
+    -- Caiguent cap endavant?
+    if self.jumpfwd then self:advance() end
+end
+
+function imp:land ()
+if DEBUG_FN_NAME then print("land") end
+-- msg_print(16,32,"land",true)
+    -- Els dos punts de baix de l'abad
+    local x1_check = self.x+self.bb.x
+    local x2_check = self.x+self.bb.x+self.bb.w
+    local y_check = self.y+self.bb.h
+    
+    -- Comprovar on està aterrant
+    local tile1_hit= arc_check_tile(x1_check, y_check )
+    local tile2_hit= arc_check_tile(x2_check, y_check)
+    local floor_tile = tile1_hit>=tiletype.half or tile2_hit>=tiletype.half
+    
+    -- Encara que siga un tile de piso s'ha de comprovar que 
+    -- la y es un múltiple de l'alt dels tiles
+    local over_tile = (y_check & 0xF) == 0 
+    
+    local can_land = floor_tile and over_tile
+    
+    if can_land then
+        self.jump_in_half_block_used = false
+        self.jump_height = 0
+        self.action_event = "land"
+    end
+    
+    return can_land
+end
+
+function imp:advance()
+if DEBUG_FN_NAME then print("advance") end
+-- msg_print(10,20,"advance",true)
+    local step_length=self.step_length; --lo que avança el imp cada pas
+    local limit=tiletype.block
+    
+    if self.moure~=imp.state_walking then limit=tiletype.half end
+
+    local x_check = self.x+self.bb.x+self.bb.w+step_length
+    -- if self.flip then 
+        -- step_length = -step_length 
+        -- x_check = self.x+self.bb.x+step_length
+    -- end
+    
+    -- self.action=="right"
+    -- if self.action=="left" then
+-- print("ADVANCE => "..self.movement)
+    if self.movement==self.actions.left then 
+        step_length = -step_length 
+        x_check = self.x+self.bb.x+step_length
+    end
+    
+    local y_check = self.y+self.bb.h-4
+    
+    if arc_check_tile(x_check, y_check)<limit then
+        self.x=self.x+step_length
+    end
+
+    local hab,xx, yy = coords.world_to_tile(self.x, self.y)
+    self.hab = hab
+    -- self.movement = ""
+end
+
+-- Controlador principal del personatge
+function imp:state_normal()
+if DEBUG_FN_NAME then print("state_normal") end
+    self.frame=28
+    self.wait=0
+    self.step=0
+    self.jumpfwd=false
+    self.jump_height = 0
+end

data/imp_super.lua

@@ -0,0 +1,74 @@
+function imp:super_ready()
+if not DEBUG_FN_NAME then print("super_ready()") end
+    if self.x<self.hot_points[3].x then
+        self.target = self.hot_points[3]
+        self.path = {next=3, actions= {{action="jumpfwd", event="land"},
+                                      {action="right"  , event="target"},
+                                      {action="super"  , event="super_ready"}}}
+    end
+    --if self.x<self.hot_points[3].x then
+    --    self.target = self.hot_points[11]
+    --    self.path = {next=11, actions= {{action="jumpfwd", event="land"},
+    --                                   {action="right"  , event="target"},
+    --                                   {action="super"  , event="super_ready"}}}
+    --else 
+    --    self.target = self.hot_points[12]
+    --    self.path = {next=12, actions= {{action="jumpfwd", event="land"},
+    --                                   {action="left"   , event="target"},
+    --                                   {action="super"  , event="super_ready"}}}
+    --end
+end
+
+function imp:super()
+if not DEBUG_FN_NAME then print("super()") end
+    self:super_movement()
+    -- self.fight_mode = self.fight_modes["super"]
+    self.invencible = true
+    self.update=self.state_super
+end
+
+function imp:state_super()
+if DEBUG_FN_NAME then print("state_super") end
+    self.super_wait = self.super_wait -1
+    if self.zoom<1.75 and self.super_wait>100 then
+        if self.super_wait%4==0 then self.zoom=self.zoom+0.1 end
+    elseif not self.super_fired and self.zoom>=1.75 and self.super_wait>100 then
+        local x_ini = self.x+self.bb.x+self.bb.w+4
+        local hab, tx, ty, off_x, off_y = coords.world_to_tile(x_ini,self.y+(self.h/2))
+        fireball.init(hab, tx, ty, false, off_x, off_y, 2)
+        self.super_fired = true
+    elseif self.zoom>1 and self.super_wait<=100 then
+        if self.super_wait%4==0 then self.zoom=self.zoom-0.1 end
+    end
+    if self.super_wait == 0 then
+        self.update=imp.super_end
+    end
+end
+
+function imp:super_end()
+    print("super_end()")
+    self.zoom = 1
+    self.super_wait = 200
+    -- self.super_cooldown=2000
+    self.super_cooldown=200
+    self:reset_fight_mode_cooldown()
+    self.invencible = false
+    self.super_fired = false
+    self:free_movement()
+    self.update=imp.state_normal
+end
+
+function imp:super_movement()
+if DEBUG_FN_NAME then print("super_movement") end
+    self.movement_type = "super"
+
+    print("Super")
+end
+
+function imp:super_next_action()
+    print("Super Next Action")
+end
+
+function imp:super_next_target()
+    print("Super Next Target")
+end

data/imp_target.lua

@@ -0,0 +1,43 @@
+
+function imp:choose_target()
+    -- Si no te ganes de fer res, no moure
+    if self.mood==self.moods.stop then return end
+    -- S'ha acabat el temps per a arribar a un target
+    if self.timers.target <= 0 then
+        -- Canviar a moviment lliure
+        self:free_movement()
+        
+        -- Reinicialitzar el patró de moviment i el cooldown
+        self:reset_mood_timer()
+        self:path_reset()
+        
+        -- Seleccionar el següent target
+        self:next_target()
+    end
+end
+
+function imp:next_target()
+    if self.move_type==self.move_types.free then
+        self:free_next_target()
+    elseif self.move_type==self.move_types.pattern then
+        self:pattern_next_target()
+    elseif self.move_type==self.move_types.super then
+        self:super_next_target()
+    end
+end
+
+function imp:free_next_target() --OK
+if DEBUG_FN_NAME then print("free_next_target") end
+    
+    ---- Abans se seleccionava un target aleatoriament ...
+    
+    -- local new_point = math.random(#self.hot_points)
+    -- if self.target == self.hot_points[new_point] then 
+    --     new_point = ((new_point+1)%#self.hot_points)+1 
+    -- end
+    -- self.old_target = self.target
+    -- self.target=self.hot_points[new_point]
+    
+    ---- ... ara s'intenta tornar al moviment per patró
+    self:pattern_recovery()
+end

data/main.lua

@@ -87,7 +87,8 @@ function mini.init()
     logo_config(font_sf)
     surf.target(0)
     surf.cls(16)
-    
+    local a = 1 | 2
+    print(a)
     flow:executar("game")
 end
 

data/trigger.lua

@@ -57,7 +57,7 @@ function trigger:draw()
     end
        
     -- debug rect
-    draw.rect(scr_x,scr_y,self.bb.w,self.bb.h,3)
+    -- draw.rect(scr_x,scr_y,self.bb.w,self.bb.h,3)
 end
 
 --function trigger:do_touched()

data/warp.lua

@@ -79,6 +79,11 @@ function warp.open(actor)
             w.x       = actor.x
             w.y       = actor.y
             w.actor   = actor
+            w.frame   = 0
+            w.wait    = 0
+            w.step    = 0
+            w.angle   = 0
+            w.d_angle = 5
             return e; -- reutilitzar
         end
     end