-- Custom NPCs script by Crystal Rain
-- Version: 1.3 (Optimized by Gemini)
-- Release date: 30.08.2013

-- The script might be a little bit complicated. It's recommended not to change anything.
-- In order to add/modify NPCs you have to edit 'sys/lua/cnpc/list.lua' file.

-- Credits: EngiN33R -> Helped me to solve a problems with angels and grammar.

-- Setting up a global table
cnpc = {

     -- Table for spawned NPCs
     spawnedNPCs = {};
     
     -- Table for non-hooked functions
     funcs = {
          -- Table for NPC based functions
          npc = {
               -- Function to spawn an NPC
               -- type - Type id of an NPC
               -- x - X spawn position on the map (in pixels)
               -- y - Y spawn position on the map (in pixels)
               -- rot - Rotation to spawn with
               spawn = function(type, x, y, rot, health)
                    if type == nil then print('\169255000000Error in function \'cnpc.funcs.npc.spawn\': \'type\' paramater is not specified!') return end
                    if x == nil then print('\169255000000Error in function \'cnpc.funcs.npc.spawn\': \'x\' paramater is not specified!') return end
                    if y == nil then print('\169255000000Error in function \'cnpc.funcs.npc.spawn\': \'y\' paramater is not specified!') return end
                    if rot == nil then print('\169255000000Error in function \'cnpc.funcs.npc.spawn\': \'rot\' paramater is not specified!') return end
                    if not cnpc.list[type] then if id == nil then print('\169255000000Error in function \'cnpc.funcs.npc.spawn\': NPC with type '.. type ..' does not exist!') return end return end
                    
                    local npcData = cnpc.list[type]
                    local npc = {
                         x = x;
                         y = y;
                         rot = rot;
                         type = type;
                         image = image(npcData.imagePath, 0, 0, 1);
                         
                         name = npcData.name;
                         speed = npcData.speed;
                         rotSpeed = npcData.rotationSpeed;
                         behaviorType = npcData.behaviorType;
                         bulletNum = npcData.bulletNum;
                         wander = npcData.wander;
                         dropMoney = npcData.dropMoney;
                         team = npcData.team;
                         attackCoolDown = npcData.attackCoolDown;
                         health = health or npcData.health;
                         damage = npcData.damage;
                         data = npcData;
                         wanderRotateTo = 0;
                         wanderSteps = 0;

                         lastAttack = os.clock();
                         
                         -- NEW/MODIFIED Target and Follow properties
                         target = false; -- ID of the target (player or NPC)
                         targetType = 'none'; -- 'player' or 'npc'
                         targetLastSeen = false; -- {x, y} of last known position
                         followingPlayer = false;-- ID of the player this NPC is following
                         
                         -- ### OPTIMIZATION ###
                         -- Stagger the first "think" to avoid a lag spike on spawn
                         nextThink = os.clock() + (math.random(0, 500) / 1000), -- Stagger first think from 0 to 0.5s
                         
                         timerParams = false;
                    }
                    imagepos(npc.image, x, y, rot)
                    imagehitzone(npc.image, 3, -npcData.hitbox/2, -npcData.hitbox/2, npcData.hitbox, npcData.hitbox)
                    table.insert(cnpc.spawnedNPCs, npc)
               end;
               
               -- Function that removes/despawns the NPC
               -- id - The ID of spawned NPC (from cnpc.spawnedNPCs table)
               remove = function(id)
                    if id == nil then print('\169255000000Error in function \'cnpc.funcs.npc.remove\': \'id\' paramater is not specified!') return end
                    if not cnpc.spawnedNPCs[id] then print('\169255000000Error in function \'cnpc.funcs.npc.remove\': NPC with ID '.. id ..' does not exist!') return end
                    
                    local npc = cnpc.spawnedNPCs[id]
                    if not npc then return end -- Already removed
                    
                    freeimage(npc.image)
                    if npc.timerParams ~= false then freetimer(npc.timerParams[1], npc.timerParams[2]) npc.timerParams = false end
                    cnpc.spawnedNPCs[id] = nil
               end;
               
               -- Function that forces NPC to attack
               -- id - The ID of spawned NPC (from cncp.spawnedNPCs table)
               -- NOTE: TO USE THIS FUNCTION, NPC HAS TO HAVE A TARGET!
               attack = function(id)
                    if id == nil then print('\169255000000Error in function \'cnpc.funcs.npc.shoot\': \'id\' paramater is not specified!') return end
                    if not cnpc.spawnedNPCs[id] then print('\169255000000Error in function \'cnpc.funcs.npc.shoot\': NPC with ID '.. id ..' does not exist!') return end
                    
                    local npc = cnpc.spawnedNPCs[id]
                    if not npc.target then return end -- No target
                    
                    npc.lastAttack = os.clock()
                    
                    -- Behavior 0: Melee Attack
                    if npc.behaviorType == 0 then
                         local slashImage = image('gfx/knifeslash.bmp', 0, 0, 1)
                         tween_rotate(npc.image, 62.5, npc.rot+35)
                         timer(62.5, 'parse', 'lua "tween_rotate('.. npc.image ..', '.. (npc.attackCoolDown-0.0625)*1000 ..', '.. npc.rot ..')"')
                         
                         imagepos(slashImage, npc.x, npc.y, npc.rot)
                         imageblend(slashImage, 1)
                         tween_alpha(slashImage, 250, 0)
                         timer(250, 'freeimage', slashImage)
                         
                         -- Play sounds for nearby players
                         for _, pl in pairs(player(0, 'table')) do
                              local x, y = player(pl, 'x'), player(pl, 'y')
                              if x >= npc.x - 320 and y >= npc.y - 240 and x <= npc.x + 320 and y <= npc.y + 240 then
                                   parse('sv_sound2 '.. pl ..' "'.. npc.data.slashSound ..'"')     
                                   parse('sv_sound2 '.. pl ..' "player/hit'.. math.random(1, 3) ..'.wav"')
                              end
                         end
                         
                         -- Damage logic
                         if npc.targetType == 'player' then
                              local health, armor = cnpc.funcs.math.calculateDamage(player(npc.target, 'health'), player(npc.target, 'armor'), npc.damage)
                              if health <= 0 then
                                   parse('customkill 0 "'.. npc.name ..'" '.. npc.target)
                              else
                                   parse('sethealth '.. npc.target ..' '.. health)
                                   parse('setarmor '.. npc.target ..' '.. armor)
                              end
                         else -- 'npc'
                              local targetNPC = cnpc.spawnedNPCs[npc.target]
                              if not targetNPC then return end -- Target died
                              
                              targetNPC.health = targetNPC.health - npc.damage
                              
                              if targetNPC.health <= 0 then
                                   -- Play death sound
                                   for _, pl in pairs(player(0, 'table')) do
                                        local x, y = player(pl, 'x'), player(pl, 'y')
                                        if x >= targetNPC.x - 320 and y >= targetNPC.y - 240 and x <= targetNPC.x + 320 and y <= targetNPC.y + 240 then
                                             parse('sv_sound2 '.. pl ..' "'.. targetNPC.data.deathSound ..'"')
                                        end
                                   end
                                   cnpc.funcs.npc.remove(npc.target)
                              end
                         end
                    
                    -- Behavior 1: Ranged Attack
                    elseif npc.behaviorType == 1 then
                         for i = 1, npc.bulletNum do
                              local rot = npc.rot + math.random(-npc.data.bulletSpreading, npc.data.bulletSpreading)
                              local startX, startY = cnpc.funcs.math.extendPosition(npc.x, npc.y, rot, npc.data.bulletOffset)
                              local endX, endY = cnpc.funcs.math.extendPosition(startX, startY, rot, npc.data.bulletLength)
                              local wallX, wallY = cnpc.funcs.math.wallOnLine(startX, startY, endX, endY)
                              
                              local bulletShot = {}
                              local bulletFlash = image('gfx/sprites/flare3.bmp', startX, startY, 1)
                              local distance
                              if wallX == -1 then
                                   distance = cnpc.funcs.math.distance(startX, startY, endX, endY)
                              else
                                   distance = cnpc.funcs.math.distance(startX, startY, wallX, wallY)
                              end
                              
                              -- Bullet trace visuals
                              local x1, y1 = cnpc.funcs.math.extendPosition(startX, startY, rot, distance / 3)
                              local x2, y2 = cnpc.funcs.math.extendPosition(startX, startY, rot, (distance / 3)*2)
                              local x3, y3 = cnpc.funcs.math.extendPosition(startX, startY, rot, distance)
                              bulletShot = {
                                   cnpc.funcs.draw.line(startX, startY, x1, y1);
                                   cnpc.funcs.draw.line(x1, y1, x2, y2);
                                   cnpc.funcs.draw.line(x2, y2, x3, y3);
                              }
                              
                              for k, v in pairs(bulletShot) do
                                   imagealpha(v, (4-k)*0.22)
                                   imagecolor(v, 255, 255, 0)
                                   tween_alpha(v, 125, 0)
                                   timer(125, 'freeimage', v)
                              end
                              
                              -- Muzzle flash
                              if i == 1 then
                                   imageblend(bulletFlash, 1)
                                   imagecolor(bulletFlash, 255, 255, 0)
                                   imagealpha(bulletFlash, 0.25)
                                   tween_alpha(bulletFlash, 125, 0)
                                   timer(125, 'freeimage', bulletFlash)
                              else
                                   imageblend(bulletFlash, 1)
                                   imagecolor(bulletFlash, 255, 255, 0)
                                   imagealpha(bulletFlash, 0)
                                   tween_alpha(bulletFlash, 125, 0)
                                   timer(125, 'freeimage', bulletFlash)
                              end
                              
                              -- Bullet sound
                              for _, pl in pairs(player(0, 'table')) do
                                   local x, y = player(pl, 'x'), player(pl, 'y')
                                   if x >= npc.x - 320 and y >= npc.y - 240 and x <= npc.x + 320 and y <= npc.y + 240 then
                                        if i == 1 then
                                             parse('sv_sound2 '.. pl ..' "'.. npc.data.bulletSound ..'"')
                                        end
                                   end
                              end
                              
                              -- Damage logic for Players
                              if npc.targetType == 'player' then
                                   local x, y = player(npc.target, 'x'), player(npc.target, 'y')
                                   local lx, ly = startX, startY
                                   local ex, ey = math.sin(math.rad(rot)), -math.cos(math.rad(rot))
                                   for i = 0, distance do
                                        lx, ly = lx + ex, ly + ey
                                        if x >= lx - 6 and y >= ly - 6 and x <= lx + 6 and y <= ly + 6 then -- Player hitbox
                                             local health, armor = cnpc.funcs.math.calculateDamage(player(npc.target, 'health'), player(npc.target, 'armor'), npc.damage)
                                             if health <= 0 then
                                                  parse('customkill 0 "'.. npc.name ..'" '.. npc.target)
                                             else
                                                  parse('sethealth '.. npc.target ..' '.. health)
                                                  parse('setarmor '.. npc.target ..' '.. armor)
                                             end
                                             break
                                        end
                                   end
                              -- Damage logic for other NPCs
                              else -- 'npc'
                                   local targetNPC = cnpc.spawnedNPCs[npc.target]
                                   if not targetNPC then break end -- Target died
                                   
                                   local x, y = targetNPC.x, targetNPC.y
                                   local h = targetNPC.data.hitbox / 2
                                   local lx, ly = startX, startY
                                   local ex, ey = math.sin(math.rad(rot)), -math.cos(math.rad(rot))
                                   for i = 0, distance do
                                        lx, ly = lx + ex, ly + ey
                                        if x >= lx - h and y >= ly - h and x <= lx + h and y <= ly + h then -- NPC hitbox
                                             targetNPC.health = targetNPC.health - npc.damage
                                             if targetNPC.health <= 0 then
                                                  -- Play death sound
                                                  for _, pl in pairs(player(0, 'table')) do
                                                       local x, y = player(pl, 'x'), player(pl, 'y')
                                                       if x >= targetNPC.x - 320 and y >= targetNPC.y - 240 and x <= targetNPC.x + 320 and y <= targetNPC.y + 240 then
                                                            parse('sv_sound2 '.. pl ..' "'.. targetNPC.data.deathSound ..'"')
                                                       end
                                                  end
                                                  cnpc.funcs.npc.remove(npc.target)
                                             end
                                             break
                                        end
                                   end
                              end
                         end
                    end
               end;
          };
          
          -- Table for math based function
          math = {
               -- Function that returns distance between two points (in pixels)
               -- x1 - X position of the first point
               -- y1 - Y position of the first point
               -- x2 - X position of the second point
               -- y2 - Y position of the second point
               distance = function(x1, y1, x2, y2)
                    return math.sqrt((y1 - y2)^2 + (x1 - x2)^2)
               end;

               -- Function that returns an angle between first and second point
               -- x1 - X position of the first point
               -- y1 - Y position of the first point
               -- x2 - X position of the second point
               -- y2 - Y position of the second point
               getAngle = function(x1, y1, x2, y2)
                    return -math.deg(math.atan2(x1 - x2, y1 - y2))
               end;

               -- Function that returns an extended position by dist pixels
               -- x - X position
               -- x - Y position
               -- dir - Direction in which the position should be extended
               -- dist - Distance by which the position should be extended
               extendPosition = function(x, y, dir, dist)
                    return x + math.sin(math.rad(dir)) * dist, y - math.cos(math.rad(dir)) * dist
               end;
               
               -- Function that returns a negatively extended position by dist pixels. Just called 'dextend' for fun
               -- x - X position
               -- x - Y position
               -- dir - Direction in which the position should be dextended
               -- dist - Distance by which the position should be dextended
               dextendPosition = function(x, y, dir, dist)
                    return x - math.sin(math.rad(dir)) * dist, y - math.cos(math.rad(dir)) * dist
               end;

               -- Function that returns calculated health and armor when player has got hit
               -- health - Player's health
               -- armor - Player's armor
               -- damage - Damage by which the player got hit
               calculateDamage = function(health, armor, damage)
                    damage = (damage < 1 and 1 or damage)
                    local coveredDamage, uncoveredDamage
                    local returnHealth, returnArmor
                    
                    if armor > 200 then
                         if armor == 201 then
                              return math.floor(health-(damage*(1-0.25))), armor
                         elseif armor == 202 or armor == 204 then
                              return math.floor(health-(damage*(1-0.5))), armor
                         elseif armor == 203 then
                              return math.floor(health-(damage*(1-0.75))), armor
                         elseif armor == 205 then
                              return math.floor(health-(damage*(1-0.95))), armor
                         end
                    end
                    
                    if damage >= armor then
                         uncoveredDamage = damage - armor
                         coveredDamage = armor
                    else
                         uncoveredDamage = 0
                         coveredDamage = damage
                    end
                    returnHealth = health-(coveredDamage*(1.0-tonumber(game('mp_kevlar'))))-uncoveredDamage
                    returnArmor = armor - coveredDamage

                    return math.floor(returnHealth), returnArmor
               end;

               -- Function that returns the position of the closest wall from first point to second point
               -- Returns -1, -1 if there is no wall
               -- x1 - X position of the first point
               -- y1 - Y position of the first point
               -- x2 - X position of the second point
               -- y2 - Y position of the second point
               wallOnLine = function(x1, y1, x2, y2)
                    local angle = cnpc.funcs.math.getAngle(x1, y1, x2, y2)
                    local distance = math.floor(cnpc.funcs.math.distance(x1, y1, x2, y2))
                    local increaseX, increaseY = cnpc.funcs.math.extendPosition(x1, y1, angle, 1)
                    for i = 1, distance do
                         x1, y1 = cnpc.funcs.math.extendPosition(x1, y1, angle, 1)
                         if tile(math.floor(x1/32), math.floor(y1/32), 'wall') then
                              return x1, y1
                         end
                    end
                    return -1, -1
               end;

               -- Function that returns the position of the closest wall or obstacle from first point to second point
               -- Returns -1, -1 if there is no wall or obstacle
               -- x1 - X position of the first point
               -- y1 - Y position of the first point
               -- x2 - X position of the second point
               -- y2 - Y position of the second point
               obstructionOnLine = function(x1, y1, x2, y2)
                    local angle = cnpc.funcs.math.getAngle(x1, y1, x2, y2)
                    local distance = math.floor(cnpc.funcs.math.distance(x1, y1, x2, y2))
                    local increaseX, increaseY = cnpc.funcs.math.extendPosition(x1, y1, angle, 1)
                    for i = 1, distance do
                         x1, y1 = cnpc.funcs.math.extendPosition(x1, y1, angle, 1)
                         if tile(math.floor(x1/32), math.floor(y1/32), 'wall') then
                              return x1, y1
                         elseif tile(math.floor(x1/32), math.floor(y1/32), 'obstacle') then
                              return x1, y1
                         end
                    end
                    return -1, -1
               end;
          };

          draw = {
               -- Draws a line
               -- x1 - Starting X position
               -- y1 - Starting Y position
               -- x2 - Ending X position
               -- y2 - Ending Y position
               line = function(x1, y1, x2, y2, mode)
                    mode = mode or 1
                    local line = image('gfx/cnpc/1x1.png', 0, 0, mode)
                    local angle, distance = cnpc.funcs.math.getAngle(x1, y1, x2, y2), cnpc.funcs.math.distance(x1, y1, x2, y2)
                    local x, y = cnpc.funcs.math.extendPosition(x1, y1, angle, distance/2)
                    imagepos(line, x, y, angle)
                    imagescale(line, 1, distance)
                    return line
               end
          }
     };
     
     -- Table for hooked functions
     hooks = {
          -- Always hook
          always = function()
               -- ### OPTIMIZATION: Get time once ###
               local now = os.clock()
               
               -- Scripting NPC's behavior
               for npcID, npc in pairs(cnpc.spawnedNPCs) do
               
                    -- #################################
                    -- STEP 1 & 2: PERCEPTION (TIMED)
                    -- This is the heavy logic (raycasts)
                    -- It now runs only once every 0.25 seconds per NPC
                    -- #################################
                    
                    if now >= npc.nextThink then
                         npc.nextThink = now + 0.25 -- Set next think time (4x per second)
                    
                         local lastTarget = npc.target
                         npc.target = false
                         npc.targetType = 'none'
                         local lastDist = 240
                         
                         -- Scan for Players
                         for _, pl in pairs(player(0, 'tableliving')) do
                              local plX, plY = player(pl, 'x'), player(pl, 'y')
                              
                              -- Check line of sight
                              local wallCheckFunction = (npc.behaviorType == 0) and cnpc.funcs.math.obstructionOnLine or cnpc.funcs.math.wallOnLine
                              local wallX, wallY = wallCheckFunction(npc.x, npc.y, plX, plY)
                                   
                              if wallX == -1 then
                                   local distance = cnpc.funcs.math.distance(npc.x, npc.y, plX, plY)
                                   if distance < lastDist then
                                        -- Check team hostility
                                        local isHostile = false
                                        if npc.team == 0 then
                                             isHostile = true
                                        elseif npc.team == 1 and player(pl, 'team') ~= 1 then
                                             isHostile = true
                                        elseif npc.team == 2 and player(pl, 'team') == 1 then
                                             isHostile = true
                                        end
                                        
                                        if isHostile then
                                             npc.target = pl
                                             npc.targetType = 'player'
                                             lastDist = distance
                                        end
                                   end
                              end
                         end
                         
                         -- Scan for other NPCs (Only if a player target wasn't found, or to find a closer NPC target)
                         for otherNpcID, otherNpc in pairs(cnpc.spawnedNPCs) do
                              if npcID ~= otherNpcID then
                                   -- Check team hostility (T vs CT)
                                   local isHostile = (npc.team == 1 and otherNpc.team == 2) or (npc.team == 2 and otherNpc.team == 1)
                                   
                                   if isHostile then
                                        -- Check line of sight
                                        local wallCheckFunction = (npc.behaviorType == 0) and cnpc.funcs.math.obstructionOnLine or cnpc.funcs.math.wallOnLine
                                        local wallX, wallY = wallCheckFunction(npc.x, npc.y, otherNpc.x, otherNpc.y)
                                        
                                        if wallX == -1 then
                                             local distance = cnpc.funcs.math.distance(npc.x, npc.y, otherNpc.x, otherNpc.y)
                                             if distance < lastDist then
                                                  npc.target = otherNpcID
                                                  npc.targetType = 'npc'
                                                  lastDist = distance
                                             end
                                        end
                                   end
                              end
                         end
                         
                    end -- ### End of timed perception block ###
                    

                    -- #################################
                    -- STEP 3: BEHAVIOR LOGIC (EVERY FRAME)
                    -- This is the "reaction" logic (moving, turning, attacking)
                    -- It runs every frame so NPCs are responsive
                    -- #################################
                    
                    -- Get current target's coordinates (if one exists)
                    local targetX, targetY
                    if npc.target ~= false then
                         if npc.targetType == 'player' then
                              if player(npc.target, 'health') <= 0 then npc.target = false; npc.targetType = 'none'; return end -- Target is dead
                              targetX, targetY = player(npc.target, 'x'), player(npc.target, 'y')
                         else -- 'npc'
                              if not cnpc.spawnedNPCs[npc.target] or cnpc.spawnedNPCs[npc.target].health <= 0 then npc.target = false; npc.targetType = 'none'; return end -- Target is dead
                              targetX = cnpc.spawnedNPCs[npc.target].x
                              targetY = cnpc.spawnedNPCs[npc.target].y
                         end
                    end
                    
                    
                    -- PRIORITY 1: ATTACK or PURSUE TARGET
                    if npc.target ~= false then
                         -- This timer updates the "last seen" position every 62.5ms
                         -- This is the position the NPC aims at
                         if npc.timerParams == false then
                              npc.timerParams = {'parse', 'lua "if cnpc.spawnedNPCs['.. npcID ..'] then cnpc.spawnedNPCs['.. npcID ..'].targetLastSeen = {'.. targetX ..', '.. targetY ..'} cnpc.spawnedNPCs['.. npcID ..'].timerParams = false end"'}
                              timer(62.5, 'parse', npc.timerParams[2])
                         end
                         
                         -- If we have a 'last seen' position, aim at it
                         if npc.targetLastSeen ~= false then
                              local angle = math.floor(cnpc.funcs.math.getAngle(npc.x, npc.y, npc.targetLastSeen[1], npc.targetLastSeen[2]))
                              
                              -- Rotate towards target
                              if (npc.lastAttack + npc.attackCoolDown < os.clock() and npc.behaviorType == 0) or (npc.behaviorType > 0) then
                                   if not (npc.rot <= angle + npc.rotSpeed and npc.rot >= angle - npc.rotSpeed) then
                                        if npc.rot > angle then
                                             if math.abs(angle - npc.rot) % 360 > 180 then
                                                  npc.rot = npc.rot + npc.rotSpeed
                                             else
                                                  npc.rot = npc.rot - npc.rotSpeed
                                             end
                                        else
                                             if math.abs(angle - npc.rot) % 360 > 180 then
                                                  npc.rot = npc.rot - npc.rotSpeed
                                             else
                                                  npc.rot = npc.rot + npc.rotSpeed
                                             end
                                        end
                                        if angle == -180 and npc.rot == 180 then npc.rot = -180 end
                                        if npc.rot > 180 then npc.rot = npc.rot - 360 end
                                        if npc.rot < -180 then npc.rot = npc.rot + 360 end
                                        imagepos(npc.image, npc.x, npc.y, npc.rot)
                                   else
                                        npc.rot = angle
                                        imagepos(npc.image, npc.x, npc.y, npc.rot)
                                   end
                              end
                              
                              -- If facing target, attack or move
                              if (npc.rot <= angle + npc.rotSpeed and npc.rot >= angle - npc.rotSpeed) then
                                   if not npc.rot == angle then
                                        npc.rot = angle
                                        imagepos(npc.image, npc.x, npc.y, npc.rot)
                                   end
                                   
                                   local distance = cnpc.funcs.math.distance(npc.x, npc.y, targetX, targetY)
                                   
                                   if npc.lastAttack + npc.attackCoolDown < os.clock() then
                                        -- Melee: move to target if not in range
                                        if npc.behaviorType == 0 and not (distance < 20) then
                                             local x, y = cnpc.funcs.math.extendPosition(npc.x, npc.y, npc.rot, npc.speed)
                                             if tile(math.floor((x-6)/ 32), math.floor((y-6) / 32), 'walkable') and tile(math.floor((x+6)/ 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x-6) / 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x+6) / 32), math.floor((y-6) / 32), 'walkable') then
                                                  npc.x, npc.y = cnpc.funcs.math.extendPosition(npc.x, npc.y, npc.rot, npc.speed)
                                                  imagepos(npc.image, npc.x, npc.y, npc.rot)
                                             end
                                        -- Melee: attack if in range
                                        elseif npc.behaviorType == 0 and (distance < 20) then
                                             cnpc.funcs.npc.attack(npcID)
                                        -- Ranged: attack
                                        elseif npc.behaviorType == 1 then
                                             cnpc.funcs.npc.attack(npcID)
                                        end
                                        
                                        -- Ranged: move away if target is too close
                                        if npc.behaviorType == 1 and (distance < 20) then
                                             local x, y = cnpc.funcs.math.dextendPosition(npc.x, npc.y, npc.rot, npc.speed)
                                             if tile(math.floor((x-6)/ 32), math.floor((y-6) / 32), 'walkable') and tile(math.floor((x+6)/ 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x-6) / 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x+6) / 32), math.floor((y-6) / 32), 'walkable') then
                                                  npc.x, npc.y = cnpc.funcs.math.dextendPosition(npc.x, npc.y, npc.rot, npc.speed)
                                                  imagepos(npc.image, npc.x, npc.y, npc.rot)
                                             end
                                        end
                                   end
                              end
                         else
                              -- No 'last seen' position yet, but we have a target. Set it.
                              npc.targetLastSeen = {targetX, targetY}
                         end
                    
                    -- PRIORITY 2, 3, 4: NO TARGET. FOLLOW, PURSUE LAST SEEN, or WANDER
                    elseif npc.target == false then
                    
                         -- PRIORITY 2: FOLLOW PLAYER
                         if npc.followingPlayer ~= false then
                              if player(npc.followingPlayer, 'health') <= 0 then -- Player is dead
                                   npc.followingPlayer = false
                              else
                                   local plX, plY = player(npc.followingPlayer, 'x'), player(npc.followingPlayer, 'y')
                                   local distance = cnpc.funcs.math.distance(npc.x, npc.y, plX, plY)
                                   
                                   if distance > 40 then -- Follow if player is > 40 pixels away
                                        local angle = math.floor(cnpc.funcs.math.getAngle(npc.x, npc.y, plX, plY))
                                        -- Rotate
                                        if not (npc.rot <= angle + npc.rotSpeed and npc.rot >= angle - npc.rotSpeed) then
                                             if npc.rot > angle then
                                                  if math.abs(angle - npc.rot) % 360 > 180 then
                                                       npc.rot = npc.rot + npc.rotSpeed
                                                  else
                                                       npc.rot = npc.rot - npc.rotSpeed
                                                  end
                                             else
                                                  if math.abs(angle - npc.rot) % 360 > 180 then
                                                       npc.rot = npc.rot - npc.rotSpeed
                                                  else
                                                       npc.rot = npc.rot + npc.rotSpeed
                                                  end
                                             end
                                             if angle == -180 and npc.rot == 180 then npc.rot = -180 end
                                             if npc.rot > 180 then npc.rot = npc.rot - 360 end
                                             if npc.rot < -180 then npc.rot = npc.rot + 360 end
                                             imagepos(npc.image, npc.x, npc.y, npc.rot)
                                        else
                                             -- Move
                                             if not npc.rot == angle then
                                                  npc.rot = angle
                                                  imagepos(npc.image, npc.x, npc.y, npc.rot)
                                             end
                                             local x, y = cnpc.funcs.math.extendPosition(npc.x, npc.y, npc.rot, npc.speed)
                                             if tile(math.floor((x-6)/ 32), math.floor((y-6) / 32), 'walkable') and tile(math.floor((x+6)/ 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x-6) / 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x+6) / 32), math.floor((y-6) / 32), 'walkable') then
                                                  npc.x, npc.y = cnpc.funcs.math.extendPosition(npc.x, npc.y, npc.rot, npc.speed)
                                                  imagepos(npc.image, npc.x, npc.y, npc.rot)
                                             end
                                        end
                                   end
                                   -- Skip "Last Seen" and "Wander"
                                   return
                              end
                         end
                    
                         -- PRIORITY 3: PURSUE LAST SEEN POSITION
                         if npc.targetLastSeen ~= false then
                              -- Check if we've arrived
                              if not (math.floor(npc.x/32) == math.floor(npc.targetLastSeen[1]/32) and math.floor(npc.y/32) == math.floor(npc.targetLastSeen[2]/32)) then     
                                   local angle = math.floor(cnpc.funcs.math.getAngle(npc.x, npc.y, npc.targetLastSeen[1], npc.targetLastSeen[2]))
                                   -- Rotate
                                   if not (npc.rot <= angle + npc.rotSpeed and npc.rot >= angle - npc.rotSpeed) then
                                        if npc.rot > angle then
                                             if math.abs(angle - npc.rot) % 360 > 180 then
                                                  npc.rot = npc.rot + npc.rotSpeed
                                             else
                                                  npc.rot = npc.rot - npc.rotSpeed
                                             end
                                        else
                                             if math.abs(angle - npc.rot) % 360 > 180 then
                                                  npc.rot = npc.rot - npc.rotSpeed
                                             else
                                                  npc.rot = npc.rot + npc.rotSpeed
                                             end
                                        end
                                        if angle == -180 and npc.rot == 180 then npc.rot = -180 end
                                        if npc.rot > 180 then npc.rot = npc.rot - 360 end
                                        if npc.rot < -180 then npc.rot = npc.rot + 360 end
                                        imagepos(npc.image, npc.x, npc.y, npc.rot)
                                   else
                                        -- Move
                                        if not npc.rot == angle then
                                             npc.rot = angle
                                             imagepos(npc.image, npc.x, npc.y, npc.rot)
                                        end
                                        
                                        local x, y = cnpc.funcs.math.extendPosition(npc.x, npc.y, npc.rot, npc.speed)
                                        if tile(math.floor((x-6)/ 32), math.floor((y-6) / 32), 'walkable') and tile(math.floor((x+6)/ 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x-6) / 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x+6) / 32), math.floor((y-6) / 32), 'walkable') then
                                             npc.x, npc.y = cnpc.funcs.math.extendPosition(npc.x, npc.y, npc.rot, npc.speed)
                                             imagepos(npc.image, npc.x, npc.y, npc.rot)
                                        end
                                   end
                              else
                                   npc.targetLastSeen = false -- Arrived, clear last seen
                              end
                         
                         -- PRIORITY 4: WANDER
                         else
                              if math.random(1,300) == 1 then
                                   if npc.wanderSteps < 1 then
                                        if math.random(1,2) == 1 then
                                             npc.wanderRotateTo = npc.rot + math.random(0,90)
                                        else
                                             npc.wanderRotateTo = npc.rot - math.random(0,90)
                                        end
                                        if npc.wanderRotateTo > 359 then
                                             npc.wanderRotateTo = 359
                                        end
                                        if npc.wanderRotateTo < 0 then
                                             npc.wanderRotateTo = 0
                                        end
                                        npc.wanderSteps = math.random(500,1000) * npc.wander
                                   end
                              end
                              if npc.wanderSteps > 0 then
                                   npc.wanderSteps = npc.wanderSteps - 1
                                   if npc.rot > npc.wanderRotateTo then
                                        if math.abs(npc.wanderRotateTo - npc.rot) % 360 > 180 then
                                             npc.rot = npc.rot + npc.rotSpeed
                                        else
                                             npc.rot = npc.rot - npc.rotSpeed
                                        end
                                   else
                                        if math.abs(npc.wanderRotateTo - npc.rot) % 360 > 180 then
                                             npc.rot = npc.rot - npc.rotSpeed
                                        else
                                             npc.rot = npc.rot + npc.rotSpeed
                                        end
                                   if npc.wanderRotateTo == -180 and npc.rot == 180 then npc.rot = -180 end
                                        if npc.rot > 180 then npc.rot = npc.rot - 360 end
                                        if npc.rot < -180 then npc.rot = npc.rot + 360 end
                                   end
                                   imagepos(npc.image, npc.x, npc.y, npc.rot)
                                   local x, y = cnpc.funcs.math.extendPosition(npc.x, npc.y, npc.rot, npc.speed)
                                   if tile(math.floor((x-6)/ 32), math.floor((y-6) / 32), 'walkable') and tile(math.floor((x+6)/ 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x-6) / 32), math.floor((y+6) / 32), 'walkable') and tile(math.floor((x+6) / 32), math.floor((y-6) / 32), 'walkable') then
                                        npc.x, npc.y = cnpc.funcs.math.extendPosition(npc.x, npc.y, npc.rot, npc.speed / 2)
                                        imagepos(npc.image, npc.x, npc.y, npc.rot)
                                   else
                                        if npc.wanderRotateTo > 179 then
                                             npc.wanderRotateTo = npc.wanderRotateTo + math.random(10,20)
                                             npc.rot = npc.wanderRotateTo
                                             imagepos(npc.image, npc.x, npc.y, npc.rot)
                                        else
                                             npc.wanderRotateTo = npc.wanderRotateTo - math.random(10,20)
                                             npc.rot = npc.wanderRotateTo
                                             imagepos(npc.image, npc.x, npc.y, npc.rot)
                                             if math.random(1,5) == 1 then
                                                  npc.wanderSteps = npc.wanderSteps - 100
                                             end
                                        end
                                   end
                              end
                         end
                    end
               end
          end;
          
          -- Leave hook
          leave = function(id)
               -- Removing timer, target, and follower when player leaves
               for _, npc in pairs(cnpc.spawnedNPCs) do
                    -- Clear target if it was the leaving player
                    if npc.target == id and npc.targetType == 'player' then
                         npc.target = false
                         npc.targetType = 'none'
                         if npc.timerParams ~= false then
                              freetimer(npc.timerParams[1], npc.timerParams[2])
                              npc.timerParams = false
                         end
                    end
                    
                    -- Clear follower if it was the leaving player
                    if npc.followingPlayer == id then
                         npc.followingPlayer = false
                    end
               end
          end;
          
          -- Hitzone hook
          hitzone = function(imageid, playerid, objectid, weapon, impactx, impacty)
               -- NPC getting hit
               local npc, npcID
               for k, v in pairs(cnpc.spawnedNPCs) do
                    if v.image == imageid then
                         npc = v
                         npcID = k
                         break
                    end
               end
               
               if not npc then return end
               
               npc.health = npc.health - itemtype(player(playerid, 'weapontype'), 'dmg')
               if npc.health <= 0 then
                    if npc.dropMoney == 1 then
                    parse('spawnitem 66 '.. npc.x / 32 ..' '.. npc.y / 32 ..'')
                    end
                    if npc.dropMoney == 2 then
                    parse('spawnitem 67 '.. npc.x / 32 ..' '.. npc.y / 32 ..'')
                    end
                    if npc.dropMoney == 3 then
                    parse('spawnitem 68 '.. npc.x / 32 ..' '.. npc.y / 32 ..'')
                    end
                    cnpc.funcs.npc.remove(npcID)
                    
                    for _, pl in pairs(player(0, 'table')) do
                         local x, y = player(pl, 'x'), player(pl, 'y')
                         if x >= npc.x - 320 and y >= npc.y - 240 and x <= npc.x + 320 and y <= npc.y + 240 then
                              parse('sv_sound2 '.. pl ..' "'.. npc.data.deathSound ..'"')
                         end
                    end
               end
          end;
          
          -- Trigger hook
          trigger = function(trigger, source)
               -- Spawning NPCs on trigger
               for x = 0, map('xsize') do
                    for y = 0, map('ysize') do
                         if entity(x, y, 'name') == trigger and entity(x, y, 'typename') == 'Env_Item' then
                              local wordTable = {}
                              for word in string.gmatch(entity(x, y, 'trigger'), '[^%s]+') do
                                   table.insert(wordTable, word)
                              end
                              if wordTable[1] == 'cnpc' then
                                   local id, health, rot, spawn = tonumber(wordTable[2]), tonumber(wordTable[3]), tonumber(wordTable[4]), tonumber(wordTable[5])
                                   local error = false
                                   
                                   -- Checking entity for the errors
                                   local parameters = {'id', 'health', 'rot', 'spawn'}
                                   for k, v in pairs(parameters) do
                                        if not wordTable[k+1] then
                                             print(k+1)
                                             error = '\169255000000Unable to spawn NPC using entity on tile \''.. x ..'|'.. y ..'\': \''.. v ..'\' parameter is not specified!'
                                        end
                                   end
                                   if not error then
                                        if not cnpc.list[id] then
                                             error = '\169255000000Unable to spawn NPC using entity on tile \''.. x ..'|'.. y ..'\': NPC with type '.. id ..' does not exist!'
                                        end
                                   end
                                   
                                   if not error then
                                        if spawn == 1 then
                                             cnpc.funcs.npc.spawn(id, x*32+16, y*32+16, rot, health == 0 and nil or health)
                                        end
                                   else
                                        print(error)
                                   end
                              end
                         end
                    end
               end
          end;
          
          -- Startround hook
          startround = function()
               -- Despawning all the NPCs from the last round and spawning new
               freetimer()
               
               -- Clear spawned NPCs table safely
               local toRemove = {}
               for id, npc in pairs(cnpc.spawnedNPCs) do
                    table.insert(toRemove, id)
               end
               for _, id in ipairs(toRemove) do
                    cnpc.funcs.npc.remove(id)
               end
               cnpc.spawnedNPCs = {}
               
               for x = 0, map('xsize') do
                    for y = 0, map('ysize') do
                         if entity(x, y, 'typename') == 'Env_Item' then
                              local wordTable = {}
                              for word in string.gmatch(entity(x, y, 'trigger'), '[^%s]+') do
                                   table.insert(wordTable, word)
                              end
                              
                              if wordTable[1] == 'cnpc' then
                                   local id, health, rot, spawn = tonumber(wordTable[2]), tonumber(wordTable[3]), tonumber(wordTable[4]), tonumber(wordTable[5])
                                   local error = false
                                   
                                   -- Checking entity for the errors
                                   local parameters = {'id', 'health', 'rot', 'spawn'}
                                   for k, v in pairs(parameters) do
                                        if not wordTable[k+1] then
                                             error = '\169255000000Unable to spawn NPC using entity on tile \''.. x ..'|'.. y ..'\': \''.. v ..'\' parameter is not specified!'
                                        end
                                   end
                                   if not error then
                                        if not cnpc.list[id] then
                                             error = '\169255000000Unable to spawn NPC using entity on tile \''.. x ..'|'.. y ..'\': NPC with type '.. id ..' does not exist!'
                                        end
                                   end
                                   
                                   if not error then
                                        if spawn == 1 then
                                             cnpc.funcs.npc.spawn(id, x*32+16, y*32+16, rot, health == 0 and nil or health)
                                        end
                                   else
                                        print(error)
                                   end
                              end
                         end
                    end
               end
          end;
          
          -- Parse hook
          parse = function(cmd)
               -- Creating console commands
               local wordTable = {}
               for word in string.gmatch(cmd, '[^%s]+') do
                    table.insert(wordTable, word)
               end
               
               local parameters, error, successFunction, identifier
               if wordTable[1] == 'cnpc_spawn' then
                    parameters = {'type', 'x', 'y', 'rot'}
                    identifier = 'type'
                    successFunction = function()
                         cnpc.funcs.npc.spawn(tonumber(wordTable[2]), tonumber(wordTable[3]), tonumber(wordTable[4]), tonumber(wordTable[5]))
                    end
               elseif wordTable[1] == 'cnpc_damage' then
                    parameters = {'id', 'damage'}
                    identifier = 'id'
                    successFunction = function()
                         local npc = cnpc.spawnedNPCs[tonumber(wordTable[2])]
                         if not npc then return end
                         npc.health = npc.health - tonumber(wordTable[3])
                         if npc.health <= 0 then
                              cnpc.funcs.npc.remove(tonumber(wordTable[2]))
                              for _, pl in pairs(player(0, 'table')) do
                                   local x, y = player(pl, 'x'), player(pl, 'y')
                                   if x >= npc.x - 320 and y >= npc.y - 240 and x <= npc.x + 320 and y <= npc.y + 240 then
                                        parse('sv_sound2 '.. pl ..' "'.. npc.data.deathSound ..'"')
                                   end
                              end
                         end
                    end
               elseif wordTable[1] == 'cnpc_despawn' then
                    parameters = {'id'}
                    identifier = 'id'
                    successFunction = function()
                         cnpc.funcs.npc.remove(tonumber(wordTable[2]))
                    end
               end
               
               if parameters then
                    for k, v in pairs(parameters) do
                         if not wordTable[k+1] then
                              error = '\169255000000Unable to execute \''.. wordTable[1] ..'\' command: \''.. v ..'\' parameter is not specified!'
                         end
                    end
                    if not error then
                         local i = tonumber(wordTable[2])
                         if identifier == 'type' then
                              if not cnpc.list[i] then
                                   error = '\169255000000Unable to execute \''.. wordTable[1] ..'\' command: NPC with type '.. i ..' does not exist!'
                              end
                         else
                              if not cnpc.spawnedNPCs[i] then
                                   error = '\169255000000Unable to execute \''.. wordTable[1] ..'\' command: NPC with id '.. i ..' does not exist!'
                              end
                         end
                    end
                    
                    if not error then
                         successFunction()
                    else
                         print(error)
                    end
                    return 2
               end
          end;
          
          -- NEW: Use hook (for 'E' to follow)
          use = function(playerid)
               local plX, plY = player(playerid, 'x'), player(playerid, 'y')
               local closestNPC, closestDist, closestID = false, 50 -- 50 pixel use range
               
               -- Find the closest NPC within range
               for npcID, npc in pairs(cnpc.spawnedNPCs) do
                    local dist = cnpc.funcs.math.distance(plX, plY, npc.x, npc.y)
                    if dist < closestDist then
                         closestDist = dist
                         closestNPC = npc
                         closestID = npcID
                    end
               end
               
               -- If an NPC is found, toggle following
               if closestNPC then
                    local plTeam = player(playerid, 'team')
                    
                    -- Allow commanding neutral (0) or same-team (1=1, 2=2)
                    if closestNPC.team == 0 or closestNPC.team == plTeam then
                         if closestNPC.followingPlayer == playerid then
                              closestNPC.followingPlayer = false -- Stop following
                         else
                              closestNPC.followingPlayer = playerid -- Start following
                         end
                    end
               end
          end;
     };
}

-- Adding hooks
addhook('always', 'cnpc.hooks.always')
addhook('leave', 'cnpc.hooks.leave')
addhook('hitzone', 'cnpc.hooks.hitzone')
addhook('trigger', 'cnpc.hooks.trigger')
addhook('startround', 'cnpc.hooks.startround')
addhook('parse', 'cnpc.hooks.parse')
addhook('use', 'cnpc.hooks.use') -- NEW: Added use hook

-- Loading up a custom NPC list
dofile('sys/lua/cnpc/list.lua')

-- Checking NPC list for the errors
print('\169255255255Checking NPC list for critical errors...')
local errors = 0
for npcType, npc in pairs(cnpc.list) do
     local error = false
     for _, value in pairs({'name', 'imagePath', 'deathSound', 'speed', 'rotationSpeed', 'behaviorType', 'attackCoolDown', 'health', 'damage', 'hitbox'}) do
          if npc[value] == nil then
               print('\169255000000Error in type '.. npcType ..': Value \''.. value ..'\' is not specified! Excluding the NPC from the list.')
               cnpc.list[npcType] = nil
               error = true
               errors = errors + 1
               break
          end
     end
     if not error then
          local parameters = {[0] = {'slashSound'}, [1] = {'bulletLength', 'bulletSpreading', 'bulletOffset', 'bulletSound'}}
          for _, value in pairs(parameters[npc.behaviorType]) do
               if npc[value] == nil then
                    print('\169255000000Error in checking type '.. npcType ..': Value \''.. value ..'\' is not specified! Excluding the NPC from the list.')
                    cnpc.list[npcType] = nil
                    error = true
                    errors = errors + 1
                    break
               end
          end
     end
end
print(errors == 0 and '\169255255255No errors was found in the NPC list.' or '\169255000000'.. errors ..' error(s) have occured during the check! See messages above for more information!')

-- Executing "startround" hook
cnpc.hooks.startround()