1135 lines
39 KiB
Ruby
1135 lines
39 KiB
Ruby
#==============================================================================
|
|||
|
|
# LonaCraft - 150_Mercs.rb (board M1 item 3, research
|
||
|
|
# docs/RESEARCH_AWAY_RAIDS_MERCS.md section 3, owner decisions 2026-10-06).
|
||
|
|
# A squad of hired mercenaries that guards one base: a captain and two
|
||
|
|
# swords, hired from the Mercenary Guild's receptionist in the Noer tavern.
|
||
|
|
# What it does:
|
||
|
|
# * Contract: $game_system.lonacraft_data["mercs"] = {"until" => last date
|
||
|
|
# unit, "base" => post base id or nil, "name" => the captain's name,
|
||
|
|
# "down" => {role => date unit they are up again}, "hired", "warned"}.
|
||
|
|
# Plain types, saved with the game. Price: "price_per_day" (1) x "coin"
|
||
|
|
# (ItemCoin2, Large Copper Coin) a day for the squad, days from
|
||
|
|
# "day_choices" (1 / 3 / 7 / 14), paid up front; paying again adds days.
|
||
|
|
# R10: the contract price is ceil(days x price_per_day x the difficulty
|
||
|
|
# level's "merc_price_mult") (Config/Bases.json "difficulty", 120_Raids.rb
|
||
|
|
# diff): hard 1 / 3 / 7 / 14, hell 2 / 4 / 9 / 18, doom 2 / 5 / 11 / 21;
|
||
|
|
# days paid stay as they are, an extension pays the price of today.
|
||
|
|
# * The guild: Data/HCGframes/event/NoerTavernGuildEmpolyee.rb is redirected
|
||
|
|
# to HCGframes/NoerTavernGuildEmpolyee.rb (Homes.redirect, the SELLERS
|
||
|
|
# pattern of 100_Homes.rb), which runs the script that ran before
|
||
|
|
# LonaCraft (RolePlayS's copy when RolePlayS is loaded first, else the
|
||
|
|
# game's) unchanged. While it runs, a call_msg alias catches the "nothing
|
||
|
|
# pending" menu (TagMapNoerTavernQuest:QuestBoard/other) and adds one line
|
||
|
|
# (Homes.extend_menu, a runtime text key): "Hire mercenaries" or
|
||
|
|
# "Mercenary contract (N days left)". The line is always choice 3 (hidden
|
||
|
|
# options keep their index); picked, the hire / extend talk runs and the
|
||
|
|
# choice is set to -1, so the script's own case does nothing. Quest
|
||
|
|
# reports and the board are untouched.
|
||
|
|
# * The squad: NPC/LonaCraftMercCaptain.json and NPC/LonaCraftMercenary.json
|
||
|
|
# (the mod's own, into $data_npcs at load_mod_database; Npc_CompanionCharge
|
||
|
|
# AI, Eyes_follower sensor, fraction 7). Runtime events built here
|
||
|
|
# (sprites: mercenaries -char-M-REGULAR04 index 2 pattern 0, the
|
||
|
|
# NFLwarrior look; captain -char-M-REGULAR01 index 3 pattern 2, the Elite
|
||
|
|
# Warrior look). Init: set_npc, master = $game_player, drop list empty,
|
||
|
|
# fraction_mode 2 (as setup_follower_summoned), not nappable. No companion
|
||
|
|
# slot and no follower flag: the game's companion slots, assembly calls
|
||
|
|
# and follower_goto never see them. Master = Lona, so 110_Bases.rb's build
|
||
|
|
# rule (npcs_present?, hostile_near?) and the raid adoption skip them.
|
||
|
|
# * Post (owner, 2026-10-06): chosen at hiring from the bases' names
|
||
|
|
# (Bases.choose_base: newest first, at most 6; the most recently visited
|
||
|
|
# when there are more); "Move post" from the captain picks again. The
|
||
|
|
# squad is made at the chosen base's next setup. A post base that is gone
|
||
|
|
# leaves the squad waiting at the guild for a new post (the receptionist
|
||
|
|
# asks for one).
|
||
|
|
# * Standing tiles (Change 2026-10-08, owner: "The mercenary hires need to
|
||
|
|
# not block any doors. Easy fix is to prevent them from posting up against
|
||
|
|
# any base wall."): a post is a free walkable tile at least POST_GAP (2)
|
||
|
|
# tiles (4 directions) from every piece of the base (never on a door, the
|
||
|
|
# tile outside or inside it, or a tile next to a wall or door) and off
|
||
|
|
# the DOOR_LANE (3) tiles straight out of each door; the nearest such
|
||
|
|
# tiles to the main door (the door nearest the StartPoint) by walking
|
||
|
|
# distance, the outside first, then inside the walls. None (a tiny
|
||
|
|
# clearing): the free tile farthest from the door, with a console line.
|
||
|
|
# The same rule at every spawn (map setup) and again when the base's
|
||
|
|
# pieces change (a post that breaks the rule is chosen again), so the
|
||
|
|
# walk back after a fight ends on a clear tile.
|
||
|
|
# * Every Game_Map#setup of the post base makes the members that are not
|
||
|
|
# down (a nap removes them, not nappable, and makes them again). Idle (no
|
||
|
|
# target), a small Game_Event#update_self_movement alias walks each back
|
||
|
|
# to its post and faces out; with a target the game's AI fights.
|
||
|
|
# * Hunting (Change 2026-10-08, owner: "change their AI logic to all attack
|
||
|
|
# any enemies on the map ... Wildlife shouldn't count. Also, anything the
|
||
|
|
# player attacks, the mercenaries become hostile to and help out."): every
|
||
|
|
# CHECK_EVERY (30) frames each member with no target takes the nearest
|
||
|
|
# foe: an NPC 110_Bases.rb counts_as_hostile? counts (the build rule:
|
||
|
|
# attacking Lona's side now, or no animal and would attack Lona), or one
|
||
|
|
# Lona hit on this map (Game_NonPlayerCharacter#set_last_attacker alias,
|
||
|
|
# @last_attacker == $game_player; animals, traders and guards included,
|
||
|
|
# Lona's own side never) until it dies or the map changes. Engaged through
|
||
|
|
# the game's aggro: npc.set_aggro(foe, nil, ENGAGE_FRAMES) (the target,
|
||
|
|
# alert 2, aggro frames; 281_Game_NonPlayerCharacter.rb:1256), topped up
|
||
|
|
# each check, so sense_target keeps it out of sight (:459) and killer?
|
||
|
|
# (:731) makes the game's AI walk to it (Npc_CompanionCharge
|
||
|
|
# move_toward_TargetSmartAI) and use its killer skills (process_killer ->
|
||
|
|
# set_killer_skill). Dead or gone: the next foe; none left: back to post.
|
||
|
|
# No nearer in GIVE_UP_CHECKS (20) checks: that foe is skipped by that
|
||
|
|
# member for SKIP_CHECKS (60). A member the game's AI already set on a
|
||
|
|
# target of its own (a live raid) is left to it. Trace: "mercs: <name>
|
||
|
|
# engages <npc> (reason hostile|lona attacked)", "mercs: <name> back to
|
||
|
|
# post".
|
||
|
|
# * Down, never dead: a member that dies is down for "down_days" (1); an
|
||
|
|
# away raid that beats the squad puts all three down (140_AwayRaids.rb
|
||
|
|
# knock_down). The captain down = no talk until he is back.
|
||
|
|
# * The captain (action key): days left, add days (same prices), move post,
|
||
|
|
# dismiss (no refund). The mercenaries send Lona to him.
|
||
|
|
# * Date hook: one day before the end a popup; at the end the contract goes
|
||
|
|
# with a popup and the squad leaves (deleted on the next map frame).
|
||
|
|
# * Away raids (140_AwayRaids.rb): guard(rec, u) = squad power ("squad_power"
|
||
|
|
# 220 x the share of members up) when posted at that base, else nil;
|
||
|
|
# deterrence "deter" x 0.5 on the chance. Live raids: the captain calls
|
||
|
|
# out when the raid warning shows (raid_warning, from 120_Raids.rb).
|
||
|
|
# * Debug (Numpad . off a base map): hire the squad 3 days free.
|
||
|
|
# * Nothing here runs without a contract: the hooks return at once when
|
||
|
|
# lonacraft_data["mercs"] is empty (the guild menu line excepted).
|
||
|
|
#==============================================================================
|
||
|
|
module LonaCraft
|
||
|
|
module Mercs
|
||
|
|
TEXT = "LonaCraft:Mercs:"
|
||
|
|
FILE = "Mercs"
|
||
|
|
GUILD_SCRIPT = "Data/HCGframes/event/NoerTavernGuildEmpolyee.rb"
|
||
|
|
GUILD_SCRIPTS = [GUILD_SCRIPT] # 98_SelfTest.rb redirect check
|
||
|
|
GUILD_MENU_KEY = "TagMapNoerTavernQuest:QuestBoard/other"
|
||
|
|
ROLES = ["L", "A", "B"] # captain, two mercenaries
|
||
|
|
NPC_DATA = {"L" => "LonaCraftMercCaptain", "A" => "LonaCraftMercenary", "B" => "LonaCraftMercenary"}
|
||
|
|
NPC_FILES = ["NPC/LonaCraftMercCaptain.json", "NPC/LonaCraftMercenary.json"]
|
||
|
|
# role => [sheet, index, pattern] (docs/RESEARCH_AWAY_RAIDS_MERCS.md 3.4: L1 and M6)
|
||
|
|
SPRITES = {
|
||
|
|
"L" => ["-char-M-REGULAR01", 3, 2],
|
||
|
|
"A" => ["-char-M-REGULAR04", 2, 0],
|
||
|
|
"B" => ["-char-M-REGULAR04", 2, 0]
|
||
|
|
}
|
||
|
|
EVENT_PREFIX = "LonaCraftMerc"
|
||
|
|
CHECK_EVERY = 30
|
||
|
|
DIRS = [[2, 0, 1], [4, -1, 0], [6, 1, 0], [8, 0, -1]]
|
||
|
|
POST_GAP = 2 # 2026-10-08: a post is this far (4 directions) from every base piece
|
||
|
|
DOOR_LANE = 3 # 2026-10-08: the tiles straight out of a door up to this far stay free
|
||
|
|
ENGAGE_FRAMES = 300 # 2026-10-08: aggro frames a foe is held for (the game's @combatAggroTime base, 281:113)
|
||
|
|
GIVE_UP_CHECKS = 20 # 2026-10-08: checks with no step nearer before a foe is left
|
||
|
|
SKIP_CHECKS = 60 # 2026-10-08: checks a left foe is skipped by that member
|
||
|
|
|
||
|
|
@tick = 0
|
||
|
|
@dist = {} # [map object id, x, y] => distance map to that post
|
||
|
|
@leave = false # the contract ended: the squad leaves on the next map frame
|
||
|
|
@engaged = {} # role => [foe event, reason, best distance, checks with no step nearer]
|
||
|
|
@busy = {} # role => true: it hunted since it last stood at its post
|
||
|
|
@skip = {} # role => {foe event => check number it is skipped until}
|
||
|
|
@lona_hit = {} # foe event => true: NPCs Lona hit on this map
|
||
|
|
@checks = 0
|
||
|
|
@piece_n = nil # [pieces, doors] of the post base at the last check (posts checked again on a change)
|
||
|
|
|
||
|
|
def self.say(text)
|
||
|
|
p "LonaCraft Mercs: #{text}"
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.text_key(key)
|
||
|
|
"#{TEXT}#{key}"
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.text(key)
|
||
|
|
$game_text[text_key(key)].to_s
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.bases
|
||
|
|
LonaCraft::Bases
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.raids
|
||
|
|
LonaCraft::Raids
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.cfg
|
||
|
|
raids.cfg["mercs"]
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.enabled?
|
||
|
|
return false unless defined?(LonaCraft::Bases) && defined?(LonaCraft::Raids)
|
||
|
|
bases.enabled? && cfg["enabled"] ? true : false
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.now
|
||
|
|
bases.date_now
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.per_day
|
||
|
|
defined?(Game_Date::DAY_LENGTH) ? Game_Date::DAY_LENGTH : 2
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.clean(label)
|
||
|
|
label.to_s.gsub(/[,\[\]\r\n]/, "")
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.wrapper_script(game_script)
|
||
|
|
LonaCraft::Homes.wrapper_script(game_script)
|
||
|
|
end
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
# The contract
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
def self.root
|
||
|
|
return nil if $game_system.nil? || !$game_system.respond_to?(:lonacraft_data)
|
||
|
|
$game_system.lonacraft_data
|
||
|
|
end
|
||
|
|
|
||
|
|
# the contract, or nil
|
||
|
|
def self.record
|
||
|
|
d = root
|
||
|
|
return nil if d.nil?
|
||
|
|
r = d["mercs"]
|
||
|
|
return nil unless r.is_a?(Hash) && r["until"].is_a?(Integer)
|
||
|
|
r["down"] = {} unless r["down"].is_a?(Hash)
|
||
|
|
r
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.hired?
|
||
|
|
r = record
|
||
|
|
!r.nil? && now <= r["until"]
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.days_left
|
||
|
|
r = record
|
||
|
|
return 0 if r.nil?
|
||
|
|
left = r["until"] - now
|
||
|
|
return 0 if left < 0
|
||
|
|
[(left + per_day - 1) / per_day, 1].max
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.coin
|
||
|
|
$data_ItemName[cfg["coin"].to_s]
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.coin_name
|
||
|
|
c = coin
|
||
|
|
c ? $game_text[c.name].to_s : cfg["coin"].to_s
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.price_of(days)
|
||
|
|
base = days.to_i * cfg["price_per_day"].to_i
|
||
|
|
[(base * raids.diff("merc_price_mult").to_f - 1e-9).ceil, 0].max # R10, hard: base
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.price_text(days)
|
||
|
|
"#{price_of(days)} #{coin_name}"
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.pick_name
|
||
|
|
list = text("Names/list").split(",").map{|n| n.strip }.reject{|n| n.empty? || n.include?(":") }
|
||
|
|
list.empty? ? "Brann" : list.sample
|
||
|
|
end
|
||
|
|
|
||
|
|
# Pays +days+: :ok (new contract), :extended, :no_coins, :off
|
||
|
|
def self.pay(days, interp = nil)
|
||
|
|
return :off unless enabled?
|
||
|
|
days = days.to_i
|
||
|
|
return :off if days < 1
|
||
|
|
d = root
|
||
|
|
return :off if d.nil?
|
||
|
|
cost = price_of(days)
|
||
|
|
c = coin
|
||
|
|
return :off if c.nil?
|
||
|
|
return :no_coins if $game_party.item_number(c) < cost
|
||
|
|
if interp && interp.respond_to?(:optain_lose_item)
|
||
|
|
interp.optain_lose_item(c, cost)
|
||
|
|
else
|
||
|
|
$game_party.lose_item(c, cost)
|
||
|
|
end
|
||
|
|
add_days(days)
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.add_days(days)
|
||
|
|
r = record
|
||
|
|
if r && now <= r["until"]
|
||
|
|
r["until"] += days * per_day
|
||
|
|
r["warned"] = false
|
||
|
|
say("contract extended by #{days} days, until #{r["until"]}")
|
||
|
|
return :extended
|
||
|
|
end
|
||
|
|
root["mercs"] = {"until" => now + days * per_day, "base" => nil, "name" => pick_name,
|
||
|
|
"down" => {}, "hired" => now, "warned" => false}
|
||
|
|
say("squad hired for #{days} days, captain #{root["mercs"]["name"]}, until #{root["mercs"]["until"]}")
|
||
|
|
:ok
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.end_contract(why)
|
||
|
|
d = root
|
||
|
|
return if d.nil?
|
||
|
|
d.delete("mercs")
|
||
|
|
@dist = {}
|
||
|
|
@leave = true
|
||
|
|
say("contract over (#{why})")
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.notice(id, str)
|
||
|
|
return unless defined?(LonaCraft::Homes)
|
||
|
|
LonaCraft::Homes.notice(LonaCraft::RuntimeText.key(FILE, id, str))
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.with_name(str)
|
||
|
|
r = record
|
||
|
|
str.to_s.gsub("NAME", r ? r["name"].to_s : "")
|
||
|
|
end
|
||
|
|
|
||
|
|
# Game_Date hook: the warning one day before and the end
|
||
|
|
def self.on_date_moved
|
||
|
|
r = record
|
||
|
|
return if r.nil?
|
||
|
|
t = now
|
||
|
|
r["down"].delete_if{|role, up| up.to_i <= t }
|
||
|
|
if t > r["until"]
|
||
|
|
notice("rt_ended", text("Notice/ended"))
|
||
|
|
end_contract(:expired)
|
||
|
|
return
|
||
|
|
end
|
||
|
|
if !r["warned"] && r["until"] - t < per_day
|
||
|
|
r["warned"] = true
|
||
|
|
notice("rt_one_day", text("Notice/one_day"))
|
||
|
|
end
|
||
|
|
rescue => e
|
||
|
|
say("date hook error #{e.class} #{e.message}")
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.down?(role, at = now)
|
||
|
|
r = record
|
||
|
|
return false if r.nil?
|
||
|
|
r["down"][role].to_i > at
|
||
|
|
end
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
# Away raids (140_AwayRaids.rb)
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
# the squad's power against an away raid on +rec+ at date unit +u+, or nil
|
||
|
|
def self.guard(rec, u)
|
||
|
|
return nil unless enabled?
|
||
|
|
r = record
|
||
|
|
return nil if r.nil? || r["base"].nil? || rec.nil? || r["base"].to_i != rec["id"].to_i
|
||
|
|
return nil if u > r["until"]
|
||
|
|
up = ROLES.count{|role| !down?(role, u) }
|
||
|
|
return nil if up == 0
|
||
|
|
cfg["squad_power"].to_f * up / ROLES.size
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.knock_down(rec, u)
|
||
|
|
r = record
|
||
|
|
return if r.nil?
|
||
|
|
back = u + cfg["down_days"].to_i * per_day
|
||
|
|
ROLES.each{|role| r["down"][role] = [r["down"][role].to_i, back].max }
|
||
|
|
say("the squad at base #{rec["id"]} is down until #{back}")
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.base_gone(rec)
|
||
|
|
r = record
|
||
|
|
return if r.nil? || r["base"].nil? || r["base"].to_i != rec["id"].to_i
|
||
|
|
r["base"] = nil
|
||
|
|
notice("rt_base_gone", text("Notice/base_gone").gsub("BASE", bases.name_of(rec)))
|
||
|
|
end
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
# The guild menu line (call_msg alias below)
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
def self.guild_label
|
||
|
|
if hired?
|
||
|
|
clean(text("Guild/menu_contract").gsub("NUM", days_left.to_s))
|
||
|
|
else
|
||
|
|
clean(text("Guild/menu_hire").gsub("PRICE", price_text(1)))
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
# [runtime key, index of the added line] or nil
|
||
|
|
def self.guild_menu
|
||
|
|
return nil unless enabled?
|
||
|
|
dialog = $game_text[GUILD_MENU_KEY].to_s
|
||
|
|
labels = [guild_label]
|
||
|
|
# R13: the maid line while Boss Mama is away (170_Maid.rb)
|
||
|
|
maid = defined?(LonaCraft::Maid) && LonaCraft::Maid.guild_offer? ? clean(LonaCraft::Maid.menu_label) : nil
|
||
|
|
labels << maid if maid
|
||
|
|
got = LonaCraft::Homes.extend_menu(dialog, labels, nil)
|
||
|
|
if got.nil?
|
||
|
|
say("the guild menu text has no \\optB list, no line added")
|
||
|
|
return nil
|
||
|
|
end
|
||
|
|
[LonaCraft::RuntimeText.key(FILE, "rt_guild_menu", got[0]), got[1], maid ? got[1] + 1 : nil]
|
||
|
|
rescue => e
|
||
|
|
say("guild menu error #{e.class} #{e.message}")
|
||
|
|
nil
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.day_labels
|
||
|
|
cfg["day_choices"].map{|d|
|
||
|
|
t = d.to_i == 1 ? text("Days/one") : text("Days/many").gsub("NUM", d.to_s)
|
||
|
|
clean(t.gsub("PRICE", price_text(d)))
|
||
|
|
}
|
||
|
|
end
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
# The squad on the map
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
def self.member?(ev)
|
||
|
|
return false if ev.nil? || (ev.respond_to?(:deleted?) && ev.deleted?)
|
||
|
|
sd = ev.respond_to?(:summon_data) ? ev.summon_data : nil
|
||
|
|
sd.is_a?(Hash) && !sd[:LonaCraftMerc].nil?
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.live_members(map)
|
||
|
|
out = {}
|
||
|
|
return out if map.nil?
|
||
|
|
map.events.values.each{|ev|
|
||
|
|
next unless member?(ev)
|
||
|
|
out[ev.summon_data[:LonaCraftMerc]] = ev
|
||
|
|
}
|
||
|
|
out
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.dead?(ev)
|
||
|
|
npc = ev.npc
|
||
|
|
return true if npc.nil?
|
||
|
|
return true if npc.action_state == :death
|
||
|
|
npc.stat.get_stat("sta") <= 0
|
||
|
|
rescue
|
||
|
|
false
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.despawn(ev)
|
||
|
|
ev.nappable = false if ev.respond_to?(:nappable=)
|
||
|
|
ev.delete
|
||
|
|
rescue => e
|
||
|
|
say("despawn error #{e.class} #{e.message}")
|
||
|
|
end
|
||
|
|
|
||
|
|
# Game_Map#setup alias (after): the squad at its post base (+entered+ is false for a nap)
|
||
|
|
def self.after_setup(map, entered)
|
||
|
|
@dist = {}
|
||
|
|
@engaged = {}
|
||
|
|
@busy = {}
|
||
|
|
@skip = {}
|
||
|
|
@lona_hit = {}
|
||
|
|
@piece_n = nil
|
||
|
|
return if map.nil? || map.isOverMap
|
||
|
|
r = record
|
||
|
|
return if r.nil? || !enabled?
|
||
|
|
rec = bases.record_for_map(map)
|
||
|
|
return if rec.nil?
|
||
|
|
if r["base"] && bases.record_by_id(r["base"]).nil?
|
||
|
|
r["base"] = nil # the post base is gone (destroy-all, emptied)
|
||
|
|
end
|
||
|
|
return if r["base"].nil? || r["base"].to_i != rec["id"].to_i
|
||
|
|
spawn_squad(map, rec)
|
||
|
|
end
|
||
|
|
|
||
|
|
# 2026-10-08: {[x, y] => true} tiles no member may post on: every base
|
||
|
|
# piece and the tiles within POST_GAP - 1 of it (4 directions), and the
|
||
|
|
# DOOR_LANE tiles straight out of each door
|
||
|
|
def self.blocked_tiles(rec)
|
||
|
|
out = {}
|
||
|
|
r = POST_GAP - 1
|
||
|
|
bases.cells_of(bases.pieces_of(rec)).each{|c|
|
||
|
|
(-r..r).each{|dx|
|
||
|
|
w = r - dx.abs
|
||
|
|
(-w..w).each{|dy| out[[c[0] + dx, c[1] + dy]] = true }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
raids.door_cells(rec).each{|d|
|
||
|
|
DIRS.each{|dir, dx, dy|
|
||
|
|
(1..DOOR_LANE).each{|k| out[[d[0] + dx * k, d[1] + dy * k]] = true }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
out
|
||
|
|
end
|
||
|
|
|
||
|
|
# {role => [x, y, facing]} (a 4th element true: the fallback tile) for
|
||
|
|
# +roles+; +taken+ {[x, y] => true} tiles already posted. 2026-10-08:
|
||
|
|
# free tiles clear of blocked_tiles, nearest the main door by walking
|
||
|
|
# distance, the outside first, then inside the walls; none: the free
|
||
|
|
# tile farthest from the door, with a console line.
|
||
|
|
def self.post_tiles(map, rec, roles = ["A", "B", "L"], taken = {})
|
||
|
|
b = raids.play_bounds(map)
|
||
|
|
reach = raids.flood_outside(map, rec, b)
|
||
|
|
sm = map.storypoint_map
|
||
|
|
sp = sm.is_a?(Hash) ? sm["StartPoint"] : nil
|
||
|
|
start = sp.is_a?(Array) ? [sp[0].to_i, sp[1].to_i] : [$game_player.x, $game_player.y]
|
||
|
|
blocked = blocked_tiles(rec)
|
||
|
|
taken = taken.dup
|
||
|
|
ok = lambda{|c| !blocked[c] && !taken[c] && raids.free_tile?(map, c[0], c[1]) }
|
||
|
|
out = {}
|
||
|
|
box = raids.base_box(rec)
|
||
|
|
return out if box.nil?
|
||
|
|
mx = (box[0] + box[2]) / 2.0
|
||
|
|
my = (box[1] + box[3]) / 2.0
|
||
|
|
# the main door and the tile outside it
|
||
|
|
door = nil
|
||
|
|
anchor = nil
|
||
|
|
face = 2
|
||
|
|
raids.door_cells(rec).sort_by{|d| (d[0] - start[0]).abs + (d[1] - start[1]).abs }.each{|d|
|
||
|
|
DIRS.each{|dir, dx, dy|
|
||
|
|
c = [d[0] + dx, d[1] + dy]
|
||
|
|
next unless reach[c]
|
||
|
|
door = d
|
||
|
|
anchor = c
|
||
|
|
face = dir
|
||
|
|
break
|
||
|
|
}
|
||
|
|
break if anchor
|
||
|
|
}
|
||
|
|
if anchor.nil?
|
||
|
|
# no door with an outside: the outside tile next to the base nearest the StartPoint
|
||
|
|
cands = reach.keys.select{|c| raids.box_dist(box, c[0], c[1]) == 1 }
|
||
|
|
anchor = cands.min_by{|c| (c[0] - start[0]).abs + (c[1] - start[1]).abs }
|
||
|
|
if anchor
|
||
|
|
dx = anchor[0] - mx
|
||
|
|
dy = anchor[1] - my
|
||
|
|
face = dx.abs > dy.abs ? (dx < 0 ? 4 : 6) : (dy < 0 ? 8 : 2)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
ref = door || anchor || [mx.round, my.round]
|
||
|
|
# the outside by walking distance from the door (ties: off the line
|
||
|
|
# straight out of it first, then by y and x), then the inside by distance to it
|
||
|
|
axis = lambda{|c| door && (door[0] == anchor[0] ? c[0] == door[0] : c[1] == door[1]) ? 1 : 0 }
|
||
|
|
outside = anchor ? raids.bfs(map, [anchor], reach).sort_by{|c, n| [n, axis.call(c), c[1], c[0]] }.map{|c, n| c } : []
|
||
|
|
inside = nil
|
||
|
|
roles.each{|role|
|
||
|
|
c = outside.find{|o| ok.call(o) }
|
||
|
|
if c.nil?
|
||
|
|
inside ||= bases.inside_tiles(map, rec, raids.region_lists(map)).keys.sort_by{|o| (o[0] - ref[0]).abs + (o[1] - ref[1]).abs }
|
||
|
|
c = inside.find{|o| ok.call(o) }
|
||
|
|
end
|
||
|
|
fell = false
|
||
|
|
if c.nil?
|
||
|
|
pool = (outside + inside).select{|o| !taken[o] && raids.free_tile?(map, o[0], o[1]) }
|
||
|
|
c = pool.max_by{|o| (o[0] - ref[0]).abs + (o[1] - ref[1]).abs }
|
||
|
|
fell = true
|
||
|
|
say("no free tile #{POST_GAP} from the base pieces for #{role}: the farthest free tile from the door, #{c.inspect}")
|
||
|
|
end
|
||
|
|
next if c.nil?
|
||
|
|
taken[c] = true
|
||
|
|
out[role] = fell ? [c[0], c[1], face, true] : [c[0], c[1], face]
|
||
|
|
}
|
||
|
|
out
|
||
|
|
end
|
||
|
|
|
||
|
|
# 2026-10-08: a member whose post breaks the rule now (a piece built
|
||
|
|
# next to it) gets a new one; the walk back goes there
|
||
|
|
def self.repost(map, rec, members)
|
||
|
|
blocked = blocked_tiles(rec)
|
||
|
|
bad = []
|
||
|
|
taken = {}
|
||
|
|
members.each{|role, ev|
|
||
|
|
post = ev.summon_data[:LonaCraftMercPost]
|
||
|
|
next unless post.is_a?(Array)
|
||
|
|
if !post[3] && blocked[[post[0], post[1]]]
|
||
|
|
bad << role
|
||
|
|
else
|
||
|
|
taken[[post[0], post[1]]] = true
|
||
|
|
end
|
||
|
|
}
|
||
|
|
return if bad.empty?
|
||
|
|
posts = post_tiles(map, rec, bad, taken)
|
||
|
|
bad.each{|role|
|
||
|
|
post = posts[role]
|
||
|
|
members[role].summon_data[:LonaCraftMercPost] = post if post
|
||
|
|
}
|
||
|
|
say("posts chosen again for #{bad.join(", ")}: #{posts.inspect}")
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.label(name)
|
||
|
|
RPG::EventCommand.new(118, 0, [name])
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.build_event(role, x, y, face)
|
||
|
|
sheet, index, pattern = SPRITES[role]
|
||
|
|
ev = RPG::Event.new(x, y)
|
||
|
|
ev.name = "#{EVENT_PREFIX}#{role}"
|
||
|
|
page = RPG::Event::Page.new
|
||
|
|
page.graphic.tile_id = 0
|
||
|
|
page.graphic.character_name = sheet
|
||
|
|
page.graphic.character_index = index
|
||
|
|
page.graphic.direction = face
|
||
|
|
page.graphic.pattern = pattern
|
||
|
|
page.move_type = 3
|
||
|
|
page.walk_anime = true
|
||
|
|
page.step_anime = false
|
||
|
|
page.direction_fix = false
|
||
|
|
page.through = false
|
||
|
|
page.priority_type = 1
|
||
|
|
page.trigger = 0
|
||
|
|
list = []
|
||
|
|
list << label("init")
|
||
|
|
list << label("common")
|
||
|
|
["@nappable = false",
|
||
|
|
"set_npc(#{NPC_DATA[role].inspect})",
|
||
|
|
"@npc.stat.set_stat(\"arousal\", 0)",
|
||
|
|
"@npc.stat.set_stat(\"mood\", 20)",
|
||
|
|
"@npc.master = $game_player",
|
||
|
|
"@npc.drop_list = []",
|
||
|
|
"@npc.fraction_mode = 2"].each{|line| list << EvLib.NewEventCMD(line) }
|
||
|
|
list << label("end_common")
|
||
|
|
list << EvLib.NewEventCMD("lonacraft_merc_talk(#{role.inspect}) if respond_to?(:lonacraft_merc_talk)")
|
||
|
|
list << RPG::EventCommand.new(0, 0, [])
|
||
|
|
page.list = list
|
||
|
|
ev.pages = [page]
|
||
|
|
ev
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.spawn_squad(map, rec)
|
||
|
|
if NPC_DATA.values.uniq.any?{|n| $data_npcs.nil? || $data_npcs[n].nil? }
|
||
|
|
say("NPC data missing (#{NPC_FILES.join(", ")}), no squad")
|
||
|
|
return
|
||
|
|
end
|
||
|
|
have = live_members(map)
|
||
|
|
need = ROLES.reject{|role| have[role] || down?(role) }
|
||
|
|
return if need.empty?
|
||
|
|
taken = {}
|
||
|
|
have.each_value{|ev|
|
||
|
|
post = ev.summon_data[:LonaCraftMercPost]
|
||
|
|
taken[[post[0], post[1]]] = true if post.is_a?(Array)
|
||
|
|
}
|
||
|
|
posts = post_tiles(map, rec, ["A", "B", "L"].select{|role| need.include?(role) }, taken)
|
||
|
|
made = []
|
||
|
|
need.each{|role|
|
||
|
|
post = posts[role]
|
||
|
|
next if post.nil?
|
||
|
|
ev = build_event(role, post[0], post[1], post[2])
|
||
|
|
map.lonacraft_spawn_event(ev, {:LonaCraftMerc => role, :LonaCraftMercPost => post})
|
||
|
|
made << role
|
||
|
|
}
|
||
|
|
say("squad at base #{rec["id"]}: #{made.join(", ")} made, posts #{posts.inspect}") unless made.empty?
|
||
|
|
rescue => e
|
||
|
|
say("spawn error #{e.class} #{e.message} #{e.backtrace ? e.backtrace[0] : ""}")
|
||
|
|
end
|
||
|
|
|
||
|
|
# Scene_Map#update: deaths count as down; a squad with no contract or
|
||
|
|
# off its post base leaves
|
||
|
|
def self.update
|
||
|
|
@tick += 1
|
||
|
|
return if @tick < CHECK_EVERY
|
||
|
|
@tick = 0
|
||
|
|
r = record
|
||
|
|
return if r.nil? && !@leave
|
||
|
|
map = $game_map
|
||
|
|
return if map.nil? || map.isOverMap
|
||
|
|
members = live_members(map)
|
||
|
|
if members.empty?
|
||
|
|
@leave = false if r.nil?
|
||
|
|
return
|
||
|
|
end
|
||
|
|
rec = bases.record_for_map(map)
|
||
|
|
if r.nil? || rec.nil? || r["base"].nil? || r["base"].to_i != rec["id"].to_i
|
||
|
|
members.each_value{|ev| despawn(ev) }
|
||
|
|
@leave = false
|
||
|
|
say("the squad leaves this map")
|
||
|
|
return
|
||
|
|
end
|
||
|
|
t = now
|
||
|
|
back = t + cfg["down_days"].to_i * per_day
|
||
|
|
members.each{|role, ev|
|
||
|
|
next unless dead?(ev)
|
||
|
|
next if r["down"][role].to_i > t
|
||
|
|
r["down"][role] = back
|
||
|
|
say("#{role} is down until #{back}")
|
||
|
|
}
|
||
|
|
up = members.reject{|role, ev| dead?(ev) }
|
||
|
|
n = [bases.pieces_of(rec).size, raids.door_cells(rec).size]
|
||
|
|
if n != @piece_n
|
||
|
|
@piece_n = n
|
||
|
|
@dist = {}
|
||
|
|
repost(map, rec, up)
|
||
|
|
end
|
||
|
|
engage(map, up)
|
||
|
|
rescue => e
|
||
|
|
say("update error #{e.class} #{e.message}")
|
||
|
|
end
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
# Hunting (2026-10-08)
|
||
|
|
#----------------------------------------------------------------------
|
||
|
|
def self.trace(line)
|
||
|
|
LonaCraft.trace(line) if LonaCraft.respond_to?(:trace_on?) && LonaCraft.trace_on?
|
||
|
|
rescue
|
||
|
|
nil
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.member_name(role)
|
||
|
|
r = record
|
||
|
|
role == "L" && r ? "#{r["name"]} (captain)" : "mercenary #{role}"
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.foe_label(ev)
|
||
|
|
"#{ev.npc.npc_name} (event #{ev.id})"
|
||
|
|
rescue
|
||
|
|
"an NPC"
|
||
|
|
end
|
||
|
|
|
||
|
|
# +ev+ is alive on +map+ and not on Lona's side
|
||
|
|
def self.foe_alive?(map, ev)
|
||
|
|
return false if ev.nil? || (ev.respond_to?(:deleted?) && ev.deleted?)
|
||
|
|
return false unless map.events[ev.id].equal?(ev)
|
||
|
|
return false unless ev.respond_to?(:npc?) && ev.npc?
|
||
|
|
npc = ev.npc
|
||
|
|
return false if npc.nil? || npc.action_state == :death
|
||
|
|
return false if npc.respond_to?(:npc_dead?) && npc.npc_dead?
|
||
|
|
!bases.lona_side?(ev)
|
||
|
|
rescue
|
||
|
|
false
|
||
|
|
end
|
||
|
|
|
||
|
|
# Game_NonPlayerCharacter#set_last_attacker alias: Lona hit +npc+
|
||
|
|
def self.lona_hit(npc)
|
||
|
|
return if record.nil?
|
||
|
|
ev = npc.event
|
||
|
|
return if ev.nil? || @lona_hit[ev]
|
||
|
|
return if npc.is_object || npc.action_state == :death
|
||
|
|
return if ev.instance_variable_get(:@missile) || bases::NOT_CREATURE_RACES.include?(npc.race.to_s)
|
||
|
|
return if bases.lona_side?(ev)
|
||
|
|
@lona_hit[ev] = true
|
||
|
|
end
|
||
|
|
|
||
|
|
# [[foe event, :hostile / :lona]] on +map+
|
||
|
|
def self.foes(map)
|
||
|
|
@lona_hit.delete_if{|ev, v| !foe_alive?(map, ev) }
|
||
|
|
out = []
|
||
|
|
map.events.values.each{|ev|
|
||
|
|
next if ev.nil?
|
||
|
|
if @lona_hit[ev]
|
||
|
|
out << [ev, :lona]
|
||
|
|
else
|
||
|
|
hostile = begin
|
||
|
|
bases.counts_as_hostile?(ev)
|
||
|
|
rescue
|
||
|
|
false
|
||
|
|
end
|
||
|
|
out << [ev, :hostile] if hostile
|
||
|
|
end
|
||
|
|
}
|
||
|
|
out
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.idle?(npc)
|
||
|
|
npc.action_state.nil? || npc.action_state == :none
|
||
|
|
end
|
||
|
|
|
||
|
|
# every CHECK_EVERY frames, the members that are up
|
||
|
|
def self.engage(map, members)
|
||
|
|
@checks += 1
|
||
|
|
list = nil
|
||
|
|
members.each{|role, ev|
|
||
|
|
begin
|
||
|
|
npc = ev.npc
|
||
|
|
next if npc.nil?
|
||
|
|
cur = @engaged[role]
|
||
|
|
# a target the game's AI took itself (a live raid, a foe it saw): its own
|
||
|
|
next if npc.target && !(cur && npc.target.equal?(cur[0]))
|
||
|
|
list ||= foes(map)
|
||
|
|
engage_one(role, ev, npc, list)
|
||
|
|
rescue => e
|
||
|
|
say("engage error #{role} #{e.class} #{e.message}")
|
||
|
|
end
|
||
|
|
}
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.engage_one(role, ev, npc, list)
|
||
|
|
cur = @engaged[role]
|
||
|
|
cur = nil if cur && !list.any?{|f| f[0].equal?(cur[0]) } # dead, gone, or no foe now
|
||
|
|
if cur
|
||
|
|
d = (ev.x - cur[0].x).abs + (ev.y - cur[0].y).abs
|
||
|
|
if d < cur[2]
|
||
|
|
cur[2] = d
|
||
|
|
cur[3] = 0
|
||
|
|
elsif d > 1
|
||
|
|
cur[3] += 1
|
||
|
|
end
|
||
|
|
if cur[3] < GIVE_UP_CHECKS
|
||
|
|
hold(npc, cur[0])
|
||
|
|
return
|
||
|
|
end
|
||
|
|
(@skip[role] ||= {})[cur[0]] = @checks + SKIP_CHECKS
|
||
|
|
trace("mercs: #{member_name(role)} cannot reach #{foe_label(cur[0])}")
|
||
|
|
npc.process_target_lost(false) if npc.target.equal?(cur[0]) && idle?(npc)
|
||
|
|
end
|
||
|
|
@engaged.delete(role)
|
||
|
|
return if npc.target # still on it: the game's AI lets go of it itself
|
||
|
|
sk = @skip[role] || {}
|
||
|
|
sk.delete_if{|e, u| u <= @checks }
|
||
|
|
pick = list.reject{|f| sk[f[0]] }.min_by{|f| (f[0].x - ev.x).abs + (f[0].y - ev.y).abs }
|
||
|
|
if pick.nil?
|
||
|
|
trace("mercs: #{member_name(role)} back to post") if @busy.delete(role)
|
||
|
|
return
|
||
|
|
end
|
||
|
|
return unless idle?(npc)
|
||
|
|
@engaged[role] = [pick[0], pick[1], (ev.x - pick[0].x).abs + (ev.y - pick[0].y).abs, 0]
|
||
|
|
@busy[role] = true
|
||
|
|
hold(npc, pick[0])
|
||
|
|
trace("mercs: #{member_name(role)} engages #{foe_label(pick[0])} (reason #{pick[1] == :lona ? "lona attacked" : "hostile"})")
|
||
|
|
end
|
||
|
|
|
||
|
|
# the game's aggro on +foe+ (281_Game_NonPlayerCharacter.rb:1256
|
||
|
|
# set_aggro: the target, alert 2, aggro frames), or its frames topped up
|
||
|
|
def self.hold(npc, foe)
|
||
|
|
return if foe.npc.nil? || foe.npc.user_redirect # set_aggro would aim at its user
|
||
|
|
if npc.target.equal?(foe)
|
||
|
|
npc.instance_variable_set(:@aggro_frame, ENGAGE_FRAMES) if npc.aggro_frame.to_i < ENGAGE_FRAMES
|
||
|
|
elsif idle?(npc)
|
||
|
|
npc.set_aggro(foe.npc, nil, ENGAGE_FRAMES)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
# Game_Event#update_self_movement alias: true = moved / held here
|
||
|
|
def self.drive(ev)
|
||
|
|
npc = ev.npc
|
||
|
|
return false if npc.nil?
|
||
|
|
return false unless npc.action_state.nil? || npc.action_state == :none
|
||
|
|
return false unless npc.target.nil?
|
||
|
|
post = ev.summon_data[:LonaCraftMercPost]
|
||
|
|
return true unless post.is_a?(Array)
|
||
|
|
if ev.x == post[0] && ev.y == post[1]
|
||
|
|
ev.set_direction(post[2]) if ev.direction != post[2]
|
||
|
|
return true
|
||
|
|
end
|
||
|
|
return true if ev.moving?
|
||
|
|
dist = dist_to(post)
|
||
|
|
d0 = dist ? dist[[ev.x, ev.y]] : nil
|
||
|
|
if d0
|
||
|
|
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)
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
end
|
||
|
|
ev.move_toward_xy(post[0], post[1]) if ev.respond_to?(:move_toward_xy) && rand(4) == 0
|
||
|
|
true
|
||
|
|
rescue => e
|
||
|
|
say("drive error #{e.class} #{e.message}")
|
||
|
|
false
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.dist_to(post)
|
||
|
|
map = $game_map
|
||
|
|
key = [map.object_id, post[0], post[1]]
|
||
|
|
return @dist[key] if @dist.key?(key)
|
||
|
|
rec = bases.record_for_map(map)
|
||
|
|
closed = rec ? raids.door_closed_at(map, rec) : {}
|
||
|
|
@dist[key] = raids.bfs(map, [[post[0], post[1]]], nil, raids.play_bounds(map), closed)
|
||
|
|
rescue
|
||
|
|
@dist[key] = nil
|
||
|
|
end
|
||
|
|
|
||
|
|
# 120_Raids.rb start_grace: the captain calls out
|
||
|
|
def self.raid_warning(map)
|
||
|
|
cap = live_members(map)["L"]
|
||
|
|
return if cap.nil? || dead?(cap)
|
||
|
|
key = LonaCraft::RuntimeText.key(FILE, "rt_warn", with_name(text("Raid/warn")))
|
||
|
|
map.popup(cap.id, key, 0, 0)
|
||
|
|
end
|
||
|
|
|
||
|
|
# Captain menu: "Move post" and "Dismiss"
|
||
|
|
# the post goes to base +rec+ (the squad is made at its next setup)
|
||
|
|
def self.post_at(rec)
|
||
|
|
r = record
|
||
|
|
return false if r.nil? || rec.nil?
|
||
|
|
return false if r["base"].to_i == rec["id"].to_i
|
||
|
|
r["base"] = rec["id"]
|
||
|
|
live_members($game_map).each_value{|ev| despawn(ev) }
|
||
|
|
say("post moved to base #{rec["id"]} (#{bases.name_of(rec)})")
|
||
|
|
true
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.post_name
|
||
|
|
r = record
|
||
|
|
rec = r && r["base"] ? bases.record_by_id(r["base"]) : nil
|
||
|
|
rec ? bases.name_of(rec) : ""
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.dismiss
|
||
|
|
live_members($game_map).each_value{|ev| despawn(ev) }
|
||
|
|
end_contract(:dismissed)
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.debug_hire(days)
|
||
|
|
res = add_days(days)
|
||
|
|
if record["base"].nil?
|
||
|
|
here = bases.record_for_map($game_map)
|
||
|
|
pick = here || bases.pick_list.first
|
||
|
|
record["base"] = pick["id"] if pick
|
||
|
|
end
|
||
|
|
bases.debug_say("LonaCraft debug squad #{res}, #{days_left} days, captain #{record["name"]}")
|
||
|
|
end
|
||
|
|
|
||
|
|
# NPC/*.json into $data_npcs (DataManager.load_mod_database alias below)
|
||
|
|
def self.load_npcs
|
||
|
|
NPC_FILES.each{|rel|
|
||
|
|
path = LonaCraft.resource(rel)
|
||
|
|
unless File.exist?(path)
|
||
|
|
say("missing #{path}")
|
||
|
|
next
|
||
|
|
end
|
||
|
|
npc = NonPlayerCharacter::Data_NPC.load_from_json(JSON.decode(File.read(path)))
|
||
|
|
$data_npcs[npc.name] = npc
|
||
|
|
}
|
||
|
|
rescue => e
|
||
|
|
say("NPC data error #{e.class} #{e.message}")
|
||
|
|
end
|
||
|
|
|
||
|
|
def self.install_redirect
|
||
|
|
return if $mod_load_script.nil? || !defined?(LonaCraft::Homes)
|
||
|
|
LonaCraft::Homes.redirect(GUILD_SCRIPT)
|
||
|
|
rescue => e
|
||
|
|
say("redirect error #{e.class} #{e.message}")
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
LonaCraft::Mercs.install_redirect
|
||
|
|
|
||
|
|
#==============================================================================
|
||
|
|
# DataManager: the squad's NPC data
|
||
|
|
#==============================================================================
|
||
|
|
module DataManager
|
||
|
|
unless respond_to?(:load_mod_database_lonacraft_mercs)
|
||
|
|
self.singleton_class.send(:alias_method, :load_mod_database_lonacraft_mercs, :load_mod_database)
|
||
|
|
def self.load_mod_database
|
||
|
|
load_mod_database_lonacraft_mercs
|
||
|
|
LonaCraft::Mercs.load_npcs
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
#==============================================================================
|
||
|
|
# Game_Date: contract warning and end (after 140_AwayRaids.rb's rolls)
|
||
|
|
#==============================================================================
|
||
|
|
class Game_Date
|
||
|
|
[:shift, :addDays, :oneDayForward].each{|meth|
|
||
|
|
old = "#{meth}_lonacraft_mercs".to_sym
|
||
|
|
next unless method_defined?(meth)
|
||
|
|
next if method_defined?(old)
|
||
|
|
alias_method old, meth
|
||
|
|
define_method(meth){|*args, **kwargs, &block|
|
||
|
|
result = kwargs.empty? ? send(old, *args, &block) : send(old, *args, **kwargs, &block)
|
||
|
|
begin
|
||
|
|
LonaCraft::Mercs.on_date_moved if $game_date.equal?(self)
|
||
|
|
rescue => e
|
||
|
|
p "LonaCraft Mercs date hook error #{e.class} #{e.message}"
|
||
|
|
end
|
||
|
|
result
|
||
|
|
}
|
||
|
|
}
|
||
|
|
end
|
||
|
|
|
||
|
|
class Game_Map
|
||
|
|
unless method_defined?(:setup_lonacraft_mercs)
|
||
|
|
alias_method :setup_lonacraft_mercs, :setup
|
||
|
|
def setup(map_id)
|
||
|
|
before = @map_id_rec
|
||
|
|
forced = @force_setup
|
||
|
|
setup_lonacraft_mercs(map_id)
|
||
|
|
begin
|
||
|
|
LonaCraft::Mercs.after_setup(self, before != @map_id_rec || forced)
|
||
|
|
rescue => e
|
||
|
|
p "LonaCraft Mercs setup error #{e.class} #{e.message}"
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
class Game_Event
|
||
|
|
unless method_defined?(:lonacraft_mercs_self_movement)
|
||
|
|
alias_method :lonacraft_mercs_self_movement, :update_self_movement
|
||
|
|
def update_self_movement
|
||
|
|
if @summon_data.is_a?(Hash) && @summon_data[:LonaCraftMerc]
|
||
|
|
return if LonaCraft::Mercs.drive(self)
|
||
|
|
end
|
||
|
|
lonacraft_mercs_self_movement
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
# 2026-10-08: the NPCs Lona hits become the squad's foes
|
||
|
|
class Game_NonPlayerCharacter
|
||
|
|
if method_defined?(:set_last_attacker) && !method_defined?(:set_last_attacker_lonacraft_mercs)
|
||
|
|
alias_method :set_last_attacker_lonacraft_mercs, :set_last_attacker
|
||
|
|
def set_last_attacker(attacker)
|
||
|
|
result = set_last_attacker_lonacraft_mercs(attacker)
|
||
|
|
begin
|
||
|
|
LonaCraft::Mercs.lona_hit(self) if !$game_player.nil? && @last_attacker.equal?($game_player)
|
||
|
|
rescue => e
|
||
|
|
p "LonaCraft Mercs hit hook error #{e.class} #{e.message}"
|
||
|
|
end
|
||
|
|
result
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
class Scene_Map
|
||
|
|
unless method_defined?(:update_lonacraft_mercs)
|
||
|
|
alias_method :update_lonacraft_mercs, :update
|
||
|
|
def update
|
||
|
|
update_lonacraft_mercs
|
||
|
|
LonaCraft::Mercs.update
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
#==============================================================================
|
||
|
|
# Game_Interpreter: the guild line, the hire talk, the captain
|
||
|
|
#==============================================================================
|
||
|
|
class Game_Interpreter
|
||
|
|
# Run by HCGframes/NoerTavernGuildEmpolyee.rb in place of the game's script
|
||
|
|
def lonacraft_merc_guild(game_script)
|
||
|
|
@lonacraft_merc_guild = LonaCraft::Mercs.enabled?
|
||
|
|
begin
|
||
|
|
lonacraft_run_previous_script(game_script)
|
||
|
|
ensure
|
||
|
|
@lonacraft_merc_guild = nil
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
# a message from a runtime text with an \optB list; the choice or -1
|
||
|
|
def lonacraft_merc_ask(id, text, options)
|
||
|
|
m = LonaCraft::Mercs
|
||
|
|
opts = options.map{|o| m.clean(o) }.join(",")
|
||
|
|
call_msg(LonaCraft::RuntimeText.key(m::FILE, id, "#{text}\\optB[#{opts}]"))
|
||
|
|
pick = $game_temp.choice
|
||
|
|
$game_temp.choice = -1
|
||
|
|
pick.nil? ? -1 : pick
|
||
|
|
end
|
||
|
|
|
||
|
|
def lonacraft_merc_say(id, text)
|
||
|
|
call_msg(LonaCraft::RuntimeText.key(LonaCraft::Mercs::FILE, id, text))
|
||
|
|
end
|
||
|
|
|
||
|
|
# days picked (nil = none) from +ask+ (a text) and the day list
|
||
|
|
def lonacraft_merc_pick_days(ask)
|
||
|
|
m = LonaCraft::Mercs
|
||
|
|
choices = m.cfg["day_choices"]
|
||
|
|
pick = lonacraft_merc_ask("rt_days", ask, [m.text("Opt/cancel")] + m.day_labels)
|
||
|
|
return nil if pick < 1 || pick > choices.size
|
||
|
|
choices[pick - 1].to_i
|
||
|
|
end
|
||
|
|
|
||
|
|
# The guild line: hire (days, then the base), or the contract's state,
|
||
|
|
# a new post when it has none, and more days
|
||
|
|
def lonacraft_merc_guild_offer
|
||
|
|
m = LonaCraft::Mercs
|
||
|
|
b = LonaCraft::Bases
|
||
|
|
price = m.price_text(1)
|
||
|
|
if m.hired?
|
||
|
|
if m.record["base"].nil?
|
||
|
|
lonacraft_merc_say("rt_status", m.with_name(m.text("Guild/status_wait")).gsub("NUM", m.days_left.to_s))
|
||
|
|
rec = b.choose_base("LonaCraft:Mercs:Guild/ask_base")
|
||
|
|
if rec && m.post_at(rec)
|
||
|
|
lonacraft_merc_say("rt_posted", m.with_name(m.text("Guild/posted")).gsub("BASE", b.name_of(rec)))
|
||
|
|
end
|
||
|
|
else
|
||
|
|
lonacraft_merc_say("rt_status", m.with_name(m.text("Guild/status")).gsub("NUM", m.days_left.to_s).gsub("BASE", m.post_name))
|
||
|
|
end
|
||
|
|
else
|
||
|
|
if b.pick_list.empty?
|
||
|
|
call_msg("LonaCraft:Mercs:Guild/no_base")
|
||
|
|
return
|
||
|
|
end
|
||
|
|
lonacraft_merc_say("rt_offer", m.text("Guild/offer").gsub("PRICE", price))
|
||
|
|
end
|
||
|
|
days = lonacraft_merc_pick_days(m.text("Guild/ask_days").gsub("PRICE", price))
|
||
|
|
return if days.nil?
|
||
|
|
rec = nil
|
||
|
|
unless m.hired?
|
||
|
|
rec = b.choose_base("LonaCraft:Mercs:Guild/ask_base")
|
||
|
|
return if rec.nil?
|
||
|
|
end
|
||
|
|
case m.pay(days, self)
|
||
|
|
when :no_coins
|
||
|
|
call_msg("LonaCraft:Mercs:Guild/no_coins")
|
||
|
|
when :ok
|
||
|
|
m.post_at(rec)
|
||
|
|
lonacraft_merc_say("rt_hired", m.with_name(m.text("Guild/hired")).gsub("BASE", b.name_of(rec)))
|
||
|
|
when :extended
|
||
|
|
lonacraft_merc_say("rt_extended", m.text("Guild/extended").gsub("NUM", days.to_s))
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
# The squad's action key
|
||
|
|
def lonacraft_merc_talk(role)
|
||
|
|
m = LonaCraft::Mercs
|
||
|
|
r = m.record
|
||
|
|
return if r.nil?
|
||
|
|
if role != "L"
|
||
|
|
lonacraft_merc_say("rt_merc", m.with_name(m.text("Talk/merc")))
|
||
|
|
cam_center(0) if respond_to?(:cam_center)
|
||
|
|
return
|
||
|
|
end
|
||
|
|
pick = lonacraft_merc_ask("rt_captain", m.with_name(m.text("Talk/captain_menu")).gsub("NUM", m.days_left.to_s),
|
||
|
|
[m.text("Talk/opt_status"), m.text("Talk/opt_add"), m.text("Talk/opt_move"), m.text("Talk/opt_dismiss"), m.text("Opt/cancel")])
|
||
|
|
case pick
|
||
|
|
when 0
|
||
|
|
down = m::ROLES.count{|x| m.down?(x) }
|
||
|
|
line = down == 0 ? m.text("Talk/status_ok") : m.text("Talk/status_down").gsub("NUM", down.to_s)
|
||
|
|
lonacraft_merc_say("rt_status", m.with_name(line).gsub("NUM", m.days_left.to_s))
|
||
|
|
when 1
|
||
|
|
days = lonacraft_merc_pick_days(m.with_name(m.text("Talk/ask_days")))
|
||
|
|
unless days.nil?
|
||
|
|
case m.pay(days, self)
|
||
|
|
when :no_coins
|
||
|
|
lonacraft_merc_say("rt_short", m.with_name(m.text("Talk/no_coins")))
|
||
|
|
when :ok, :extended
|
||
|
|
lonacraft_merc_say("rt_extended", m.with_name(m.text("Talk/extended")).gsub("NUM", days.to_s))
|
||
|
|
end
|
||
|
|
end
|
||
|
|
when 2
|
||
|
|
rec = LonaCraft::Bases.choose_base("LonaCraft:Mercs:Talk/ask_post")
|
||
|
|
if rec && m.post_at(rec)
|
||
|
|
name = LonaCraft::Bases.name_of(rec)
|
||
|
|
lonacraft_merc_say("rt_move", m.with_name(m.text("Talk/move")).gsub("BASE", name))
|
||
|
|
$game_map.popup(0, LonaCraft::RuntimeText.key(m::FILE, "rt_moving", m.text("Notice/moving").gsub("BASE", name)), 0, 0)
|
||
|
|
end
|
||
|
|
when 3
|
||
|
|
yes = lonacraft_merc_ask("rt_dismiss", m.with_name(m.text("Talk/dismiss_ask")), [m.text("Talk/opt_no"), m.text("Talk/opt_yes")])
|
||
|
|
if yes == 1
|
||
|
|
lonacraft_merc_say("rt_dismissed", m.with_name(m.text("Talk/dismissed")))
|
||
|
|
m.dismiss
|
||
|
|
$game_map.popup(0, "LonaCraft:Mercs:Notice/dismissed", 0, 0)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
cam_center(0) if respond_to?(:cam_center)
|
||
|
|
portrait_hide if respond_to?(:portrait_hide)
|
||
|
|
$game_temp.choice = -1
|
||
|
|
end
|
||
|
|
|
||
|
|
# The guild's "nothing pending" menu gets the mercenary line (choice 3)
|
||
|
|
if method_defined?(:call_msg) && !method_defined?(:call_msg_lonacraft_mercs)
|
||
|
|
alias_method :call_msg_lonacraft_mercs, :call_msg
|
||
|
|
def call_msg(*args)
|
||
|
|
return call_msg_lonacraft_mercs(*args) unless @lonacraft_merc_guild && args[0] == LonaCraft::Mercs::GUILD_MENU_KEY
|
||
|
|
@lonacraft_merc_guild = nil
|
||
|
|
menu = LonaCraft::Mercs.guild_menu
|
||
|
|
return call_msg_lonacraft_mercs(*args) if menu.nil?
|
||
|
|
new_args = args.dup
|
||
|
|
new_args[0] = menu[0]
|
||
|
|
result = call_msg_lonacraft_mercs(*new_args)
|
||
|
|
if $game_temp.choice == menu[1]
|
||
|
|
$game_temp.choice = -1
|
||
|
|
begin
|
||
|
|
lonacraft_merc_guild_offer
|
||
|
|
rescue => e
|
||
|
|
p "LonaCraft Mercs guild error #{e.class} #{e.message}"
|
||
|
|
end
|
||
|
|
$game_temp.choice = -1
|
||
|
|
elsif menu[2] && $game_temp.choice == menu[2]
|
||
|
|
$game_temp.choice = -1
|
||
|
|
begin
|
||
|
|
lonacraft_maid_offer
|
||
|
|
rescue => e
|
||
|
|
p "LonaCraft Maid guild error #{e.class} #{e.message}"
|
||
|
|
end
|
||
|
|
$game_temp.choice = -1
|
||
|
|
end
|
||
|
|
result
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|