Coding Help Needed

[TheSAguy]

Hi,

I have created a new enemy unit, with it's own force. Vampire unit & force.

I'm trying to accomplish the following. When a Vampire unit kills another vanilla enemy, a new vampire unit will spawn.
This was my approach, when a small biter dies, look in the immediate area and see if there is a vampire biter. if there is one, assume that it killed the biter and spawn a new vampire biter.

I'm not 100% sure how to search the area around the dead biter and if I need to use "find_non_colliding_position" when spawning the new unit.
Below is my code attempt, with some alternative possibilities commented out. Could I please have someone review this and give me pointers?

Code: Select all

---------------------------------------------
script.on_event({defines.events.on_entity_died,},function(event) On_Remove(event) end)
---------------------------------------------

function On_Remove(event)

	-- When a small biter gets killed.

	if event.entity.name == "small-biter" then
		local surface = game.get_surface(0)
		local radius = 1
		local pos = event.entity.position
		local area = {{pos.x - radius, pos.y - radius}, {pos.x + radius, pos.y + radius}}
       
	   -- find nearby Vampire biters
       local V_Biters = surface.find_entities_filtered{area=area, name="small-vampire"}
	   --local V_Biters = surface.find_enemy_units(pos, radius, vampire) -- Alternative possibility?
	   --local V_Biter = surface.find_entities_filtered{area=area, force="vampire"} -- Alternative possibility?

		if V_Biters then   
			player.surface.create_entity{name="small-vampire", position={pos}, force=game.forces.vampire}
			-- player.surface.create_entity{name="small-vampire", position={PosX,PosY}, force=game.forces.vampire} -- Alternative possibility?
			--SpawnVampire(event.entity) -- Alternative possibility using below function	
		end
			
	end
	
end

function SpawnVampire(enemy)
		
		local SpawnPosition = enemy.surface.find_non_colliding_position(enemy, enemy.position, 2, 0.5)
		if SpawnPosition then
			enemy.surface.create_entity({name = "small-vampire", position = SpawnPosition, force = game.forces.enemy})
		end
end

Thanks!

[Adil]

I'm not good at C++ so no pointers
The code you've made looks like it could work. At least for default surface and a single type of vampires.
Though I'm not sure if

Code: Select all

game.get_surface(0) 

is correct syntax at all. (I believe a name of surface should be instead of zero there.) But generally, you don't need that function, you can obtain relevant surface from the entity which is given to handler. (See example in my code below.)
Also, if there's more than one type of vampires it'd be indeed better to use the third variant of find_entities:

Code: Select all

local V_Biter = surface.find_entities_filtered{area=area, force="vampire"}

As I said, I'm not good with pointers and reviewing. When I see code, alternatives of how would I do the same keep popping out in my head. So below under spoiler my untested implementation is provided. Feel free to examine or use it.

My code

Assuming you have a force named "vampire" and it can only have units, that turn other biters into vampires, you can get away without find_entity(). Considering that most of the time it will be your turrets, that do the killing, it might be more efficient.

Also, it might be a good thing to give newly spawned vampires to game AI handler.

Code: Select all

victims={
    ["small-biter"]="small-vampire",
}

function On_Remove(event)

   -- When an entity from the list of valid victims is killed

    if victims[event.entity.name]  then
        local victim=event.entity
        local killcount = game.forces.vampire.get_kill_count(victim.name)
        global.vampire_kills=global.vampire_kills or {}
        global.vampire_kills[victim.name]=global.vampire_kills[victim.entity.name] or 0
        if global.vampire_kills[victim.name] ~= killcount then
            global.vampire_kills[victim.name] = killcount
            SpawnVampire(victim)
        end
  end
end

function SpawnVampire(former_entity)
    local e= former_entity
      --local SpawnPosition = enemy.surface.find_non_colliding_position(enemy, enemy.position, 2, 0.5) --we probably don't need this, since the former_entity did occupy some perfectly valid position and is dying this tick anyway, freeing that space
    local new_ent = e.surface.create_entity{name=victim[e.name], position=e.position, force=game.forces.vampire}
    
    --below is additional functionality that has sneaked in. Namely, the mentioned creation of unit group and giving it to the game AI
    global.last_arisen = global.last_arisen or {}
    global.last_arisen[e.surface.name] = global.last_arisen[e.surface.name] or {}
    table.insert(global.last_arisen[e.surface.name], new_ent) --prepare for giving group to AI
    if not global.next_group_formation then 
         --register the handler which should eventually pass the group if it was not initialized before
         global.next_group_formation={}
         script.on_event(defines.events.on_tick, group_pass)
    end
    global.next_group_formation[e.surface.name] = game.tick+ 5 * 60 --this sets the timeout for group formation on this surface to be 5 seconds after the last vampire creation
end

function group_pass(event)
    --handle giving the vampires a greater goal
    for surf_name, time in pairs(global.next_group_formation) do
    if time == event.tick then
        local units = global.last_arisen[ global.next_group_formation[event.tick] ]
        local vamp = units[1]
        group = vamp.surface.create_unit_group(force=vamp.force, position=vamp.position}
        for i =2, #units do
             group.add_member(units[i])
        end
        group.set_autonomous() --the game will probably use them for building a base or attacking player
        
        --clean up
       global.last_arisen[ global.next_group_formation[event.tick] ] = nil
       global.next_group_formation[surf_name] = nil 
       if not next(global.next_group_formation) then
           --if there's no non-nil elements in global.next_group_formation then all fights are finished for now and we don't need the on_tick handler for a while
           script.on_event(defines.events.on_tick, nil)
       end
    end
    end        
end

edit: code bugfix

[TheSAguy]

OMG Adil!
This looks great, can't wait to give it a try.

Thanks.