#============================================================================== # LonaCraft - 80_CraftScene.rb # What it does: # * Scene_LonaCraft: the crafting screen, built on the storage-box scene # (Data/Scripts/Frames/203_Storage Boxes.rb, Scene_ItemStorage): two title # windows on top, two panes below, keyboard + mouse, left with # SceneManager.goto(Scene_Map) like the storage box (the game's # SceneManager.call/return pop a debug msgbox, 6_SceneManager.rb:91-102). # Left - recipe list of ONE station (LonaCraft.open_craft_scene(station); # the left title shows the station's name), grouped Processing / # Weapons / Ammo / Armour / Furniture / Decorations. Rows the # player cannot afford are dimmed; rows above the player's # effective skill are left out of the list (CraftUI::HIDE_LOCKED; # with it false they are shown dimmed and marked Locked, and # try_craft buzzes and blinks the skill line). # Right - details of the selected recipe: output (with the amount made), # materials have/need (red when short; need = what the open # station really takes, Recipes.inputs_at, so by hand it is the # bench amount x1.25 rounded up, with a note in the Materials # line; the list's dimming uses the same amounts), skill needed vs the # player's, the five tier chances (after the station's and the # recipe's tier cap, Recipes.tier_cap), and for gear what Common # gives. # Confirm (OK key or left click on a row) crafts; Cancel / Esc / right # click / the "Cancel" label leaves (to the main menu when it was opened # from there, else to the map). # * Recipes come from LonaCraft::Recipes.all (Scripts/55_Recipes.rb). The # Process list of Scripts/30_Process.rb is folded into the Processing group: # a Process row is added only when Recipes did not build it (Recipes. # process_key_known?) and no Recipes entry makes the same output from the # same inputs, so Config/Recipes.json changes win. Process recipes keep their own rules # (1 STA each, any plant for the "*plant" input, no roll, no exp). # * LonaCraft.open_craft_scene(station, back) opens the screen (the main # menu's crafting with :hand and back = :menu; the station furniture with # its station, Scripts/90_Furniture.rb). # * Crash trace (with "debug"; 05_Config.rb LonaCraft.trace, added # 2026-10-06 after two RGSS301.dll access violations, offset 0x00111a1c, # in this screen): one line per step to UserData/LonaCraft_trace.log, # flushed and closed each time: every window and contents Bitmap.new # (size, failsafe address flag), row builds, list rows drawn, list / # detail / title refreshes, cursor, page, hover, keys, crafts, the result # popup, start / post_start / terminate with memory, an "alive" line every # 300 frames, Ruby errors caught by data_call or raised in a frame. # Text keys: LonaCraft:Craft: in Text//Craft.txt. # Stores nothing itself; every data-layer call is wrapped so an error there # prints to the console instead of crashing the game. #============================================================================== module LonaCraft # Shared font profile for every custom LonaCraft bitmap/window. RUS2 uses # the same sharp menu face as the rest of the game's mod UI. def self.ui_font_name begin if defined?(MPSafeFont) && MPSafeFont.respond_to?(:rus2_active?) && MPSafeFont.rus2_active? name = MPSafeFont.rus2_font(:MENU_L, :TITLE_MENU, :CHOICE) return name if name && Font.exist?(name) end rescue end value = Font.default_name rescue "VL Gothic" value = value[0] if value.is_a?(Array) value.to_s.empty? ? "VL Gothic" : value.to_s rescue "VL Gothic" end def self.apply_ui_font(bitmap) return if bitmap.nil? || !bitmap.respond_to?(:font) || bitmap.font.nil? bitmap.font.name = ui_font_name bitmap.font.bold = true bitmap.font.shadow = false bitmap.font.outline = false end # station: :hand, :carpentry, :furnace, :anvil or :tailor (Stations in # 55_Recipes.rb; "pot" counts as :hand); the screen lists only that # station's recipes. back: :map (default) or :menu, where leaving goes. def self.open_craft_scene(station = :hand, back = :map) station = defined?(LonaCraft::Stations) ? LonaCraft::Stations.normalize(station) : nil @craft_station = station || :hand @craft_back = back == :menu ? :menu : :map p "LonaCraft Craft: open #{@craft_station} (back to #{@craft_back})" LonaCraft.trace{ "open_craft_scene station #{@craft_station} back #{@craft_back} from #{SceneManager.scene.class}, goto Scene_LonaCraft" } SceneManager.goto(Scene_LonaCraft) LonaCraft.trace("open_craft_scene goto done") end # Station of the crafting screen that is (or was last) open def self.craft_station @craft_station || :hand end # Where the crafting screen goes when it is left: :map or :menu def self.craft_back @craft_back || :map end #-------------------------------------------------------------------------- # One craftable row. kind is :recipe (a LonaCraft::Recipes object in # source) or :process_list (an entry of PROCESS_RECIPES in source). #-------------------------------------------------------------------------- class CraftEntry attr_reader :kind, :source, :output_name, :output_qty, :inputs, :skill_req, :group, :fixed_tier def initialize(kind, source, output_name, output_qty, inputs, skill_req, group, fixed_tier) @kind = kind @source = source @output_name = output_name @output_qty = output_qty.to_i < 1 ? 1 : output_qty.to_i @inputs = inputs.is_a?(Hash) ? inputs : {} @skill_req = skill_req.to_i @group = group @fixed_tier = fixed_tier end def output_item $data_ItemName[@output_name] end end #-------------------------------------------------------------------------- # Helpers shared by the crafting windows and scene. #-------------------------------------------------------------------------- module CraftUI GROUPS = [:process, :weapon, :ammo, :armor, :building, :furniture, :decoration] GROUP_KEYS = { :process => "Group/Processing", :weapon => "Group/Weapons", :ammo => "Group/Ammo", :armor => "Group/Armour", :building => "Group/Building", :furniture => "Group/Furniture", :decoration => "Group/Decorations" } def self.text(key) $game_text["LonaCraft:Craft:#{key}"] end def self.group_label(group) text(GROUP_KEYS[group] || GROUP_KEYS[:process]) end # Runs the block; on any error prints it and returns +default+. def self.data_call(default) begin yield rescue => e p "LonaCraft craft screen: #{e.class} #{e.message}" LonaCraft.trace_error("craft screen data_call", e) default end end def self.fibre_key LonaCraft.const_defined?(:FIBRE) ? LonaCraft::FIBRE : nil end #---------------------------------------------------------------------- # Recipe list #---------------------------------------------------------------------- def self.group_of(obj) return :weapon if obj.is_a?(RPG::Weapon) return :armor if obj.is_a?(RPG::Armor) :process end def self.station_name(station) text("Station/#{station}") end def self.build_entries(station = LonaCraft.craft_station) list = [] recipes = [] if defined?(LonaCraft::Recipes) recipes = data_call([]) { LonaCraft::Recipes.for_station(station).to_a } end recipes.each{|recipe| entry = data_call(nil) { obj = $data_ItemName[recipe.output] if obj.nil? nil else case recipe.category.to_s when "process" then group = :process when "furniture" then group = :furniture when "decoration" then group = :decoration when "ammo" then group = :ammo when "building" then group = :building else group = group_of(obj) end CraftEntry.new(:recipe, recipe, recipe.output, recipe.amount, recipe.inputs, recipe.skill_req, group, recipe.fixed_tier) end } list << entry if entry } # Fallback for PROCESS rows the recipe list does not have (e.g. its # build failed); rows it has, Config/Recipes.json changes included, # are left to it. if LonaCraft.const_defined?(:PROCESS_RECIPES) LonaCraft::PROCESS_RECIPES.each{|recipe| out_name, out_qty = recipe[2].first next if out_name.nil? || $data_ItemName[out_name].nil? next if defined?(LonaCraft::Recipes) && LonaCraft::Recipes.respond_to?(:process_key_known?) && LonaCraft::Recipes.process_key_known?(recipe[0]) next if defined?(LonaCraft::Stations) && !LonaCraft::Stations.for_process(recipe[0]).include?(station) in_keys = recipe[1].keys.map{|k| k.to_s }.sort next if list.any?{|e| e.output_name == out_name && e.inputs.keys.map{|k| k.to_s }.sort == in_keys } list << CraftEntry.new(:process_list, recipe, out_name, out_qty, recipe[1], 0, :process, 1) } end list end # Owner option (2026-10-06): recipes above the player's effective skill # are left out of the list instead of being shown dimmed and Locked. HIDE_LOCKED = true # [[:header, group], [:entry, CraftEntry], ...] in group order, # sorted by skill requirement inside a group (stable). With HIDE_LOCKED # only recipes the player's skill allows are listed (the Locked path # below stays for HIDE_LOCKED = false). def self.build_rows LonaCraft.trace{ "build_rows begin station #{LonaCraft.craft_station}" } list = build_entries rows = [] GROUPS.each{|group| members = [] list.each_with_index{|entry, i| members << [entry, i] if entry.group == group } next if members.empty? members = members.select{|pair| skill_ok?(pair[0]) } if HIDE_LOCKED next if members.empty? members = members.sort_by{|pair| [pair[0].skill_req, pair[1]] } rows << [:header, group] members.each{|pair| rows << [:entry, pair[0]] } } LonaCraft.trace{ "build_rows end #{list.size} entries, #{rows.size} rows (skill #{skill_effective})" } rows end #---------------------------------------------------------------------- # Player state #---------------------------------------------------------------------- def self.skill_effective return 0 unless defined?(LonaCraft::Skill) data_call(0) { LonaCraft::Skill.effective.to_i } end def self.skill_level return 0 unless defined?(LonaCraft::Skill) data_call(0) { LonaCraft::Skill.level.to_i } end def self.skill_exp return 0 unless defined?(LonaCraft::Skill) data_call(0) { LonaCraft::Skill.exp.to_i } end def self.skill_ok?(entry) entry.skill_req <= skill_effective end def self.have_count(name) if !fibre_key.nil? && name == fibre_key return LonaCraft.respond_to?(:fibre_total) ? LonaCraft.fibre_total : 0 end obj = $data_ItemName[name] return 0 if obj.nil? $game_party.item_number(obj).to_i end # {item_name => count} the open station takes for +entry+: the recipe's # inputs times the station's cost, rounded up per input # (Recipes.inputs_at / scale_inputs, 55_Recipes.rb); the entry's own # inputs when that is not available. def self.entry_inputs(entry) station = LonaCraft.craft_station if defined?(LonaCraft::Recipes) && LonaCraft::Recipes.respond_to?(:inputs_at) res = data_call(nil) { if entry.kind == :recipe LonaCraft::Recipes.inputs_at(entry.source, station) else LonaCraft::Recipes.scale_inputs(entry.inputs, station) end } return res if res.is_a?(Hash) end entry.inputs end # The station's cost multiplier when above 1 (1.25), else nil def self.cost_factor(station = LonaCraft.craft_station) return nil unless defined?(LonaCraft::Stations) && LonaCraft::Stations.respond_to?(:cost) mult = data_call(1.0) { LonaCraft::Stations.cost(station).to_f } mult > 1.0 ? mult : nil end # 1.25 => "1.25", 2.0 => "2" def self.factor_text(mult) mult == mult.to_i ? mult.to_i.to_s : mult.round(2).to_s end # "By hand, materials x1.25" (Label/CostNote); nil when the station costs the bench amounts def self.cost_note(station = LonaCraft.craft_station) mult = cost_factor(station) return nil if mult.nil? fmt = text("Label/CostNote").to_s return nil if fmt.empty? data_call(nil) { sprintf(fmt, station_name(station).to_s, factor_text(mult)) } end def self.affordable?(entry) if entry.kind == :recipe return data_call(false) { LonaCraft::Recipes.affordable?(entry.source, LonaCraft.craft_station) ? true : false } end missing(entry).empty? end # {item_name => shortfall} def self.missing(entry) return {} if LonaCraft::Debug.free? # D2 god mode: nothing missing if entry.kind == :recipe res = data_call(nil) { LonaCraft::Recipes.missing(entry.source, LonaCraft.craft_station) } return res if res.is_a?(Hash) end out = {} entry_inputs(entry).each{|name, qty| short = qty.to_i - have_count(name) out[name] = short if short > 0 } out end # [icon_index or nil, display name] for an input def self.input_icon_and_name(name) if !fibre_key.nil? && name == fibre_key obj = nil if LonaCraft.respond_to?(:fibre_owned) owned = LonaCraft.fibre_owned obj = owned.first[0] unless owned.empty? end if obj.nil? && LonaCraft.respond_to?(:fibre_items) first = LonaCraft.fibre_items.first obj = $data_ItemName[first] if first end return [obj ? obj.icon_index : nil, text("Label/Fibre")] end obj = $data_ItemName[name] return [nil, name.to_s] if obj.nil? [obj.icon_index, $game_text[obj.name]] end #---------------------------------------------------------------------- # Tiers #---------------------------------------------------------------------- def self.tier_chances(entry) if entry.fixed_tier tier = entry.fixed_tier.to_i tier = 1 if tier < 1 || tier > 5 out = [0, 0, 0, 0, 0] out[tier - 1] = 100 return cap_chances(out, tier_cap(entry)) end res = nil if defined?(LonaCraft::Skill) res = data_call(nil) { LonaCraft::Skill.tier_chances(entry.skill_req) } end return [100, 0, 0, 0, 0] unless res.is_a?(Array) && res.length == 5 cap_chances(res.map{|v| v.to_f }, tier_cap(entry)) end # Best tier the entry can give at the open station (Recipes.tier_cap), nil = no cap def self.tier_cap(entry) return nil unless entry.kind == :recipe && defined?(LonaCraft::Recipes) && LonaCraft::Recipes.respond_to?(:tier_cap) data_call(nil) { LonaCraft::Recipes.tier_cap(entry.source, LonaCraft.craft_station) } end # Every chance above +cap+ is added to the cap tier (what the roll gives). def self.cap_chances(out, cap) return out if cap.nil? || cap.to_i >= 5 cap = cap.to_i < 1 ? 1 : cap.to_i extra = 0 cap.upto(4){|i| extra += out[i] out[i] = 0 } out[cap - 1] += extra out end def self.tier_color(tier) return 0 unless defined?(LonaCraft::Tiers) data_call(0) { LonaCraft::Tiers.tier_color(tier).to_i } end def self.tier_name(tier) return tier.to_s unless defined?(LonaCraft::Tiers) data_call(tier.to_s) { LonaCraft::Tiers.tier_name(tier).to_s } end #---------------------------------------------------------------------- # Gear summary: [atk, def] added by the base (Common) item, read from # its already-loaded effects (no load_additional_data call). #---------------------------------------------------------------------- def self.base_stats(obj) effects = obj.instance_variable_get(:@lona_effect) return [0.0, 0.0] unless effects.is_a?(Array) atk = 0.0 dfn = 0.0 effects.each{|eff| next unless eff.respond_to?(:attr) && eff.respond_to?(:adjust) next unless eff.type.to_s == "+" case eff.attr.to_s when "atk_plus" then atk += eff.adjust.to_f when "def_plus" then dfn += eff.adjust.to_f end } [atk, dfn] end def self.signed_number(value) num = value == value.to_i ? value.to_i : value.round(1) num > 0 ? "+#{num}" : num.to_s end #---------------------------------------------------------------------- # Crafting. Returns [item, tier] or nil. #---------------------------------------------------------------------- def self.craft(entry) return process_craft(entry.source, entry_inputs(entry)) if entry.kind == :process_list res = data_call(nil) { LonaCraft::Recipes.craft(entry.source, nil, LonaCraft.craft_station) } return nil unless res.is_a?(Array) && res[0] item = res[0] item = $data_ItemName[item] if item.is_a?(String) return nil if item.nil? tier = res[1] tier = data_call(1) { LonaCraft::Tiers.tier_of(item).to_i } if tier.nil? && defined?(LonaCraft::Tiers) tier = 1 if tier.nil? || tier.to_i < 1 [item, tier.to_i] end # Same rules as Game_Interpreter#lonacraft_process_run (30_Process.rb), # without the map popups (this runs inside the crafting scene). # inputs: what the open station takes (entry_inputs) def self.process_craft(recipe, inputs = nil) inputs ||= recipe[1] # D2 god mode: no inputs taken, no stamina (process_affordable? asks Recipes.affordable?) free = LonaCraft::Debug.free? inputs = {} if free return nil unless LonaCraft.process_affordable?(recipe) return nil unless inputs.all?{|name, qty| have_count(name) >= qty.to_i } fibre = fibre_key picked = nil inputs.each{|name, qty| next if fibre.nil? || name != fibre picked = LonaCraft.pick_fibre(qty) return nil if picked.empty? } $game_player.actor.sta -= LonaCraft::PROCESS_STA_COST unless LonaCraft::Debug.god? picked.each{|obj, amount| $game_party.lose_item(obj, amount) } if picked inputs.each{|name, qty| next if !fibre.nil? && name == fibre obj = $data_ItemName[name] $game_party.lose_item(obj, qty) if obj } out = nil recipe[2].each{|name, qty| obj = $data_ItemName[name] next if obj.nil? $game_party.gain_item(obj, qty) out = obj if out.nil? } out ? [out, 1] : nil end end #-------------------------------------------------------------------------- # Crash trace for the crafting windows (05_Config.rb LonaCraft.trace): each # contents Bitmap.new (Window_Base#create_contents, also run by every list # refresh) gets a line before and one after with its size and the game's # failsafe flag (5100_LonaBitmapChanger_hugememmonkeyfix.rb). #-------------------------------------------------------------------------- module CraftTraceContents def create_contents LonaCraft.trace{ "#{self.class} create_contents #{contents_width}x#{contents_height} begin" } super LonaCraft.trace_bitmap("#{self.class} contents", contents) end end end #============================================================================== # Title bar above each pane (same size and place as Window_BoxTitle). # kind :list -> "Recipes" + effective skill # kind :info -> "Details" + level/exp + a clickable "Cancel" #============================================================================== class Window_LonaCraftTitle < Window_Base include LonaCraft::CraftTraceContents def initialize(x, kind) @kind = kind @cancel_rect = nil super(x, 0, Graphics.width / 2, fitting_height(1)) refresh end def cancel_hit? return false if @cancel_rect.nil? Mouse.within?(@cancel_rect) ? true : false end def refresh LonaCraft.trace{ "title #{@kind} refresh begin" } ui = LonaCraft::CraftUI contents.clear LonaCraft.apply_ui_font(contents) contents.font.size = Font.default_size cw = contents.width change_color(normal_color) if @kind == :list title = ui.station_name(LonaCraft.craft_station).to_s title = ui.text("Head/Recipes").to_s if title.empty? draw_text(0, 0, cw, line_height, title) contents.font.size = 16 draw_text(0, 0, cw, line_height, "#{ui.text("Label/Skill")} #{ui.skill_effective}", 2) else draw_text(0, 0, cw, line_height, ui.text("Head/Details")) contents.font.size = 16 draw_text(0, 0, cw, line_height, "#{ui.text("Label/Level")} #{ui.skill_level} #{ui.text("Label/Exp")} #{ui.skill_exp}", 1) label = ui.text("Label/Cancel") tw = text_size(label).width + 4 change_color(system_color) draw_text(cw - tw, 0, tw, line_height, label, 2) @cancel_rect = Rect.new(self.x + standard_padding + cw - tw, self.y + standard_padding, tw, line_height) end LonaCraft.trace{ "title #{@kind} refresh end" } end end #============================================================================== # Left pane: the recipe list. Header rows cannot be selected. #============================================================================== class Window_LonaCraftList < Window_Selectable include LonaCraft::CraftTraceContents # Hard cap on listed rows: the contents bitmap is rows x line_height high # (create_contents), so a runaway recipe list can never ask RGSS for a # giant Bitmap. Real lists are far below it (hand ~15, a bench ~150). MAX_ROWS = 400 def initialize(x, y, width, height) @rows = [] super(x, y, width, height) refresh end def set_rows(rows) @rows = rows || [] if @rows.size > MAX_ROWS p "LonaCraft Craft: #{@rows.size} rows, only the first #{MAX_ROWS} are listed" LonaCraft.trace{ "list #{@rows.size} rows cut to #{MAX_ROWS}" } @rows = @rows[0, MAX_ROWS] end refresh select_first end def item_max @rows ? @rows.size : 0 end def selectable?(i) return false if i.nil? || i < 0 row = @rows[i] !row.nil? && row[0] == :entry end def entry return nil if @index.nil? || @index < 0 row = @rows[@index] (row && row[0] == :entry) ? row[1] : nil end #-------------------------------------------------------------------------- # Cursor movement that skips header rows #-------------------------------------------------------------------------- def next_selectable(from, step, wrap) return nil if item_max < 1 i = from item_max.times{ i += step if i < 0 || i >= item_max return nil unless wrap i = i % item_max end return i if selectable?(i) } nil end def select_first i = next_selectable(-1, 1, false) i ? select(i) : unselect end def cursor_down(wrap = false) i = next_selectable(@index, 1, wrap) select(i) if i end def cursor_up(wrap = false) i = next_selectable(@index, -1, wrap) select(i) if i end def cursor_pagedown LonaCraft.trace{ "page down from #{@index}" } super fix_selection(1) end def cursor_pageup LonaCraft.trace{ "page up from #{@index}" } super fix_selection(-1) end def fix_selection(step) return if @index < 0 || selectable?(@index) i = next_selectable(@index, step, false) i = next_selectable(@index, -step, false) if i.nil? select(i) if i end # Keep a group's header in view when its first recipe is selected. def ensure_cursor_visible super if @index > 0 && !selectable?(@index - 1) && row - 1 < top_row self.top_row = row - 1 end end #-------------------------------------------------------------------------- # Drawing (sizes as Window_ItemList#draw_item: name 20, numbers 16) #-------------------------------------------------------------------------- def refresh LonaCraft.trace{ "list refresh begin #{@rows.size} rows" } create_contents LonaCraft.apply_ui_font(contents) draw_all_items if @rows.empty? contents.font.outline = false contents.font.size = 16 change_color(normal_color, false) draw_text(4, 0, contents.width - 8, line_height, LonaCraft::CraftUI.text("Msg/NoRecipes")) end LonaCraft.trace("list refresh end") end def draw_item(index) row = @rows[index] return if row.nil? LonaCraft.trace{ "list draw row #{index} #{row[0] == :header ? "header #{row[1]}" : row[1].output_name}" } ui = LonaCraft::CraftUI rect = item_rect(index) contents.font.outline = false if row[0] == :header contents.font.size = 18 change_color(system_color) draw_text(rect.x + 4, rect.y, rect.width - 8, rect.height, ui.group_label(row[1])) contents.fill_rect(rect.x + 4, rect.y + rect.height - 2, rect.width - 8, 1, system_color) return end entry = row[1] obj = entry.output_item return if obj.nil? skill_ok = ui.skill_ok?(entry) enabled = skill_ok && ui.affordable?(entry) contents.font.size = 16 if skill_ok label = "#{ui.text("Label/Skill")} #{entry.skill_req}" else label = "#{ui.text("Label/Locked")} #{entry.skill_req}" end right_w = text_size(label).width + 8 if skill_ok change_color(normal_color, enabled) else change_color(knockout_color, false) end draw_text(rect.x, rect.y, rect.width - 4, rect.height, label, 2) qty_text = entry.output_qty > 1 ? "x#{entry.output_qty}" : "" qty_w = qty_text.empty? ? 0 : text_size(qty_text).width + 6 name_w = rect.width - 8 - 24 - right_w - qty_w name_w = 24 if name_w < 24 unless qty_text.empty? change_color(normal_color, enabled) draw_text(rect.x + 8 + 24 + name_w, rect.y, qty_w, rect.height, qty_text) end contents.font.size = 20 draw_item_name(obj, rect.x + 8, rect.y, enabled, name_w) end end #============================================================================== # Right pane: details of the selected recipe. #============================================================================== class Window_LonaCraftDetail < Window_Base include LonaCraft::CraftTraceContents FLASH_FRAMES = 48 def initialize(x, y, width, height) @entry = nil @flash = 0 @flash_kind = nil super(x, y, width, height) refresh end def set_entry(entry) @entry = entry @flash = 0 @flash_kind = nil refresh end # kind :materials or :skill. Blinks the short rows red for a moment. def flash(kind) @flash_kind = kind @flash = FLASH_FRAMES refresh end def update super if @flash > 0 @flash -= 1 refresh if @flash % 8 == 0 end end def flash_on?(kind) @flash > 0 && @flash_kind == kind && (@flash / 8) % 2 == 1 end def flash_color Color.new(255, 40, 40, 90) end def refresh LonaCraft.trace{ "detail refresh begin #{@entry ? @entry.output_name : "none"}#{@flash > 0 ? " flash #{@flash_kind} #{@flash}" : ""}" } refresh_body LonaCraft.trace("detail refresh end") end def refresh_body contents.clear LonaCraft.apply_ui_font(contents) return if @entry.nil? ui = LonaCraft::CraftUI entry = @entry obj = entry.output_item return if obj.nil? cw = contents.width y = 0 # Output contents.font.size = 20 draw_item_name(obj, 0, y, true, cw - 24) if entry.output_qty > 1 contents.font.size = 16 change_color(normal_color) draw_text(0, y, cw - 2, line_height, "x#{entry.output_qty}", 2) end y += line_height # Materials contents.font.size = 16 change_color(system_color) draw_text(0, y, cw, 20, ui.text("Label/Materials")) draw_text(0, y, cw - 2, 20, "#{ui.text("Label/Have")}/#{ui.text("Label/Need")}", 2) note = ui.cost_note unless note.nil? head_w = text_size(ui.text("Label/Materials").to_s).width + 12 have_w = text_size("#{ui.text("Label/Have")}/#{ui.text("Label/Need")}").width + 12 contents.font.size = 14 change_color(normal_color, false) draw_text(head_w, y, cw - head_w - have_w, 20, note, 1) contents.font.size = 16 end y += 20 missing = ui.missing(entry) inputs = ui.entry_inputs(entry) row_h = inputs.size > 4 ? 20 : 24 inputs.each{|name, qty| have = ui.have_count(name) short = missing.has_key?(name) contents.fill_rect(0, y, cw, row_h, flash_color) if short && flash_on?(:materials) icon, label = ui.input_icon_and_name(name) draw_icon(icon, 4, y + (row_h - 24) / 2) if icon contents.font.size = 16 change_color(normal_color) draw_text(32, y, cw - 32 - 72, row_h, label) change_color(short ? knockout_color : normal_color) draw_text(0, y, cw - 2, row_h, "#{have}/#{qty}", 2) y += row_h } # Skill y += 4 eff = ui.skill_effective skill_ok = entry.skill_req <= eff contents.fill_rect(0, y, cw, line_height, flash_color) if !skill_ok && flash_on?(:skill) contents.font.size = 16 change_color(system_color) draw_text(0, y, cw, line_height, ui.text("Label/Skill")) change_color(skill_ok ? normal_color : knockout_color) skill_text = "#{ui.text("Label/Need")} #{entry.skill_req} #{ui.text("Label/You")} #{eff} (#{ui.text("Label/Level")} #{ui.skill_level})" draw_text(0, y, cw - 2, line_height, skill_text, 2) y += line_height # Tier chances: a bar, tier names, percentages change_color(system_color) draw_text(0, y, cw, 20, ui.text("Label/TierChance")) y += 20 chances = ui.tier_chances(entry) total = 0.0 chances.each{|v| total += v if v > 0 } total = 100.0 if total <= 0 bar_w = cw - 4 contents.fill_rect(2, y, bar_w, 8, gauge_back_color) bx = 2 last = nil chances.each_with_index{|v, i| last = i if v > 0 } chances.each_with_index{|v, i| next if v <= 0 w = i == last ? (2 + bar_w - bx) : (bar_w * v / total).round contents.fill_rect(bx, y, w, 8, text_color(ui.tier_color(i + 1))) if w > 0 bx += w } y += 10 col_w = cw / 5 contents.font.size = 14 5.times{|i| change_color(text_color(ui.tier_color(i + 1)), chances[i] > 0) draw_text(i * col_w, y, col_w, 16, ui.tier_name(i + 1), 1) } y += 16 contents.font.size = 16 5.times{|i| change_color(text_color(ui.tier_color(i + 1)), chances[i] > 0) draw_text(i * col_w, y, col_w, 18, "#{chances[i].round}%", 1) } y += 20 # Gear: what Common gives return unless obj.is_a?(RPG::EquipItem) y += 2 stats = ui.base_stats(obj) parts = [] parts << "#{ui.text("Label/Atk")} #{ui.signed_number(stats[0])}" if stats[0] != 0 parts << "#{ui.text("Label/Def")} #{ui.signed_number(stats[1])}" if stats[1] != 0 contents.font.size = 16 unless parts.empty? change_color(normal_color) draw_text(0, y, cw, 20, "#{ui.text("Label/GearCommon")} #{parts.join(" ")}") y += 20 end change_color(normal_color, false) draw_text(0, y, cw, 20, ui.text("Label/GearScale")) end end #============================================================================== # Result popup in the middle of the screen. Closed by any confirm/cancel. #============================================================================== class Window_LonaCraftResult < Window_Base include LonaCraft::CraftTraceContents def initialize(item, tier, message = nil) @item = item @tier = tier @message = message w = Graphics.width / 2 + 64 h = fitting_height(@message ? 1 : 3) super((Graphics.width - w) / 2, (Graphics.height - h) / 2, w, h) self.z = 200 refresh end def refresh ui = LonaCraft::CraftUI contents.clear LonaCraft.apply_ui_font(contents) contents.font.size = 20 cw = contents.width if @message || @item.nil? change_color(normal_color) draw_text(0, 0, cw, line_height, @message.to_s, 1) return end change_color(system_color) draw_text(0, 0, cw, line_height, ui.text("Label/Crafted"), 1) name = $game_text[@item.name].to_s tw = text_size(name).width x = (cw - tw - 28) / 2 x = 0 if x < 0 draw_icon(@item.icon_index, x, line_height) change_color(normal_color) draw_text(x + 28, line_height, cw - x - 28, line_height, name) change_color(text_color(ui.tier_color(@tier))) draw_text(0, line_height * 2, cw, line_height, ui.tier_name(@tier), 1) end end #============================================================================== # Scene_LonaCraft #============================================================================== class Scene_LonaCraft < Scene_MenuBase # Scene_ItemStorage defines this too (203_Storage Boxes.rb:489). def hud end def start LonaCraft.trace{ "scene start begin, #{LonaCraft.trace_mem(true)}" } super LonaCraft.trace_bitmap("scene background (snapshot)", @background_sprite ? @background_sprite.bitmap : nil, false) LonaCraft.trace{ "graphics #{Graphics.width}x#{Graphics.height} rate #{Graphics.frame_rate} frame #{Graphics.frame_count}; font #{Font.default_name.inspect} size #{Font.default_size} bold #{Font.default_bold} outline #{Font.default_outline}" } @saved_hud_hide = $hudForceHide @saved_balloon_hide = $balloonForceHide LonaCraft.trace("se openChest") SndLib.openChest create_windows LonaCraft.trace("scene start end") end # The screen transition (Scene_Base#post_start -> perform_transition -> # Graphics.transition(10), then Input.update). The owner's third silent # crash (2026-10-07 07:59, RGSS301.dll+0x111a1c, access violation, the same # offset as the two before) fell between "post_start begin" and "post_start # end": inside the engine's 10-frame fade, the first time this screen is # drawn. The fade is replaced by an instant cut (Graphics.transition(0), # what Scene_Map does after a black screen): the windows are drawn once # instead of blended ten times. TRANSITION_FRAMES = 10 brings the fade back. TRANSITION_FRAMES = 0 def perform_transition LonaCraft.trace{ "viewport guard: #{LonaCraft::ViewportGuard.stats}" } if defined?(LonaCraft::ViewportGuard) LonaCraft.trace{ "transition #{TRANSITION_FRAMES} frames begin" } Graphics.transition(TRANSITION_FRAMES) LonaCraft.trace("transition end") end def post_start LonaCraft.trace("post_start begin (transition, then Input.update)") super LonaCraft.trace("post_start end") end # Crash trace: makes a window (the block) with a line before and after. def traced_window(label) LonaCraft.trace{ "window #{label} new begin" } win = yield LonaCraft.trace{ "window #{label} #{win.class} x #{win.x} y #{win.y} w #{win.width} h #{win.height} contents #{win.contents.width}x#{win.contents.height} font #{win.contents.font.name.inspect} #{win.contents.font.size}" } win end def create_windows @list_title = traced_window("list_title"){ Window_LonaCraftTitle.new(0, :list) } @info_title = traced_window("info_title"){ Window_LonaCraftTitle.new(Graphics.width / 2, :info) } y = @list_title.height @list_window = traced_window("list"){ Window_LonaCraftList.new(0, y, Graphics.width / 2, Graphics.height - y) } @detail_window = traced_window("detail"){ Window_LonaCraftDetail.new(Graphics.width / 2, y, Graphics.width - Graphics.width / 2, Graphics.height - y) } @result_window = nil @shown_index = nil rows = LonaCraft::CraftUI.build_rows # Console breadcrumb (owner's hang report 2026-10-06): the rows were built. p "LonaCraft Craft: #{LonaCraft.craft_station} #{rows.size} rows" LonaCraft.trace{ "set_rows #{rows.size} begin" } @list_window.set_rows(rows) LonaCraft.trace{ "set_rows end, index #{@list_window.index}" } @list_window.activate sync_detail end def update super unless @first_frame_logged @first_frame_logged = true p "LonaCraft Craft: first frame" LonaCraft.trace{ "first frame, #{LonaCraft.trace_mem}" } end if @result_window update_result return end sync_detail acted = update_item_selection return if acted || SceneManager.scene != self mouse_input sync_detail end def sync_detail return if @shown_index == @list_window.index LonaCraft.trace{ e = @list_window.entry; "index #{@shown_index.inspect} -> #{@list_window.index} #{e ? e.output_name : "none"}" } @shown_index = @list_window.index @detail_window.set_entry(@list_window.entry) end def refresh_all LonaCraft.trace("refresh_all begin") @list_window.refresh @detail_window.refresh @list_title.refresh @info_title.refresh LonaCraft.trace("refresh_all end") end #-------------------------------------------------------------------------- # Keyboard / gamepad (same keys as Scene_ItemStorage#update_item_selection) #-------------------------------------------------------------------------- def update_item_selection if Input.trigger?(:B) || WolfPad.trigger?(:X_LINK) || (Mouse.enable? && Input.trigger?(:MX_LINK)) LonaCraft.trace("input cancel (B, pad X or right click)") exit_scene return true elsif Input.trigger?(:C) || WolfPad.trigger?(:Z_LINK) LonaCraft.trace("input confirm (C or pad Z)") try_craft return true end false end def exit_scene LonaCraft.trace{ "exit_scene se closeChest, goto #{LonaCraft.craft_back == :menu ? "Scene_Menu" : "Scene_Map"}" } SndLib.closeChest if LonaCraft.craft_back == :menu SceneManager.goto(Scene_Menu) else SceneManager.goto(Scene_Map) end LonaCraft.trace("exit_scene goto done") end def try_craft ui = LonaCraft::CraftUI entry = @list_window.entry LonaCraft.trace{ "craft attempt #{entry ? "#{entry.output_name} (#{entry.kind}, index #{@list_window.index})" : "with no recipe selected"}" } return SndLib.sys_buzzer if entry.nil? unless ui.skill_ok?(entry) LonaCraft.trace("craft blocked: skill") SndLib.sys_buzzer @detail_window.flash(:skill) return end unless ui.affordable?(entry) LonaCraft.trace("craft blocked: materials") SndLib.sys_buzzer @detail_window.flash(:materials) return end if entry.kind == :process_list && $game_player.actor.sta <= 0 LonaCraft.trace("craft blocked: stamina") SndLib.sys_buzzer open_result(nil, nil, ui.text("Msg/NoStamina")) return end LonaCraft.trace("craft call begin") result = ui.craft(entry) LonaCraft.trace{ result ? "craft call end: #{result[0].name} tier #{result[1]}" : "craft call end: failed" } refresh_all if result.nil? SndLib.sys_buzzer open_result(nil, nil, ui.text("Msg/Failed")) return end LonaCraft.trace("se WoodenBuild") SndLib.WoodenBuild open_result(result[0], result[1], nil) end #-------------------------------------------------------------------------- # Result popup #-------------------------------------------------------------------------- def open_result(item, tier, message) LonaCraft.trace{ "result popup open: #{item ? "#{item.name} tier #{tier}" : message.to_s}" } @list_window.deactivate @result_window = traced_window("result"){ Window_LonaCraftResult.new(item, tier, message) } end def update_result close = Input.trigger?(:C) || Input.trigger?(:B) || WolfPad.trigger?(:Z_LINK) || WolfPad.trigger?(:X_LINK) close = true if Mouse.enable? && (Input.trigger?(:MZ_LINK) || Input.trigger?(:MX_LINK)) return unless close LonaCraft.trace("result popup close, dispose begin") SndLib.play_cursor @result_window.dispose @result_window = nil @list_window.activate LonaCraft.trace("result popup disposed") end #-------------------------------------------------------------------------- # Mouse: hover selects a recipe, left click crafts it, right click leaves # (handled with :B above), click on "Cancel" leaves. Row rectangles as in # Scene_ItemStorage#mouse_input_result. #-------------------------------------------------------------------------- def mouse_input return Mouse.ForceIdle if Input.MouseWheelForceIdle? return if !Mouse.enable? if Input.trigger?(:MZ_LINK) && @info_title.cancel_hit? LonaCraft.trace("mouse click on Cancel") return exit_scene end return unless Mouse.within?(@list_window) hit = list_index_under_mouse if hit && hit != @list_window.index && @list_window.selectable?(hit) LonaCraft.trace{ "hover select #{hit} (from #{@list_window.index}), se cursor" } @list_window.select(hit) SndLib.play_cursor end return unless Input.trigger?(:MZ_LINK) LonaCraft.trace{ "mouse click row #{hit.inspect}" } return SndLib.sys_buzzer if hit.nil? || !@list_window.selectable?(hit) sync_detail try_craft end def list_index_under_mouse w = @list_window top = w.y + w.standard_padding bottom = w.y + w.height - w.padding_bottom w.item_max.times{|i| rect = w.item_rect(i) rect.x += w.x + w.standard_padding - w.ox rect.y += w.y + w.standard_padding - w.oy if !w.viewport.nil? rect.x += w.viewport.rect.x - w.viewport.ox rect.y += w.viewport.rect.y - w.viewport.oy end next if rect.y + rect.height <= top || rect.y >= bottom return i if Mouse.within?(rect) } nil end def terminate LonaCraft.trace{ "scene terminate begin (freeze, dispose windows and background), #{LonaCraft.trace_mem(true)}" } super $hudForceHide = @saved_hud_hide $balloonForceHide = @saved_balloon_hide LonaCraft.trace{ "scene terminate end, next #{SceneManager.scene.class}" } end end #============================================================================== # Crash trace safety net (05_Config.rb LonaCraft.trace): an "alive" line # with memory every TRACE_ALIVE_FRAMES frames while the screen runs, so a # crash while idle still shows the screen was alive; a Ruby error raised in # a frame is traced, then goes on to the game's error box as before. #============================================================================== class Scene_LonaCraft TRACE_ALIVE_FRAMES = 300 unless method_defined?(:lonacraft_trace_update) alias_method :lonacraft_trace_update, :update end def update @lonacraft_trace_frames = (@lonacraft_trace_frames || 0) + 1 if @lonacraft_trace_frames % TRACE_ALIVE_FRAMES == 0 LonaCraft.trace{ "alive frame #{@lonacraft_trace_frames}, index #{@list_window ? @list_window.index : "?"}, #{LonaCraft.trace_mem}" } end lonacraft_trace_update rescue Exception => e LonaCraft.trace_error("Scene_LonaCraft#update frame #{@lonacraft_trace_frames}", e) raise end end