#============================================================================== # LonaCraft - 120_Raids.rb (board R4, design: docs/RESEARCH_RAIDS.md; owner # decisions 2026-10-06). Night raids on a base, with wall and door damage. # What it does: # * Trigger: a nap on a base map (Bases.record_for_map) keeps the game's own # danger roll (region_map_wildness_nap_stats, 34_Functions_RegionMap.rb:237-246) # and adds a base-value bonus to WildDangerous first: min(danger_cap, # value x danger_per_value), value = walls + 2 x doors + 3 x furniture. The # group list is the base's SCENARIO (7, by the record's world-map region, # research 2.3) instead of the region list (:248-337). A roll that picked a # raid group arms the raid. night_only: a raid rolled while napping at night # keeps it night (Game_Map#nap alias takes back the one $game_date.shift, # 70_Game_Map_DayNightAndOvermap.rb:13-14), so every raid comes at night. # * Spawn: the game's BIOS spawns the group after the nap # (region_map_wildness_spawn, :361-1115) on the outer spawn lists, which # 110_Bases.rb already pruned of built and enclosed tiles. This file adopts # the group (summon_data[:WildnessNapEvent] == the group, the tag the # templates set, Map001 ev 384), moves each raider to a tile at least # spawn_min_distance tiles from the base, door_bias of them on the side of # the door nearest Lona, and adds +1 raider (the group's first unit, # EXTRA_UNIT) per extra_raider_per_value of base value, up to # extra_raiders_max; never more than max_raiders in all. # * Warning: a popup and the group's spot sound; raiders hold their tiles for # the scenario's grace (8 s, forest 5 s), +5 s when Lona has a dog companion # (race "Dog", NPCdata/CompDoggy.json). # * Siege driver (research 3.5): while Lona is enclosed (flood from the play # area's edge with LIVE doors, an open door lets the flood through), each # breacher gets a stand tile beside a wall or door between the outside and # Lona's side, walks there over a distance map, faces the piece and swings: # a forced launch_skill of its first melee skill (animation and sound only, # the game's hit cannot pass a tag-4 tile, research 3.1) on a timer of # swing_frames + rand(swing_rand); the damage is the mod's: # max(1, atk - armour) x the race's breach factor, taken off the piece's HP # (Bases.damage_piece). At 0 HP the piece breaks (Bases.break_piece) and # the plan is made again; once Lona is not enclosed the game's own AI runs # and each raider without a target is sent to look where Lona is # (search_target_unit, 480_EventCharacterBatch.rb:880-902). # Breacher = breach factor > 0, not ranged, atk >= min_breach_atk. Others # mill outside (animals, commoners) or wait at range (ranged). # * End: all raiders down (dead, or stamina <= 0, as check_enemy_survival?, # 34_Functions_RegionMap.rb:1848-1866, which then runs too); give_up_frames # of siege without any breach (they walk to the edge of the area and go); # Lona leaves the map (any Game_Map#setup; past the warning, the raid # goes on as an away raid, below). Drops are the raiders' own. # A base left with no piece and no furniture ends after the raid. # * Nap during a raid: refused at Game_Map#call_nap_event # (31_Game_Map.rb:1305-1309), where Command_Nap.rb:9 and the bed / bedroll # nap of Command_AreaNap.rb hand over to the map's NapEvent, and again in # region_map_wildness_nap (the NapEvent's own command). # * A raid in progress is runtime only: not saved. After a load there is no # raid; the base record (with its HP table) is saved as always. # * Config/Bases.json (user file, never written by the mod) changes the # numbers; Config/Bases_defaults.json is written at the first use when its # text changed. Strict reader LonaCraft::ConfigJSON (55_Recipes.rb); a bad # file is not used, a bad entry is skipped, both with a console line. # * Debug (DEBUG): Numpad . (DEBUG_KEY) on a base map opens a menu, scenario # then group, and starts that raid at once (no roll, any time of day). # * Console lines "LonaCraft Raids: ..." for every phase. # * Nothing here runs on maps without a base: every hook first looks for a # base record, a running raid or the raid tag on an event. # * M1 (owner 2026-10-06): a door set in stone walls (the wall above it, or # both walls of a sideways door, are Stone Walls) is the piece kind "SD", # 600 HP / armour 6, here and in the away simulation (Bases.piece_kind). # Config/Bases.json gets the "away" (Scripts/140_AwayRaids.rb) and "mercs" # (Scripts/150_Mercs.rb) sections; Numpad . off a base map opens the # away-raid / mercenary debug menu (140_AwayRaids.rb). # * Deep Sewer (board R9, Scripts/130_Sewer.rb): the sewer is a tag map, so # the game's danger roll does not run there (region_map_wildness_nap_stats # needs OnRegionMap >= 1, 34_Functions_RegionMap.rb:1832, and # enter_static_tag_map sets it to 0, 34_Functions_ChangeMap.rb:84). The # sewer's own NapEvent rolls (35 % by day, 60 % at night), picks the group # from the "sewer" scenario (region 90, the sewer record's region) and arms # the raid with Raids.arm; its BIOS spawns the group on the tunnel mouths # (region 1) after the nap. Two groups for it: "AbomBreedlingRaid" (the # game's own case, :1077) and "SewerRats" (WildGiantMice, spawned by # 130_Sewer.rb, tagged through the summon data). # * Difficulty (board R10, docs/RESEARCH_DIFFICULTY.md, owner 2026-10-07): # Config/Bases.json "difficulty" {"level": "hard" / "hell" / "doom", one # table of knobs per level, "base_danger" {lower, higher}}. Independent of # the game's own mode (owner: "Let's keep it from following the game mode, # to give users customizability"). The level is read once, at config load # (console "LonaCraft difficulty: Hell (Config/Bases.json)"); an unknown # name falls back to hard. Every knob is an addition (_add) or a factor # (_mult) at an existing read site; "hard" is all 0 / 1.0, today's # numbers. diff(knob) reads the level's table, step(rec, knob) the base's # own Danger (rec["danger"] -1 Lower / 0 Normal / 1 Higher, missing = 0, # set on the world-map tile menu and the Deep Sewer ladders, 110_Bases.rb). # Here: roll_add (+ the base's step) added to WildDangerous with the # base-value bonus; danger_mult on danger_per_value and danger_cap; # extra_per_value_add, extra_raiders_add (+ step), max_raiders_add; # damage_mult on every swing; grace_mult on the warning (the dog's extra # time is not scaled); give_up_mult on give_up_frames, fixed when the raid # begins. The other knobs are read in 130_Sewer.rb, 140_AwayRaids.rb, # 150_Mercs.rb, 160_Rest.rb and 170_Maid.rb. # * Any hostile on a base map (owner bug report 2026-10-08: the game's own # nap group ignored the base and a hostile that lost sight of Lona behind # a shut door gave up). Before, only the raiders this file adopted and # tagged (summon_data[:LonaCraftRaid]) were driven, and only while they had # no target (drive / update_swings); the game's AI drops a target it cannot # see (sense_target, 281_Game_NonPlayerCharacter.rb:456-463: the sight # line ends on a tag-4 wall top or closed door, Sensors.rb:161-172, and # after targetLock_HP (10 sensor ticks) process_target_lost :490-504). # Now, every CHECK_EVERY frames on a base map (watch, Scene_Map alias), # an NPC joins the siege when Lona is shut in, it stands outside, and # either it targets Lona's side (Lona, her followers, the mercenaries, # the maid: Bases.lona_side?) and that target is shut in too ("aggro"), # or it is the game's own nap group of this map (summon_data # [:WildnessNapEvent] == OnRegionMapSpawnRace) and would attack Lona by # the game's own test (Bases.would_attack_lona?) ("nap group"). No running # raid: a siege state of its own (why :hostile) starts at once (no # warning, no extra raiders, no relocation); during a raid's siege phase # they join the raid (r[:joined], never tagged: the tag only marks the # mod's own raiders). Idle wanderers, non-hostile NPCs (traders, hobos, # guards that are not after Lona) and anything while Lona is not shut in # keep the game's AI. Same driver, same roles, same damage rules (armour, # breach factor, difficulty damage_mult); a unit with a target is driven # while its target is shut in, and keeps that target (Game_Event # #update_npc_sensor alias: targetLock_HP refilled before the game's # sensor tick, hold_target). The :hostile siege ends quietly (no popup, # no check_enemy_survival?) when its units are down or Lona is no longer # shut in; it gives up (walks off, deleted) as a raid does. The game's # nap spawn on a base map that the mod did not arm is never doubled: its # units join (after_spawn console line). Config raids "hostiles" (true). # Trace (LonaCraft.trace, debug + trace on): "siege: targets # at (x,y), reason no path / breach" when a unit is taken over or # re-targeted after a break, "siege: released, reason ..." when # it is let go (path open, down, gave up, raid over). # * Leaving during a raid (owner 2026-10-08: "If the player leaves the map, # with a base, during a raid (any raid, night time event), then it needs # to get treated like an away raid."). Hook: this file's Game_Map#setup # alias, BEFORE the game's setup (31_Game_Map.rb:159), the one point every # way off the map passes (map edge / exit menu, change_map_leave_region # and change_map_leave_tag_map, 34_Functions_ChangeMap.rb:179, 271, a # capture, a story transfer) while the raiders are still on the map. A # setup of the same map (a nap, handleNap -> setup(map_id_rec), as the # game's own nap test, 31_Game_Map.rb:165) is not a leave. Taken over: # a raid in its warning, siege or assault phase (not while the group is # collected or retreats) and every :hostile siege, with at least one unit # up. The units up (name, race, atk, current health, ranged, extra: # adopted after reserve_extras, r[:extra_ids]) go to # AwayRaids.left_raid!, which works the raid out at once on the record # as an away raid (140_AwayRaids.rb header). The live raid ends as # :handed: no popup, no check_enemy_survival?, no revert_if_empty (as a # :left end; the game's leave path clears its own nap race, # change_map_story_stats_fix, 34_Functions_ChangeMap.rb:131), @armed # cleared. Group: the raid's own; for a :hostile siege the units' nap # tag (summon_data[:WildnessNapEvent]) most of them carry, else # "Hostiles". Console and trace: "raid: Lona left during at , N raiders, handing to away raid". #============================================================================== module LonaCraft module Raids TEXT = "LonaCraft:Raids:" DEBUG = LonaCraft.debug? # Numpad . ; Config/LonaCraft.json "debug" (05_Config.rb), read at load DEBUG_KEY = :DECIMAL # Numpad . : free (95_Debug.rb 0 1 3 5 7 9 + - *, 110_Bases.rb /, the game 2 4 6 8) USER_FILE = "Config/Bases.json" DEFAULTS_FILE = "Config/Bases_defaults.json" ADOPT_FRAMES = 120 # frames to collect the spawned group (RandomGoblin summons in two steps) EXTRA_ADOPT_FRAMES = 90 CHECK_EVERY = 30 # frames between the end / door / enclosure checks HUNT_EVERY = 120 # frames between "go look where Lona is" in the assault STUCK_FRAMES = 60 # a breacher blocked this long gives its stand tile up DIRS = [[2, 0, 1], [4, -1, 0], [6, 1, 0], [8, 0, -1]] # group => the unit added as an extra raider (the group's first unit in # region_map_wildness_spawn, 34_Functions_RegionMap.rb:361-1115) EXTRA_UNIT = { "Orkind" => "RandomGoblin", "OrkindPlayGround" => "RandomHobgoblin", "Fishkind" => "FishkindCharger", "FishPPL" => "DeeponeSpearGuard", "BanditMobs" => "MobHumanRogueSpear", "CommonMobs" => "MobHumanCommoner", "UndeadWalking" => "UndeadCommoner", "WolfGroup" => "WildDireWolf", "AbomManager" => "AbomCreatureSpider", "AbomSpider" => "AbomCreatureSpider", "AbomBreedlingRaid" => "AbomCreatureBreedling", "SewerRats" => "WildGiantMice" } GROUPS = EXTRA_UNIT.keys SPOT_SOUND = { "Orkind" => :sound_goblin_spot, "OrkindPlayGround" => :sound_OrcSpot, "Fishkind" => :FishkindSmSpot, "FishPPL" => :FishkindSmSpot, "BanditMobs" => :sound_MaleWarriorSpot, "CommonMobs" => :sound_MaleWarriorSpot, "UndeadWalking" => :sound_ZombieSpot, "WolfGroup" => :dogSpot, "AbomManager" => :BreedlingSpot, "AbomSpider" => :BreedlingSpot, "AbomBreedlingRaid" => :BreedlingSpot, "SewerRats" => :ratSpot } SCENARIO_ORDER = ["field", "road", "forest", "shore", "swamp", "wasteland", "house", "sewer"] DEFAULTS = { "pieces" => { "W" => {"hp" => 600, "armour" => 3}, "D" => {"hp" => 300, "armour" => 3}, "S" => {"hp" => 1200, "armour" => 8}, # W1 stone wall (was "A4", the building wall) "SD" => {"hp" => 600, "armour" => 6} # M1: a door set in stone walls }, "repair" => {"item" => "ItemLonaCraftPlank", "hp" => 150, "frames" => 120, "blocked_after_hit_frames" => 180}, "raids" => { "enabled" => true, "danger_per_value" => 0.1, "danger_cap" => 10, "night_only" => true, "grace_frames" => 480, "dog_extra_frames" => 300, "give_up_frames" => 10800, "retreat_frames" => 1200, "swing_frames" => 60, "swing_rand" => 30, "spawn_min_distance" => 8, "door_bias" => 0.5, "extra_raider_per_value" => 30, "extra_raiders_max" => 4, "max_raiders" => 12, "min_breach_atk" => 3, "refuse_nap" => true, "hostiles" => true, # 2026-10-08: any hostile that cannot reach Lona through the walls attacks them "breach" => {"Orkind" => 1.5, "Goblin" => 1.0, "Human" => 1.0, "Fishkind" => 1.0, "Undead" => 0.75, "Abomination" => 1.25}, "scenarios" => { "field" => {"regions" => [1], "groups" => {"Orkind" => 70, "BanditMobs" => 30, "UndeadWalking" => 20, "WolfGroup" => 20}, "grace_frames" => 480, "door_bias" => 0.5}, "road" => {"regions" => [11, 17, 23], "groups" => {"BanditMobs" => 60, "Orkind" => 20, "CommonMobs" => 20}, "grace_frames" => 480, "door_bias" => 0.7}, "forest" => {"regions" => [4, 5, 7], "groups" => {"Orkind" => 70, "BanditMobs" => 20, "UndeadWalking" => 30, "WolfGroup" => 40}, "grace_frames" => 300, "door_bias" => 0.5}, "shore" => {"regions" => [2, 27], "groups" => {"Orkind" => 50, "BanditMobs" => 40, "FishPPL" => 20}, "grace_frames" => 480, "door_bias" => 0.5}, "swamp" => {"regions" => [8, 13, 15, 24, 25, 26], "groups" => {"Fishkind" => 70, "Orkind" => 30, "UndeadWalking" => 20}, "grace_frames" => 480, "door_bias" => 0.5}, "wasteland" => {"regions" => [3, 6, 14, 16, 19, 28], "groups" => {"AbomManager" => 40, "AbomSpider" => 30, "Orkind" => 30}, "grace_frames" => 480, "door_bias" => 0.5}, "house" => {"regions" => [9], "groups" => {"BanditMobs" => 60, "CommonMobs" => 30, "Orkind" => 10}, "grace_frames" => 480, "door_bias" => 0.8}, "sewer" => {"regions" => [90], "groups" => {"CommonMobs" => 50, "AbomBreedlingRaid" => 30, "SewerRats" => 30, "UndeadWalking" => 10}, "grace_frames" => 300, "door_bias" => 0.5} } }, # M1 item 2, away raids (Scripts/140_AwayRaids.rb, docs/RESEARCH_AWAY_RAIDS_MERCS.md 2, 5) "away" => { "enabled" => true, "chance" => 10.0, "value_bonus_per" => 10.0, "value_bonus_cap" => 10.0, "scenario_mult" => {"road" => 1.5, "house" => 1.5, "sewer" => 1.5}, "grace_days" => 1, "cooldown_days" => 2, "catchup_days" => 14, "swings" => 24.0, "per_extra_breacher" => 0.15, "breacher_cap" => 2.0, "spread" => 0.25, "difficulty_scale" => 0.01, "loot_fraction" => 0.5, "carry_per_looter" => 1500, "smash" => 0.25, "smash_station" => 0.1, "smash_cap" => 3, "reports_kept" => 5, "looters" => ["Human", "Moot", "Goblin", "Orkind", "Fishkind"] }, # M1 item 3, mercenaries (Scripts/150_Mercs.rb, research 3) "mercs" => { "enabled" => true, "coin" => "ItemCoin2", "price_per_day" => 1, "day_choices" => [1, 3, 7, 14], "squad_power" => 220.0, "deter" => 0.5, "down_days" => 1 }, # R12 / R14 rest tiers, the chest meal and the bath (Scripts/160_Rest.rb, docs/RESEARCH_REST.md 2.6) "rest" => { "enabled" => true, "ground_sta_mult" => 0.6, "ground_sta_cap_pct" => 80, "ground_health_mult" => 0.5, "ground_mood" => 10, "ground_dirt" => 15, "ground_sick_chance" => 10, "ground_danger" => 10, "bed_mood" => 10, "bed_roll_mult" => 0.75, "meal_sat" => 30, "food_on_bedroll" => false, "bath_on_bedroll" => false, "mystery_dishes" => false, "human_dishes" => false }, # R13 the maid (Scripts/170_Maid.rb, docs/RESEARCH_MAID.md 6) "maid" => { "enabled" => true, "hire_fee" => 5, "coin" => "ItemCoin1", "pay" => 1, "grace_days" => 3, "catchup_days" => 14, "dishes_per_day" => 2, "pantry_cap" => 6, "cook_skill" => 10, "need_fire" => true, "wander" => 3, "flee_radius" => 6, "away_kill" => 0.5 }, # R10 difficulty (docs/RESEARCH_DIFFICULTY.md section 4): "hard" is # today's numbers (every _add 0, every _mult 1.0); "hell" and "doom" # are the research's Harsh and Brutal columns "difficulty" => { "level" => "hard", "hard" => { "roll_add" => 0, "danger_mult" => 1.0, "extra_per_value_add" => 0, "extra_raiders_add" => 0, "max_raiders_add" => 0, "damage_mult" => 1.0, "grace_mult" => 1.0, "give_up_mult" => 1.0, "away_chance_mult" => 1.0, "away_grace_days_add" => 0, "away_cooldown_days_add" => 0, "away_power_mult" => 1.0, "smash_add" => 0.0, "smash_station_add" => 0.0, "smash_cap_add" => 0, "loot_add" => 0.0, "sewer_day_add" => 0, "sewer_night_add" => 0, "sewer_pop_mult" => 1.0, "merc_price_mult" => 1.0, "maid_fee_add" => 0, "maid_kill_add" => 0.0, "ground_danger_add" => 0, "ground_sick_add" => 0, "bed_roll_add" => 0.0 }, "hell" => { "roll_add" => 4, "danger_mult" => 1.5, "extra_per_value_add" => -5, "extra_raiders_add" => 1, "max_raiders_add" => 2, "damage_mult" => 1.25, "grace_mult" => 0.85, "give_up_mult" => 1.33, "away_chance_mult" => 1.5, "away_grace_days_add" => 0, "away_cooldown_days_add" => 0, "away_power_mult" => 1.25, "smash_add" => 0.05, "smash_station_add" => 0.02, "smash_cap_add" => 1, "loot_add" => 0.1, "sewer_day_add" => 5, "sewer_night_add" => 10, "sewer_pop_mult" => 1.25, "merc_price_mult" => 1.25, "maid_fee_add" => 2, "maid_kill_add" => 0.1, "ground_danger_add" => 5, "ground_sick_add" => 5, "bed_roll_add" => 0.1 }, "doom" => { "roll_add" => 8, "danger_mult" => 2.0, "extra_per_value_add" => -10, "extra_raiders_add" => 2, "max_raiders_add" => 4, "damage_mult" => 1.5, "grace_mult" => 0.7, "give_up_mult" => 1.67, "away_chance_mult" => 2.0, "away_grace_days_add" => 0, "away_cooldown_days_add" => -1, "away_power_mult" => 1.5, "smash_add" => 0.15, "smash_station_add" => 0.05, "smash_cap_add" => 2, "loot_add" => 0.25, "sewer_day_add" => 15, "sewer_night_add" => 20, "sewer_pop_mult" => 1.5, "merc_price_mult" => 1.5, "maid_fee_add" => 3, "maid_kill_add" => 0.25, "ground_danger_add" => 10, "ground_sick_add" => 10, "bed_roll_add" => 0.15 }, # the per-base Danger step (C4), on top of the level "base_danger" => { "lower" => {"roll_add" => -4, "away_chance_mult" => 0.67, "extra_raiders_add" => -1, "sewer_chance_add" => -10}, "higher" => {"roll_add" => 4, "away_chance_mult" => 1.5, "extra_raiders_add" => 1, "sewer_chance_add" => 10} } } } LEVELS = ["hard", "hell", "doom"] LEVEL_NAMES = {"hard" => "Hard", "hell" => "Hell", "doom" => "Doom"} DANGER_STEPS = {-1 => "lower", 0 => "normal", 1 => "higher"} @cfg = nil @raid = nil # the running raid (runtime only, never saved) @armed = nil # a nap roll picked a raid group; consumed by the spawn @debug_pending = nil @hits = {} # "map key:x,y" => Graphics.frame_count of the last hit @melee = {} # npc name => melee skill (or false) @level = nil # R10: the difficulty level, set at config load @watch_t = 0 # 2026-10-08: frame counter of the hostile watch @reach_cache = nil # [signature, {[x, y] => true}] of outside_reach # NPC races that are no creature (projectiles, traps, dummies) NOT_UNITS = ["Missile", "Bomb", "Mine", "SkillDummy", "AreaDot", "Overmap", "Johnson"] def self.say(text) p "LonaCraft Raids: #{text}" end def self.text_key(key) "#{TEXT}#{key}" end def self.bases LonaCraft::Bases end #---------------------------------------------------------------------- # Config/Bases.json #---------------------------------------------------------------------- def self.cfg load_config if @cfg.nil? @cfg end def self.rc cfg["raids"] end def self.copy(obj) Marshal.load(Marshal.dump(obj)) end def self.load_config @cfg = copy(DEFAULTS) write_defaults data = read_user merge_user(data) if data.is_a?(Hash) resolve_level bases.set_config(@cfg["pieces"], @cfg["repair"]) p "LonaCraft Raids: config ready, palisade #{@cfg["pieces"]["W"]["hp"]} HP, stone #{@cfg["pieces"]["S"]["hp"]} HP, door #{@cfg["pieces"]["D"]["hp"]} HP, raids #{rc["enabled"] ? "on" : "off"}" rescue => e say("config error #{e.class} #{e.message}, defaults used") @cfg = copy(DEFAULTS) resolve_level bases.set_config(@cfg["pieces"], @cfg["repair"]) end def self.read_user path = LonaCraft.resource(USER_FILE) return nil unless File.exist?(path) LonaCraft::ConfigJSON.parse(File.open(path, "rb"){|f| f.read }) rescue LonaCraft::ConfigJSON::Error => e say("#{USER_FILE} not used, #{e.message}") nil rescue => e say("#{USER_FILE} not used, #{e.class} #{e.message}") nil end def self.skip(where, why) say("#{USER_FILE} #{where} skipped, #{why}") end # a user value fits the default's type (numbers >= 0) def self.value_ok?(default, v) case default when true, false then v == true || v == false when Integer then v.is_a?(Integer) && v >= 0 when Float then v.is_a?(Numeric) && v >= 0 when String then v.is_a?(String) && !v.empty? else false end end def self.merge_flat(target, val, where) unless val.is_a?(Hash) skip(where, "not a {...} block") return end val.each{|k, v| if !target.key?(k) || target[k].is_a?(Hash) || target[k].is_a?(Array) skip("#{where}/#{k}", "unknown key") elsif !value_ok?(target[k], v) skip("#{where}/#{k}", "bad value #{v.inspect}") else target[k] = target[k].is_a?(Float) ? v.to_f : v end } end def self.merge_user(data) data.each{|sec, val| case sec when "pieces" unless val.is_a?(Hash) skip("pieces", "not a {...} block") next end val.each{|kind, v| if @cfg["pieces"][kind].nil? skip("pieces/#{kind}", "unknown piece (W, S, D, SD)") next end merge_flat(@cfg["pieces"][kind], v, "pieces/#{kind}") @cfg["pieces"][kind]["hp"] = DEFAULTS["pieces"][kind]["hp"] if @cfg["pieces"][kind]["hp"] < 1 } when "repair" merge_flat(@cfg["repair"], val, "repair") when "raids" merge_raids(val) when "away", "mercs" merge_lists(sec, val) when "rest", "maid" merge_flat(@cfg[sec], val, sec) when "difficulty" merge_difficulty(val) else skip(sec.to_s, "unknown section (pieces, repair, raids, away, mercs, rest, maid, difficulty)") end } r = rc r["door_bias"] = 1.0 if r["door_bias"] > 1.0 r["max_raiders"] = 1 if r["max_raiders"] < 1 r["extra_raider_per_value"] = 1 if r["extra_raider_per_value"] < 1 end # "away" / "mercs": flat numbers plus their few lists and tables def self.merge_lists(sec, val) unless val.is_a?(Hash) skip(sec, "not a {...} block") return end target = @cfg[sec] flat = {} val.each{|k, v| case k when "looters" if v.is_a?(Array) && v.all?{|n| n.is_a?(String) } target[k] = v else skip("#{sec}/#{k}", "needs a list of race names") end when "day_choices" if v.is_a?(Array) && !v.empty? && v.all?{|n| n.is_a?(Integer) && n > 0 } target[k] = v else skip("#{sec}/#{k}", "needs a list of day counts above 0") end when "scenario_mult" if v.is_a?(Hash) && v.all?{|n, m| n.is_a?(String) && m.is_a?(Numeric) && m >= 0 } target[k] = Hash[v.map{|n, m| [n, m.to_f] }] else skip("#{sec}/#{k}", "needs {scenario: multiplier}") end else flat[k] = v end } merge_flat(target, flat, sec) unless flat.empty? end # R10 "difficulty": "level" (a name), the three level tables and # "base_danger" {lower, higher}; knobs are numbers, negative allowed for # an _add, 0 or more for a _mult; whole numbers where the default is one def self.merge_difficulty(val) unless val.is_a?(Hash) skip("difficulty", "not a {...} block") return end dc = @cfg["difficulty"] val.each{|k, v| where = "difficulty/#{k}" if k == "level" if v.is_a?(String) && !v.strip.empty? dc["level"] = v.strip.downcase # an unknown name: resolve_level falls back to hard else skip(where, "needs a level name (#{LEVELS.join(", ")})") end elsif LEVELS.include?(k) merge_knobs(dc[k], v, where) elsif k == "base_danger" unless v.is_a?(Hash) skip(where, "not a {...} block") next end v.each{|st, t| if dc["base_danger"][st].is_a?(Hash) merge_knobs(dc["base_danger"][st], t, "#{where}/#{st}") else skip("#{where}/#{st}", "unknown step (lower, higher)") end } else skip(where, "unknown key (level, #{LEVELS.join(", ")}, base_danger)") end } end def self.merge_knobs(target, val, where) unless val.is_a?(Hash) skip(where, "not a {...} block") return end val.each{|k, v| d = target[k] if d.nil? skip("#{where}/#{k}", "unknown key") elsif !v.is_a?(Numeric) || (d.is_a?(Integer) && !v.is_a?(Integer)) skip("#{where}/#{k}", "bad value #{v.inspect}") elsif k.end_with?("_mult") && v < 0 skip("#{where}/#{k}", "bad value #{v.inspect} (a factor is 0 or more)") else target[k] = d.is_a?(Float) ? v.to_f : v end } end def self.merge_raids(val) unless val.is_a?(Hash) skip("raids", "not a {...} block") return end flat = {} val.each{|k, v| case k when "breach" unless v.is_a?(Hash) skip("raids/breach", "not a {...} block") next end v.each{|race, f| if f.is_a?(Numeric) && f >= 0 rc["breach"][race.to_s] = f.to_f else skip("raids/breach/#{race}", "bad value #{f.inspect}") end } when "scenarios" merge_scenarios(v) else flat[k] = v end } merge_flat(rc, flat, "raids") end def self.merge_scenarios(val) unless val.is_a?(Hash) skip("raids/scenarios", "not a {...} block") return end val.each{|name, sc| where = "raids/scenarios/#{name}" unless sc.is_a?(Hash) skip(where, "not a {...} block") next end cur = rc["scenarios"][name] if cur.nil? unless sc["regions"].is_a?(Array) && sc["groups"].is_a?(Hash) skip(where, "a new scenario needs regions and groups") next end cur = {"regions" => [], "groups" => {}, "grace_frames" => rc["grace_frames"], "door_bias" => rc["door_bias"]} end ok = true out = copy(cur) sc.each{|k, v| case k when "regions" if v.is_a?(Array) && v.all?{|n| n.is_a?(Integer) && n > 0 } out["regions"] = v else skip("#{where}/regions", "needs a list of region numbers") ok = false end when "groups" if v.is_a?(Hash) && v.all?{|g, w| GROUPS.include?(g) && w.is_a?(Integer) && w >= 0 } out["groups"] = v else skip("#{where}/groups", "needs {group: weight}, groups #{GROUPS.join(" ")}") ok = false end when "grace_frames" if v.is_a?(Integer) && v >= 0 out[k] = v else skip("#{where}/#{k}", "bad value #{v.inspect}") end when "door_bias" if v.is_a?(Numeric) && v >= 0 && v <= 1 out[k] = v.to_f else skip("#{where}/#{k}", "bad value #{v.inspect}") end else skip("#{where}/#{k}", "unknown key") end } rc["scenarios"][name] = out if ok || !rc["scenarios"][name].nil? } end def self.json(v, ind = "") case v when Hash return "{}" if v.empty? inner = ind + " " "{\n" + v.map{|k, x| "#{inner}#{k.to_s.inspect}: #{json(x, inner)}" }.join(",\n") + "\n#{ind}}" when Array then "[" + v.map{|x| json(x, ind) }.join(", ") + "]" when String then v.inspect when nil then "null" else v.to_s end end def self.defaults_text lines = [] lines << "// LonaCraft base and raid defaults (Scripts/120_Raids.rb), written by the game." lines << "// Do not edit this file: copy the keys you want to change into Config/Bases.json" lines << "// (only those keys, inside the same section). README \"Raids\" explains each key," lines << "// README \"Difficulty\" the \"difficulty\" section." lines << json(DEFAULTS) lines.join("\n") + "\n" end def self.write_defaults text = defaults_text text.force_encoding("ASCII-8BIT") if text.respond_to?(:force_encoding) path = LonaCraft.resource(DEFAULTS_FILE) old = File.exist?(path) ? File.open(path, "rb"){|f| f.read } : nil return if old == text dir = File.dirname(path) Dir.mkdir(dir) unless File.directory?(dir) File.open(path, "wb"){|f| f.write(text) } say("wrote #{DEFAULTS_FILE}") rescue => e say("cannot write #{DEFAULTS_FILE}, #{e.class} #{e.message}") end #---------------------------------------------------------------------- # Difficulty (R10): the level, its knobs, the base's Danger step #---------------------------------------------------------------------- # Sets @level from the config's "level" (once, at config load) and # names it on the console; an unknown name falls back to hard def self.resolve_level want = @cfg["difficulty"]["level"].to_s @level = LEVELS.include?(want) ? want : "hard" say("difficulty level #{want.inspect} unknown (#{LEVELS.join(", ")}), hard used") unless LEVELS.include?(want) p "LonaCraft difficulty: #{LEVEL_NAMES[@level]} (#{USER_FILE})" rescue => e @level = "hard" say("difficulty error #{e.class} #{e.message}, hard used") end def self.level cfg @level || "hard" end def self.level_name LEVEL_NAMES[level] end # the identity of a knob: 1.0 for a factor, 0 for an addition def self.knob_identity(knob) knob.to_s.end_with?("_mult") ? 1.0 : 0 end # the level's value of +knob+ def self.diff(knob) t = cfg["difficulty"][level] v = t.is_a?(Hash) ? t[knob] : nil v.is_a?(Numeric) ? v : knob_identity(knob) end # the base's Danger step: -1 Lower, 0 Normal (missing, old saves), 1 Higher def self.danger_of(rec) d = rec.is_a?(Hash) ? rec["danger"] : nil d.is_a?(Integer) && d >= -1 && d <= 1 ? d : 0 end # the base's Danger value of +knob+ (Normal: the identity) def self.step(rec, knob) name = DANGER_STEPS[danger_of(rec)] t = cfg["difficulty"]["base_danger"][name] v = t.is_a?(Hash) ? t[knob] : nil v.is_a?(Numeric) ? v : knob_identity(knob) end # "Hell, danger higher" for console lines def self.diff_tag(rec = nil) d = rec ? danger_of(rec) : 0 d == 0 ? level_name : "#{level_name}, danger #{DANGER_STEPS[d]}" end # the scaled raid sizes (also the away party, 140_AwayRaids.rb) def self.extra_per_value [rc["extra_raider_per_value"].to_i + diff("extra_per_value_add").to_i, 1].max end def self.extras_max(rec) [rc["extra_raiders_max"].to_i + diff("extra_raiders_add").to_i + step(rec, "extra_raiders_add").to_i, 0].max end def self.max_raiders [rc["max_raiders"].to_i + diff("max_raiders_add").to_i, 1].max end # true while a live raid runs on base +rec+ (the Danger line is refused) def self.busy_on?(rec) !@raid.nil? && rec.is_a?(Hash) && @raid[:base] == rec["id"] end #---------------------------------------------------------------------- # Bases, scenarios, value #---------------------------------------------------------------------- def self.enabled? bases.enabled? && rc["enabled"] ? true : false end # the base record of the map Lona is on, or nil (never on a world map) def self.base_here(map = $game_map) return nil if map.nil? || map.isOverMap bases.record_for_map(map) end def self.scenario_names rc["scenarios"].keys.sort_by{|n| SCENARIO_ORDER.index(n) || 99 } end def self.scenario_for(rec) region = rec["region"].to_i name = scenario_names.find{|n| rc["scenarios"][n]["regions"].include?(region) } name || (rc["scenarios"]["field"] ? "field" : scenario_names.first) end def self.groups_of(scen) s = rc["scenarios"][scen] return [] if s.nil? s["groups"].select{|g, w| w.to_i > 0 }.keys end def self.pick_group(scen) s = rc["scenarios"][scen] return nil if s.nil? list = s["groups"].select{|g, w| w.to_i > 0 }.to_a total = list.inject(0){|t, gw| t + gw[1].to_i } return nil if total <= 0 n = rand(total) list.each{|g, w| return g if n < w.to_i n -= w.to_i } list.last[0] end def self.base_value(rec) pieces = bases.pieces_of(rec) w = pieces.values.count{|v| bases.wall?(v) } d = pieces.values.count{|v| bases.door?(v) } f = bases.furniture_on(rec).size w + 2 * d + 3 * f end #---------------------------------------------------------------------- # The nap roll (GIM_ADDON aliases below) #---------------------------------------------------------------------- # Before the game's roll: the base-value bonus. Returns the record or nil. def self.before_roll @armed = nil return nil unless enabled? rec = base_here return nil if rec.nil? value = base_value(rec) dm = diff("danger_mult").to_f bonus = [(value * rc["danger_per_value"].to_f * dm).floor, (rc["danger_cap"].to_i * dm).floor].min $story_stats["WildDangerous"] += bonus if bonus > 0 # R10: the level's roll_add and the base's Danger step; a cut never # takes WildDangerous below 0 add = diff("roll_add").to_i + step(rec, "roll_add").to_i if add != 0 w = $story_stats["WildDangerous"] $story_stats["WildDangerous"] = [w + add, [w, 0].min].max end extra = add == 0 ? "" : format(" %+d (%s)", add, diff_tag(rec)) say("nap on base #{rec["id"]}, value #{value}, danger +#{bonus}#{extra} -> #{$story_stats["WildDangerous"]}") rec end # The game's group list for the roll on a base map: the scenario's def self.race_list_here return nil unless enabled? rec = base_here return nil if rec.nil? scen = scenario_for(rec) list = rc["scenarios"][scen]["groups"].select{|g, w| w.to_i > 0 }.map{|g, w| [w.to_i, g] } return nil if list.empty? list end def self.after_roll(rec) race = $story_stats["OnRegionMapSpawnRace"] unless GROUPS.include?(race) say("no raid this nap (#{race.inspect})") if race == 0 say("the game's group #{race.inspect} comes instead of a raid") unless race == 0 return end @armed = {:key => $game_map.map_id_rec, :base => rec["id"], :race => race, :scen => scenario_for(rec), :night => $game_date.night?, :fresh => true} say("raid armed on base #{rec["id"]}: #{race} (#{@armed[:scen]}), #{@armed[:night] ? "napping at night" : "napping by day"}") end # R9: the Deep Sewer's own nap roll (130_Sewer.rb) picked +race+ on the base # +rec+: arm the raid as after_roll does. Returns true when armed. def self.arm(rec, race) @armed = nil return false unless enabled? && rec && GROUPS.include?(race) @armed = {:key => $game_map.map_id_rec, :base => rec["id"], :race => race, :scen => scenario_for(rec), :night => $game_date.night?, :fresh => true} say("raid armed on base #{rec["id"]}: #{race} (#{@armed[:scen]}), #{@armed[:night] ? "napping at night" : "napping by day"}") true end # Game_Map#nap alias (after the game's shift): a raid rolled at night keeps the night def self.after_map_nap(map, init_from_event) a = @armed return if a.nil? || !a[:fresh] a[:fresh] = false return unless rc["night_only"] && a[:night] && $game_date.day? $game_date.rshift map.send(:set_light) unless init_from_event say("woken in the same night") rescue => e say("night error #{e.class} #{e.message}") end # region_map_wildness_spawn alias (after): the game's group is on the map def self.after_spawn(force) map = $game_map if @debug_pending scen, race = @debug_pending @debug_pending = nil begin_raid(map, race, scen, :debug) return end a = @armed race = force ? force : $story_stats["OnRegionMapSpawnRace"] if a.nil? || !map || map.map_id_rec != a[:key] || race != a[:race] note_game_spawn(map, race) return end @armed = nil begin_raid(map, a[:race], a[:scen], :nap) end # 2026-10-08: the game's own spawn on a base map that the mod did not arm: # no second group; its units join the siege (watch) while Lona is shut in def self.note_game_spawn(map, race) return if map.nil? || race.nil? || race == 0 || !hostiles_on? rec = base_here(map) return if rec.nil? say("the game's own group #{race.inspect} came to base #{rec["id"]}: no second group, its units join the siege while Lona is shut in") end #---------------------------------------------------------------------- # Raid state #---------------------------------------------------------------------- def self.busy? !@raid.nil? end def self.active? !@raid.nil? end def self.reset say("raid state cleared (load)") if @raid || @armed @raid = nil @armed = nil @debug_pending = nil @hits = {} @reach_cache = nil end def self.recently_hit?(x, y, frames) return false if $game_map.nil? t = @hits["#{$game_map.map_id_rec}:#{x.to_i},#{y.to_i}"] !t.nil? && Graphics.frame_count - t < frames end # the state of a raid (+why+ :nap / :debug) or of a siege of hostiles (:hostile) def self.new_state(map, rec, race, scen, why) { :id => Graphics.frame_count, :key => map.map_id_rec, :base => rec["id"], :race => race, :scen => scen, :why => why, :phase => :adopt, :t => 0, :adopt_left => ADOPT_FRAMES, :extras_done => false, :raiders => [], :placed_door => 0, :role => {}, :assign => {}, :reserved => {}, :walk => {}, :stuck => {}, :swing => {}, :blocked => {}, :siege_t => 0, :breached => false, :grace => 0, :retreat_t => 0, :reach => nil, :door_sig => nil, :assign_budget => 2, :give_up => (rc["give_up_frames"].to_i * diff("give_up_mult").to_f).round, # R10, kept for this raid :joined => {}, :traced => {}, :rebreach => {}, # 2026-10-08: joined hostiles, trace bookkeeping :extra_ids => {} # 2026-10-08: the extra raiders (reserve_extras), for a leave hand-over } end def self.begin_raid(map, race, scen, why) rec = base_here(map) return say("no base here, raid dropped") if rec.nil? scen = scenario_for(rec) if rc["scenarios"][scen].nil? end_raid(:replaced) if @raid # a siege of hostiles gives way; they join again in the raid's siege phase @raid = new_state(map, rec, race, scen, why) say("raid begins on base #{rec["id"]}: #{race} (#{scen}, #{why}, #{diff_tag(rec)}), collecting the group") end def self.end_raid(why) r = @raid @raid = nil return if r.nil? map = $game_map hostile = r[:why] == :hostile r[:raiders].each{|ev| let_go(r, ev, "#{hostile ? "siege" : "raid"} over (#{why})") } on_base = map && !map.isOverMap && map.map_id_rec == r[:key] if on_base && why != :left && why != :replaced && why != :handed # :handed: the away raid has it (leave_check) unless hostile # a siege of hostiles ends quietly; the game keeps its own bookkeeping case why when :cleared then $game_map.popup(0, text_key("Raid/over"), 0, 0) when :gave_up then $game_map.popup(0, text_key("Raid/gave_up"), 0, 0) end begin map.interpreter.check_enemy_survival? # the game's clear: WildDangerous -50 when none is left rescue => e say("survival check error #{e.class} #{e.message}") end end bases.revert_if_empty(map) end say("#{hostile ? "siege of hostiles" : "raid"} over (#{why}) after #{r[:t]} frames, #{r[:breached] ? "a piece was broken" : "no breach"}") end def self.raider_alive?(ev) return false if ev.nil? || ev.deleted? || ev.npc.nil? return false if ev.npc.action_state == :death ev.npc.stat.get_stat("sta") > 0 rescue false end def self.mine?(ev, r = @raid) return false if r.nil? || ev.nil? sd = ev.summon_data sd.is_a?(Hash) && sd[:LonaCraftRaid] == r[:id] end #---------------------------------------------------------------------- # Any hostile on a base map (2026-10-08, header). A unit = a raider of # the mod's raid (tagged) or a hostile that joined (r[:joined], by id). #---------------------------------------------------------------------- def self.hostiles_on? enabled? && rc["hostiles"] ? true : false end def self.unit?(ev, r = @raid) return false if r.nil? || ev.nil? return true if r[:joined] && r[:joined][ev.id] mine?(ev, r) end def self.trace(text) LonaCraft.trace("siege: #{text}") if LonaCraft.respond_to?(:trace) rescue nil end # the game's own nap group of this map (its templates tag themselves, # check_enemy_survival? 34_Functions_RegionMap.rb:1848-1866 counts them); # never the sewer's own population (R9) def self.nap_unit?(ev) sd = ev.summon_data return false unless sd.is_a?(Hash) && !sd[:LonaCraftSewerPop] race = $story_stats["OnRegionMapSpawnRace"] return false if race.nil? || race == 0 sd[:WildnessNapEvent] == race rescue false end # why the NPC on +ev+ joins the siege ("aggro", "nap group") or nil def self.join_reason(ev) return nil if ev.deleted? || !ev.respond_to?(:npc?) || !ev.npc? return nil if ev.instance_variable_get(:@missile) npc = ev.npc return nil if npc.nil? || !raider_alive?(ev) return nil if npc.respond_to?(:is_object) && npc.is_object return nil if NOT_UNITS.include?(npc.race.to_s) return nil if bases.lona_side?(ev) return nil unless npc.action_state.nil? || npc.action_state == :none return "aggro" if bases.lona_side?(npc.target) && npc.ai_state != :flee return "nap group" if nap_unit?(ev) && bases.would_attack_lona?(ev, npc) nil rescue nil end # {[x, y] => true}: the tiles the outside reaches (flood_outside), cached # until a door opens or closes or a piece comes or goes def self.outside_reach(map, rec) pieces = bases.pieces_of(rec) sig = [map.map_id_rec, door_signature(map, rec), pieces.size, pieces.keys.sort.join(";")] c = @reach_cache return c[1] if c && c[0] == sig reach = flood_outside(map, rec, play_bounds(map)) @reach_cache = [sig, reach] reach end # Scene_Map#update alias, every frame: every CHECK_EVERY frames on a base # map, the hostiles that cannot reach Lona's side join the siege def self.watch @watch_t = (@watch_t || 0) + 1 return unless @watch_t % CHECK_EVERY == 0 return unless hostiles_on? map = $game_map return if map.nil? || map.isOverMap || $game_player.nil? return if map.interpreter.running? || ($game_message && $game_message.busy?) r = @raid return if r && r[:phase] != :siege # adopt, grace, assault, retreat: the raid's own rules rec = base_here(map) return if rec.nil? list = [] map.events.values.each{|ev| next if ev.nil? || unit?(ev, r) why = join_reason(ev) list << [ev, why] if why } return if list.empty? reach = outside_reach(map, rec) return if reach[[$game_player.x, $game_player.y]] # Lona is not shut in: the game's own AI list = list.select{|ev, why| next false unless reach[[ev.x, ev.y]] # it stands outside t = ev.npc.target why != "aggro" || t.nil? || !reach[[t.x, t.y]] # and its target is shut in } return if list.empty? r ||= begin_hostile(map, rec) return if r.nil? || !r.equal?(@raid) list.each{|ev, why| join(r, ev, why) } rescue => e say("watch error #{e.class} #{e.message}") end def self.begin_hostile(map, rec) @raid = new_state(map, rec, nil, nil, :hostile) r = @raid r[:phase] = :siege say("hostiles on base #{rec["id"]} cannot reach Lona: the siege driver takes them (#{diff_tag(rec)})") replan(map, r) @raid end def self.join(r, ev, why) r[:joined][ev.id] = why r[:raiders] << ev unless r[:raiders].include?(ev) say("#{ev.npc.npc_name} (event #{ev.id}) joins the siege: #{why}") end def self.piece_name(rec, piece) case bases.piece_kind(bases.pieces_of(rec), piece[0], piece[1]) when "D" then "door" when "SD" then "door in stone" when "S" then "stone wall" when "W" then "palisade" else "piece" end end def self.nearest_cand(r, ev) c = r[:cands] return nil if c.nil? || c.empty? c.keys.min_by{|pc| (pc[0] - ev.x).abs + (pc[1] - ev.y).abs } end # the take-over line (once per unit, again after a break re-targets it) def self.note_take(r, ev, piece) re = r[:rebreach].delete(ev.id) return if r[:traced].key?(ev.id) && !re piece ||= nearest_cand(r, ev) return if piece.nil? r[:traced][ev.id] = true rec = base_here joined = r[:joined][ev.id] text = "#{ev.npc.npc_name} targets #{rec ? piece_name(rec, piece) : "piece"} at (#{piece[0]},#{piece[1]}), " + "reason #{re ? "breach" : "no path"} (event #{ev.id}, #{joined ? "joined: #{joined}" : "raider"}, #{role(ev, r)})" say("siege: #{text}") trace(text) rescue => e say("trace error #{e.class} #{e.message}") end # the release line (only for a unit that had its take-over line) def self.let_go(r, ev, why) return if ev.nil? || !r[:traced].delete(ev.id) name = begin ev.npc.npc_name rescue "?" end text = "#{name} released, reason #{why} (event #{ev.id})" say("siege: #{text}") trace(text) end # Game_Event#update_npc_sensor alias (before the game's tick): a unit at # work on the siege keeps its target while that target is shut in. The # game drops a target it does not sense once targetLock_HP runs out # (281_Game_NonPlayerCharacter.rb:456-463); it is refilled here. def self.hold_target(ev) r = @raid return if r.nil? || r[:phase] != :siege || !unit?(ev, r) npc = ev.npc return if npc.nil? t = npc.target return unless bases.lona_side?(t) return if t.respond_to?(:deleted?) && t.deleted? return if t.actor.nil? || t.actor.action_state == :death return if (r[:reach] || {})[[t.x, t.y]] # it can reach its target: the game's own rules npc.targetLock_HP = 10 if npc.targetLock_HP.to_i < 10 rescue nil end #---------------------------------------------------------------------- # Spawn placement #---------------------------------------------------------------------- def self.region_lists(map) rm = map.instance_variable_get(:@region_map) rm.is_a?(Array) ? rm : [] end def self.base_box(rec) cells = bases.cells_of(bases.pieces_of(rec)) return nil if cells.empty? [cells.map{|c| c[0] }.min, cells.map{|c| c[1] }.min, cells.map{|c| c[0] }.max, cells.map{|c| c[1] }.max] end def self.box_dist(box, x, y) [box[0] - x, 0, x - box[2]].max + [box[1] - y, 0, y - box[3]].max end def self.door_cells(rec) pieces = bases.pieces_of(rec) pieces.keys.select{|k| bases.door?(pieces[k]) }.map{|k| k.split(",").map{|n| n.to_i } } end # [far tiles, far tiles on the door side] from the outer spawn lists def self.spawn_tiles(map, r, rec) return r[:spawn] if r[:spawn] rm = region_lists(map) ids = $story_stats["RegionMap_RegionOuta"] ids = (2...rm.size).to_a unless ids.is_a?(Array) && !ids.empty? tiles = [] ids.each{|i| list = rm[i.to_i] tiles.concat(list.map{|c| [c[0], c[1]] }) if list.is_a?(Array) } tiles.uniq! box = base_box(rec) || [$game_player.x, $game_player.y, $game_player.x, $game_player.y] min = rc["spawn_min_distance"].to_i far = tiles.select{|c| box_dist(box, c[0], c[1]) >= min } if far.size < 8 want = [8, tiles.size / 4].max far = tiles.sort_by{|c| -box_dist(box, c[0], c[1]) }.first(want) end doors = door_cells(rec) side = far unless doors.empty? px = $game_player.x py = $game_player.y door = doors.min_by{|d| (d[0] - px).abs + (d[1] - py).abs } mx = (box[0] + box[2]) / 2.0 my = (box[1] + box[3]) / 2.0 vx = door[0] - mx vy = door[1] - my side = far.select{|c| (c[0] - mx) * vx + (c[1] - my) * vy > 0 } side = far if side.empty? end say("spawn tiles: #{tiles.size} outer, #{far.size} at >= #{min} from the base, #{side.size} on the door side") r[:spawn] = [far, side] end def self.free_tile?(map, x, y) return false unless map.valid?(x, y) return false if $game_player.x == x && $game_player.y == y return false unless map.events_xy(x, y).empty? [2, 4, 6, 8].any?{|d| bases.layer_pass?(map, x, y, d) } end def self.pick_spawn(map, r, rec, door_side) far, side = spawn_tiles(map, r, rec) pool = door_side ? side : far 20.times{ c = pool.sample return c if c && free_tile?(map, c[0], c[1]) } nil end def self.place_raider(map, r, rec, ev) bias = (rc["scenarios"][r[:scen]] || {})["door_bias"] || rc["door_bias"] door_side = r[:placed_door] < (r[:raiders].size * bias.to_f).round c = pick_spawn(map, r, rec, door_side) return if c.nil? r[:placed_door] += 1 if door_side ev.moveto(c[0], c[1]) end def self.adopt_scan(map, r, rec) max = max_raiders map.events.values.each{|ev| next if ev.nil? || ev.deleted? || !ev.respond_to?(:npc?) || !ev.npc? sd = ev.summon_data next unless sd.is_a?(Hash) && sd[:WildnessNapEvent] == r[:race] && !sd[:LonaCraftRaid] next if sd[:LonaCraftSewerPop] # R9: the sewer's own hobos and goblins are never raiders next if ev.npc.nil? || ev.npc.master == $game_player if r[:raiders].size >= max ev.nappable = false ev.delete say("raider over the cap of #{max} removed") next end sd[:LonaCraftRaid] = r[:id] r[:raiders] << ev r[:extra_ids][ev.id] = true if r[:extras_done] # adopted after reserve_extras: an extra raider place_raider(map, r, rec, ev) } end def self.reserve_extras(map, r, rec) r[:extras_done] = true value = base_value(rec) n = [value / extra_per_value, extras_max(rec)].min n = [n, max_raiders - r[:raiders].size].min unit = EXTRA_UNIT[r[:race]] return 0 if n <= 0 || unit.nil? $story_stats["OnRegionMapSpawnRace"] = r[:race] # the templates tag themselves with it made = 0 n.times{ c = pick_spawn(map, r, rec, false) next if c.nil? # the tag also in the summon data: WildGiantMice (SewerRats) does not tag itself map.reserve_summon_event(unit, c[0], c[1], -1, {:WildnessNapEvent => r[:race]}) made += 1 } say("base value #{value}: #{made} extra #{unit}") made end def self.dog_companion?(map) map.npcs.any?{|ev| ev && !ev.deleted? && ev.npc && ev.npc.master == $game_player && ev.npc.race == "Dog" } rescue false end def self.start_grace(map, r) r[:phase] = :grace sc = rc["scenarios"][r[:scen]] || {} r[:grace] = ((sc["grace_frames"] || rc["grace_frames"]).to_i * diff("grace_mult").to_f).round # R10 dog = dog_companion?(map) r[:grace] += rc["dog_extra_frames"].to_i if dog $game_map.popup(0, text_key(dog ? "Warn/raid_dog" : "Warn/raid"), 0, 0) begin LonaCraft::Mercs.raid_warning(map) if defined?(LonaCraft::Mercs) # M1: the captain calls out rescue => e say("mercenary warning error #{e.class} #{e.message}") end begin SndLib.dogSpot(90) if dog snd = SPOT_SOUND[r[:race]] SndLib.send(snd, 90) if snd rescue => e say("sound error #{e.class} #{e.message}") end say("#{r[:raiders].size} raiders (#{r[:race]}) hold for #{r[:grace]} frames#{dog ? ", the dog heard them" : ""}") end #---------------------------------------------------------------------- # The siege plan #---------------------------------------------------------------------- def self.play_bounds(map) xs = [] ys = [] region_lists(map).each_with_index{|list, id| next if id == 0 || !list.is_a?(Array) list.each{|c| xs << c[0]; ys << c[1] } } return [0, 0, map.width - 1, map.height - 1] if xs.empty? [[xs.min - 1, 0].max, [ys.min - 1, 0].max, [xs.max + 1, map.width - 1].min, [ys.max + 1, map.height - 1].min] end def self.door_closed_at(map, rec) out = {} door_cells(rec).each{|c| ev = bases.door_event_at(map, c[0], c[1]) out[c] = true unless ev && ev.through } out end def self.door_signature(map, rec) door_closed_at(map, rec).keys.sort.inspect end # {[x, y] => true}: tiles the outside reaches (live doors), as # Bases.inside_tiles seeds it (play-area edge and the exit ring) def self.flood_outside(map, rec, b) closed = door_closed_at(map, rec) reached = {} queue = [] ax0, ay0, ax1, ay1 = b (ay0..ay1).each{|y| (ax0..ax1).each{|x| next if closed[[x, y]] edge = x == ax0 || x == ax1 || y == ay0 || y == ay1 || [[1, 0], [-1, 0], [0, 1], [0, -1]].any?{|dx, dy| map.region_id(x + dx, y + dy) == bases::EXIT_REGION } next unless edge next unless [2, 4, 6, 8].any?{|d| bases.layer_pass?(map, x, y, d) } reached[[x, y]] = true queue << [x, y] } } head = 0 while head < queue.size x, y = queue[head] head += 1 DIRS.each{|d, dx, dy| k = [x + dx, y + dy] next if k[0] < ax0 || k[0] > ax1 || k[1] < ay0 || k[1] > ay1 next if reached[k] || closed[k] next unless bases.layer_pass?(map, x, y, d) && bases.layer_pass?(map, k[0], k[1], 10 - d) reached[k] = true queue << k } end reached end # distance map {[x, y] => steps} from +sources+ over +allowed+ tiles # (+allowed+ nil: anywhere within +b+, closed doors excepted) def self.bfs(map, sources, allowed, b = nil, closed = {}) dist = {} queue = [] sources.each{|c| next if dist.key?(c) dist[c] = 0 queue << c } head = 0 while head < queue.size x, y = queue[head] head += 1 d0 = dist[[x, y]] DIRS.each{|d, dx, dy| k = [x + dx, y + dy] next if dist.key?(k) if allowed next unless allowed[k] else next if k[0] < b[0] || k[0] > b[2] || k[1] < b[1] || k[1] > b[3] || closed[k] end next unless bases.layer_pass?(map, x, y, d) && bases.layer_pass?(map, k[0], k[1], 10 - d) dist[k] = d0 + 1 queue << k } end dist end # Makes the plan again (start, a break, a door opened or closed, Lona # going in or out). Switches between :siege and :assault. def self.replan(map, r) rec = base_here(map) return end_raid(:left) if rec.nil? r[:assign] = {} r[:reserved] = {} r[:walk] = {} r[:stuck] = {} reach = outside_reach(map, rec) r[:reach] = reach r[:door_sig] = door_signature(map, rec) lona = [$game_player.x, $game_player.y] if reach[lona] r[:raiders].each{|ev| let_go(r, ev, "path open") } return end_raid(:path_open) if r[:why] == :hostile # hostiles siege only while Lona is shut in r[:phase] = :assault unless r[:phase] == :retreat r[:hunt_t] = 0 say("Lona is not shut in: the raiders go for her (assault)") hunt(map, r) return end r[:phase] = :siege unless r[:phase] == :retreat # Lona's side: what she reaches without crossing a wall or a closed door closed = door_closed_at(map, rec) box = base_box(rec) || [lona[0], lona[1], lona[0], lona[1]] ib = [[box[0] - 1, 0].max, [box[1] - 1, 0].max, [box[2] + 1, map.width - 1].min, [box[3] + 1, map.height - 1].min] inner = bfs(map, [lona], nil, ib, closed) pieces = bases.pieces_of(rec) touching = {} outer = {} pieces.each{|k, v| next unless bases.wall?(v) || bases.door?(v) x, y = k.split(",").map{|n| n.to_i } stands = [] near_lona = false # A4 walls: a wall covers its top and its face (the tile below), so a # raider stands beside the top or south / beside the face fp = bases.respond_to?(:footprint) ? bases.footprint(pieces, map, x, y) : [[x, y]] fp.each{|fx, fy| DIRS.each{|d, dx, dy| c = [fx + dx, fy + dy] next if fp.include?(c) stands << c if reach[c] near_lona = true if inner.key?(c) } } stands.uniq! next if stands.empty? (near_lona ? touching : outer)[[x, y]] = stands } r[:cands] = touching.empty? ? outer : touching all = r[:cands].values.flatten(1).uniq r[:approach] = bfs(map, all, reach) say("siege plan: #{r[:cands].size} pieces to break, #{all.size} stand tiles, outside #{reach.size} tiles") end def self.hunt(map, r) r[:raiders].each{|ev| next unless raider_alive?(ev) npc = ev.npc next unless npc.target.nil? && (npc.action_state.nil? || npc.action_state == :none) ev.search_target_unit($game_player, ev, 2) if ev.respond_to?(:search_target_unit) } end def self.breach_factor(ev) rc["breach"][ev.npc.race.to_s].to_f rescue 0.0 end def self.atk_of(ev) ev.npc.atk.to_i rescue 0 end def self.role(ev, r) return r[:role][ev.id] if r[:role][ev.id] ranged = (ev.npc.ranged? rescue false) role = if ranged :ranged elsif breach_factor(ev) > 0 && atk_of(ev) >= rc["min_breach_atk"].to_i :breach else :mill end r[:role][ev.id] = role end def self.swing_damage(ev, armour) f = breach_factor(ev) return 0 if f <= 0 [([atk_of(ev) - armour, 1].max * f * diff("damage_mult").to_f).round, 1].max # R10 damage_mult end def self.mean_swing rc["swing_frames"].to_i + rc["swing_rand"].to_i / 2.0 end def self.next_swing rc["swing_frames"].to_i + rand(rc["swing_rand"].to_i + 1) end def self.frames_per_tile(ev) 256.0 / (2 ** ev.move_speed.to_f) rescue 16.0 end # breacher +ev+ takes the free stand tile with the lowest walk + break time def self.assign(map, r, ev) rec = base_here(map) return nil if rec.nil? || r[:cands].nil? return nil if (r[:assign_budget] -= 1) < 0 # at most 2 a frame from = bfs(map, [[ev.x, ev.y]], r[:reach]) pieces = bases.pieces_of(rec) fpt = frames_per_tile(ev) best = nil r[:cands].each{|piece, stands| kind = bases.piece_kind(pieces, piece[0], piece[1]) # M1: "SD" for a door set in stone next if kind.nil? hp = bases.hp_at(rec, piece[0], piece[1]) dmg = swing_damage(ev, bases.armour_of(kind)) next if dmg <= 0 break_frames = hp[0] / (dmg / mean_swing) stands.each{|s| next if r[:reserved][s] || (r[:blocked][s] && r[:blocked][s] > r[:t]) steps = from[s] next if steps.nil? cost = steps * fpt + break_frames best = [cost, piece, s] if best.nil? || cost < best[0] } } return nil if best.nil? r[:assign][ev.id] = [best[1], best[2]] r[:reserved][best[2]] = ev.id r[:walk][best[2]] ||= bfs(map, [best[2]], r[:reach]) say("#{ev.npc.npc_name} goes for (#{best[1][0]},#{best[1][1]}) from stand (#{best[2][0]},#{best[2][1]}), about #{(best[0] / 60.0).round} s") r[:assign][ev.id] end def self.release(r, ev, block_stand = false) a = r[:assign].delete(ev.id) return if a.nil? r[:reserved].delete(a[1]) r[:blocked][a[1]] = r[:t] + 300 if block_stand r[:swing].delete(ev.id) end def self.dir_to(from, to) dx = to[0] - from[0] dy = to[1] - from[1] return (dx > 0 ? 6 : 4) if dx.abs > dy.abs dy > 0 ? 2 : 8 end # one step down the distance map; true when it moved or waits def self.step_down(ev, dist, r) d0 = dist[[ev.x, ev.y]] if d0.nil? # off the map of this walk: wander, and count as stuck ev.move_random if rand(30) == 0 r[:stuck][ev.id] = (r[:stuck][ev.id] || 0) + 1 return false end DIRS.each{|d, dx, dy| k = [ev.x + dx, ev.y + dy] next unless dist[k] && dist[k] == d0 - 1 next unless ev.passable?(ev.x, ev.y, d) ev.move_straight(d) r[:stuck][ev.id] = 0 return true } r[:stuck][ev.id] = (r[:stuck][ev.id] || 0) + 1 false end #---------------------------------------------------------------------- # Movement (Game_Event#update_self_movement alias, called while the # event stands still). true = the raid moved it, skip the game's own. #---------------------------------------------------------------------- def self.drive(ev) r = @raid return false if r.nil? || !unit?(ev, r) npc = ev.npc return false if npc.nil? return false unless npc.action_state.nil? || npc.action_state == :none t = npc.target unless t.nil? # 2026-10-08: a unit with a target is driven only in the siege and # only while that target is shut in; else the game's AI return false unless r[:phase] == :siege if (r[:reach] || {})[[t.x, t.y]] let_go(r, ev, "path open") return false end end case r[:phase] when :adopt, :grace true when :siege drive_siege(ev, r) when :retreat drive_retreat(ev, r) else false end rescue => e say("drive error #{e.class} #{e.message}") false end def self.drive_siege(ev, r) map = $game_map case role(ev, r) when :breach a = r[:assign][ev.id] || assign(map, r, ev) note_take(r, ev, a ? a[0] : nil) return approach(ev, r, 2) if a.nil? piece, stand = a if ev.x == stand[0] && ev.y == stand[1] ev.set_direction(dir_to(stand, piece)) return true end step_down(ev, r[:walk][stand] || {}, r) if (r[:stuck][ev.id] || 0) > STUCK_FRAMES release(r, ev, true) r[:stuck][ev.id] = 0 ev.move_random end true when :ranged note_take(r, ev, nil) approach(ev, r, 5) else note_take(r, ev, nil) approach(ev, r, 2) end end # walk toward the stand tiles until +near+ steps away, then wait / mill def self.approach(ev, r, near) dist = r[:approach] || {} d0 = dist[[ev.x, ev.y]] if d0 && d0 > near step_down(ev, dist, r) elsif rand(90) == 0 ev.move_random elsif rand(30) == 0 ev.turn_toward_character($game_player) end true end def self.drive_retreat(ev, r) dist = r[:exit] || {} d0 = dist[[ev.x, ev.y]] return true if d0.nil? || d0 == 0 # removed by update step_down(ev, dist, r) true end def self.start_retreat(map, r) r[:phase] = :retreat r[:retreat_t] = 0 r[:raiders].each{|ev| let_go(r, ev, "gave up") } r[:assign] = {} r[:reserved] = {} reach = r[:reach] || {} exits = bases.outer_band(map).select{|c| reach[c] } r[:exit] = exits.empty? ? {} : bfs(map, exits, reach) say("no breach in #{r[:siege_t]} frames: the raiders give up (#{exits.size} exit tiles)") end #---------------------------------------------------------------------- # Swings #---------------------------------------------------------------------- def self.melee_skill(ev) name = ev.npc.npc_name return @melee[name] if @melee.key?(name) list = ev.npc.skills_killer || [] s = list.find{|k| next false if k.nil? next false if k.respond_to?(:is_projectile?) && k.is_projectile? next false if k.respond_to?(:holding?) && k.holding? next false if k.respond_to?(:blocking?) && k.blocking? true } @melee[name] = s || false rescue @melee[name] = false end # the swing's picture and sound: a forced launch of the raider's melee # skill, its cost given back (its hit cannot pass the tag-4 piece). The # skill's user effect gets the piece's tile as its target, a FakeTarget # as the game gives Lona's own skills (25_Game_Actor.rb:1542). def self.animate_swing(ev, piece) s = melee_skill(ev) return unless s npc = ev.npc old = npc.instance_variable_get(:@target) npc.instance_variable_set(:@target, Struct::FakeTarget.new(piece[0], piece[1])) begin if npc.launch_skill(s, true) npc.process_skill_cost_reverse(s) if npc.respond_to?(:process_skill_cost_reverse) end ensure npc.instance_variable_set(:@target, old) end rescue => e say("swing animation error #{e.class} #{e.message}") end def self.vol(ev) ev.report_distance_to_vol_close rescue 80 end def self.swing(map, r, rec, ev, piece) x, y = piece kind = bases.piece_kind(bases.pieces_of(rec), x, y) if kind.nil? release(r, ev) return false end ev.set_direction(dir_to([ev.x, ev.y], piece)) animate_swing(ev, piece) dmg = swing_damage(ev, bases.armour_of(kind)) @hits["#{r[:key]}:#{x},#{y}"] = Graphics.frame_count res = bases.damage_piece(map, x, y, dmg) begin SndLib.sys_KnockDoor(vol(ev)) $game_damage_popups.add(dmg, x, y, ev.direction, 1) rescue end if res == :broken r[:breached] = true begin SndLib.stoneCollapsed(vol(ev)) rescue end $game_map.popup(0, text_key("Raid/breach"), 0, 0) say("#{kind == "D" ? "door" : "wall"} at (#{x},#{y}) broken by #{ev.npc.npc_name} after #{r[:t]} frames") r[:traced].each_key{|id| r[:rebreach][id] = true } # their next target line says "breach" replan(map, r) return true end if res.is_a?(Array) first = !r[:first_hit] r[:first_hit] = true say("first hit: (#{x},#{y}) #{res[0]}/#{res[1]} HP by #{ev.npc.npc_name} (#{dmg} a swing)") if first end false end def self.update_swings(map, r) rec = base_here(map) return if rec.nil? r[:assign].to_a.each{|id, a| piece, stand = a ev = map.events[id] next unless raider_alive?(ev) next unless ev.x == stand[0] && ev.y == stand[1] && !ev.moving? npc = ev.npc next unless npc.action_state.nil? || npc.action_state == :none tg = npc.target next if tg && (r[:reach] || {})[[tg.x, tg.y]] # it can reach its target: the game's AI t = (r[:swing][id] || next_swing) - 1 if t > 0 r[:swing][id] = t next end r[:swing][id] = next_swing return if swing(map, r, rec, ev, piece) # the plan changed } end #---------------------------------------------------------------------- # Each frame (Scene_Map#update alias, only while a raid runs) #---------------------------------------------------------------------- def self.update r = @raid return if r.nil? map = $game_map return end_raid(:left) if map.nil? || map.isOverMap || map.map_id_rec != r[:key] return if map.interpreter.running? || ($game_message && $game_message.busy?) r[:t] += 1 r[:assign_budget] = 2 case r[:phase] when :adopt rec = base_here(map) return end_raid(:left) if rec.nil? adopt_scan(map, r, rec) r[:adopt_left] -= 1 return if r[:adopt_left] > 0 return end_raid(:no_group) if r[:raiders].empty? unless r[:extras_done] r[:adopt_left] = EXTRA_ADOPT_FRAMES if reserve_extras(map, r, rec) > 0 return if r[:adopt_left] > 0 end start_grace(map, r) when :grace r[:grace] -= 1 if r[:grace] <= 0 say("grace over, the raiders move in") r[:phase] = :siege replan(map, r) end when :siege, :assault update_swings(map, r) if r[:phase] == :siege return if @raid.nil? if r[:phase] == :siege r[:siege_t] += 1 if !r[:breached] && r[:siege_t] >= (r[:give_up] || rc["give_up_frames"]).to_i start_retreat(map, r) return end else r[:hunt_t] = (r[:hunt_t] || 0) + 1 hunt(map, r) if r[:hunt_t] % HUNT_EVERY == 0 end if r[:t] % CHECK_EVERY == 0 r[:raiders].each{|ev| let_go(r, ev, "down") unless raider_alive?(ev) } return end_raid(:cleared) unless r[:raiders].any?{|ev| raider_alive?(ev) } rec = base_here(map) return end_raid(:left) if rec.nil? lona_out = r[:reach] && r[:reach][[$game_player.x, $game_player.y]] ? true : false if door_signature(map, rec) != r[:door_sig] || lona_out != (r[:phase] == :assault) replan(map, r) end end when :retreat r[:retreat_t] += 1 gone = r[:retreat_t] >= rc["retreat_frames"].to_i r[:raiders].each{|ev| next unless raider_alive?(ev) # the downed stay where they fell next unless gone || (r[:exit] || {})[[ev.x, ev.y]] == 0 ev.nappable = false ev.delete } return end_raid(:gave_up) unless r[:raiders].any?{|ev| raider_alive?(ev) } end rescue => e say("update error #{e.class} #{e.message} #{e.backtrace ? e.backtrace[0] : ""}") end_raid(:error) end #---------------------------------------------------------------------- # Leaving during a raid (owner 2026-10-08, header): an away raid at once #---------------------------------------------------------------------- LEAVE_PHASES = [:grace, :siege, :assault] # after the warning; not while collecting or retreating # Game_Map#setup alias, BEFORE the game's setup of +map_id+: Lona leaves # the map of the running raid (any other map) while its units are up def self.leave_check(map, map_id) r = @raid return if r.nil? || map.nil? || !map.equal?($game_map) || map.isOverMap return if map.map_id_rec != r[:key] return if map_id == r[:key] || (map_id.is_a?(Integer) && map_id == map.map_id) # a nap: the same map handover(map, r) rescue => e say("leave error #{e.class} #{e.message} #{e.backtrace ? e.backtrace[0] : ""}") end # the away code's unit of the raider on +ev+ (140_AwayRaids.rb party) def self.leave_unit(ev, r) npc = ev.npc {:name => npc.npc_name.to_s, :race => npc.race.to_s, :atk => atk_of(ev), :health => npc.health.to_i, :ranged => role(ev, r) == :ranged, :extra => r[:extra_ids][ev.id] ? true : false} rescue nil end # the raid's group; a :hostile siege: the nap tag most of its units carry def self.leave_group(r, live) return r[:race].to_s if r[:why] != :hostile && r[:race] tags = Hash.new(0) live.each{|ev| sd = ev.summon_data t = sd.is_a?(Hash) ? sd[:WildnessNapEvent] : nil tags[t.to_s] += 1 if t && t != 0 } tags.empty? ? "Hostiles" : tags.max_by{|t, n| n }[0] end def self.handover(map, r) away = defined?(LonaCraft::AwayRaids) ? LonaCraft::AwayRaids : nil rec = bases.record_by_id(r[:base]) hostile = r[:why] == :hostile live = r[:raiders].select{|ev| raider_alive?(ev) } unless rec && away && away.enabled? && LEAVE_PHASES.include?(r[:phase]) && !live.empty? # a :hostile siege is in :siege say("Lona left during the #{r[:phase]} phase, #{live.size} up: no hand-over") # after_setup ends it (:left) return end units = live.map{|ev| leave_unit(ev, r) }.compact group = leave_group(r, live) line = "raid: Lona left during #{hostile ? "hostile siege" : "raid"} at #{bases.name_of(rec)}, #{units.size} raiders, handing to away raid" say(line) LonaCraft.trace(line) if LonaCraft.respond_to?(:trace_on?) && LonaCraft.trace_on? end_raid(:handed) @armed = nil @debug_pending = nil away.left_raid!(rec, group, units, hostile ? "hostile" : "raid") end #---------------------------------------------------------------------- # Map change, load, nap refusal #---------------------------------------------------------------------- # any Game_Map#setup ends a running raid: a map change, or a nap (refused # while a raid runs, so only a forced one); begin_raid comes after the setup def self.after_setup(map) end_raid(:left) if @raid @reach_cache = nil @armed = nil if @armed && map.map_id_rec != @armed[:key] end def self.nap_refused? !@raid.nil? && rc["refuse_nap"] end def self.refuse_nap SndLib.sys_buzzer $game_player.call_balloon(0) $game_player.animation = nil $game_map.popup(0, text_key("Nap/refused"), 0, 0) say("nap refused, the raid (#{@raid[:phase]}) is still on") rescue => e say("nap refusal error #{e.class} #{e.message}") end #---------------------------------------------------------------------- # Debug: Numpad . on a base map #---------------------------------------------------------------------- def self.debug_active? return false unless DEBUG && bases.enabled? return false unless SceneManager.scene_is?(Scene_Map) return false if $game_map.nil? || $game_player.nil? return false if $game_message && $game_message.busy? return false if $game_map.interpreter && $game_map.interpreter.running? true end def self.debug_say(text) bases.debug_say(text) end def self.debug_update pressed = begin Input.trigger?(DEBUG_KEY) rescue false end return unless pressed && debug_active? if base_here.nil? # M1: off a base map, the away-raid / mercenary debug menu (140_AwayRaids.rb) return $game_temp.loadEval("lonacraft_away_debug_menu") if defined?(LonaCraft::AwayRaids) return debug_say("LonaCraft debug raids need a base map") end return debug_say("LonaCraft debug a raid is on (#{@raid[:phase]})") if @raid && @raid[:why] != :hostile $game_temp.loadEval("lonacraft_raid_debug_menu") rescue => e say("debug error #{e.class} #{e.message}") end def self.debug_start(scen, race, interp) map = $game_map rec = base_here(map) return debug_say("LonaCraft debug no base here") if rec.nil? outa = $story_stats["RegionMap_RegionOuta"] unless outa.is_a?(Array) && !outa.empty? ids = [] region_lists(map).each_with_index{|l, i| ids << i if i > bases::EXIT_REGION && l.is_a?(Array) && !l.empty? } $story_stats["RegionMap_RegionOuta"] = ids end $story_stats["OverMapEvent_saw"] = 0 unless $story_stats["OverMapEvent_saw"] == 1 $story_stats["OnRegionMapSpawnRace"] = race @debug_pending = [scen, race] say("debug raid: #{race} (#{scen}) on base #{rec["id"]}") begin interp.region_map_wildness_spawn(race) rescue => e say("debug spawn error #{e.class} #{e.message}, extra units only") end if @debug_pending # the spawn alias did not run (the group is then missing: the raid ends as :no_group) @debug_pending = nil begin_raid(map, race, scen, :debug) end end end end #============================================================================== # The nap roll and the group spawn (GIM_ADDON, 34_Functions_RegionMap.rb:51-1949) #============================================================================== module GIM_ADDON if method_defined?(:region_map_wildness_nap_stats) && !method_defined?(:lonacraft_raids_nap_stats) alias_method :lonacraft_raids_nap_stats, :region_map_wildness_nap_stats def region_map_wildness_nap_stats rec = nil begin rec = LonaCraft::Raids.before_roll rescue => e p "LonaCraft Raids roll error #{e.class} #{e.message}" end lonacraft_raids_nap_stats begin LonaCraft::Raids.after_roll(rec) if rec rescue => e p "LonaCraft Raids roll error #{e.class} #{e.message}" end end end if method_defined?(:region_map_wildness_nap_stats_create_race_list) && !method_defined?(:lonacraft_raids_race_list) alias_method :lonacraft_raids_race_list, :region_map_wildness_nap_stats_create_race_list def region_map_wildness_nap_stats_create_race_list list = nil begin list = LonaCraft::Raids.race_list_here rescue => e p "LonaCraft Raids race list error #{e.class} #{e.message}" end list || lonacraft_raids_race_list end end if method_defined?(:region_map_wildness_spawn) && !method_defined?(:lonacraft_raids_spawn) alias_method :lonacraft_raids_spawn, :region_map_wildness_spawn def region_map_wildness_spawn(tmpForceSpawn = false) res = lonacraft_raids_spawn(tmpForceSpawn) begin LonaCraft::Raids.after_spawn(tmpForceSpawn) rescue => e p "LonaCraft Raids spawn error #{e.class} #{e.message}" end res end end if method_defined?(:region_map_wildness_nap) && !method_defined?(:lonacraft_raids_wildness_nap) alias_method :lonacraft_raids_wildness_nap, :region_map_wildness_nap def region_map_wildness_nap(tmpForce = nil) if !tmpForce && LonaCraft::Raids.nap_refused? LonaCraft::Raids.refuse_nap return end lonacraft_raids_wildness_nap(tmpForce) end end end #============================================================================== # Game_Map: the night kept, the nap refused, map changes #============================================================================== class Game_Map unless method_defined?(:lonacraft_raids_map_nap) alias_method :lonacraft_raids_map_nap, :nap def nap(initFromEvent = false) lonacraft_raids_map_nap(initFromEvent) LonaCraft::Raids.after_map_nap(self, initFromEvent) end end unless method_defined?(:lonacraft_raids_call_nap_event) alias_method :lonacraft_raids_call_nap_event, :call_nap_event def call_nap_event if LonaCraft::Raids.nap_refused? LonaCraft::Raids.refuse_nap return end lonacraft_raids_call_nap_event end end unless method_defined?(:setup_lonacraft_raids) alias_method :setup_lonacraft_raids, :setup def setup(map_id) LonaCraft::Raids.leave_check(self, map_id) # 2026-10-08: leaving during a raid, before the old map goes setup_lonacraft_raids(map_id) begin LonaCraft::Raids.after_setup(self) rescue => e p "LonaCraft Raids setup error #{e.class} #{e.message}" end end end end #============================================================================== # Game_Event: the siege driver moves raiders while they stand still #============================================================================== class Game_Event unless method_defined?(:lonacraft_raids_self_movement) alias_method :lonacraft_raids_self_movement, :update_self_movement def update_self_movement # 2026-10-08: every unit of the siege (the mod's raiders and joined hostiles) if LonaCraft::Raids.busy? && LonaCraft::Raids.unit?(self) return if LonaCraft::Raids.drive(self) end lonacraft_raids_self_movement end end # 2026-10-08: a unit at work on the siege keeps its target although the # walls cut its sight (39_Game_Event.rb:698-707 -> sense_target) if method_defined?(:update_npc_sensor) && !method_defined?(:lonacraft_raids_npc_sensor) alias_method :lonacraft_raids_npc_sensor, :update_npc_sensor def update_npc_sensor LonaCraft::Raids.hold_target(self) if LonaCraft::Raids.busy? lonacraft_raids_npc_sensor end end end #============================================================================== # Scene_Map: the raid's frame and the debug key #============================================================================== class Scene_Map unless method_defined?(:update_lonacraft_raids) alias_method :update_lonacraft_raids, :update def update update_lonacraft_raids LonaCraft::Raids.update if LonaCraft::Raids.busy? LonaCraft::Raids.watch # 2026-10-08: hostiles that cannot reach Lona join the siege LonaCraft::Raids.debug_update if LonaCraft::Raids::DEBUG end end end #============================================================================== # DataManager: a raid is never saved; after a load there is none #============================================================================== module DataManager unless respond_to?(:extract_save_contents_lonacraft_raids) self.singleton_class.send(:alias_method, :extract_save_contents_lonacraft_raids, :extract_save_contents) def self.extract_save_contents(contents) extract_save_contents_lonacraft_raids(contents) begin LonaCraft::Raids.reset LonaCraft::Raids.cfg # HP and repair numbers before any menu reads them rescue => e p "LonaCraft Raids load error #{e.class} #{e.message}" end end end end #============================================================================== # Game_Interpreter: the debug menu (Numpad . on a base map) #============================================================================== class Game_Interpreter def lonacraft_raid_debug_choice(title, options) $game_message.background = 0 $game_message.position = 2 $game_message.add("#{title}\\optB[#{options.join(",")}]") $game_map.interpreter.wait_for_message end def lonacraft_raid_debug_menu raids = LonaCraft::Raids rec = raids.base_here return eventPlayEnd if rec.nil? names = raids.scenario_names lonacraft_raid_debug_choice("LonaCraft debug raid. Scenario (this base is #{raids.scenario_for(rec)})", names + ["Cancel"]) pick = $game_temp.choice $game_temp.choice = -1 return eventPlayEnd if pick.nil? || pick < 0 || pick >= names.size scen = names[pick] groups = raids.groups_of(scen) lonacraft_raid_debug_choice("LonaCraft debug raid. Group for #{scen}", groups + ["Any", "Cancel"]) pick = $game_temp.choice $game_temp.choice = -1 race = nil race = groups[pick] if pick && pick >= 0 && pick < groups.size race = raids.pick_group(scen) if pick == groups.size eventPlayEnd return if race.nil? raids.debug_start(scen, race, self) end end # Config/Bases.json at boot, so the piece HP and repair numbers are set # before any menu reads them (and the defaults file is written) begin LonaCraft::Raids.cfg rescue => e p "LonaCraft Raids config error #{e.class} #{e.message}" end