Release 0.0.1.8.8.7
This commit is contained in:
1 parent
3c8a17aa78
commit
c7beab414c
16283 files changed
+768761
-2
No files matched your search
@@ -0,0 +1,454 @@
|
||||
#==============================================================================
|
||||
# LonaCraft - 160_Rest.rb (board R12 + R14, research docs/RESEARCH_REST.md,
|
||||
# owner decisions 2026-10-06: all 12 choices as recommended).
|
||||
# How well Lona sleeps depends on what she sleeps on, and a Bed inside walls
|
||||
# can give the inn's meal and bath from a chest and a tub inside the walls.
|
||||
# What it does:
|
||||
# * Three tiers, decided when the nap starts (research 2.1):
|
||||
# GROUND a nap with no bed (the nap skill anywhere): stamina gain x
|
||||
# "ground_sta_mult" 0.6 and never above "ground_sta_cap_pct" 80 %
|
||||
# of max, health GAIN x "ground_health_mult" 0.5 (hunger damage
|
||||
# unchanged), mood -"ground_mood" 10, dirt +"ground_dirt" 15,
|
||||
# "ground_sick_chance" 10 % for one FeelsSick stack, and
|
||||
# WildDangerous +"ground_danger" 10 before the danger roll (kept).
|
||||
# BEDROLL the Bedroll's Sleep, the nap skill on a Bedroll, the game's
|
||||
# own camp bed (PlayerBed), a Bed outside the walls: the plain nap.
|
||||
# BED a Bed / Dark Bed / Blue Bed whose own tile is inside the walls
|
||||
# (Bases.inside_tiles) or in an owned home: health and stamina to
|
||||
# max before the nap math (as the inn, NoerTavern_Nap.rb:131-132),
|
||||
# mood +"bed_mood" 10, the danger roll sees WildDangerous x
|
||||
# "bed_roll_mult" 0.75 (this roll only, the cut is put back).
|
||||
# R10 (Config/Bases.json "difficulty", 120_Raids.rb diff; hard changes
|
||||
# nothing): "ground_danger" + "ground_danger_add" (hell 15, doom 20),
|
||||
# "ground_sick_chance" + "ground_sick_add" (15 / 20 %), "bed_roll_mult"
|
||||
# + "bed_roll_add" (0.85 / 0.90). The level comes from the config file
|
||||
# only, read once at load, never from the game's mode.
|
||||
# * Meal (BED only, "food_on_bedroll" false): cooked dishes (DISHES, the dark
|
||||
# pot's food recipe outputs in Effects/Alchemy/2000_* and 6000_*) in
|
||||
# storage pieces inside the walls, never Lona's bag. One meal = "meal_sat"
|
||||
# 30 points: the smallest single dish worth that much, else dishes from the
|
||||
# largest down until 30; fewer than 30 points there = nothing taken, no
|
||||
# refill (research 2.2 "Not enough"). Eaten: satiety to max before the nap
|
||||
# math (as NoerTavern_Nap.rb:133); the dish's own effects do not apply.
|
||||
# Mystery and human dishes only with "mystery_dishes" / "human_dishes".
|
||||
# * Bath (BED only, "bath_on_bedroll" false): a piece with the Bathe action
|
||||
# (Water Trough, Wash Tub) inside the walls: the inn's 4 x
|
||||
# batch_take_bath(0.5) (0.25 cuffed) and dirt 0 (NoerTavern_Nap.rb:134-135),
|
||||
# no scene, no EXP.
|
||||
# * Where: base maps and plain field maps (OnRegionMap), owned homes (the
|
||||
# whole house map is inside walls); not while captured or in a rape loop;
|
||||
# the rented inn room is left alone (Homes.nap_keys_active); the Deep Sewer
|
||||
# keeps its own roll (C9).
|
||||
# * Hooks: the furniture Sleep action (lonacraft_furniture_action alias)
|
||||
# notes the bed; Game_Map#call_nap_event and GIM_OM#handleNap note the tier
|
||||
# (the interpreter still runs the bed's event there); GIM_ADDON#
|
||||
# region_map_wildness_nap_stats adds the ground danger / the bed cut;
|
||||
# Game_Actor#process_nap_change (Lona only) does the meal, bath, restore
|
||||
# before and scales the deltas after, around every other mod's nap math.
|
||||
# * Popups after waking (Homes.notice): "Lona ate a meal from the chest.",
|
||||
# "Lona washed before bed.", the ground and bed lines. Console lines give
|
||||
# the numbers.
|
||||
# * Nothing is saved; nothing runs on other maps or for other actors.
|
||||
#==============================================================================
|
||||
module LonaCraft
|
||||
module Rest
|
||||
TEXT = "LonaCraft:Bases:"
|
||||
BED_KINDS = ["Bed", "BedDark", "BedBlue"]
|
||||
BEDROLL_KINDS = ["PottedPlant"] # the Bedroll (90_Furniture.rb KINDS)
|
||||
CAMP_BED_EVENT = "PlayerBed" # the game's camp bed (Action_BuildCamp.rb)
|
||||
FRESH_FRAMES = 1800 # a noted tier is valid this long
|
||||
# item_name => [satiety, group] (research 1.7; read again from the item
|
||||
# at run time when it has a "sat" effect)
|
||||
DISHES = {
|
||||
"ItemMeatSalad" => [80, :plain], "ItemSopGood" => [32, :plain], "ItemSmokedMeat" => [26, :plain],
|
||||
"ItemSopMeat" => [16, :plain], "ItemSopPlant" => [16, :plain], "ItemDryFood" => [16, :plain],
|
||||
"ItemSopGoodMystery" => [24, :mystery], "ItemSmokedMeatMystery" => [18, :mystery], "ItemSopMeatMystery" => [12, :mystery],
|
||||
"ItemSopGoodHuman" => [32, :human], "ItemSmokedMeatHuman" => [32, :human], "ItemSopMeatHuman" => [16, :human],
|
||||
"ItemSopGoodHumanMystery" => [24, :human], "ItemSmokedMeatHumanMystery" => [18, :human], "ItemSopMeatHumanMystery" => [12, :human]
|
||||
}
|
||||
MEAT_SALAD_ID = 153 # food_SF_MeatSalad.json:2 has "ItemOil" for "item_name" (game data typo)
|
||||
|
||||
@pending = nil # the bed whose Sleep was picked
|
||||
@ctx = nil # the tier of the nap about to happen
|
||||
|
||||
def self.say(text)
|
||||
p "LonaCraft Rest: #{text}"
|
||||
end
|
||||
|
||||
def self.text_key(key)
|
||||
"#{TEXT}#{key}"
|
||||
end
|
||||
|
||||
def self.cfg
|
||||
LonaCraft::Raids.cfg["rest"]
|
||||
end
|
||||
|
||||
def self.enabled?
|
||||
defined?(LonaCraft::Raids) && defined?(LonaCraft::Furniture) && cfg["enabled"] ? true : false
|
||||
end
|
||||
|
||||
def self.bases
|
||||
LonaCraft::Bases
|
||||
end
|
||||
|
||||
def self.fur
|
||||
LonaCraft::Furniture
|
||||
end
|
||||
|
||||
def self.homes
|
||||
defined?(LonaCraft::Homes) ? LonaCraft::Homes : nil
|
||||
end
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# Where tiers apply
|
||||
#----------------------------------------------------------------------
|
||||
def self.owned_home?(map)
|
||||
h = homes
|
||||
return false if h.nil? || !h.enabled?
|
||||
id = h.home_at_map?(map)
|
||||
!id.nil? && h.owned?(id)
|
||||
rescue
|
||||
false
|
||||
end
|
||||
|
||||
def self.scope_ok?(map)
|
||||
return false if map.nil? || map.isOverMap
|
||||
return false if $story_stats["Captured"].to_i != 0 || $story_stats["RapeLoop"].to_i != 0
|
||||
return false if homes && homes.nap_keys_active
|
||||
return true if $story_stats["OnRegionMap"].to_i >= 1
|
||||
return true if bases.record_for_map(map)
|
||||
owned_home?(map)
|
||||
end
|
||||
|
||||
# {[x, y] => true} of the tiles inside the walls of +map+, :all for an
|
||||
# owned home, {} otherwise
|
||||
def self.inside(map)
|
||||
return :all if owned_home?(map)
|
||||
rec = bases.record_for_map(map)
|
||||
return {} if rec.nil?
|
||||
rm = map.instance_variable_get(:@region_map)
|
||||
bases.inside_tiles(map, rec, rm.is_a?(Array) ? rm : [])
|
||||
end
|
||||
|
||||
def self.inside?(ins, x, y)
|
||||
ins == :all || (ins.is_a?(Hash) && ins[[x.to_i, y.to_i]])
|
||||
end
|
||||
|
||||
def self.records_on(map)
|
||||
fur.records.select{|f| f.is_a?(Hash) && f["map_id"] == map.map_id }
|
||||
end
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# The tier
|
||||
#----------------------------------------------------------------------
|
||||
# 90_Furniture.rb Sleep on a placed piece
|
||||
def self.note_sleep(rec, kind)
|
||||
return if rec.nil? || kind.nil?
|
||||
@pending = {:map => $game_map.map_id_rec, :x => $game_player.x, :y => $game_player.y,
|
||||
:frame => Graphics.frame_count, :uid => rec["uid"].to_i, :key => kind[:key].to_s}
|
||||
end
|
||||
|
||||
def self.fresh?(h)
|
||||
h.is_a?(Hash) && h[:map] == $game_map.map_id_rec && h[:x] == $game_player.x && h[:y] == $game_player.y &&
|
||||
Graphics.frame_count - h[:frame].to_i <= FRESH_FRAMES
|
||||
end
|
||||
|
||||
# :ground, :bedroll or :bed for a nap started by +interp+ now; nil = untouched
|
||||
def self.detect(interp)
|
||||
map = $game_map
|
||||
return nil unless enabled? && scope_ok?(map)
|
||||
pend = fresh?(@pending) ? @pending : nil
|
||||
@pending = nil
|
||||
if pend
|
||||
return :bedroll if BEDROLL_KINDS.include?(pend[:key])
|
||||
if BED_KINDS.include?(pend[:key])
|
||||
rec = fur.record(pend[:uid])
|
||||
return :bedroll if rec.nil?
|
||||
return inside?(inside(map), rec["x"], rec["y"]) ? :bed : :bedroll
|
||||
end
|
||||
end
|
||||
ev = (interp && interp.respond_to?(:event_id)) ? map.events[interp.event_id] : nil
|
||||
return :bedroll if ev && ev.respond_to?(:name) && ev.name.to_s == CAMP_BED_EVENT
|
||||
px = $game_player.x
|
||||
py = $game_player.y
|
||||
on_roll = records_on(map).any?{|f|
|
||||
k = fur.kind_for(f["item_name"])
|
||||
k && BEDROLL_KINDS.include?(k[:key]) && fur.footprint(k, f["x"].to_i, f["y"].to_i).include?([px, py])
|
||||
}
|
||||
on_roll ? :bedroll : :ground
|
||||
rescue => e
|
||||
say("tier error #{e.class} #{e.message}")
|
||||
nil
|
||||
end
|
||||
|
||||
# call_nap_event / handleNap: note the tier unless one is noted already
|
||||
def self.capture(interp)
|
||||
return if fresh?(@ctx)
|
||||
tier = detect(interp)
|
||||
@ctx = tier ? {:tier => tier, :map => $game_map.map_id_rec, :x => $game_player.x, :y => $game_player.y,
|
||||
:frame => Graphics.frame_count} : nil
|
||||
say("nap tier #{tier}") if tier
|
||||
end
|
||||
|
||||
def self.tier
|
||||
fresh?(@ctx) ? @ctx[:tier] : nil
|
||||
end
|
||||
|
||||
def self.clear
|
||||
@ctx = nil
|
||||
end
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# The danger roll (GIM_ADDON alias below)
|
||||
#----------------------------------------------------------------------
|
||||
def self.before_roll
|
||||
case tier
|
||||
when :ground
|
||||
add = cfg["ground_danger"].to_i + LonaCraft::Raids.diff("ground_danger_add").to_i # R10
|
||||
$story_stats["WildDangerous"] += add
|
||||
say("ground nap: WildDangerous +#{add} -> #{$story_stats["WildDangerous"]}")
|
||||
nil
|
||||
when :bed
|
||||
pre = $story_stats["WildDangerous"].to_f
|
||||
mult = [cfg["bed_roll_mult"].to_f + LonaCraft::Raids.diff("bed_roll_add").to_f, 0.0].max # R10
|
||||
cut = pre * (1.0 - mult)
|
||||
$story_stats["WildDangerous"] = pre - cut
|
||||
say("bed nap: WildDangerous #{pre.round(1)} x#{mult} for this roll")
|
||||
cut
|
||||
end
|
||||
end
|
||||
|
||||
def self.after_roll(cut)
|
||||
$story_stats["WildDangerous"] += cut if cut
|
||||
end
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# Dishes
|
||||
#----------------------------------------------------------------------
|
||||
def self.dish_name(obj)
|
||||
return "ItemMeatSalad" if obj.is_a?(RPG::Item) && obj.id == MEAT_SALAD_ID
|
||||
n = obj.respond_to?(:item_name) ? obj.item_name.to_s : ""
|
||||
DISHES.key?(n) ? n : nil
|
||||
end
|
||||
|
||||
def self.dish_ok?(name)
|
||||
row = DISHES[name]
|
||||
return false if row.nil?
|
||||
case row[1]
|
||||
when :mystery then cfg["mystery_dishes"] ? true : false
|
||||
when :human then cfg["human_dishes"] ? true : false
|
||||
else true
|
||||
end
|
||||
end
|
||||
|
||||
def self.satiety_of(obj, name)
|
||||
if obj.respond_to?(:use_item_effect) && obj.use_item_effect.is_a?(Array)
|
||||
le = obj.use_item_effect.find{|e| e && e.respond_to?(:attr) && e.attr.to_s == "sat" && e.stats_key.nil? }
|
||||
return le.adjust.to_i if le && le.respond_to?(:adjust) && le.adjust.to_f > 0
|
||||
end
|
||||
DISHES[name][0]
|
||||
rescue
|
||||
DISHES[name][0]
|
||||
end
|
||||
|
||||
# [[obj, name, sat, box id], ...] one row per unit, chests in record order
|
||||
def self.dishes_inside(map, ins)
|
||||
out = []
|
||||
records_on(map).each{|f|
|
||||
k = fur.kind_for(f["item_name"])
|
||||
next unless k && k[:storage] && inside?(ins, f["x"], f["y"])
|
||||
box = fur.box_contents(f["box"].to_i)
|
||||
next unless box.is_a?(Hash)
|
||||
box.each{|obj, n|
|
||||
name = dish_name(obj)
|
||||
next if name.nil? || !dish_ok?(name)
|
||||
sat = satiety_of(obj, name)
|
||||
n.to_i.times{ out << [obj, name, sat, f["box"].to_i] }
|
||||
}
|
||||
}
|
||||
out
|
||||
end
|
||||
|
||||
# the units that make one meal of +need+ points, or nil (research 2.2)
|
||||
def self.pick_meal(units, need)
|
||||
single = units.select{|u| u[2] >= need }.min_by{|u| u[2] }
|
||||
return [single] if single
|
||||
taken = []
|
||||
total = 0
|
||||
units.each_with_index.sort_by{|u, i| [-u[2], i] }.each{|u, i|
|
||||
break if total >= need
|
||||
taken << u
|
||||
total += u[2]
|
||||
}
|
||||
total >= need ? taken : nil
|
||||
end
|
||||
|
||||
def self.bath_inside?(map, ins)
|
||||
records_on(map).any?{|f|
|
||||
k = fur.kind_for(f["item_name"])
|
||||
k && (k[:actions] || []).include?(:bathe) && inside?(ins, f["x"], f["y"])
|
||||
}
|
||||
end
|
||||
|
||||
def self.notice(key)
|
||||
homes.notice(text_key(key)) if homes
|
||||
end
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# The nap (Game_Actor#process_nap_change alias below)
|
||||
#----------------------------------------------------------------------
|
||||
# before the nap math; returns the state for after_nap, or nil
|
||||
def self.before_nap(actor)
|
||||
t = tier
|
||||
clear
|
||||
return nil if t.nil? || !enabled?
|
||||
return nil if homes && homes.nap_keys_active # the inn room: its own rest
|
||||
map = $game_map
|
||||
st = {:tier => t, :sta => actor.sta.to_f, :health => actor.health.to_f}
|
||||
if t == :bed
|
||||
dim = actor.attr_dimensions
|
||||
actor.health = dim["health"][2]
|
||||
actor.sta = dim["sta"][2]
|
||||
end
|
||||
fed = t == :bed || cfg["food_on_bedroll"]
|
||||
wash = t == :bed || cfg["bath_on_bedroll"]
|
||||
if t != :ground && (fed || wash)
|
||||
ins = inside(map)
|
||||
if fed
|
||||
units = dishes_inside(map, ins)
|
||||
meal = pick_meal(units, cfg["meal_sat"].to_i)
|
||||
if meal
|
||||
meal.each{|obj, name, sat, box| $game_boxes.remove_item(obj, 1, box, false) }
|
||||
actor.sat = actor.attr_dimensions["sat"][2]
|
||||
notice("Rest/ate")
|
||||
say("meal from the chest: #{meal.map{|u| u[1] }.join(", ")} (#{meal.inject(0){|s, u| s + u[2] }} points)")
|
||||
else
|
||||
say("no meal: #{units.inject(0){|s, u| s + u[2] }} points of dishes inside the walls")
|
||||
end
|
||||
end
|
||||
if wash && bath_inside?(map, ins)
|
||||
scale = actor.respond_to?(:is_cuffed?) && actor.is_cuffed? ? 0.25 : 0.5
|
||||
4.times{ actor.batch_take_bath(scale) }
|
||||
actor.dirt = 0
|
||||
notice("Rest/bathed")
|
||||
say("washed before bed")
|
||||
end
|
||||
end
|
||||
st
|
||||
rescue => e
|
||||
say("before nap error #{e.class} #{e.message}")
|
||||
nil
|
||||
end
|
||||
|
||||
def self.after_nap(actor, st)
|
||||
return if st.nil?
|
||||
case st[:tier]
|
||||
when :ground
|
||||
dim = actor.attr_dimensions
|
||||
gain = actor.sta.to_f - st[:sta]
|
||||
if gain > 0
|
||||
cap = dim["sta"][2].to_f * cfg["ground_sta_cap_pct"].to_f / 100.0
|
||||
actor.sta = [st[:sta] + gain * cfg["ground_sta_mult"].to_f, [cap, st[:sta]].max].min.round
|
||||
end
|
||||
hgain = actor.health.to_f - st[:health]
|
||||
actor.health = (st[:health] + hgain * cfg["ground_health_mult"].to_f).round if hgain > 0
|
||||
actor.mood -= cfg["ground_mood"].to_i
|
||||
actor.dirt += cfg["ground_dirt"].to_i
|
||||
sick = rand(100) < cfg["ground_sick_chance"].to_i + LonaCraft::Raids.diff("ground_sick_add").to_i # R10
|
||||
actor.add_state("FeelsSick") if sick
|
||||
notice("Rest/ground")
|
||||
say("ground: stamina #{st[:sta].round} -> #{actor.sta.round} (gain #{gain.round} x#{cfg["ground_sta_mult"]}), health #{st[:health].round} -> #{actor.health.round}#{sick ? ", feels sick" : ""}")
|
||||
when :bed
|
||||
actor.mood += cfg["bed_mood"].to_i
|
||||
notice("Rest/bed")
|
||||
say("bed: health #{actor.health.round}, stamina #{actor.sta.round}, satiety #{actor.sat.round}")
|
||||
else
|
||||
say("bedroll: a plain nap")
|
||||
end
|
||||
rescue => e
|
||||
say("after nap error #{e.class} #{e.message}")
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
#==============================================================================
|
||||
# The hooks
|
||||
#==============================================================================
|
||||
class Game_Interpreter
|
||||
# the furniture Sleep action notes the bed (90_Furniture.rb:1123-1127)
|
||||
if method_defined?(:lonacraft_furniture_action) && !method_defined?(:lonacraft_furniture_action_rest)
|
||||
alias_method :lonacraft_furniture_action_rest, :lonacraft_furniture_action
|
||||
def lonacraft_furniture_action(action, kind, rec)
|
||||
begin
|
||||
LonaCraft::Rest.note_sleep(rec, kind) if action == :sleep
|
||||
rescue => e
|
||||
p "LonaCraft Rest sleep note error #{e.class} #{e.message}"
|
||||
end
|
||||
lonacraft_furniture_action_rest(action, kind, rec)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module GIM_OM
|
||||
if method_defined?(:handleNap) && !method_defined?(:handleNap_lonacraft_rest)
|
||||
alias_method :handleNap_lonacraft_rest, :handleNap
|
||||
def handleNap(*args)
|
||||
begin
|
||||
LonaCraft::Rest.capture(self)
|
||||
rescue => e
|
||||
p "LonaCraft Rest capture error #{e.class} #{e.message}"
|
||||
end
|
||||
begin
|
||||
handleNap_lonacraft_rest(*args)
|
||||
ensure
|
||||
LonaCraft::Rest.clear
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class Game_Map
|
||||
if method_defined?(:call_nap_event) && !method_defined?(:call_nap_event_lonacraft_rest)
|
||||
alias_method :call_nap_event_lonacraft_rest, :call_nap_event
|
||||
def call_nap_event
|
||||
begin
|
||||
LonaCraft::Rest.capture(interpreter) unless LonaCraft::Raids.nap_refused?
|
||||
rescue => e
|
||||
p "LonaCraft Rest capture error #{e.class} #{e.message}"
|
||||
end
|
||||
call_nap_event_lonacraft_rest
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
module GIM_ADDON
|
||||
if method_defined?(:region_map_wildness_nap_stats) && !method_defined?(:lonacraft_rest_nap_stats)
|
||||
alias_method :lonacraft_rest_nap_stats, :region_map_wildness_nap_stats
|
||||
def region_map_wildness_nap_stats
|
||||
cut = nil
|
||||
begin
|
||||
cut = LonaCraft::Rest.before_roll
|
||||
rescue => e
|
||||
p "LonaCraft Rest roll error #{e.class} #{e.message}"
|
||||
end
|
||||
begin
|
||||
lonacraft_rest_nap_stats
|
||||
ensure
|
||||
LonaCraft::Rest.after_roll(cut)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class Game_Actor
|
||||
if method_defined?(:process_nap_change) && !method_defined?(:process_nap_change_lonacraft_rest)
|
||||
alias_method :process_nap_change_lonacraft_rest, :process_nap_change
|
||||
def process_nap_change(*args)
|
||||
st = nil
|
||||
st = LonaCraft::Rest.before_nap(self) if $game_player && equal?($game_player.actor)
|
||||
result = process_nap_change_lonacraft_rest(*args)
|
||||
LonaCraft::Rest.after_nap(self, st) if st
|
||||
result
|
||||
end
|
||||
end
|
||||
end
|
||||
Reference in new issue
Block a user