Add harrassment attack

Author: Afforess

Makefile

@@ -1,5 +1,5 @@
 PACKAGE_NAME := Misanthrope
-VERSION_STRING := 0.4.1
+VERSION_STRING := 0.4.2
 
 OUTPUT_NAME := $(PACKAGE_NAME)_$(VERSION_STRING)
 OUTPUT_DIR := build/$(OUTPUT_NAME)

libs/biter/ai/attack_area.lua

@@ -3,6 +3,25 @@ local AttackArea = {stages = {}}
 local Log = function(str, ...) BiterBase.LogAI("[AttackArea] " .. str, ...) end
 
 AttackArea.stages.attacking = function(base, data)
+    if not data.attack_group.valid then
+        local entities = base:get_entities()
+        Log("Unit group invalid, valid entities: %d", base, #entities)
+
+        if #entities == 0 then
+            return 'fail'
+        end
+        local command = {type = defines.command.attack_area, destination = data.attack_target, radius = 18}
+        local unit_group = BiterBase.create_unit_group(base, {position = entities[1].position, force = 'enemy'})
+        for _, biter in pairs(entities) do
+            if biter.unit_group and biter.unit_group.valid then
+                biter.unit_group.destroy()
+            end
+            unit_group.add_member(biter)
+        end
+        unit_group.set_command(command)
+        unit_group.start_moving()
+        data.attack_group = unit_group
+    end
     return 'attacking'
 end
 
@@ -22,8 +41,7 @@ AttackArea.stages.spawning = function(base, data)
         unit_group.start_moving()
     end
 
-    local attack_group_size = math.floor(15 + game.evolution_factor / 0.025)
-    if #base:get_entities() > attack_group_size then
+    if #base:get_entities() > data.attack_group_size then
         return 'plan_attack'
     end
     return 'spawning'
@@ -43,8 +61,9 @@ AttackArea.stages.plan_attack = function(base, data)
     end
 
     local end_pos = Area.center(Chunk.to_area(candidate.chunk_pos))
-    local command = {type = defines.command.attack_area, destination = end_pos, radius = 16}
-    local entities = table.filter(base.entities, Game.VALID_FILTER)
+    data.attack_target = end_pos
+    local command = {type = defines.command.attack_area, destination = end_pos, radius = 18}
+    local entities = base:get_entities()
 
     local unit_group = BiterBase.create_unit_group(base, {position = entities[1].position, force = 'enemy'})
     for _, biter in pairs(entities) do
@@ -73,11 +92,20 @@ function AttackArea.tick(base, data)
     return true
 end
 
+function AttackArea.initialize(base, data)
+    data.attack_group_size = math.floor(10 + game.evolution_factor / 0.025)
+    if base.currency > BiterBase.plans.attack_area.cost * 2 then
+        base.currency = base.currency - BiterBase.plans.attack_area.cost
+        data.attack_group_size = data.attack_group_size + math.floor(15 + game.evolution_factor / 0.02)
+    end
+    Log("Attack group size: %d", base, data.attack_group_size)
+end
+
 function AttackArea.is_expired(base, data)
     if data.stage == 'fail' or data.stage == 'success' then
         return true
     end
-    return data.attack_group and (not data.attack_group.valid or game.tick > data.attack_tick + Time.MINUTE * 6)
+    return data.attack_group and ( --[[not data.attack_group.valid or --]] game.tick > data.attack_tick + Time.MINUTE * 6)
 end
 
 return AttackArea

libs/biter/ai/harrassment.lua

@@ -0,0 +1,81 @@
+
+local Harrassment = {stages = {}}
+local Log = function(str, ...) BiterBase.LogAI("[Harrassment] " .. str, ...) end
+
+Harrassment.stages.attacking = function(base, data)
+    return 'attacking'
+end
+
+Harrassment.stages.spawning = function(base, data)
+    local command = {type = defines.command.attack_area, destination = data.target_pos, radius = 8}
+    for _, hive in pairs(base:all_hives()) do
+        local biter = Biters.spawn_biter(base, data.surface, hive)
+        if biter then
+            biter.set_command(command)
+        end
+    end
+    return 'spawning'
+end
+
+Harrassment.stages.search = function(base, data)
+    if data.search_idx > #data.search_queue then
+        if not data.worst_candidate.chunk_pos then
+            return 'fail'
+        end
+        data.end_tick = game.tick + (Time.MINUTE * math.random(3,7))
+        data.surface = base.queen.surface
+        data.target_pos = Area.center(Chunk.to_area(data.worst_candidate.chunk_pos))
+        return 'spawning'
+    end
+    local chunk_pos = data.search_queue[data.search_idx]
+
+    local chunk_data = Chunk.get_data(base.queen.surface, chunk_pos)
+    if chunk_data and chunk_data.player_value and chunk_data.player_value < 0 then
+        local dist = Position.manhattan_distance(chunk_pos, data.start_chunk)
+
+        value = (chunk_data.player_value * chunk_data.player_value) / ((1 + dist) * (1 + dist))
+        if data.worst_candidate.value == nil or data.worst_candidate.value < value then
+            data.worst_candidate = { chunk_pos = chunk_pos, value = value }
+        end
+    end
+
+    data.search_idx = data.search_idx + 1
+    return 'search'
+end
+
+Harrassment.stages.setup = function(base, data)
+    local chunk_pos = Chunk.from_position(base.queen.position)
+    local search_area = Position.expand_to_area(chunk_pos, 12)
+    data.start_chunk = chunk_pos
+    data.search_queue = {}
+    data.search_idx = 1
+    data.worst_candidate = { chunk_pos = nil, value = nil }
+    for x, y in Area.spiral_iterate(search_area) do
+        table.insert(data.search_queue, {x = x, y = y})
+    end
+    return 'search'
+end
+
+function Harrassment.tick(base, data)
+    if not data.stage then
+        data.stage = 'setup'
+    end
+    local prev_stage = data.stage
+    data.stage = Harrassment.stages[data.stage](base, data)
+    if prev_stage ~= data.stage then
+        Log("Updating stage from %s to %s", base, prev_stage, data.stage)
+    end
+    return true
+end
+
+function Harrassment.is_expired(base, data)
+    if data.stage == 'fail' or data.stage == 'success' then
+        return true
+    end
+    if data.end_tick then
+        return game.tick > data.end_tick
+    end
+    return false
+end
+
+return Harrassment

libs/biter/base.lua

@@ -204,6 +204,7 @@ BiterBase.plans = {
     idle = { passive = true, cost = 1, update_frequency = 60 * 60 },
     identify_targets = { passive = true, cost = 600, update_frequency = 120, class = require 'libs/biter/ai/identify_targets' },
     attack_area = { passive = false, cost = 3000, update_frequency = 300, class = require 'libs/biter/ai/attack_area'},
+    harrassment = { passive = false, cost = 5000, update_frequency = 173, class = require 'libs/biter/ai/harrassment'},
     attacked_recently = { passive = false, cost = 240, update_frequency = 120, class = require 'libs/biter/ai/attacked_recently' },
     alert = { passive = false, cost = 120, update_frequency = 180, class = require 'libs/biter/ai/alert' },
     grow_hive = { passive = true, cost = 2000, update_frequency = 300, class = require 'libs/biter/ai/grow_hive' },
@@ -239,18 +240,30 @@ function BiterBase.create_plan(base)
         return true
     end
 
-    local wanted_hives = base:wanted_hive_count()
-    LogAI("Wanted new hives: %d", base, wanted_hives)
-    if wanted_hives > 0 and base:can_afford('grow_hive') then
-        BiterBase.set_active_plan(base, 'grow_hive')
-        return true
+    if math.random(100) > 60 then
+        local wanted_hives = base:wanted_hive_count()
+        LogAI("Wanted new hives: %d", base, wanted_hives)
+        if wanted_hives > 0 and base:can_afford('grow_hive') then
+            BiterBase.set_active_plan(base, 'grow_hive')
+            return true
+        end
+
+        local wanted_worms = base:wanted_worm_count()
+        LogAI("Wanted new worms: %d", base, wanted_worms)
+        if wanted_worms > 0 and base:can_afford('build_worm') and math.random(100) > 70 then
+            BiterBase.set_active_plan(base, 'build_worm')
+            return true
+        end
     end
 
-    local wanted_worms = base:wanted_worm_count()
-    LogAI("Wanted new worms: %d", base, wanted_worms)
-    if wanted_worms > 0 and base:can_afford('build_worm') and math.random(100) > 70 then
-        BiterBase.set_active_plan(base, 'build_worm')
-        return true
+    if math.random(100) > 75 and base:can_afford('harrassment') and base.targets then
+        local active_chunk = BiterBase.is_in_active_chunk(base)
+        if active_chunk then LogAI("Is in an active chunk: true", base) else LogAI("Is in an active chunk: false", base) end
+
+        if active_chunk then
+            BiterBase.set_active_plan(base, 'harrassment')
+            return true
+        end
     end
 
     if base:can_afford('attack_area') and base.targets then

libs/biter/overmind.lua

@@ -107,7 +107,7 @@ Overmind.stages.spawn_biters = function(data)
     end
 
     local max_age = game.tick + Time.MINUTE * 10
-    local attack_group_size = math.floor(10 + game.evolution_factor / 0.025)
+    local attack_group_size = math.floor(30 + game.evolution_factor / 0.025)
     local tracked_entities = global.overmind.tracked_entities
     local biters = {}
     local all_units = {'behemoth-biter', 'behemoth-spitter', 'big-biter', 'big-spitter', 'medium-biter', 'medium-spitter', 'small-spitter', 'small-biter'}

libs/biter_targets.lua

@@ -1,17 +1,36 @@
-BITER_TARGETS = {}
-BITER_TARGETS["big-electric-pole"] = { value = 300, danger_modifier = 0.25 }
-BITER_TARGETS["medium-electric-pole"] = { value = 100, danger_modifier = 0.5 }
-BITER_TARGETS["small-electric-pole"] = { value = 60, danger_modifier = 0.75 }
+require 'libs/biter/biter'
 
-BITER_TARGETS["roboport"] = { value = 500, danger_modifier = 1 }
-BITER_TARGETS["roboportmk2"] = { value = 750, danger_modifier = 1 }
+Biters.targets = {}
 
-BITER_TARGETS["pipe-to-ground"] = { value = 50, danger_modifier = 1 }
-BITER_TARGETS["pipe"] = { value = 8, danger_modifier = 1 }
+table.insert(Biters.targets, {name = "big-electric-pole", value = 300, min_evolution = 0.9})
+table.insert(Biters.targets, {name = "medium-electric-pole", value = 100, min_evolution = 0.7})
+table.insert(Biters.targets, {name = "small-electric-pole", value = 60, min_evolution = 0.5})
 
-BITER_TARGETS["express-transport-belt-to-ground"] = { value = 50, danger_modifier = 1 }
-BITER_TARGETS["fast-transport-belt-to-ground"] = { value = 20, danger_modifier = 1 }
-BITER_TARGETS["basic-transport-belt-to-ground"] = { value = 10, danger_modifier = 1 }
+table.insert(Biters.targets, {type = "roboport", value = 500, min_evolution = 0})
+table.insert(Biters.targets, {type = "radar", value = 500, min_evolution = 0})
+table.insert(Biters.targets, {type = "pipe", value = 10, min_evolution = 0})
+table.insert(Biters.targets, {name = "pipe-to-ground", value = 50, min_evolution = 0})
 
-BITER_TARGETS["offshore-pump"] = { value = 150, danger_modifier = 1 }
-BITER_TARGETS["storage-tank"] = { value = 50, danger_modifier = 1 }
+table.insert(Biters.targets, {type = "transport-belt", value = 20, min_evolution = 0})
+table.insert(Biters.targets, {type = "offshore-pump", value = 20, min_evolution = 0})
+table.insert(Biters.targets, {type = "storage-tank", value = 20, min_evolution = 0})
+
+table.insert(Biters.targets, {type = "solar-panel", value = 100, min_evolution = 0.5})
+table.insert(Biters.targets, {type = "boiler", value = 25, min_evolution = 0.3})
+
+function Biters.entity_value(entity)
+    local entity_name = entity.name
+    local entity_type = entity.type
+    local evo_factor = game.evolution_factor
+    for i = 1, #Biters.targets do
+        local target_data = Biters.targets[i]
+        if evo_factor > target_data.min_evolution then
+            if target_data.name == entity_name then
+                return target_data.value
+            elseif target_data.type == entity_type then
+                return target_data.value
+            end
+        end
+    end
+    return -1
+end

libs/region/chunk_value.lua

@@ -31,27 +31,29 @@ function World.entity_value(entity)
     local entity_name = entity.name
     local value = 0
     local adj_value = 0
+    local biter_value = Biters.entity_value(entity)
     if entity.type:contains('turret') then
         value = -1 * game.entity_prototypes[entity_name].max_health
         adj_value = value / 2
-    elseif BITER_TARGETS[entity_name] then
-        value = BITER_TARGETS[entity_name].value
-    elseif entity.type:contains('electric-pole') then
-        value = game.entity_prototypes[entity_name].max_health
-    elseif entity.type:contains('roboport') then
-        value = game.entity_prototypes[entity_name].max_health / 8
-    elseif entity.type:contains('transport-belt') then
-        value = game.entity_prototypes[entity_name].max_health / 2
+    elseif biter_value > 0 then
+        value = biter_value
     elseif entity.type:contains('container') then
         value = game.entity_prototypes[entity_name].max_health / 3
     end
     if value ~= 0 then
         Log("Entity %s value is %d", entity.name, value)
     end
-    return value, adj_value
+    return math.floor(value), math.floor(adj_value)
 end
 
 function World.recalculate_chunk_values()
+    local nauvis = game.surfaces.nauvis
+    for chunk in nauvis.get_chunks() do
+        local chunk_data = Chunk.get_data(nauvis, chunk)
+        if chunk_data then
+            chunk_data.player_value = nil
+        end
+    end
     local all_entities = Surface.find_all_entities({force = game.forces.player})
     Log("Total number of player entities: %d", #all_entities)
     local entity_prototypes = game.entity_prototypes

libs/world.lua

@@ -5,7 +5,7 @@ require 'stdlib/surface'
 require 'libs/biter/base'
 
 World = {}
-World.version = 41
+World.version = 42
 World.Logger = Logger.new("Misanthrope", "world", DEBUG_MODE)
 local Log = function(str, ...) World.Logger.log(string.format(str, ...)) end
 
@@ -41,7 +41,8 @@ function World.migrate(old_version, new_version)
                 end
             end
         end
-    elseif old_version < 41 then
+    end
+    if old_version < 41 then
         for i = #global.bases, 1, -1 do
             local base = global.bases[i]
             base.target = nil
@@ -50,6 +51,14 @@ function World.migrate(old_version, new_version)
             global.overmind.currency = 0
         end
     end
+    if old_version < 42 then
+        World.recalculate_chunk_values()
+        for i = #global.bases, 1, -1 do
+            local base = global.bases[i]
+            base.targets = nil
+            BiterBase.set_active_plan(base, 'idle')
+        end
+    end
 end
 
 function World.all_characters(surface)