2024-08-07 17:11:55 +03:00
|
|
|
local util = dofile_once("mods/quant.ew/files/core/util.lua")
|
|
|
|
local ctx = dofile_once("mods/quant.ew/files/core/ctx.lua")
|
|
|
|
local net = dofile_once("mods/quant.ew/files/core/net.lua")
|
|
|
|
local player_fns = dofile_once("mods/quant.ew/files/core/player_fns.lua")
|
2024-06-02 13:49:11 +03:00
|
|
|
local np = require("noitapatcher")
|
2024-05-30 12:41:56 +03:00
|
|
|
|
2024-08-16 22:54:58 +03:00
|
|
|
local ffi = require("ffi")
|
2024-05-30 12:41:56 +03:00
|
|
|
local rpc = net.new_rpc_namespace()
|
2024-05-08 20:33:41 +03:00
|
|
|
|
2024-08-16 21:52:15 +03:00
|
|
|
local EnemyData = util.make_type({
|
2024-08-16 23:58:11 +03:00
|
|
|
u32 = {"enemy_id"},
|
2024-08-17 00:55:05 +03:00
|
|
|
f32 = {"x", "y", "vx", "vy"},
|
2024-08-16 21:52:15 +03:00
|
|
|
})
|
2024-08-16 22:20:00 +03:00
|
|
|
|
2024-08-16 23:38:38 +03:00
|
|
|
-- Variant of EnemyData for when we don't have any motion (or no VelocityComponent).
|
|
|
|
local EnemyDataNoMotion = util.make_type({
|
2024-08-16 23:58:11 +03:00
|
|
|
u32 = {"enemy_id"},
|
2024-08-17 00:55:05 +03:00
|
|
|
f32 = {"x", "y"}
|
|
|
|
})
|
|
|
|
|
|
|
|
local HpData = util.make_type({
|
|
|
|
u32 = {"enemy_id"},
|
|
|
|
f32 = {"hp", "max_hp"}
|
2024-08-16 23:38:38 +03:00
|
|
|
})
|
|
|
|
|
2024-08-16 22:20:00 +03:00
|
|
|
local FULL_TURN = math.pi * 2
|
|
|
|
|
2024-08-16 21:38:14 +03:00
|
|
|
local PhysData = util.make_type({
|
2024-08-16 22:20:00 +03:00
|
|
|
f32 = {"x", "y", "vx", "vy", "vr"},
|
|
|
|
-- We should be able to cram rotation into 1 byte.
|
|
|
|
u8 = {"r"}
|
2024-08-16 21:38:14 +03:00
|
|
|
})
|
|
|
|
|
2024-08-16 22:54:58 +03:00
|
|
|
-- Variant of PhysData for when we don't have any motion.
|
|
|
|
local PhysDataNoMotion = util.make_type({
|
|
|
|
f32 = {"x", "y"},
|
|
|
|
-- We should be able to cram rotation into 1 byte.
|
|
|
|
u8 = {"r"}
|
|
|
|
})
|
|
|
|
|
2024-05-08 20:33:41 +03:00
|
|
|
local enemy_sync = {}
|
|
|
|
|
2024-06-02 13:49:11 +03:00
|
|
|
local dead_entities = {}
|
2024-08-13 18:43:01 +03:00
|
|
|
-- TODO this basically never happens, doesn't seem that useful anymore. Perhaps should be removed to conserve memory.
|
2024-06-13 15:56:33 +03:00
|
|
|
local confirmed_kills = {}
|
2024-06-02 13:49:11 +03:00
|
|
|
|
2024-08-13 18:43:01 +03:00
|
|
|
local spawned_by_us = {}
|
|
|
|
|
2024-08-15 23:23:24 +03:00
|
|
|
-- HACK
|
|
|
|
local times_spawned_last_minute = {}
|
|
|
|
|
2024-08-17 18:46:04 +03:00
|
|
|
local DISTANCE_LIMIT = 128*5
|
|
|
|
|
2024-08-15 21:02:23 +03:00
|
|
|
for filename, _ in pairs(constants.phys_sync_allowed) do
|
|
|
|
util.add_tag_to(filename, "prop_physics")
|
|
|
|
-- Idk it just causes the minecart to not appear at all.
|
|
|
|
-- util.replace_text_in(filename, 'kill_entity_after_initialized="1"', 'kill_entity_after_initialized="0"')
|
|
|
|
end
|
|
|
|
|
2024-06-02 13:49:11 +03:00
|
|
|
np.CrossCallAdd("ew_es_death_notify", function(enemy_id, responsible_id)
|
|
|
|
local player_data = player_fns.get_player_data_by_local_entity_id(responsible_id)
|
2024-08-15 09:16:29 -04:00
|
|
|
local responsible
|
2024-06-02 13:49:11 +03:00
|
|
|
if player_data ~= nil then
|
|
|
|
responsible = player_data.peer_id
|
|
|
|
else
|
|
|
|
responsible = responsible_id
|
|
|
|
end
|
|
|
|
table.insert(dead_entities, {enemy_id, responsible})
|
|
|
|
end)
|
|
|
|
|
2024-05-08 20:33:41 +03:00
|
|
|
local function world_exists_for(entity)
|
|
|
|
local x, y = EntityGetFirstHitboxCenter(entity)
|
|
|
|
local w, h = 5, 5 -- TODO
|
|
|
|
w = w * 0.5
|
|
|
|
h = h * 0.5
|
|
|
|
return DoesWorldExistAt(x - w, y - h, x + w, y + h)
|
|
|
|
end
|
|
|
|
|
2024-05-09 23:37:50 +03:00
|
|
|
local function table_extend(to, from)
|
|
|
|
for _, e in ipairs(from) do
|
|
|
|
to[#to+1] = e
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
local function table_extend_filtered(to, from, filter)
|
|
|
|
for _, e in ipairs(from) do
|
|
|
|
if filter(e) then
|
|
|
|
to[#to+1] = e
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2024-08-23 20:39:38 +03:00
|
|
|
local function serialize_phys_component(phys_component)
|
|
|
|
local px, py, pr, pvx, pvy, pvr = np.PhysBodyGetTransform(phys_component)
|
|
|
|
if math.abs(pvx) < 0.01 and math.abs(pvy) < 0.01 and math.abs(pvr) < 0.01 then
|
|
|
|
return PhysDataNoMotion {
|
|
|
|
x = px,
|
|
|
|
y = py,
|
|
|
|
r = math.floor((pr % FULL_TURN) / FULL_TURN * 255),
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return PhysData {
|
|
|
|
x = px,
|
|
|
|
y = py,
|
|
|
|
r = math.floor((pr % FULL_TURN) / FULL_TURN * 255),
|
|
|
|
vx = pvx,
|
|
|
|
vy = pvy,
|
|
|
|
vr = pvr,
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
local function deserialize_phys_component(phys_component, phys_info)
|
|
|
|
if ffi.typeof(phys_info) == PhysDataNoMotion then
|
|
|
|
np.PhysBodySetTransform(phys_component, phys_info.x, phys_info.y, phys_info.r / 255 * FULL_TURN, 0, 0, 0)
|
|
|
|
else
|
|
|
|
np.PhysBodySetTransform(phys_component, phys_info.x, phys_info.y, phys_info.r / 255 * FULL_TURN, phys_info.vx, phys_info.vy, phys_info.vr)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2024-08-17 18:46:04 +03:00
|
|
|
local function get_sync_entities(return_all)
|
|
|
|
local entities = {}
|
2024-06-14 20:40:38 +03:00
|
|
|
table_extend_filtered(entities, EntityGetWithTag("enemy"), function (ent)
|
|
|
|
return not (EntityHasTag(ent, "ew_no_enemy_sync"))
|
|
|
|
end)
|
2024-06-19 13:12:06 +03:00
|
|
|
table_extend(entities, EntityGetWithTag("ew_enemy_sync_extra"))
|
2024-08-13 14:18:45 +03:00
|
|
|
table_extend_filtered(entities, EntityGetWithTag("prop_physics"), function (ent)
|
|
|
|
return constants.phys_sync_allowed[EntityGetFilename(ent)]
|
|
|
|
end)
|
|
|
|
|
2024-08-17 18:46:04 +03:00
|
|
|
local skipped_counter = 0
|
|
|
|
local entities2 = {}
|
|
|
|
if return_all then
|
|
|
|
entities2 = entities
|
|
|
|
else
|
|
|
|
table_extend_filtered(entities2, entities, function(ent)
|
|
|
|
local x, y = EntityGetTransform(ent)
|
2024-08-25 11:13:24 -04:00
|
|
|
local has_anyone = #EntityGetInRadiusWithTag(x, y, DISTANCE_LIMIT, "ew_client") > 0
|
2024-08-17 18:46:04 +03:00
|
|
|
if not has_anyone then
|
|
|
|
skipped_counter = skipped_counter + 1
|
|
|
|
end
|
|
|
|
return has_anyone
|
|
|
|
end)
|
|
|
|
end
|
|
|
|
-- GamePrint("skipped "..skipped_counter.." out of "..#entities)
|
|
|
|
|
|
|
|
return entities2
|
2024-05-10 10:30:14 +03:00
|
|
|
end
|
|
|
|
|
|
|
|
function enemy_sync.host_upload_entities()
|
|
|
|
local entities = get_sync_entities()
|
2024-05-08 20:33:41 +03:00
|
|
|
local enemy_data_list = {}
|
2024-05-09 23:37:50 +03:00
|
|
|
for i, enemy_id in ipairs(entities) do
|
2024-05-08 20:33:41 +03:00
|
|
|
if not world_exists_for(enemy_id) then
|
|
|
|
goto continue
|
|
|
|
end
|
|
|
|
local filename = EntityGetFilename(enemy_id)
|
2024-08-16 20:43:59 +03:00
|
|
|
filename = constants.interned_filename_to_index[filename] or filename
|
|
|
|
|
2024-05-08 20:33:41 +03:00
|
|
|
local x, y = EntityGetTransform(enemy_id)
|
2024-05-09 23:37:50 +03:00
|
|
|
local character_data = EntityGetFirstComponentIncludingDisabled(enemy_id, "VelocityComponent")
|
2024-05-08 22:13:17 +03:00
|
|
|
local vx, vy = 0, 0
|
2024-05-09 23:37:50 +03:00
|
|
|
if character_data ~= nil then
|
2024-05-08 22:13:17 +03:00
|
|
|
vx, vy = ComponentGetValue2(character_data, "mVelocity")
|
|
|
|
end
|
2024-05-09 23:37:50 +03:00
|
|
|
local ai_component = EntityGetFirstComponentIncludingDisabled(enemy_id, "AnimalAIComponent")
|
2024-06-13 21:30:19 +03:00
|
|
|
if ai_component ~= 0 and ai_component ~= nil then
|
2024-05-09 23:37:50 +03:00
|
|
|
ComponentSetValue2(ai_component, "max_distance_to_cam_to_start_hunting", math.pow(2, 29))
|
|
|
|
end
|
2024-05-21 10:48:40 +03:00
|
|
|
local hp, max_hp, has_hp = util.get_ent_health(enemy_id)
|
|
|
|
|
2024-08-23 20:39:38 +03:00
|
|
|
local phys_info = {}
|
|
|
|
local phys_info_2 = {}
|
2024-08-13 18:43:01 +03:00
|
|
|
-- Some things (like physics object) don't react well to making their entities ephemerial.
|
|
|
|
local not_ephemerial = false
|
2024-08-13 14:18:45 +03:00
|
|
|
|
2024-08-23 20:39:38 +03:00
|
|
|
for _, phys_component in ipairs(EntityGetComponent(enemy_id, "PhysicsBodyComponent") or {}) do
|
|
|
|
if phys_component ~= nil and phys_component ~= 0 then
|
|
|
|
not_ephemerial = true
|
|
|
|
table.insert(phys_info, serialize_phys_component(phys_component))
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
for _, phys_component in ipairs(EntityGetComponent(enemy_id, "PhysicsBody2Component") or {}) do
|
|
|
|
if phys_component ~= nil and phys_component ~= 0 then
|
|
|
|
not_ephemerial = true
|
|
|
|
local initialized = ComponentGetValue2(phys_component, "mInitialized")
|
|
|
|
if initialized then
|
|
|
|
table.insert(phys_info_2, serialize_phys_component(phys_component))
|
2024-08-16 22:54:58 +03:00
|
|
|
else
|
2024-08-23 20:39:38 +03:00
|
|
|
table.insert(phys_info_2, nil)
|
2024-08-16 22:54:58 +03:00
|
|
|
end
|
2024-08-13 14:18:45 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2024-05-21 10:48:40 +03:00
|
|
|
if has_hp then
|
|
|
|
util.ensure_component_present(enemy_id, "LuaComponent", "ew_death_notify", {
|
2024-08-07 17:21:25 +03:00
|
|
|
script_death = "mods/quant.ew/files/resource/cbs/death_notify.lua"
|
2024-05-21 10:48:40 +03:00
|
|
|
})
|
|
|
|
end
|
2024-05-12 18:05:25 +03:00
|
|
|
|
2024-07-10 14:23:57 +03:00
|
|
|
-- TODO: figure out how to sync those.
|
|
|
|
-- local laser_sight_data = nil
|
|
|
|
-- local laser_sight = EntityGetFirstComponentIncludingDisabled(enemy_id, "SpriteComponent", "laser_sight")
|
|
|
|
-- if laser_sight ~= nil and laser_sight ~= 0 then
|
2024-08-15 09:16:29 -04:00
|
|
|
-- -- local x, y, r =
|
2024-07-10 14:23:57 +03:00
|
|
|
-- end
|
2024-08-16 23:58:11 +03:00
|
|
|
|
2024-08-16 23:38:38 +03:00
|
|
|
local en_data
|
|
|
|
if math.abs(vx) < 0.01 and math.abs(vy) < 0.01 then
|
|
|
|
en_data= EnemyDataNoMotion {
|
2024-08-16 23:58:11 +03:00
|
|
|
enemy_id = enemy_id,
|
2024-08-16 23:38:38 +03:00
|
|
|
x = x,
|
|
|
|
y = y,
|
|
|
|
}
|
|
|
|
else
|
|
|
|
en_data= EnemyData {
|
2024-08-16 23:58:11 +03:00
|
|
|
enemy_id = enemy_id,
|
2024-08-16 23:38:38 +03:00
|
|
|
x = x,
|
|
|
|
y = y,
|
|
|
|
vx = vx,
|
|
|
|
vy = vy,
|
2024-08-17 00:55:05 +03:00
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2024-08-23 20:39:38 +03:00
|
|
|
table.insert(enemy_data_list, {filename, en_data, not_ephemerial, phys_info, phys_info_2})
|
2024-05-08 20:33:41 +03:00
|
|
|
::continue::
|
|
|
|
end
|
2024-05-21 10:48:40 +03:00
|
|
|
|
2024-08-17 00:55:05 +03:00
|
|
|
-- local estimate = net.estimate_rpc_size(enemy_data_list)
|
|
|
|
-- GamePrint(#enemy_data_list.." "..net.estimate_rpc_size(enemy_data_list).." "..(estimate*30))
|
2024-08-16 20:43:59 +03:00
|
|
|
|
2024-05-30 12:41:56 +03:00
|
|
|
rpc.handle_enemy_data(enemy_data_list)
|
|
|
|
if #dead_entities > 0 then
|
|
|
|
rpc.handle_death_data(dead_entities)
|
|
|
|
end
|
2024-06-02 13:49:11 +03:00
|
|
|
dead_entities = {}
|
2024-08-17 12:58:01 +03:00
|
|
|
end
|
|
|
|
|
|
|
|
local function host_upload_health()
|
|
|
|
local entities = get_sync_entities()
|
|
|
|
|
|
|
|
local enemy_health_list = {}
|
|
|
|
for i, enemy_id in ipairs(entities) do
|
|
|
|
if not world_exists_for(enemy_id) then
|
|
|
|
goto continue
|
|
|
|
end
|
|
|
|
|
|
|
|
local hp, max_hp, has_hp = util.get_ent_health(enemy_id)
|
|
|
|
|
|
|
|
if has_hp then
|
|
|
|
table.insert(enemy_health_list, HpData {
|
|
|
|
enemy_id = enemy_id,
|
|
|
|
hp = hp,
|
|
|
|
max_hp = max_hp,
|
|
|
|
})
|
|
|
|
end
|
|
|
|
|
|
|
|
::continue::
|
|
|
|
end
|
|
|
|
|
2024-08-17 00:55:05 +03:00
|
|
|
if #enemy_health_list > 0 then
|
|
|
|
rpc.handle_enemy_health(enemy_health_list)
|
|
|
|
end
|
2024-05-08 20:33:41 +03:00
|
|
|
end
|
|
|
|
|
|
|
|
function enemy_sync.client_cleanup()
|
2024-08-17 18:46:04 +03:00
|
|
|
local entities = get_sync_entities(true)
|
2024-05-10 10:30:14 +03:00
|
|
|
for i, enemy_id in ipairs(entities) do
|
2024-05-08 20:33:41 +03:00
|
|
|
if not EntityHasTag(enemy_id, "ew_replicated") then
|
2024-06-19 13:12:06 +03:00
|
|
|
local filename = EntityGetFilename(enemy_id)
|
|
|
|
print("Despawning unreplicated "..enemy_id.." "..filename)
|
2024-05-08 20:33:41 +03:00
|
|
|
EntityKill(enemy_id)
|
2024-08-13 18:43:01 +03:00
|
|
|
elseif not spawned_by_us[enemy_id] then
|
|
|
|
local filename = EntityGetFilename(enemy_id)
|
|
|
|
print("Despawning persisted "..enemy_id.." "..filename)
|
|
|
|
EntityKill(enemy_id)
|
2024-05-08 20:33:41 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
local frame = GameGetFrameNum()
|
2024-05-10 10:30:14 +03:00
|
|
|
for remote_id, enemy_data in pairs(ctx.entity_by_remote_id) do
|
|
|
|
if frame - enemy_data.frame > 60*1 then
|
2024-05-30 11:57:02 +03:00
|
|
|
print("Despawning stale "..remote_id.." "..enemy_data.id)
|
2024-05-08 20:33:41 +03:00
|
|
|
EntityKill(enemy_data.id)
|
2024-05-10 10:30:14 +03:00
|
|
|
ctx.entity_by_remote_id[remote_id] = nil
|
2024-05-08 20:33:41 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2024-05-30 12:41:56 +03:00
|
|
|
function enemy_sync.on_world_update_host()
|
2024-08-17 18:27:58 +03:00
|
|
|
if GameGetFrameNum() % ctx.proxy_opt.enemy_sync_interval == 1 then
|
2024-05-30 12:41:56 +03:00
|
|
|
enemy_sync.host_upload_entities()
|
|
|
|
end
|
2024-08-17 12:58:01 +03:00
|
|
|
if GameGetFrameNum() % 10 == 5 then
|
|
|
|
host_upload_health()
|
|
|
|
end
|
2024-05-30 12:41:56 +03:00
|
|
|
end
|
|
|
|
|
|
|
|
function enemy_sync.on_world_update_client()
|
|
|
|
if GameGetFrameNum() % 20 == 1 then
|
|
|
|
enemy_sync.client_cleanup()
|
|
|
|
end
|
2024-08-15 23:23:24 +03:00
|
|
|
if GameGetFrameNum() % (60*60) == 1 then
|
|
|
|
times_spawned_last_minute = {}
|
|
|
|
end
|
2024-05-30 12:41:56 +03:00
|
|
|
end
|
|
|
|
|
|
|
|
rpc.opts_reliable()
|
|
|
|
function rpc.handle_death_data(death_data)
|
2024-06-02 13:49:11 +03:00
|
|
|
for _, remote_data in ipairs(death_data) do
|
|
|
|
local remote_id = remote_data[1]
|
2024-06-17 20:57:49 +03:00
|
|
|
if confirmed_kills[remote_id] then
|
|
|
|
GamePrint("Remote id has been killed already..?")
|
|
|
|
goto continue
|
|
|
|
end
|
2024-06-13 15:56:33 +03:00
|
|
|
confirmed_kills[remote_id] = true
|
2024-06-02 13:49:11 +03:00
|
|
|
local responsible_entity = 0
|
|
|
|
local peer_data = player_fns.peer_get_player_data(remote_data[2], true)
|
|
|
|
if peer_data ~= nil then
|
|
|
|
responsible_entity = peer_data.entity
|
|
|
|
elseif ctx.entity_by_remote_id[remote_data[2]] ~= nil then
|
|
|
|
responsible_entity = ctx.entity_by_remote_id[remote_data[2]]
|
|
|
|
end
|
|
|
|
|
2024-05-19 12:03:03 +03:00
|
|
|
local enemy_data = ctx.entity_by_remote_id[remote_id]
|
2024-06-14 17:07:52 +03:00
|
|
|
if enemy_data ~= nil and EntityGetIsAlive(enemy_data.id) then
|
2024-05-19 12:03:03 +03:00
|
|
|
local enemy_id = enemy_data.id
|
2024-05-30 11:57:02 +03:00
|
|
|
local immortal = EntityGetFirstComponentIncludingDisabled(enemy_id, "LuaComponent", "ew_immortal")
|
2024-06-09 19:55:07 +03:00
|
|
|
if immortal ~= 0 then
|
2024-05-30 11:57:02 +03:00
|
|
|
EntityRemoveComponent(enemy_id, immortal)
|
|
|
|
end
|
|
|
|
local protection_component_id = GameGetGameEffect(enemy_id, "PROTECTION_ALL")
|
2024-06-01 17:10:16 +03:00
|
|
|
if protection_component_id ~= 0 then
|
2024-05-30 11:57:02 +03:00
|
|
|
EntitySetComponentIsEnabled(enemy_id, protection_component_id, false)
|
|
|
|
end
|
2024-05-21 10:48:40 +03:00
|
|
|
|
2024-06-17 20:57:49 +03:00
|
|
|
local damage_component = EntityGetFirstComponentIncludingDisabled(enemy_id, "DamageModelComponent")
|
|
|
|
if damage_component and damage_component ~= 0 then
|
|
|
|
ComponentSetValue2(damage_component, "wait_for_kill_flag_on_death", false)
|
|
|
|
end
|
2024-08-18 13:48:46 -04:00
|
|
|
|
2024-08-16 12:28:35 +03:00
|
|
|
-- Enable explosion back
|
|
|
|
local expl_component = EntityGetFirstComponent(enemy_id, "ExplodeOnDamageComponent")
|
|
|
|
if expl_component ~= nil and expl_component ~= 0 then
|
|
|
|
ComponentSetValue2(expl_component, "explode_on_death_percent", 1)
|
|
|
|
end
|
2024-06-17 20:57:49 +03:00
|
|
|
|
2024-05-19 12:03:03 +03:00
|
|
|
local current_hp = util.get_ent_health(enemy_id)
|
|
|
|
local dmg = current_hp
|
|
|
|
if dmg > 0 then
|
2024-06-02 13:49:11 +03:00
|
|
|
EntityInflictDamage(enemy_id, dmg+0.1, "DAMAGE_CURSE", "", "NONE", 0, 0, responsible_entity)
|
2024-05-19 12:03:03 +03:00
|
|
|
end
|
2024-08-16 12:28:35 +03:00
|
|
|
|
2024-06-02 13:49:11 +03:00
|
|
|
EntityInflictDamage(enemy_id, 1000000000, "DAMAGE_CURSE", "", "NONE", 0, 0, responsible_entity) -- Just to be sure
|
2024-08-18 13:48:46 -04:00
|
|
|
local parent = EntityGetParent(enemy_id)
|
|
|
|
if parent ~= nil then
|
|
|
|
EntityKill(parent)
|
|
|
|
end
|
2024-05-30 11:57:02 +03:00
|
|
|
EntityKill(enemy_id)
|
2024-05-19 12:03:03 +03:00
|
|
|
end
|
2024-06-17 20:57:49 +03:00
|
|
|
::continue::
|
2024-05-19 12:03:03 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2024-05-30 12:41:56 +03:00
|
|
|
function rpc.handle_enemy_data(enemy_data)
|
2024-08-16 20:43:59 +03:00
|
|
|
-- GamePrint("Got enemy data: "..#enemy_data)
|
2024-05-08 20:33:41 +03:00
|
|
|
for _, enemy_info_raw in ipairs(enemy_data) do
|
2024-08-16 23:58:11 +03:00
|
|
|
local filename = enemy_info_raw[1]
|
2024-08-16 20:43:59 +03:00
|
|
|
filename = constants.interned_index_to_filename[filename] or filename
|
2024-08-18 13:48:46 -04:00
|
|
|
|
2024-08-16 23:58:11 +03:00
|
|
|
local en_data = enemy_info_raw[2]
|
|
|
|
local remote_enemy_id = en_data.enemy_id
|
2024-08-16 21:52:15 +03:00
|
|
|
|
|
|
|
local x = en_data.x
|
|
|
|
local y = en_data.y
|
2024-08-16 23:38:38 +03:00
|
|
|
local vx = 0
|
|
|
|
local vy = 0
|
|
|
|
if ffi.typeof(en_data) == EnemyData then
|
|
|
|
vx = en_data.vx
|
|
|
|
vy = en_data.vy
|
|
|
|
end
|
2024-08-23 20:39:38 +03:00
|
|
|
local not_ephemerial = enemy_info_raw[3]
|
|
|
|
local phys_infos = enemy_info_raw[4]
|
|
|
|
local phys_infos_2 = enemy_info_raw[5]
|
2024-05-19 12:03:03 +03:00
|
|
|
local has_died = filename == nil
|
2024-05-08 20:33:41 +03:00
|
|
|
|
|
|
|
local frame = GameGetFrameNum()
|
2024-08-15 09:16:29 -04:00
|
|
|
|
2024-06-13 15:56:33 +03:00
|
|
|
if confirmed_kills[remote_enemy_id] then
|
|
|
|
goto continue
|
|
|
|
end
|
|
|
|
|
2024-05-10 10:30:14 +03:00
|
|
|
if ctx.entity_by_remote_id[remote_enemy_id] ~= nil and not EntityGetIsAlive(ctx.entity_by_remote_id[remote_enemy_id].id) then
|
|
|
|
ctx.entity_by_remote_id[remote_enemy_id] = nil
|
2024-05-08 20:33:41 +03:00
|
|
|
end
|
2024-08-15 09:16:29 -04:00
|
|
|
|
2024-05-10 10:30:14 +03:00
|
|
|
if ctx.entity_by_remote_id[remote_enemy_id] == nil then
|
2024-05-19 12:03:03 +03:00
|
|
|
if filename == nil then
|
|
|
|
goto continue
|
|
|
|
end
|
2024-08-15 23:23:24 +03:00
|
|
|
times_spawned_last_minute[remote_enemy_id] = (times_spawned_last_minute[remote_enemy_id] or 0) + 1
|
|
|
|
if times_spawned_last_minute[remote_enemy_id] > 5 then
|
2024-08-15 23:24:24 +03:00
|
|
|
if times_spawned_last_minute[remote_enemy_id] == 6 then
|
2024-08-16 20:43:59 +03:00
|
|
|
print("Entity has been spawned again more than 5 times in last minute, skipping "..filename)
|
2024-08-15 23:23:24 +03:00
|
|
|
end
|
|
|
|
goto continue
|
|
|
|
end
|
2024-08-13 18:43:01 +03:00
|
|
|
local enemy_id
|
|
|
|
if not_ephemerial then
|
|
|
|
enemy_id = EntityLoad(filename, x, y)
|
|
|
|
else
|
|
|
|
enemy_id = util.load_ephemerial(filename, x, y)
|
|
|
|
end
|
|
|
|
spawned_by_us[enemy_id] = true
|
2024-05-12 18:05:25 +03:00
|
|
|
EntityAddTag(enemy_id, "ew_replicated")
|
2024-05-21 10:48:40 +03:00
|
|
|
EntityAddTag(enemy_id, "polymorphable_NOT")
|
2024-08-07 17:21:25 +03:00
|
|
|
EntityAddComponent2(enemy_id, "LuaComponent", {_tags="ew_immortal", script_damage_about_to_be_received = "mods/quant.ew/files/resource/cbs/immortal.lua"})
|
2024-06-17 20:57:49 +03:00
|
|
|
local damage_component = EntityGetFirstComponentIncludingDisabled(enemy_id, "DamageModelComponent")
|
|
|
|
if damage_component and damage_component ~= 0 then
|
|
|
|
ComponentSetValue2(damage_component, "wait_for_kill_flag_on_death", true)
|
|
|
|
end
|
2024-08-23 20:39:38 +03:00
|
|
|
for _, name in ipairs({"AnimalAIComponent", "PhysicsAIComponent", "CameraBoundComponent"}) do
|
2024-06-09 19:55:07 +03:00
|
|
|
local ai_component = EntityGetFirstComponentIncludingDisabled(enemy_id, name)
|
|
|
|
if ai_component ~= 0 then
|
|
|
|
EntityRemoveComponent(enemy_id, ai_component)
|
|
|
|
end
|
2024-05-08 22:13:17 +03:00
|
|
|
end
|
2024-05-10 10:30:14 +03:00
|
|
|
ctx.entity_by_remote_id[remote_enemy_id] = {id = enemy_id, frame = frame}
|
2024-08-23 20:39:38 +03:00
|
|
|
|
|
|
|
for _, phys_component in ipairs(EntityGetComponent(enemy_id, "PhysicsBody2Component") or {}) do
|
|
|
|
if phys_component ~= nil and phys_component ~= 0 then
|
|
|
|
ComponentSetValue2(phys_component, "destroy_body_if_entity_destroyed", true)
|
|
|
|
end
|
2024-08-13 17:39:03 +03:00
|
|
|
end
|
|
|
|
-- Make sure stuff doesn't decide to explode on clients by itself.
|
|
|
|
local expl_component = EntityGetFirstComponent(enemy_id, "ExplodeOnDamageComponent")
|
|
|
|
if expl_component ~= nil and expl_component ~= 0 then
|
|
|
|
ComponentSetValue2(expl_component, "explode_on_damage_percent", 0)
|
|
|
|
ComponentSetValue2(expl_component, "physics_body_modified_death_probability", 0)
|
2024-08-16 12:28:35 +03:00
|
|
|
ComponentSetValue2(expl_component, "explode_on_death_percent", 0)
|
2024-08-13 17:39:03 +03:00
|
|
|
end
|
|
|
|
|
2024-05-08 20:33:41 +03:00
|
|
|
end
|
|
|
|
|
2024-08-15 09:16:29 -04:00
|
|
|
local enemy_data_new = ctx.entity_by_remote_id[remote_enemy_id]
|
|
|
|
enemy_data_new.frame = frame
|
|
|
|
local enemy_id = enemy_data_new.id
|
2024-05-08 22:13:17 +03:00
|
|
|
|
2024-08-23 20:39:38 +03:00
|
|
|
for i, phys_component in ipairs(EntityGetComponent(enemy_id, "PhysicsBodyComponent") or {}) do
|
|
|
|
local phys_info = phys_infos[i]
|
|
|
|
if phys_component ~= nil and phys_component ~= 0 and phys_info ~= nil then
|
|
|
|
deserialize_phys_component(phys_component, phys_info)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
for i, phys_component in ipairs(EntityGetComponent(enemy_id, "PhysicsBody2Component") or {}) do
|
|
|
|
local phys_info = phys_infos_2[i]
|
|
|
|
if phys_component ~= nil and phys_component ~= 0 and phys_info ~= nil then
|
|
|
|
-- A physics body doesn't exist otherwise, causing a crash
|
|
|
|
local initialized = ComponentGetValue2(phys_component, "mInitialized")
|
|
|
|
if initialized then
|
|
|
|
deserialize_phys_component(phys_component, phys_info)
|
2024-08-16 22:54:58 +03:00
|
|
|
end
|
2024-08-13 14:18:45 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2024-05-19 12:03:03 +03:00
|
|
|
if not has_died then
|
|
|
|
local character_data = EntityGetFirstComponentIncludingDisabled(enemy_id, "CharacterDataComponent")
|
|
|
|
if character_data ~= nil then
|
|
|
|
ComponentSetValue2(character_data, "mVelocity", vx, vy)
|
|
|
|
end
|
|
|
|
local velocity_data = EntityGetFirstComponentIncludingDisabled(enemy_id, "VelocityComponent")
|
|
|
|
if velocity_data ~= nil then
|
|
|
|
ComponentSetValue2(velocity_data, "mVelocity", vx, vy)
|
|
|
|
end
|
2024-05-08 20:33:41 +03:00
|
|
|
EntitySetTransform(enemy_id, x, y)
|
2024-05-19 12:03:03 +03:00
|
|
|
end
|
2024-08-17 00:55:05 +03:00
|
|
|
::continue::
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
function rpc.handle_enemy_health(enemy_health_data)
|
|
|
|
-- GamePrint("Got enemy data: "..#enemy_data)
|
|
|
|
for _, en_data in ipairs(enemy_health_data) do
|
|
|
|
local remote_enemy_id = en_data.enemy_id
|
|
|
|
local hp = en_data.hp
|
|
|
|
local max_hp = en_data.max_hp
|
|
|
|
|
|
|
|
if ctx.entity_by_remote_id[remote_enemy_id] == nil or not EntityGetIsAlive(ctx.entity_by_remote_id[remote_enemy_id].id) then
|
|
|
|
goto continue
|
|
|
|
end
|
|
|
|
local enemy_data = ctx.entity_by_remote_id[remote_enemy_id]
|
|
|
|
local enemy_id = enemy_data.id
|
|
|
|
|
2024-05-12 18:05:25 +03:00
|
|
|
local current_hp = util.get_ent_health(enemy_id)
|
|
|
|
local dmg = current_hp-hp
|
|
|
|
if dmg > 0 then
|
2024-06-13 15:56:33 +03:00
|
|
|
-- Make sure the enemy doesn't die from the next EntityInflictDamage.
|
|
|
|
util.set_ent_health(enemy_id, {dmg*2, dmg*2})
|
|
|
|
-- Deal damage, so that game displays damage numbers.
|
2024-06-02 14:00:55 +03:00
|
|
|
EntityInflictDamage(enemy_id, dmg, "DAMAGE_CURSE", "", "NONE", 0, 0, GameGetWorldStateEntity())
|
2024-05-12 18:05:25 +03:00
|
|
|
end
|
2024-05-08 20:33:41 +03:00
|
|
|
util.set_ent_health(enemy_id, {hp, max_hp})
|
2024-05-19 12:03:03 +03:00
|
|
|
::continue::
|
2024-05-08 20:33:41 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2024-06-17 17:16:00 +03:00
|
|
|
function enemy_sync.on_projectile_fired(shooter_id, projectile_id, initial_rng, position_x, position_y, target_x, target_y, send_message,
|
|
|
|
unknown1, multicast_index, unknown3)
|
|
|
|
local not_a_player = not EntityHasTag(shooter_id, "ew_no_enemy_sync") and not EntityHasTag(shooter_id, "player_unit") and not EntityHasTag(shooter_id, "ew_client")
|
|
|
|
if not_a_player and ctx.is_host then
|
|
|
|
local projectileComponent = EntityGetFirstComponentIncludingDisabled(projectile_id, "ProjectileComponent")
|
2024-08-21 17:46:01 -04:00
|
|
|
if projectileComponent ~= nil then
|
|
|
|
local entity_that_shot = ComponentGetValue2(projectileComponent, "mEntityThatShot")
|
|
|
|
if entity_that_shot == 0 then
|
|
|
|
rpc.replicate_projectile(np.SerializeEntity(projectile_id), position_x, position_y, target_x, target_y, shooter_id, initial_rng)
|
|
|
|
end
|
2024-06-17 17:16:00 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
rpc.opts_reliable()
|
|
|
|
function rpc.replicate_projectile(seri_ent, position_x, position_y, target_x, target_y, remote_source_ent, rng)
|
2024-06-18 14:25:19 +03:00
|
|
|
if rng ~= nil then
|
|
|
|
np.SetProjectileSpreadRNG(rng)
|
|
|
|
end
|
|
|
|
if ctx.entity_by_remote_id[remote_source_ent] == nil then
|
|
|
|
return
|
|
|
|
end
|
2024-06-17 17:16:00 +03:00
|
|
|
local source_ent = ctx.entity_by_remote_id[remote_source_ent].id
|
|
|
|
local ent = EntityCreateNew()
|
|
|
|
np.DeserializeEntity(ent, seri_ent)
|
|
|
|
GameShootProjectile(source_ent, position_x, position_y, target_x, target_y, ent)
|
|
|
|
end
|
|
|
|
|
2024-08-15 09:16:29 -04:00
|
|
|
return enemy_sync
|