Files
LonaRPG-Online-Games/ModScripts/_Mods/LonaCraft/Scripts/170_Maid.rb
T
2026-10-29 21:59:06 +04:00

1207 lines
39 KiB
Ruby

#==============================================================================
# LonaCraft - 170_Maid.rb (board R13, research docs/RESEARCH_MAID.md, owner
# decisions 2026-10-06: all 14 choices as recommended, except choice 12: she
# needs a Bed or Bedroll inside the walls to take post).
# A maid who keeps one post, a base or a house Lona owns (owner 2026-10-07:
# "The maid should also be able to be sent to any houses you own, not just
# bases."): she cooks the food left in its chests into the dark pot's dishes,
# is paid a copper a day from a chest there, never fights, and is gone for
# good when she dies.
# What it does:
# * Posts: a named base (Bases.pick_list), or a bought house of 100_Homes.rb
# (a LOCATIONS row with its own map, not :mode :rent; today the Old Shack
# and the Stone House; a rented inn room is never a post). Saved as "base"
# (the base record id) or "home" (the location id), never both; Maid.post
# gives [:base, record] or [:home, id]; a save with only "base" is as
# before. In a house the whole house is inside the walls (as 160_Rest.rb
# Rest.inside): every placed piece on the house's map counts for the bed
# rule, the wages and the cooking.
# * Hire: Boss Mama in the Noer tavern, a line "Hire a maid 5 Copper" in her
# menu (Homes.add_menu_provider over the SELLERS wrapper of
# NoerTavernWaifu.rb, 100_Homes.rb); while Boss Mama is away from the tavern
# (her event's own init rule, Map059 ev69: UniqueCharUniqueTavernWaifu -1,
# RecQuestCocona 14-20 or 25, or 4 before RecQuestCoconaAmt) the guild
# receptionist offers the same line (150_Mercs.rb guild menu). The post is
# picked by name (Maid.post_choices: the bases, then the owned houses); it
# needs a Bed or Bedroll inside the walls, else Boss Mama says "There is
# nowhere for her to sleep." (Hire/no_bed; Change 2026-10-08, owner: "We
# are talking to Big Momma, not the maid she sends.") and nothing is
# charged.
# "hire_fee" 5 Copper Coins from Lona's purse (+ the difficulty level's
# "maid_fee_add": hard 5, hell 7, doom 8; R10, Config/Bases.json
# "difficulty"); a name, hair and face are drawn and saved. A hired maid
# keeps her terms; her daily "pay" is never scaled.
# * Wages: at every date move into day ("catchup_days" 14 at most), "pay" 1
# "coin" (ItemCoin1) from a chest or wardrobe inside the walls (the pantry
# first); none: one more unpaid day; a paid day clears them. "grace_days" 3
# unpaid days: she leaves, with a popup.
# * Cooking, the same morning, after the wages: with a Stove or Cooking Fire
# inside the walls ("need_fire"; the fire stands in for the recipes' Wood),
# up to "dishes_per_day" 2 dishes while fewer than "pantry_cap" 6 cooked
# dishes are inside the walls. Recipes: $data_AlchemyRecipes (the dark pot)
# whose output is one of the rest's plain dishes (160_Rest.rb DISHES: Meat
# Salad, Good Soup, Smoked Meat, Meat Soup, Plant Soup, Dry Food); never
# human or mystic meat, never FoodBad; MinStatReq checked against
# "cook_skill" 10. Ingredients: items with pot_data in the chests inside
# the walls, covered greedily (the item covering most of what is still
# missing first, then the cheapest). Best = satiety of the dish (+ mood / 10)
# minus the satiety of cooked dishes used up. Into the pantry: the chest
# inside the walls nearest the fire. A popup on waking: "<name> cooked ...".
# The rest's chest meal (160_Rest.rb) eats these dishes.
# * At the post: the runtime event (NPC/LonaCraftMaid.json, AI
# Npc_LonaCraftMaid < Npc_RunAway, no skills, health 150; sheet
# -char-F-REGULAR01 index 0 pattern 2, the game's unused "02Maid" look; the
# saved hair and face are put back after every spawn), made after every
# setup of the post's map (a base, or the house map, Homes.map_id_for).
# She stands by the fire (else by a bed), wanders "wander" 3 tiles inside
# her room; a hostile within "flee_radius" 6 tiles or a live raid (bases
# only): she runs to the tile of her room farthest from its doors. In a
# house her room is the floor (Homes.floor_tiles) minus the tiles on or
# next to the -point-StartPoint / -point-ExitPoint (the stairs stay free),
# and the hiding tile is the floor tile farthest from those points.
# * Death: in a live raid (Game_NonPlayerCharacter#process_death alias) the
# hire ends for good with a popup; rehire at Boss Mama. Away raids
# (140_AwayRaids.rb): raiders who reach her room with blows left kill her
# one time in two ("away_kill" 0.5, + the level's "maid_kill_add": hell
# 0.6, doom 0.75), else she hid; both in the report.
# Away raids never touch a house (towns are safe).
# * Her menu: status (days paid, dishes cooked, the pantry, where she is),
# Move (the bases and the owned houses, the same bed rule; her refusal is
# her own line Talk/no_bed "There is nowhere for me to sleep there.",
# 2026-10-08), Dismiss.
# * Save: $game_system.lonacraft_data["maid"] (plain types; "base" or "home").
# * Nothing here runs without a hire (the Boss Mama line excepted).
#==============================================================================
module LonaCraft
module Maid
TEXT = "LonaCraft:Maid:"
FILE = "Maid"
NPC_NAME = "LonaCraftMaid"
NPC_FILE = "NPC/LonaCraftMaid.json"
SPRITE = ["-char-F-REGULAR01", 0, 2] # "02Maid" (CHSconfigs_NPC/-char-F-REGULAR01.json)
# the "02Maid" part lists of that file (hair = head_equip, face = head)
HAIRS = ["FregC_HeadEquip_human_GoldenWave.png", "FregC_HeadEquip_human_ShorGoldtWave.png",
"FregC_HeadEquip_human_PoorSlaveLong.png", "FregC_HeadEquip_human_PoorSlaveShort.png",
"FregC_HeadEquip_human_PurpleShort.png", "FregC_HeadEquip_human_FeiraGreen.png",
"FregC_HeadEquip_human_EliseGoldHair.png", "FregC_HeadEquip_human_ElfArcher.png",
"FregC_HeadEquip_HairMootRedMessy.png", "FregC_HeadEquip_human_ShortWhite.png",
"FregC_HeadEquip_human_LongBrown.png", "FregC_HeadEquip_human_ShortRound.png",
"FregC_HeadEquip_human_OldSlut.png"]
FACES = ["FregC_head_human_NPC.png", "FregC_head_human_teller.png",
"FregC_head_human_OldMama.png", "FregC_head_human_anonymous.png"]
SELLER = "NoerTavernWaifu"
FIRE_KINDS = ["Stove", "Campfire"]
BED_KINDS = ["Bed", "BedDark", "BedBlue", "PottedPlant"] # PottedPlant = the Bedroll
BAD_TAGS = ["HumanMeat", "MysticMeat", "HumanMysticMeat"]
DISH_MOOD = {"ItemMeatSalad" => 40, "ItemSopGood" => 20, "ItemSopMeat" => 10, "ItemSopPlant" => 10}
CHECK_EVERY = 30
DIRS = [[2, 0, 1], [4, -1, 0], [6, 1, 0], [8, 0, -1]]
@tick = 0
@leave = false
@flee = {} # event id => true while she hides
@dist = {} # [map object id, x, y] => distance map over her room
@rooms = {} # map object id => {tile => true} her room
def self.say(text)
p "LonaCraft Maid: #{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.fur
LonaCraft::Furniture
end
def self.cfg
raids.cfg["maid"]
end
def self.enabled?
return false unless defined?(LonaCraft::Bases) && defined?(LonaCraft::Raids) && defined?(LonaCraft::Furniture)
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
#----------------------------------------------------------------------
# The hire record
#----------------------------------------------------------------------
def self.root
return nil if $game_system.nil? || !$game_system.respond_to?(:lonacraft_data)
$game_system.lonacraft_data
end
def self.record
d = root
return nil if d.nil?
r = d["maid"]
r.is_a?(Hash) && r["name"].is_a?(String) ? r : nil
end
#----------------------------------------------------------------------
# Her post: a base or a house (2026-10-07)
#----------------------------------------------------------------------
def self.homes
defined?(LonaCraft::Homes) ? LonaCraft::Homes : nil
end
# true for location +id+ of 100_Homes.rb that can be a post: a bought
# house with its own map, registered this session (never a rented room)
def self.house?(id)
h = homes
return false if h.nil? || !h.enabled? || !id.is_a?(String)
loc = h.location(id)
!loc.nil? && !h.rent?(loc) && loc[:interior].is_a?(Array) && !h.map_id_for(id).nil?
end
# the houses Lona owns that can be posts (LOCATIONS order)
def self.house_ids
h = homes
return [] if h.nil? || !h.enabled?
h.owned_ids.select{|id| house?(id) }
end
# [:home, location id] / [:base, base id] as saved in +r+, or nil (no lookup)
def self.post_ref(r)
return nil unless r.is_a?(Hash)
return [:home, r["home"]] if r["home"].is_a?(String) && !r["home"].empty?
r["base"].nil? ? nil : [:base, r["base"].to_i]
end
# [:base, base record] / [:home, location id] of her post (or of +r+);
# nil when it is gone (a base removed, a house not owned or not loaded)
def self.post(r = record)
ref = post_ref(r)
return nil if ref.nil?
return (house?(ref[1]) && homes.owned?(ref[1]) ? ref : nil) if ref[0] == :home
rec = bases.record_by_id(ref[1])
rec ? [:base, rec] : nil
end
# writes post +pt+ into record +r+: "base" or "home", never both
def self.set_post(r, pt)
if pt[0] == :home
r.delete("base")
r["home"] = pt[1]
else
r.delete("home")
r["base"] = pt[1]["id"]
end
end
def self.same_post?(a, b)
return false if a.nil? || b.nil? || a[0] != b[0]
a[0] == :home ? a[1] == b[1] : a[1]["id"].to_i == b[1]["id"].to_i
end
def self.house_name(id)
h = homes
loc = h ? h.location(id) : nil
loc ? h.text(loc[:name]) : id.to_s
end
# the post's name for texts ("-" for none)
def self.post_name(pt)
return "-" if pt.nil?
pt[0] == :home ? house_name(pt[1]) : bases.name_of(pt[1])
end
# a menu entry for +pt+ (as Bases.choose_base: no commas, brackets,
# colons or backslashes)
def self.post_label(pt)
post_name(pt).gsub(bases::NAME_DROP, "")
end
# the hire and Move menus: the bases the picker offers (Bases.pick_list),
# then the owned houses
def self.post_choices
bases.pick_list.map{|rc| [:base, rc] } + house_ids.map{|id| [:home, id] }
end
# true when +map+ (the live Game_Map) is the map of post +pt+
def self.here?(map, pt)
return false if map.nil? || pt.nil?
return homes.home_at_map?(map) == pt[1] if pt[0] == :home
rec = bases.record_for_map(map)
!rec.nil? && rec["id"].to_i == pt[1]["id"].to_i
end
def self.notice(id, str)
return unless defined?(LonaCraft::Homes)
LonaCraft::Homes.notice(LonaCraft::RuntimeText.key(FILE, id, str))
end
def self.named(key)
r = record
text(key).gsub("NAME", r ? r["name"].to_s : "")
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
# R10: the hire fee of the difficulty level
def self.fee
[cfg["hire_fee"].to_i + raids.diff("maid_fee_add").to_i, 0].max
end
def self.fee_text
"#{fee} #{coin_name}"
end
def self.pick_name
list = text("Names/list").split(",").map{|n| n.strip }.reject{|n| n.empty? || n.include?(":") }
list.empty? ? "Anna" : list.sample
end
# ends the hire; +how+ :left, :dismissed, :killed
def self.end_hire(how)
d = root
r = record
return if d.nil? || r.nil?
d["maid_lost"] = {"name" => r["name"], "at" => now, "how" => how.to_s}
d.delete("maid")
@leave = true
say("#{r["name"]} is gone (#{how})")
end
#----------------------------------------------------------------------
# Inside the walls, offline (140_AwayRaids.rb inside_rooms)
#----------------------------------------------------------------------
def self.inside_of(rec)
return {} if rec.nil? || !defined?(LonaCraft::AwayRaids)
LonaCraft::AwayRaids.inside_rooms(rec)
end
# [[furniture record, kind], ...] of base +rec+ whose own tile is inside
def self.inside_furniture(rec, rooms = nil)
rooms ||= inside_of(rec)
out = []
bases.furniture_on(rec).each{|f|
k = fur.kind_for(f["item_name"])
next if k.nil?
out << [f, k] if rooms[[f["x"].to_i, f["y"].to_i]]
}
out
end
# [[furniture record, kind], ...] of house +id+: every placed piece on its
# map (the whole house is inside the walls, 160_Rest.rb Rest.inside)
def self.house_furniture(id)
h = homes
no = h ? h.map_id_for(id) : nil
return [] if no.nil?
out = []
fur.records.each{|f|
next unless f.is_a?(Hash) && f["map_id"].to_i == no.to_i
k = fur.kind_for(f["item_name"])
out << [f, k] if k
}
out
end
# the furniture inside the walls of post +pt+
def self.post_furniture(pt)
return [] if pt.nil?
pt[0] == :home ? house_furniture(pt[1]) : inside_furniture(pt[1])
end
def self.bed_inside?(pt)
post_furniture(pt).any?{|f, k| BED_KINDS.include?(k[:key]) }
end
def self.fire_of(list)
list.find{|f, k| FIRE_KINDS.include?(k[:key]) }
end
# storage pieces inside, the pantry first (the one nearest the fire)
def self.chests_of(list)
chests = list.select{|f, k| k[:storage] }
fire = fire_of(list)
return chests if fire.nil?
fx = fire[0]["x"].to_i
fy = fire[0]["y"].to_i
chests.sort_by{|f, k| (f["x"].to_i - fx).abs + (f["y"].to_i - fy).abs }
end
def self.box_of(f, make = false)
id = f["box"].to_i
if id < fur::BOX_BASE
return nil unless make
id = fur.next_box_id
f["box"] = id
end
$game_boxes.box(id) if make
fur.box_contents(id).is_a?(Hash) ? id : (make ? id : nil)
end
#----------------------------------------------------------------------
# The date hook: wages, then cooking, once per day
#----------------------------------------------------------------------
def self.on_date_moved
r = record
return if r.nil? || !enabled?
t = now
last = r["t"].is_a?(Integer) ? r["t"] : t
r["t"] = [last, t].max
return if t <= last
first = [last + 1, t - cfg["catchup_days"].to_i * per_day + 1].max
cooked = []
(first..t).each{|u|
next unless u.even?
break if record.nil?
pt = post
if pt.nil?
r["base"] = nil unless r["home"] # a base gone; a house not loaded keeps its place
break
end
list = post_furniture(pt)
pay_day(r, list)
break if record.nil?
cooked.concat(cook_day(r, list))
}
report_cooking(r, cooked) if record
rescue => e
say("date hook error #{e.class} #{e.message} #{e.backtrace ? e.backtrace[0] : ""}")
end
def self.pay_day(r, list)
c = coin
need = cfg["pay"].to_i
paid = false
if c && need > 0
chests_of(list).each{|f, k|
id = box_of(f)
next if id.nil?
box = fur.box_contents(id)
obj = box.keys.find{|o| o.respond_to?(:item_name) && o.item_name.to_s == c.item_name.to_s && box[o].to_i >= need }
next if obj.nil?
$game_boxes.remove_item(obj, need, id, false)
paid = true
break
}
else
paid = true
end
if paid
r["unpaid"] = 0
r["paid"] = r["paid"].to_i + 1
return
end
r["unpaid"] = r["unpaid"].to_i + 1
say("no wages today (#{r["unpaid"]} unpaid)")
if r["unpaid"] >= cfg["grace_days"].to_i
notice("rt_left", named("Notice/left").gsub("NUM", r["unpaid"].to_s))
end_hire(:left)
else
notice("rt_unpaid", named("Notice/unpaid"))
end
end
#----------------------------------------------------------------------
# Cooking
#----------------------------------------------------------------------
def self.rest
defined?(LonaCraft::Rest) ? LonaCraft::Rest : nil
end
# the plain dishes (160_Rest.rb DISHES group :plain) she may cook
def self.dish?(name)
r = rest
row = r ? r::DISHES[name.to_s] : nil
!row.nil? && row[1] == :plain
end
def self.dish_sat(name)
r = rest
row = r ? r::DISHES[name.to_s] : nil
row ? row[0].to_i : 0
end
def self.dish_item(name)
it = $data_ItemName[name.to_s]
it = $data_items[rest::MEAT_SALAD_ID] if it.nil? && name.to_s == "ItemMeatSalad" && rest
it
end
# [{:out, :req, :ban, :excl, :min}, ...] from the dark pot's table
def self.recipes
list = defined?($data_AlchemyRecipes) && $data_AlchemyRecipes.is_a?(Array) ? $data_AlchemyRecipes : []
out = []
list.each{|rc|
next unless rc.is_a?(Hash) && rc["output"].is_a?(Hash) && rc["requirements"].is_a?(Hash)
name = rc["output"].keys.first.to_s
next unless dish?(name) && dish_item(name)
req = rc["requirements"]
next if req.keys.any?{|tag| BAD_TAGS.include?(tag.to_s) }
cond = rc["conditions"].is_a?(Hash) ? rc["conditions"] : {}
min = cond["MinStatReq"].is_a?(Hash) ? cond["MinStatReq"].values.map{|v| v.to_i }.max.to_i : 0
req2 = {}
req.each{|tag, n| req2[tag.to_s] = n.to_i unless tag.to_s == "Wood" } # the fire burns
out << {:out => name, :req => req2, :ban => (rc["bannedItem"].is_a?(Hash) ? rc["bannedItem"].keys.map{|k| k.to_s } : []),
:excl => Array(cond["excludeIngredients"]).map{|k| k.to_s } + BAD_TAGS, :min => min}
}
out
end
def self.unit_name(obj)
r = rest
return "ItemMeatSalad" if r && obj.is_a?(RPG::Item) && obj.id == r::MEAT_SALAD_ID
obj.respond_to?(:item_name) ? obj.item_name.to_s : ""
end
# one entry per unit: {:obj, :box, :tags, :price, :sat}
def self.pool(list)
units = []
chests_of(list).each{|f, k|
id = box_of(f)
next if id.nil?
fur.box_contents(id).each{|obj, n|
tags = obj.respond_to?(:pot_data) ? obj.pot_data : nil
next unless tags.is_a?(Hash) && !tags.empty?
next if tags.keys.any?{|tag| BAD_TAGS.include?(tag.to_s) }
name = unit_name(obj)
type = obj.respond_to?(:type) ? obj.type.to_s : ""
next unless type == "Food" || name == "ItemOil"
t2 = {}
tags.each{|tag, v| t2[tag.to_s] = v.to_i }
price = obj.respond_to?(:price) ? obj.price.to_i : 0
sat = dish?(name) ? dish_sat(name) : 0
n.to_i.times{ units << {:obj => obj, :box => id, :tags => t2, :price => price, :sat => sat, :name => name} }
}
}
units
end
# the units that cover +rc+, or nil
def self.cover(rc, units)
missing = rc[:req].dup
taken = []
left = units.reject{|u| u[:tags].keys.any?{|tag| rc[:ban].include?(tag) || rc[:excl].include?(tag) } }
loop do
break if missing.values.all?{|v| v <= 0 }
best = nil
best_key = nil
left.each{|u|
c = 0
missing.each{|tag, v| c += [u[:tags][tag].to_i, v].min if v > 0 }
next if c <= 0
key = [c, -u[:price]]
if best.nil? || (key <=> best_key) > 0
best = u
best_key = key
end
}
return nil if best.nil?
taken << best
left.delete_at(left.index{|u| u.equal?(best) })
best[:tags].each{|tag, v| missing[tag] -= v if missing.key?(tag) }
end
taken
end
# [recipe, units, score] of the best dish, or nil
def self.best_dish(units)
skill = cfg["cook_skill"].to_i
best = nil
recipes.each{|rc|
next if rc[:min] > skill
used = cover(rc, units)
next if used.nil?
score = dish_sat(rc[:out]) + DISH_MOOD[rc[:out]].to_i / 10.0 - used.inject(0){|s, u| s + u[:sat] }
next if score <= 0
best = [rc, used, score] if best.nil? || score > best[2]
}
best
end
def self.cooked_inside(list)
n = 0
chests_of(list).each{|f, k|
id = box_of(f)
next if id.nil?
fur.box_contents(id).each{|obj, c| n += c.to_i if dish?(unit_name(obj)) }
}
n
end
# cooks this morning; returns the dish names made
def self.cook_day(r, list)
made = []
if fire_of(list).nil? && cfg["need_fire"]
r["why"] = "no_fire"
return made
end
pantry = chests_of(list).first
if pantry.nil?
r["why"] = "no_chest"
return made
end
cfg["dishes_per_day"].to_i.times{
break if cooked_inside(list) >= cfg["pantry_cap"].to_i
pick = best_dish(pool(list))
if pick.nil?
r["why"] = "bare" if made.empty?
break
end
rc, used, score = pick
used.each{|u| $game_boxes.remove_item(u[:obj], 1, u[:box], false) }
id = box_of(pantry[0], true)
$game_boxes.add_item(dish_item(rc[:out]), 1, id, :force)
made << rc[:out]
r["cooked"] = r["cooked"].to_i + 1
r.delete("why")
say("cooked #{rc[:out]} from #{used.map{|u| u[:name] }.join(", ")} (score #{score})")
}
made
end
def self.item_label(name)
it = dish_item(name)
it ? $game_text[it.name].to_s : name.to_s
end
def self.report_cooking(r, made)
if made.empty?
case r["why"]
when "no_fire" then notice("rt_cook", named("Notice/no_fire"))
when "bare"
notice("rt_cook", named("Notice/bare")) unless r["bare_told"]
r["bare_told"] = true
end
return
end
r.delete("bare_told")
pairs = []
made.each{|n|
row = pairs.find{|p| p[0] == n }
if row
row[1] += 1
else
pairs << [n, 1]
end
}
r["last"] = pairs
txt = pairs.map{|n, c| c > 1 ? "#{item_label(n)} x#{c}" : item_label(n) }.join(", ")
notice("rt_cook", named("Notice/cooked").gsub("LIST", txt))
end
#----------------------------------------------------------------------
# Away raids (140_AwayRaids.rb simulate): raiders reached her room
#----------------------------------------------------------------------
def self.away_tile(rec)
ref = post_ref(record)
return nil if ref.nil? || ref[0] != :base || ref[1] != rec["id"].to_i
list = inside_furniture(rec)
f = fire_of(list) || list.find{|ff, k| BED_KINDS.include?(k[:key]) }
f ? [f[0]["x"].to_i, f[0]["y"].to_i] : nil
end
# ["killed" / "hid", name] once she is reached, else nil
def self.away_reached(rec, reached)
tile = away_tile(rec)
return nil if tile.nil?
x, y = tile
hit = reached[[x, y]] || DIRS.any?{|d, dx, dy| reached[[x + dx, y + dy]] }
return nil unless hit
name = record["name"]
if rand < cfg["away_kill"].to_f + raids.diff("maid_kill_add").to_f # R10
notice("rt_killed", named("Notice/killed"))
end_hire(:killed)
["killed", name]
else
["hid", name]
end
end
#----------------------------------------------------------------------
# Boss Mama's line (and the guild's while she is away)
#----------------------------------------------------------------------
def self.mama_away?
s = $story_stats
return false if s.nil?
return true if s["UniqueCharUniqueTavernWaifu"].to_i == -1
q = s["RecQuestCocona"].to_i
return true if q.between?(14, 20) || q == 25
q == 4 && $game_date && $game_date.dateAmt < s["RecQuestCoconaAmt"].to_i
rescue
false
end
def self.guild_offer?
enabled? && mama_away?
end
def self.menu_label
r = record
r ? text("Menu/yours").gsub("NAME", r["name"].to_s) : text("Menu/hire").gsub("PRICE", fee_text)
end
def self.menu_entries
return [] unless enabled?
[[menu_label, lambda{|interp| interp.lonacraft_maid_offer }]]
end
def self.new_record(pt)
r = {"name" => pick_name, "hired" => now, "t" => now, "unpaid" => 0,
"paid" => 0, "cooked" => 0, "look" => {"head_equip" => HAIRS.sample, "head" => FACES.sample}}
set_post(r, pt)
r
end
# a new hire for post +pt+ ([:base, rec] / [:home, id]); :ok, :no_coins, :no_bed
def self.hire(pt, interp)
return :no_bed unless bed_inside?(pt)
c = coin
fee = self.fee
return :no_coins if c.nil? || $game_party.item_number(c) < fee
interp.optain_lose_item(c, fee) if fee > 0
root["maid"] = new_record(pt)
say("#{record["name"]} hired for #{post_ref(record).inspect}")
:ok
end
def self.move_to(pt)
r = record
return :no_bed unless bed_inside?(pt)
return :same if same_post?(post, pt)
set_post(r, pt)
r.delete("why")
live_members($game_map).each{|ev| despawn(ev) }
:ok
end
def self.dismiss
live_members($game_map).each{|ev| despawn(ev) }
end_hire(:dismissed)
end
#----------------------------------------------------------------------
# The maid 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[:LonaCraftMaid]
end
def self.live_members(map)
return [] if map.nil?
map.events.values.select{|ev| member?(ev) }
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
def self.label(name)
RPG::EventCommand.new(118, 0, [name])
end
def self.build_event(x, y, face)
sheet, index, pattern = SPRITE
ev = RPG::Event.new(x, y)
ev.name = "LonaCraftMaid"
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.direction_fix = false
page.through = false
page.priority_type = 1
page.trigger = 0
list = [label("init"), label("common")]
["@nappable = false",
"set_npc(#{NPC_NAME.inspect})",
"@npc.stat.set_stat(\"arousal\", 0)",
"@npc.stat.set_stat(\"mood\", 50)",
"@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_maid_talk if respond_to?(:lonacraft_maid_talk)")
list << RPG::EventCommand.new(0, 0, [])
page.list = list
ev.pages = [page]
ev
end
# her saved hair and face over the random parts (Charset_System.rb:121-130)
def self.apply_look(ev)
r = record
look = r ? r["look"] : nil
return unless look.is_a?(Hash)
conf = ev.instance_variable_get(:@chs_configuration)
return unless conf.is_a?(Hash)
changed = false
["head_equip", "head"].each{|part|
want = look[part]
next unless want.is_a?(String) && conf.key?(part) && conf[part] != want
conf[part] = want
changed = true
}
ev.instance_variable_set(:@chs_need_update, true) if changed
rescue => e
say("look error #{e.class} #{e.message}")
end
# her room on the live map: the inside tiles joined to the fire (else a
# bed, else the largest room); [room hash, anchor tile] or nil
def self.live_room(map, rec)
rm = map.instance_variable_get(:@region_map)
ins = bases.inside_tiles(map, rec, rm.is_a?(Array) ? rm : [])
return nil if ins.empty?
list = bases.furniture_on(rec).map{|f| [f, fur.kind_for(f["item_name"])] }.select{|f, k| k && ins[[f["x"].to_i, f["y"].to_i]] }
pick = fire_of(list) || list.find{|f, k| BED_KINDS.include?(k[:key]) }
anchor = pick ? [pick[0]["x"].to_i, pick[0]["y"].to_i] : ins.keys.first
room = {}
raids.bfs(map, [anchor], ins).each_key{|c| room[c] = true }
room[anchor] = true
[room, anchor]
end
# the way out of house +id+ on the live map: its -point-ExitPoint and
# -point-StartPoint (Game_Map#storypoint_map), else the entry tile
def self.house_exits(map, id)
out = []
sm = map.storypoint_map
if sm.is_a?(Hash)
["ExitPoint", "StartPoint"].each{|n|
sp = sm[n]
out << [sp[0].to_i, sp[1].to_i] if sp.is_a?(Array)
}
end
loc = homes.location(id)
out << [loc[:interior][2].to_i, loc[:interior][3].to_i] if out.empty? && loc && loc[:interior].is_a?(Array)
out.uniq
end
# her room in house +id+: the floor (Homes.floor_tiles) minus the tiles
# on or next to the way out; the anchor is the fire, else a bed, else
# the top-left floor tile. [room, anchor, way out, floor] or nil
def self.house_room(map, id)
floor = homes.floor_tiles(map, id)
return nil if floor.nil? || floor.empty?
exits = house_exits(map, id)
room = {}
floor.each_key{|c|
room[c] = true unless exits.any?{|e| (e[0] - c[0]).abs + (e[1] - c[1]).abs <= 1 }
}
return nil if room.empty?
list = house_furniture(id)
pick = fire_of(list) || list.find{|f, k| BED_KINDS.include?(k[:key]) }
anchor = pick ? [pick[0]["x"].to_i, pick[0]["y"].to_i] : room.keys.min_by{|c| [c[1], c[0]] }
[room, anchor, exits, floor]
end
# her room on the live map of post +pt+: [room, anchor, door tiles, the
# tiles the hiding distance is measured over], or nil
def self.room_for(map, pt)
return house_room(map, pt[1]) if pt[0] == :home
rec = pt[1]
got = live_room(map, rec)
return nil if got.nil?
room, anchor = got
doors = []
bases.pieces_of(rec).each{|k, v|
next unless bases.door?(v)
x, y = k.split(",").map{|n| n.to_i }
DIRS.each{|d, dx, dy| doors << [x + dx, y + dy] if room[[x + dx, y + dy]] }
}
[room, anchor, doors.uniq, room]
end
def self.after_setup(map)
@dist = {}
@rooms = {}
@flee = {}
return if map.nil? || map.isOverMap
r = record
return if r.nil? || !enabled?
pt = post
return unless here?(map, pt)
return unless live_members(map).empty?
if $data_npcs.nil? || $data_npcs[NPC_NAME].nil?
say("NPC data missing (#{NPC_FILE}), no maid")
return
end
got = room_for(map, pt)
return say("no room inside the walls at #{post_ref(r).inspect}") if got.nil?
room, anchor, doors, area = got
ax, ay = anchor
free = room.keys.select{|c| raids.free_tile?(map, c[0], c[1]) }
return say("no free tile in her room") if free.empty?
spot = free.min_by{|c| [(c[0] - ax).abs + (c[1] - ay).abs, c[1], c[0]] }
src = doors.empty? ? [spot] : doors
from_doors = raids.bfs(map, src, area)
far = free.max_by{|c| [from_doors[c].to_i, -((c[0] - ax).abs + (c[1] - ay).abs)] } || spot
face = ax == spot[0] ? (ay < spot[1] ? 8 : 2) : (ax < spot[0] ? 4 : 6)
ev = map.lonacraft_spawn_event(build_event(spot[0], spot[1], face),
{:LonaCraftMaid => true, :LonaCraftMaidPost => spot, :LonaCraftMaidFar => far})
@rooms[map.object_id] = room
apply_look(ev)
r["post"] = spot
say("#{r["name"]} at #{post_ref(r).inspect}, post #{spot.inspect}, hiding tile #{far.inspect}, room #{room.size} tiles")
rescue => e
say("spawn error #{e.class} #{e.message} #{e.backtrace ? e.backtrace[0] : ""}")
end
def self.room_here
@rooms[$game_map.object_id] || {}
end
def self.dist_to(tile)
key = [$game_map.object_id, tile[0], tile[1]]
return @dist[key] if @dist.key?(key)
room = room_here
@dist[key] = room.empty? ? nil : raids.bfs($game_map, [tile], room)
end
def self.step_to(ev, tile)
dist = dist_to(tile)
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
}
end
ev.move_toward_xy(tile[0], tile[1]) if ev.respond_to?(:move_toward_xy) && rand(4) == 0
end
def self.hostile_near?(ev)
r2 = cfg["flee_radius"].to_i ** 2
$game_map.events.values.any?{|o|
next false if o.nil? || o.equal?(ev) || (o.respond_to?(:deleted?) && o.deleted?)
next false unless o.respond_to?(:npc?) && o.npc?
npc = o.npc
next false if npc.nil? || npc.master == $game_player
next false if npc.respond_to?(:is_object) && npc.is_object
next false if npc.action_state == :death
dx = o.x - ev.x
dy = o.y - ev.y
next false if dx * dx + dy * dy > r2
!npc.friendly?($game_player)
}
rescue
false
end
# Game_Event#update_self_movement alias: true = handled here
def self.drive(ev)
npc = ev.npc
return false if npc.nil?
return true unless npc.action_state.nil? || npc.action_state == :none
return true if ev.moving?
sd = ev.summon_data
post = sd[:LonaCraftMaidPost]
return true unless post.is_a?(Array)
if @flee[ev.id]
far = sd[:LonaCraftMaidFar] || post
step_to(ev, far) unless ev.x == far[0] && ev.y == far[1]
return true
end
off = (ev.x - post[0]).abs + (ev.y - post[1]).abs
if off > cfg["wander"].to_i || !room_here[[ev.x, ev.y]]
step_to(ev, post)
elsif rand(150) == 0
d, dx, dy = DIRS.sample
k = [ev.x + dx, ev.y + dy]
ev.move_straight(d) if room_here[k] && (k[0] - post[0]).abs + (k[1] - post[1]).abs <= cfg["wander"].to_i && ev.passable?(ev.x, ev.y, d)
end
true
rescue => e
say("drive error #{e.class} #{e.message}")
false
end
# Scene_Map#update: flee checks, her look, leaving
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
evs = live_members(map)
if evs.empty?
@leave = false if r.nil?
return
end
pt = r ? post : nil
unless here?(map, pt)
evs.each{|ev| despawn(ev) }
@leave = false
return
end
if @rooms[map.object_id].nil? # after a load: her room again
got = room_for(map, pt)
@rooms[map.object_id] = got ? got[0] : {}
end
danger = pt[0] == :base && raids.active? # no live raids in a house
evs.each{|ev|
apply_look(ev)
@flee[ev.id] = danger || hostile_near?(ev)
}
rescue => e
say("update error #{e.class} #{e.message}")
end
# Game_NonPlayerCharacter#process_death alias: she is gone for good
def self.on_death(npc)
ev = npc.respond_to?(:event) ? npc.event : nil
return unless member?(ev) && record
notice("rt_killed", named("Notice/killed"))
end_hire(:killed)
rescue => e
say("death error #{e.class} #{e.message}")
end
def self.load_npc
path = LonaCraft.resource(NPC_FILE)
return say("missing #{path}") unless File.exist?(path)
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
# for the house Lona stands in, else the base here, else the newest base
def self.debug_hire
h = homes
id = h ? h.home_at_map?($game_map) : nil
pt = house?(id) ? [:home, id] : nil
if pt.nil?
rec = bases.record_for_map($game_map) || bases.pick_list.first
return bases.debug_say("LonaCraft debug no base") if rec.nil?
pt = [:base, rec]
end
root["maid"] = new_record(pt)
bases.debug_say("LonaCraft debug maid #{record["name"]} for #{post_name(pt)}")
end
end
end
#==============================================================================
# The AI: runs from danger, never fights (Npc_RunAway, Editables/4003)
#==============================================================================
if defined?(Npc_RunAway) && !defined?(Npc_LonaCraftMaid)
class Npc_LonaCraftMaid < Npc_RunAway
def get_move_command
nil # 170_Maid.rb drives her steps
end
def set_killer_skill(dist)
nil
end
def set_assaulter_skill(dist)
nil
end
end
end
if defined?(LonaCraft::Homes)
LonaCraft::Homes.add_menu_provider(LonaCraft::Maid::SELLER){ LonaCraft::Maid.menu_entries }
end
module DataManager
unless respond_to?(:load_mod_database_lonacraft_maid)
self.singleton_class.send(:alias_method, :load_mod_database_lonacraft_maid, :load_mod_database)
def self.load_mod_database
load_mod_database_lonacraft_maid
LonaCraft::Maid.load_npc
end
end
end
class Game_Date
[:shift, :addDays, :oneDayForward].each{|meth|
old = "#{meth}_lonacraft_maid".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::Maid.on_date_moved if $game_date.equal?(self)
rescue => e
p "LonaCraft Maid date hook error #{e.class} #{e.message}"
end
result
}
}
end
class Game_Map
unless method_defined?(:setup_lonacraft_maid)
alias_method :setup_lonacraft_maid, :setup
def setup(map_id)
setup_lonacraft_maid(map_id)
begin
LonaCraft::Maid.after_setup(self)
rescue => e
p "LonaCraft Maid setup error #{e.class} #{e.message}"
end
end
end
end
class Game_Event
unless method_defined?(:lonacraft_maid_self_movement)
alias_method :lonacraft_maid_self_movement, :update_self_movement
def update_self_movement
if @summon_data.is_a?(Hash) && @summon_data[:LonaCraftMaid]
return if LonaCraft::Maid.drive(self)
end
lonacraft_maid_self_movement
end
end
end
class Scene_Map
unless method_defined?(:update_lonacraft_maid)
alias_method :update_lonacraft_maid, :update
def update
update_lonacraft_maid
LonaCraft::Maid.update
end
end
end
class Game_NonPlayerCharacter
unless method_defined?(:process_death_lonacraft_maid)
alias_method :process_death_lonacraft_maid, :process_death
def process_death(*args)
LonaCraft::Maid.on_death(self) if @action_state != :death && @event.respond_to?(:summon_data) && @event.summon_data.is_a?(Hash) && @event.summon_data[:LonaCraftMaid]
process_death_lonacraft_maid(*args)
end
end
end
#==============================================================================
# Game_Interpreter: the hire line, her menu
#==============================================================================
class Game_Interpreter
def lonacraft_maid_say(id, text)
call_msg(LonaCraft::RuntimeText.key(LonaCraft::Maid::FILE, id, text))
end
def lonacraft_maid_ask(id, text, options)
m = LonaCraft::Maid
call_msg(LonaCraft::RuntimeText.key(m::FILE, id, "#{text}\\optB[#{options.map{|o| m.clean(o) }.join(",")}]"))
pick = $game_temp.choice
$game_temp.choice = -1
pick.nil? ? -1 : pick
end
# the bases, then the owned houses (Maid.post_choices), Cancel last; the
# post picked ([:base, rec] / [:home, id]) or nil
def lonacraft_maid_choose(id, prompt)
m = LonaCraft::Maid
posts = m.post_choices
return nil if posts.empty?
pick = lonacraft_maid_ask(id, prompt, posts.map{|pt| m.post_label(pt) } + [LonaCraft::Bases.text("Pick/cancel")])
pick >= 0 && pick < posts.size ? posts[pick] : nil
end
# Boss Mama's line (and the guild's while she is away)
def lonacraft_maid_offer
m = LonaCraft::Maid
r = m.record
if r
lonacraft_maid_say("rt_status", m.named("Hire/status").gsub("BASE", m.post_name(m.post)).gsub("NUM", r["paid"].to_i.to_s).gsub("DISHES", r["cooked"].to_i.to_s))
return
end
if m.post_choices.empty?
lonacraft_maid_say("rt_no_base", m.text("Hire/no_base"))
return
end
lonacraft_maid_say("rt_offer", m.text("Hire/offer").gsub("PRICE", m.fee_text))
pt = lonacraft_maid_choose("rt_pick_post", m.text("Hire/ask_base"))
return if pt.nil?
case m.hire(pt, self)
when :no_bed
lonacraft_maid_say("rt_no_bed", m.text("Hire/no_bed"))
when :no_coins
lonacraft_maid_say("rt_no_coins", m.text("Hire/no_coins").gsub("PRICE", m.fee_text))
when :ok
lonacraft_maid_say("rt_hired", m.named("Hire/done").gsub("BASE", m.post_name(pt)))
end
end
# her action key
def lonacraft_maid_talk
m = LonaCraft::Maid
r = m.record
return if r.nil?
pick = lonacraft_maid_ask("rt_menu", m.named("Talk/menu"),
[m.text("Talk/opt_status"), m.text("Talk/opt_move"), m.text("Talk/opt_dismiss"), m.text("Opt/cancel")])
case pick
when 0
pt = m.post
pantry = pt ? m.cooked_inside(m.post_furniture(pt)) : 0
where = pt ? " " + m.text("Talk/where").gsub("BASE", m.post_name(pt)) : ""
unpaid = r["unpaid"].to_i > 0 ? " " + m.text("Talk/unpaid").gsub("NUM", r["unpaid"].to_i.to_s) : ""
lonacraft_maid_say("rt_status", m.named("Talk/status").gsub("NUM", r["paid"].to_i.to_s).gsub("DISHES", r["cooked"].to_i.to_s).gsub("PANTRY", pantry.to_s) + where + unpaid)
when 1
pt = lonacraft_maid_choose("rt_pick_post", m.text("Talk/ask_base"))
if pt
case m.move_to(pt)
when :no_bed then lonacraft_maid_say("rt_no_bed", m.named("Talk/no_bed")) # 2026-10-08: her own voice
when :ok then lonacraft_maid_say("rt_moved", m.named("Talk/moved").gsub("BASE", m.post_name(pt)))
end
end
when 2
if lonacraft_maid_ask("rt_dismiss", m.named("Talk/dismiss_ask"), [m.text("Talk/opt_no"), m.text("Talk/opt_yes")]) == 1
lonacraft_maid_say("rt_bye", m.named("Talk/dismissed"))
m.dismiss
end
end
cam_center(0) if respond_to?(:cam_center)
portrait_hide if respond_to?(:portrait_hide)
$game_temp.choice = -1
end
end