# encoding: UTF-8 module StartupPortraitFix START_DELAY_FRAMES = 2 OVERMAP_FAST_DELAY_FRAMES = 8 STEP_DELAY_FRAMES = 1 RETRY_DELAY_FRAMES = 2 MAX_ATTEMPTS = 16 WORKER_POLL_SEC = 0.03 WORKER_TIMEOUT_SEC = 4.0 HAIR_PROBE_BITMAP = "Graphics/CharacterCharsets/LonaMCC/LonaMCC_equip_BasicHair.png" module_function def hair_palette_ready? return true unless defined?(BitmapChanger) return false unless $game_player actor = nil begin actor = $game_player.actor rescue actor = nil end return false if actor.nil? hair_color = 0 begin hair_color = actor.record_HairColor.to_i rescue hair_color = 0 end return true if hair_color <= 0 begin cache_name = BitmapChanger.find_cache_name(HAIR_PROBE_BITMAP) return !cache_name.nil? && !cache_name.empty? rescue return false end end def player_visuals_ready? return false unless $game_player return false unless hair_palette_ready? actor, portrait = fetch_player_actor_portrait return false if actor.nil? || portrait.nil? return true if player_chs_cached? begin return !$game_player.instance_variable_get(:@last_chs_visual_signature).nil? rescue return true end end def player_chs_cached? return false unless defined?(Cache) && $game_player store = Cache.instance_variable_get(:@chs_chars) rescue nil return false unless store.is_a?(Hash) key = $game_player.chs_name rescue nil return false if key.nil? || key.to_s.empty? !store[key].nil? rescue false end def warmup_steps steps = [:prepare] steps << :chs unless player_chs_cached? steps << :pose steps << :force steps rescue [:prepare, :pose, :force] end def fetch_player_actor_portrait actor = nil portrait = nil begin actor = $game_player.actor portrait = actor.portrait if actor rescue actor = nil portrait = nil end [actor, portrait] rescue [nil, nil] end def prepare_portrait_context(actor, portrait) begin actor.refresh_part_key_blacklist if actor.respond_to?(:refresh_part_key_blacklist) rescue end begin if portrait.respond_to?(:part_key_blacklist=) && actor.respond_to?(:part_key_blacklist) portrait.part_key_blacklist = actor.part_key_blacklist end rescue end true rescue false end def refresh_player_chs_visual begin if $game_player.respond_to?(:force_refresh_chs_visual) $game_player.force_refresh_chs_visual elsif $game_player.respond_to?(:refresh_chs) $game_player.refresh_chs end return true rescue return false end end def update_portrait_pose(portrait) begin portrait.updatePose if portrait.respond_to?(:updatePose) return true rescue return false end end def force_portrait_refresh(portrait) begin portrait.force_update if portrait.respond_to?(:force_update) return true rescue return false end end def warmup_step(step) return :retry unless $game_player return :wait unless hair_palette_ready? actor, portrait = fetch_player_actor_portrait return :retry if actor.nil? || portrait.nil? ok = case step when :prepare prepare_portrait_context(actor, portrait) when :chs # This is the heavy part. Keep it isolated to one frame. refresh_player_chs_visual when :pose update_portrait_pose(portrait) when :force force_portrait_refresh(portrait) else true end ok ? :ok : :retry rescue => e p "StartupPortraitFix step #{step} failed: #{e.class}: #{e}" :retry end def start_worker(token) @worker_token = token @worker_ready_token = nil @worker_failed_token = nil begin if @worker_thread && @worker_thread.alive? return true if @worker_thread[:token] == token end rescue end @worker_thread = Thread.new do Thread.current[:token] = token rescue nil deadline = (Time.now.to_f rescue 0.0) + WORKER_TIMEOUT_SEC loop do current_token = @worker_token rescue nil break if current_token != token begin actor, portrait = fetch_player_actor_portrait if hair_palette_ready? && !actor.nil? && !portrait.nil? @worker_ready_token = token break end rescue end now = Time.now.to_f rescue 0.0 if now >= deadline @worker_failed_token = token break end sleep(WORKER_POLL_SEC) end end true rescue false end def worker_ready?(token) (@worker_ready_token == token) rescue false end def worker_failed?(token) (@worker_failed_token == token) rescue false end def stop_worker(token = nil) current = @worker_token rescue nil return if !token.nil? && current != token @worker_token = nil @worker_ready_token = nil if token.nil? || @worker_ready_token == token @worker_failed_token = nil if token.nil? || @worker_failed_token == token @worker_thread = nil rescue @worker_token = nil @worker_ready_token = nil @worker_failed_token = nil @worker_thread = nil end end class Scene_Map < Scene_Base unless method_defined?(:startup_portrait_fix_start) alias startup_portrait_fix_start start end unless method_defined?(:startup_portrait_fix_update) alias startup_portrait_fix_update update end def start(*args, &block) startup_portrait_fix_start(*args, &block) return if startup_portrait_fix_skip? # OverMap used to take a separate "fast" path here. # That path skipped hair_palette_ready? and could rebuild CHS once with # default hair after Cache.clear_chs_material on map change. Result: # normal maps recolored correctly, while OverMap could stay default until # some later forced refresh. # # Use the normal warmup path for OverMap too, so we only rebuild after the # palette backend is actually ready. @startup_portrait_fix_mode = :normal @startup_portrait_fix_frames = StartupPortraitFix::START_DELAY_FRAMES @startup_portrait_fix_worker_token = "#{object_id}:#{Graphics.frame_count rescue 0}:#{Time.now.to_f rescue 0.0}" @startup_portrait_fix_waiting_worker = true @startup_portrait_fix_step_index = 0 @startup_portrait_fix_attempts = 0 StartupPortraitFix.start_worker(@startup_portrait_fix_worker_token) end def update(*args, &block) startup_portrait_fix_update(*args, &block) update_startup_portrait_fix end def update_startup_portrait_fix return if startup_portrait_fix_skip? return if @startup_portrait_fix_frames.nil? if @startup_portrait_fix_frames > 0 @startup_portrait_fix_frames -= 1 return end if @startup_portrait_fix_waiting_worker if StartupPortraitFix.worker_ready?(@startup_portrait_fix_worker_token) @startup_portrait_fix_waiting_worker = false @startup_portrait_fix_frames = StartupPortraitFix::STEP_DELAY_FRAMES elsif StartupPortraitFix.worker_failed?(@startup_portrait_fix_worker_token) reset_startup_portrait_fix else @startup_portrait_fix_frames = StartupPortraitFix::RETRY_DELAY_FRAMES end return end @startup_portrait_fix_step_index ||= 0 @startup_portrait_fix_attempts ||= 0 steps = StartupPortraitFix.warmup_steps if @startup_portrait_fix_step_index >= steps.size @startup_portrait_fix_attempts += 1 if StartupPortraitFix.player_visuals_ready? || @startup_portrait_fix_attempts >= StartupPortraitFix::MAX_ATTEMPTS reset_startup_portrait_fix else @startup_portrait_fix_step_index = 0 @startup_portrait_fix_frames = StartupPortraitFix::RETRY_DELAY_FRAMES end return end step = steps[@startup_portrait_fix_step_index] result = StartupPortraitFix.warmup_step(step) case result when :ok @startup_portrait_fix_step_index += 1 @startup_portrait_fix_frames = StartupPortraitFix::STEP_DELAY_FRAMES when :wait @startup_portrait_fix_frames = StartupPortraitFix::RETRY_DELAY_FRAMES else @startup_portrait_fix_attempts += 1 if @startup_portrait_fix_attempts >= StartupPortraitFix::MAX_ATTEMPTS reset_startup_portrait_fix else @startup_portrait_fix_step_index = 0 @startup_portrait_fix_frames = StartupPortraitFix::RETRY_DELAY_FRAMES end end end def startup_portrait_fix_skip? defined?(Scene_MapTitle) && is_a?(Scene_MapTitle) end def startup_portrait_fix_overmap_fast_path? # Legacy hook kept only for compatibility; fast path disabled because it # could lock OverMap into default hair colors. false end def reset_startup_portrait_fix begin StartupPortraitFix.stop_worker(@startup_portrait_fix_worker_token) rescue end @startup_portrait_fix_frames = nil @startup_portrait_fix_worker_token = nil @startup_portrait_fix_waiting_worker = nil @startup_portrait_fix_step_index = nil @startup_portrait_fix_attempts = nil @startup_portrait_fix_mode = nil end end