cxr2 = arcade_config.character_per_row_base2

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","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=6,
       max_energia=6,
       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
       shot_cooldown=500,        -- 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,
       flip_wait=100,      -- Temps per a forçar un flip 
       -- 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.state_super, -- Entra en mode 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
       
       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:fight()
if DEBUG_FN_NAME then print("fight") end
    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.target = self.hot_points[6]
    self.path = {next=6, actions={{action="right",event="target"}}}
    
    self.paths[1] = { 
        {next=3, actions= {{action="right"  , event="prefall"},
                           {action="jumpfwd", event="land"},
                           {action="right"  , event="target"}}},
        {next=4, actions= {{action="right"  , event="land"},
                           {action="left"   , event="target"}}},
        {next=4, actions= {{action="right"  , event="prefall"},
                            {action="jumpfwd", event="land"},
                            {action="left"   , event="target"}}},
        {next=10, actions= {{action="right" , event="prefall"},
                           {action="jumpfwd", event="land"},
                           {action="right"  , event="target"}}},
        {next=6, actions= {{action="right"  , event="prefall"},
                           {action="jumpfwd", event="land"},
                           {action="right"  , event="target"}}},
        {next=5, actions= {{action="right"  , event="prefall"},
                           {action="jumpfwd", event="land"},
                           {action="right"  , event="land"},
                           {action="left"   , event="target"}}},
        {next=5, actions= {{action="right"  , event="target"}}}
    }
    self.paths[2] = {
        {next=3, actions= {{action="left"   , event="prefall"},
                           {action="jumpfwd", event="land"},
                           {action="left"   , event="target"}}},
        {next=6, actions= {{action="left"   , event="land"},
                           {action="right"  , event="target"}}},
        {next=6, actions= {{action="left"   , event="prefall"},
                           {action="jumpfwd", event="land"},
                           {action="right"  , event="target"}}},
        {next=9, actions= {{action="left"   , event="prefall"},
                           {action="jumpfwd", event="land"},
                           {action="left"   , event="target"}}},
        {next=4, actions= {{action="left"   , event="prefall"},
                           {action="jumpfwd", event="land"},
                           {action="left"   , event="target"}}},
        {next=5, actions= {{action="left"   , event="prefall"},
                           {action="jumpfwd", event="land"},
                           {action="left"   , event="land"},
                           {action="right"  , event="target"}}},
        {next=5, actions= {{action="left"   , event="target"}}}
    }
    self.paths[3] = {
        {next=1, actions={{action="left"   , event="prefall"},
                          {action="jumpfwd", event="land"},
                          {action="left"   , event="prefall"},
                          {action="jump"   , event="target"}}},
        {next=2, actions={{action="right"  , event="prefall"},
                          {action="jumpfwd", event="land"},
                          {action="right"  , event="prefall"},
                          {action="jump"   , event="target"}}},
        {next=4, actions={{action="left"   , event="prefall"},
                          {action="jumpfwd", event="land"},
                          {action="right"  , event="land"},
                          {action="left"   , event="target"}}},
        {next=5, actions={{action="left"   , event="land"},
                          {action="right"  , event="target"}}},
        {next=6, actions={{action="left"   , event="land"},
                          {action="right"  , event="target"}}}
    }
    self.paths[4] = {
        {next=1, actions={{action="jump" , event="target"}}},
        {next=5, actions={{action="right", event="target"}}},
        {next=6, actions={{action="right", event="target"}}},
        {next=8, actions={{action="jump" , event="target"}}},
    }
    self.paths[5] = {
        {next=4, actions={{action="left" , event="target"}}},
        {next=6, actions={{action="right", event="target"}}}
    }
    self.paths[6] = {
        {next=2, actions={{action="jump", event="target"}}},
        --{next=5, actions={{action="left", event="target"}}},
        --{next=7, actions={{action="jump", event="target"}}},
        --{next=4, actions={{action="left", event="target"}}}
    }
    self.paths[7] = {
        {next=5, actions={{action="left"   , event="prefall"},
                          {action="jumpfwd", event="land"},
                          {action="left"   , event="target"}}},
        {next=10,actions={{action="left"   , event="prefall"},
                          {action="jumpfwd", event="land"},
                          {action="left"   , event="target"}}},
        {next=2, actions={{action="jump"   , event="target"}}}
    }
    self.paths[8] = {
        {next=5, actions={{action="right"   , event="prefall"},
                         {action="jumpfwd" , event="land"},
                         {action="right"   , event="target"}}},
        {next=9, actions={{action="right"   , event="prefall"},
                          {action="jumpfwd" , event="land"},
                          {action="right"   , event="target"}}},
        {next=1, actions={{action="jump"    , event="target"}}}
    }
    self.paths[9] = {
        {next=5, actions={{action="right"   , event="target"}}},
        {next=1, actions={{action="left"   , event="prefall"},
                          {action="jumpfwd" , event="land"},
                          {action="left"   , event="prefall"},
                          {action="jump"    , event="target"}}},
        {next=4, actions={{action="left"    , event="target"}}}
    }
    self.paths[10] = {
        {next=5, actions={{action="left"    , event="target"}}},
        {next=2, actions={{action="right"    , event="prefall"},
                          {action="jumpfwd" , event="land"},
                          {action="right"    , event="prefall"},
                          {action="jump"    , event="target"}}},
        {next=6, actions={{action="right"   , event="target"}}}
    }
    -- self.paths[11] = {}

    self.fight_mode="chase"
    self:pattern_movement()
end

function imp:draw()
    local scr_x, scr_y = viewp:screen_coords( self.x, self.y )
    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)
    draw.rect(scr_x+self.bb.x,scr_y+self.bb.y,self.bb.w,self.bb.h,3)
        
    if #self.hot_points>0 then
        for _, p in pairs(self.hot_points) do
            if self.target==p then
                p:draw(true)
            else
                p:draw()
            end
        end
    end
    
    -- print("DRAW path= "..#self.path)
    if #self.path>0 then
        for i=1,#self.path do
            local world_x, world_y = coords.room_to_world(self.path[i][1], self.path[i][2], self.path[i][3])
            local scr_x, scr_y = viewp:screen_coords( world_x, world_y )
            draw.rect(scr_x, scr_y, 16, 16, 14)
        end
    end
end

function imp:hit()
if DEBUG_FN_NAME then print("hit") end
end

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.update=imp.state_jumping
    self.step=0
    self.jumpfwd=jumpfwd
    self.action=""
end

function imp:state_jumping()
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.update=imp.state_falling
    end
    self.step=self.step+1

    -- cap endavant?
    if self.jumpfwd then self:advance() end
    
    self:actualitzar_comportament()
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 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
    
    -- representació del moviment
    -- 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
    
    -- 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.update=imp.state_falling
        return
    end
    
    self:advance()
    self:actualitzar_comportament()
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.update=imp.state_normal
        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
    self:actualitzar_comportament()
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(0,0,"advance",true)
    local step_length=self.step_length; --lo que avança el imp cada pas
    local limit=tiletype.block
    
    if self.update~=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=="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
    self:actualitzar_comportament()
end

function imp:state_super()
if DEBUG_FN_NAME then print("state_super") end
    self.fight_mode = self.fight_modes["super"]
    self:reset_fight_mode_cooldown(1)
    self.super_cooldown=2000
    self.update=imp.state_normal
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!!")
    self.shot_cooldown = 500
end

function imp:do_flip(actor)
if DEBUG_FN_NAME then print("do_flip") end
    if actor.x<self.x then self.flip=true else self.flip=false end
end

function imp:reduce_cooldown()
if DEBUG_FN_NAME then print("reduce_cooldown") end
    if self.fight_mode=="stop" then return end
    
    self.fight_mode_cooldown  = self.fight_mode_cooldown  -1
    self.super_cooldown = self.super_cooldown -1
    self.shot_cooldown = self.shot_cooldown -1
    self.flip_wait = self.flip_wait -1
end

function imp:reset_fight_mode_cooldown( value )
if DEBUG_FN_NAME then print("reset_fight_mode_cooldown") end
    value = value or 1500
    self.fight_mode_cooldown = value
    return value
end

function imp:path_reset()
if DEBUG_FN_NAME then print("path_reset") end
    self.path={}
    self.path_curr_action=1;
end

function imp:path_action()
if DEBUG_FN_NAME then print("path_action") end
    local action = self.path.actions[self.path_curr_action].action
    -- print("PATTERN");
    -- print("    TARGET= "..self.path.next)
    -- print("    ACTION= "..action)
    return action
end

function imp:pattern_movement()
if DEBUG_FN_NAME then print("pattern_movement") end
    self.movement_type = "pattern"

    -- print("Pattern")
end

function imp:pattern_next_action()
if DEBUG_FN_NAME then print("pattern_next_action") end
    local path_event = self.path.actions[self.path_curr_action].event
-- print("    PATH_EVENT= "..path_event)
-- print("    ACTION_EV = "..self.action_event)
    -- Si no s'ha donat l'event mantindre el moviment
    if self.action_event~=path_event then
        action = self.path.actions[self.path_curr_action].action
    else
    -- Si s'ha donat l'event avançar el punter del path
-- print("    #"..self.path_curr_action.." / "..#self.path.actions)
        if self.path_curr_action<#self.path.actions then
            -- En el path
            self.path_curr_action = self.path_curr_action + 1
-- print("    CURR_ACC= "..self.path_curr_action)
            action = self:path_action()
-- print("    ACTION 1= "..action)
        else
            -- Path acabat, anar al següent
            action = self:path_next_action()
-- print("    ACTION 2= "..action)
        end
    end
    self.action_event = ""; -- Action_event processat
-- print("    ACTION    ="..action)
    return action
end

function imp:pattern_next_target(from)
if DEBUG_FN_NAME then print("pattern_next_target") end
    -- obtindre uno dels possibles camins des del punt "from" (en el que està)
    local next_path_idx = math.random(#self.paths[from])
        
    self.path = self.paths[from][next_path_idx]
    self.path_curr_action = 1
    self.target = self.hot_points[self.path.next]
    print("Next pattern target => "..self.path.next)
end

function imp:path_next_action( from )
    from = from or self.path.next
if DEBUG_FN_NAME then print("path_next_action "..from) end
    if #self.paths[from]>0 then
        self:pattern_movement()
        self:reset_fight_mode_cooldown()
        -- Activar següent target
        self:next_target(from)
        action = self:path_action()
        -- self.action_event=""
    else
        -- self:free_movement()
        -- action = self:next_action()
        action = self:pattern_recovery()
    end
    return action
end

function imp:free_movement()
if DEBUG_FN_NAME then print("free_movement") end
    self.movement_type = "free"

    print("Free")
end

function imp:pattern_recovery()
    self:pattern_movement()
    self:path_reset()
    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
    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
    
    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
    return self.path.actions[1].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_fight_mode_cooldown()

        -- 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
        action = self:path_next_action(idx)
    -- 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:free_next_target()
if DEBUG_FN_NAME then print("free_next_target") end
    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]
end

function imp:analyze_env()
if DEBUG_FN_NAME then print("analyze_env") end
    -- Distancia fins els punts
    local scr_x, scr_y = viewp:screen_coords(self.x, self.y)
    -- for _, p in pairs(self.hot_points) do
    --     local scr_x1, scr_y1 = viewp:screen_coords(p.x, p.y)
    --     local color = 2
    --     if self.target == p then color = 4 end
    --     draw.line(scr_x, scr_y, scr_x1, scr_y1, color)
    --     
    --     dx = (self.x-p.x)
    --     dy = (self.y-p.y)
    --     d = math.sqrt(dx*dx+dy*dy)
    -- end
    
    -- Distancia fins a l'abad
    dx = (self.x-abad.x)
    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 
        -- draw.circ(scr_x+self.bb.w/2,scr_y+self.bb.h/2,r,2) 
        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.super_cooldown<=0 then self.analisis.can_super=true end
    
    -- Acces a la zona central
    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
        self.analisis.can_go_altar = true
    end

    -- Cau al següent moviment
    self.analisis.going_to_fall = false
    if self.movement=="left" then
        x1_check=x1_check-self.step_length
        x2_check=x2_check-self.step_length
    elseif self.movement=="right" then
        x1_check=x1_check+self.step_length
        x2_check=x2_check+self.step_length
    end
    local tile_type1, tile_code1= arc_check_tile(x1_check,y_check)
    local tile_type2, tile_code2= arc_check_tile(x2_check,y_check)
    if tile_type1==tiletype.void and tile_type2==tiletype.void then
        self.analisis.going_to_fall = true
    end
    
    self.analisis.target_reached = false
    -- local target_aligned = false
    -- self.path= {}
    -- -- print("ANALYZE => "..#self.target)
    if not empty_table(self.target) then
        -- Target reached
        if collision(self, self.target) then self.analisis.target_reached=true end
    --         
    --     -- Target aligned
    --     if half_collision(self, self.target) then target_aligned=true end
    -- 
    --     local hab1, tx1, ty1 = coords.world_to_tile(self.x+self.bb.x, self.y+self.bb.y+self.h/2)
    --     local hab2, tx2, ty2 = coords.world_to_tile(self.target.x, self.target.y)
    --     -- print(hab1..", "..tx1..", "..ty1)
    --     -- print(hab2..", "..tx2..", "..ty2)
    --     local floorImp    = math.floor(hab1 / 10)
    --     local floorTarget = math.floor(hab2 / 10)
    --     local roomImp     = hab1 % 10
    --     local roomTarget  = hab2 % 10
    --     
    --     local sentit_y = 1
    --     if floorImp>floorTarget then 
    --         sentit_y = -1 
    --     elseif floorImp==floorTarget then
    --         sentit_y = 1
    --         if ty1>ty2 then 
    --             sentit_y= -1 
    --         elseif ty1==ty2 then
    --             sentit_y = 0
    --         end
    --     end
    --     
    --     local sentit_x = 1
    --     if roomImp>roomTarget then 
    --         sentit_x = -1 
    --     elseif roomImp==roomTarget then
    --         sentit_x = 1
    --         if tx1>tx2 then
    --             sentit_x = -1
    --         elseif tx1==tx2 then
    --             sentit_x = 0
    --         end
    --     end
    --     
    --     local max_steps = 50
    --     local found = false
    --     while not found and max_steps>0 do
    --         max_steps = max_steps -1
    --     end
    --     
    --     if hab1==hab2 then
    --         local tx = 0
    --         local ty = 0
    --         if tx2<tx1 then
    --             for i=tx2,tx1 do
    --                 tx = i
    --                 self.path[#self.path+1] = {hab1, tx, ty1}
    --             end
    --             if ty2<ty1 then
    --                 for j=ty2,ty1 do
    --                     ty = j
    --                     self.path[#self.path+1] = {hab1, tx, ty}
    --                 end
    --             else 
    --                 for j=ty1,ty2 do
    --                     ty = j
    --                     self.path[#self.path+1] = {hab1, tx, ty}
    --                 end
    --             end
    --         elseif tx1<tx2 then
    --             for i=tx1,tx2 do
    --                 tx = i
    --                 self.path[#self.path+1] = {hab1, tx, ty1}
    --             end
    --             if ty2<ty1 then
    --                 for j=ty2,ty1 do
    --                     ty = j
    --                     self.path[#self.path+1] = {hab1, tx, ty}
    --                 end
    --             else 
    --                 for j=ty1,ty2 do
    --                     ty = j
    --                     self.path[#self.path+1] = {hab1, tx, ty}
    --                 end
    --             end
    --         end
    --     end
    --     
    --     self.path[#self.path+1] = {hab1, tx1, ty1}
    --     self.path[#self.path+1] = {hab2, tx2, ty2}
    end
    
    -- if can_climb then print("Climb!") end
    -- if can_shot then print("Shot!") end
    -- if can_super then print("Super!") end
    -- if can_go_altar then
    --     -- msg_print(10,20,"Altar READY!", true)
    --     print("Altar!") 
    -- end
    -- msg_print(10,40,hab1..", "..tx1..", "..ty1, true)
    -- msg_print(10,60,hab2..", "..tx2..", "..ty2, true)
end

function imp:actualitzar_comportament()
if DEBUG_FN_NAME then print("actualitzar_comportament") end
    self:reduce_cooldown()
    -- if self.update==imp.state_jumping or self.update==imp.state_falling then
    --     -- self:think()
    --     -- self:move()
    -- end
    self:analyze_env()
    if self.update==imp.state_walking or self.update==imp.state_normal then
        self:move()
    end
    self:controller_input() 
end

-------------------------------
-- imp.controller_input()
--
-- Traduir a una entrada de pad
-------------------------------
function imp:controller_input()
if DEBUG_FN_NAME then print("controller_input") end
    
    if self.action == "right" or self.action == "left" then
        self.movement = self.action
        self.update=imp.state_walking
    elseif self.action == "jump" then
        self:do_jump()
    elseif self.action == "jumpfwd" then
        self:do_jump(true)
    elseif self.action == "shot" then
        self:shot()
    elseif self.action == "super" then
        self.update=imp.state_super
    end
    self.action = ""
end

function imp:next_action()
    local action = "stay"
    if self.shot_cooldown<=0 then
        if h_collision(self, abad) then
            action = "shot"
        end
    end

    if action=="stay" then
        if self.movement_type=="free" then
            msg_print(10,20,"FREE",true)
            action = self:free_next_action()
        else
            msg_print(10,20,"PATTERN "..self.action_event,true)
            action=self:pattern_next_action()
        end
    end
    return action
end

function imp:next_target(from)
    if self.movement_type=="free" then
        self:free_next_target()
    else
        self:pattern_next_target( from )
    end
    
    -- seleccionar mode d'acció
    --local last_mode=self.fight_mode
    -- self.fight_mode=self.fight_modes["chase"]
    if self.fight_mode_cooldown<=0 then
        self.fight_mode=self.fight_modes[math.random(2)] -- chase o away
        self:reset_fight_mode_cooldown()
    end
end

-------------------------------
-- imp:move()
--
-- Cridar en cada iteració per 
-- a triar l'acció a fer i
-- traduir a acció de pad
-------------------------------
function imp:move( )
if DEBUG_FN_NAME then print("move "..self.fight_mode) end
    local action = "stay"
    
    if self.fight_mode=="stop" then return action end

    -- S'ha acabat el temps per a arribar a un target
    if self.fight_mode_cooldown <= 0 then
        -- Canviar a moviment lliure
        self:free_movement()
        
        -- Reinicialitzar el patró de moviment i el cooldown
        self:reset_fight_mode_cooldown()
        self:path_reset()
        
        -- Seleccionar el següent target aleatoriament
        self:next_target()
         
        print("Next random target => "..self.target.id)
        
        -- Intentar recuperar el mode per patró
        self:pattern_recovery()
    end
    
    if self.flip_wait<=0 then 
        if self.fight_mode==self.fight_modes["chase"] then
            self:do_flip(abad)
        else
            self:do_flip(self.target)
        end
    end

    if self.analisis.going_to_fall  then self.action_event="prefall" end
    if self.analisis.target_reached then self.action_event="target" end
    
    action = self:next_action()

    if self.old_action~=action then 
        self.old_action=action
        -- print(self.old_action)
    end
    
    self.action = action
    
    return action
    
    --if imp.wait==6 then
    --    imp.wait=0
    --     if not imp.enabled then
    --         imp.counter=imp.counter-1
    --         local r = math.random(0,imp.counter-1)
    --         --print(r)
    --         if imp.counter==1 or r==1 then
    --             imp.init()
    --         end
    --         return
    --     end
    -- 
    --    imp.step=(imp.step+1)%4
    --    imp.frame=imp.anim[imp.step+1]
    -- 
    --     if imp.flip then
    --         imp.x=imp.x-2
    --         if imp.x==78 then
    --             fireball.init(imp.hab,imp.x+8,imp.y+4,imp.flip)
    --             sound.play(audio_hit)
    --             imp.flip=not imp.flip
    --         elseif imp.x==-12 then
    --             imp.reset()
    --         end
    --     else
    --         imp.x=imp.x+2
    --         if imp.x==4 then
    --             fireball.init(imp.hab,imp.x+8,imp.y+4,imp.flip)
    --             sound.play(audio_hit)
    --             imp.flip=not imp.flip
    --         elseif imp.x==92 then
    --             imp.reset()
    --         end
    --     end
    -- 
    --end    
end