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

4478 lines
122 KiB
Ruby
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
$imported = {} if $imported.nil?
$noerHomeFolder = "ModScripts/_Mods/#{$noer_home_config["noer_home"]["resourse_name"]}/"
module DataManager
self.singleton_class.send(:alias_method, :load_mod_database_NoerHome, :load_mod_database)
def self.load_mod_database
load_mod_database_NoerHome
DataManager.extra_map_register("NoerHome","#{$noerHomeFolder}NoerHome.rvdata2")
$data_tag_maps["NoerHome"] = ["#{$noerHomeFolder}NoerHome.rvdata2"]
DataManager.extra_map_register("NoerHomeOut","#{$noerHomeFolder}NoerHomeOut.rvdata2")
$data_tag_maps["NoerHomeOut"] = ["#{$noerHomeFolder}NoerHomeOut.rvdata2"]
noerHomeHash = FileGetter.load_mod_EventLib("#{$noerHomeFolder}NoerHomeOvr.rvdata2")
noerHomeHash.each{|evName,evData|
evData[1].pages.each{|tmpPage|
if tmpPage.graphic.character_name == "WrldMpHouse"
tmpPage.graphic.character_name = "../../#{$noerHomeFolder}Graphics/Characters/WrldMpHouse.png"
end
}
}
$data_EventLib = $data_EventLib.merge(noerHomeHash)
end
end
$mod_load_script["Data/HCGframes/event/NoerBankMaani.rb"] = "#{$noerHomeFolder}HCGframes/event/NoerBankMaani.rb"
module NoerHomeOnlineSave
module_function
def house_bought?
return false unless defined?($story_stats) && $story_stats
$story_stats["NoerHouseBought"].to_i != 0
rescue
false
end
def overmap_ready?
return false unless defined?($game_map) && $game_map
return false unless $game_map.respond_to?(:isOverMap)
$game_map.isOverMap
rescue
false
end
def overmap_entry_exists?
return false unless defined?($game_map) && $game_map && $game_map.respond_to?(:events)
queued = $game_map.instance_variable_get(:@summoned_evs) rescue nil
if queued.is_a?(Array)
return true if queued.any?{|row| row.is_a?(Array) && row[0].to_s == "NoerHome"}
end
$game_map.events.any?{|_id, event|
begin
event && event.respond_to?(:name) && event.name.to_s == "NoerHome"
rescue
false
end
}
rescue
false
end
def ensure_overmap_entry
return false unless overmap_ready?
return true if overmap_entry_exists?
EvLib.sum("NoerHome",$noer_home_config["noer_home"]["x"],$noer_home_config["noer_home"]["y"])
true
rescue
false
end
end
class Game_Map
alias setup_NoerHome setup
def setup(map_id)
setup_NoerHome(map_id)
NoerHomeOnlineSave.ensure_overmap_entry
end
end
module System_Settings
if $noer_home_config["noer_home"]["storage_bank"] == 'true'
STORAGE_NOERHOME = 65533
else
STORAGE_NOERHOME = 65633
end
end
class Scene_NoerHomeStorage < Scene_ItemStorage
def create_window_ItemStorageLeft
@bag_window = Window_NoerHomeStorageLeft.new
end
end
class Window_NoerHomeStorageLeft < Window_ItemStorageLeft
def enable?(item)
return false if item.common_tags["Lock_BankStorage"] if $noer_home_config["noer_home"]["storage_bank"] == 'true'
return super
end
end
class Game_Actor
alias_method(:process_nap_change_original, :process_nap_change)
def process_nap_change
process_nap_change_original
begin
if $story_stats["Setup_Hardcore"] >= 1 && $noer_home_config["noer_home"]["storage_bank"] != 'true'
$game_boxes.drop_raw(65633)
end
rescue
end
end
if $noer_home_config["noer_home"]["inheritance"] == 'true'
alias_method(:build_inheritance_data_original, :build_inheritance_data)
def build_inheritance_data(choosedRace)
build_inheritance_data_original(choosedRace)
begin
$inheritance["NoerHomeStorage"] = $game_boxes.get_box(System_Settings::STORAGE_NOERHOME)
$inheritance["IsNoerHouseBought"] = $story_stats["NoerHouseBought"]
rescue
end
end
alias_method(:setup_inheritance_original, :setup_inheritance)
def setup_inheritance(inheritance=nil)
return if inheritance.nil?
begin
$game_boxes.write_box(System_Settings::STORAGE_NOERHOME,inheritance["NoerHomeStorage"]) if inheritance["NoerHomeStorage"] && $inheritance["rebirthData"]["remember_bank"]
$story_stats["NoerHouseBought"] = inheritance["IsNoerHouseBought"]
rescue
end
setup_inheritance_original(inheritance)
end
end
end
###music checker
begin
if !File.file?($mod_manager.get_resource "#{$noer_home_config["noer_home"]["resourse_name"]}", "Music/#{$noer_home_config["noer_home"]["house_music"]}.ogg")
$noer_home_config["noer_home"]["house_music"] = "Medieval"
end
if !File.file?($mod_manager.get_resource "#{$noer_home_config["noer_home"]["resourse_name"]}", "Music/#{$noer_home_config["noer_home"]["garden_music"]}.ogg")
$noer_home_config["noer_home"]["garden_music"] = "Awkward"
end
rescue
$noer_home_config["noer_home"]["house_music"] = "Medieval"
$noer_home_config["noer_home"]["garden_music"] = "Awkward"
end
# ===== NoerHome cat menu + color + effects =====
class Game_System
attr_accessor :noerhome_cat_color_id
attr_accessor :noerhome_cat_effect_id
attr_accessor :noerhome_cat_music_id
attr_accessor :noerhome_cat_follow_enabled
end
module NoerHomeCat
SAVE_COLOR_KEY = "noerhome_cat_color_id"
SAVE_EFFECT_KEY = "noerhome_cat_effect_id"
SAVE_MUSIC_KEY = "noerhome_cat_music_id"
SAVE_FOLLOW_KEY = "noerhome_cat_follow_enabled"
CAT_EVENT_ID = 107
CAT_CHARACTER_NAME = "-char-Creatures48C01"
CAT_CHARACTER_INDEX = 4
def self.cat_charset_index
x = CAT_CHARACTER_INDEX.to_i % 4 * 3 + 1
y = CAT_CHARACTER_INDEX.to_i / 4
y * 12 + x
rescue
13
end
EFFECT_NONE = 0
EFFECT_NYAN = 1
MUSIC_LIST_RELATIVE_PATH = "Music/CatMusic.json"
DEFAULT_CAT_MUSIC_LIST = [
{ "id" => 1, "title" => "Nyan Cat", "file" => "Nyan_Cat.ogg", "volume" => 90, "pitch" => 100 },
{ "id" => 2, "title" => "Drug_slowed_8bit", "file" => "Drug_slowed_8bit.ogg", "volume" => 90, "pitch" => 100 }
]
NYAN_MUSIC_VOLUME = 90
NYAN_MUSIC_PITCH = 100
NYAN_BITMAP_WIDTH = 40
NYAN_BITMAP_HEIGHT = 12
NYAN_BITMAP_WIDTH_V = 12
NYAN_BITMAP_HEIGHT_V = 40
NYAN_FRAME_STEP = 4
NYAN_TRAIL_GAP = 6
NYAN_TRAIL_LIFE = 18
NYAN_TRAIL_LIMIT = 16
NYAN_TRAIL_BACK_OFFSET = 12.0
NYAN_TRAIL_BODY_Y_OFFSET = -18.0
COLORS = [
[0, "CatMenu/Color/Default", [0, 0, 0, 0]],
[1, "CatMenu/Color/Orange", [55, 10, -35, 0]],
[2, "CatMenu/Color/Gray", [-25, -25, -25, 0]],
[3, "CatMenu/Color/Black", [-120, -120, -120, 0]],
[4, "CatMenu/Color/White", [45, 45, 45, 0]],
[5, "CatMenu/Color/Siamese", [20, 0, -10, 0]],
[6, "CatMenu/Color/Golden", [40, 18, -28, 0]]
]
EFFECTS = [
[0, "CatMenu/Effect/None"],
[1, "CatMenu/Effect/Nyan"]
]
def self.storage_path
base = nil
begin
if defined?(System_Settings) && System_Settings.const_defined?(:USER_DATA_PATH)
base = System_Settings::USER_DATA_PATH.to_s
end
rescue
base = nil
end
base = "UserData" if base.nil? || base.to_s.strip == ""
File.join(base, "noerhome_cat.json")
end
def self.ensure_parent_dir(path)
dir = File.dirname(path.to_s)
return if dir.to_s.strip == "" || Dir.exist?(dir)
parts = dir.gsub("\\", "/").split("/")
cur = parts.shift.to_s
if cur =~ /\A[A-Za-z]:\z/
cur += "/"
elsif cur == ""
cur = "/"
end
parts.each do |part|
next if part.to_s == ""
cur = cur == "/" ? "/#{part}" : File.join(cur, part)
Dir.mkdir(cur) unless Dir.exist?(cur)
end
rescue
end
def self.valid_color_id?(id)
COLORS.any? { |row| row[0].to_i == id.to_i }
end
def self.valid_effect_id?(id)
EFFECTS.any? { |row| row[0].to_i == id.to_i }
end
def self.music_list_path
base = $noerHomeFolder.to_s
base = "ModScripts/_Mods/NoerHome/" if base.to_s.strip == ""
File.join(base, MUSIC_LIST_RELATIVE_PATH).gsub("\\", "/")
rescue
"ModScripts/_Mods/NoerHome/Music/CatMusic.json"
end
def self.normalize_music_entry(raw)
return nil unless raw.is_a?(Hash)
id = (raw["id"] || raw[:id] || 0).to_i
return nil if id <= 0
title = (raw["title"] || raw[:title] || raw["name"] || raw[:name] || "Track #{id}").to_s
file = (raw["file"] || raw[:file] || "").to_s
file = "#{file}.ogg" if file != "" && File.extname(file).to_s.strip == ""
return nil if file.to_s.strip == ""
{
:id => id,
:title => title,
:file => file,
:volume => (raw["volume"] || raw[:volume] || NYAN_MUSIC_VOLUME).to_i,
:pitch => (raw["pitch"] || raw[:pitch] || NYAN_MUSIC_PITCH).to_i
}
rescue
nil
end
def self.default_music_catalog
rows = []
DEFAULT_CAT_MUSIC_LIST.each do |entry|
norm = normalize_music_entry(entry)
rows << norm if norm
end
rows
rescue
[]
end
def self.music_catalog(force = false)
@music_catalog = nil if force
return @music_catalog if @music_catalog.is_a?(Array)
rows = []
path = music_list_path
if File.file?(path) && defined?(JSON)
begin
raw = Ruby310Compat.read_text_file(path)
parsed = JSON.parse(raw)
items = if parsed.is_a?(Hash)
parsed["tracks"] || parsed[:tracks] || parsed["music"] || parsed[:music] || []
elsif parsed.is_a?(Array)
parsed
else
[]
end
items.each do |entry|
norm = normalize_music_entry(entry)
rows << norm if norm
end
rescue
rows = []
end
end
rows = default_music_catalog if rows.empty?
rows = rows.sort_by { |entry| entry[:id].to_i }
@music_catalog = rows
rescue
@music_catalog = default_music_catalog
end
def self.music_entry_for_id(id)
music_catalog.find { |entry| entry[:id].to_i == id.to_i }
rescue
nil
end
def self.valid_music_id?(id)
return true if id.to_i == 0
!music_entry_for_id(id).nil?
rescue
false
end
def self.music_track_path(entry_or_id)
entry = entry_or_id.is_a?(Hash) ? entry_or_id : music_entry_for_id(entry_or_id)
return nil if entry.nil?
base = $noerHomeFolder.to_s
base = "ModScripts/_Mods/NoerHome/" if base.to_s.strip == ""
File.join(base, "Music", entry[:file].to_s).gsub("\\", "/")
rescue
nil
end
def self.read_persisted_state
result = {
SAVE_COLOR_KEY => 0,
SAVE_EFFECT_KEY => 0,
SAVE_MUSIC_KEY => 0,
SAVE_FOLLOW_KEY => 0
}
path = storage_path
return result unless File.file?(path)
raw = Ruby310Compat.read_text_file(path)
if defined?(JSON)
begin
data = JSON.parse(raw)
if data.is_a?(Hash)
color_id = (data[SAVE_COLOR_KEY] || data[SAVE_COLOR_KEY.to_sym] || 0).to_i
effect_id = (data[SAVE_EFFECT_KEY] || data[SAVE_EFFECT_KEY.to_sym] || 0).to_i
music_id = (data[SAVE_MUSIC_KEY] || data[SAVE_MUSIC_KEY.to_sym] || 0).to_i
follow_raw = (data[SAVE_FOLLOW_KEY] || data[SAVE_FOLLOW_KEY.to_sym] || 0)
follow_flag = follow_raw.to_i != 0 ? 1 : 0
result[SAVE_COLOR_KEY] = valid_color_id?(color_id) ? color_id : 0
result[SAVE_EFFECT_KEY] = valid_effect_id?(effect_id) ? effect_id : 0
result[SAVE_MUSIC_KEY] = valid_music_id?(music_id) ? music_id : 0
result[SAVE_FOLLOW_KEY] = follow_flag
return result
end
rescue
end
end
if raw.to_s =~ /"#{SAVE_COLOR_KEY}"\s*:\s*(-?\d+)/
color_id = $1.to_i
result[SAVE_COLOR_KEY] = valid_color_id?(color_id) ? color_id : 0
end
if raw.to_s =~ /"#{SAVE_EFFECT_KEY}"\s*:\s*(-?\d+)/
effect_id = $1.to_i
result[SAVE_EFFECT_KEY] = valid_effect_id?(effect_id) ? effect_id : 0
end
if raw.to_s =~ /"#{SAVE_MUSIC_KEY}"\s*:\s*(-?\d+)/
music_id = $1.to_i
result[SAVE_MUSIC_KEY] = valid_music_id?(music_id) ? music_id : 0
end
if raw.to_s =~ /"#{SAVE_FOLLOW_KEY}"\s*:\s*(true|false|-?\d+)/i
token = $1.to_s.downcase
result[SAVE_FOLLOW_KEY] = (token == "true" || token.to_i != 0) ? 1 : 0
end
result
rescue
{
SAVE_COLOR_KEY => 0,
SAVE_EFFECT_KEY => 0,
SAVE_MUSIC_KEY => 0,
SAVE_FOLLOW_KEY => 0
}
end
def self.write_persisted_state(color_id = nil, effect_id = nil, follow_enabled = nil, music_id = nil)
state = read_persisted_state
color_id = state[SAVE_COLOR_KEY] if color_id.nil?
effect_id = state[SAVE_EFFECT_KEY] if effect_id.nil?
music_id = state[SAVE_MUSIC_KEY] if music_id.nil?
follow_enabled = state[SAVE_FOLLOW_KEY] if follow_enabled.nil?
color_id = valid_color_id?(color_id) ? color_id.to_i : 0
effect_id = valid_effect_id?(effect_id) ? effect_id.to_i : 0
music_id = valid_music_id?(music_id) ? music_id.to_i : 0
follow_flag = follow_enabled.to_i != 0 ? 1 : 0
payload = "{\"#{SAVE_COLOR_KEY}\":#{color_id},\"#{SAVE_EFFECT_KEY}\":#{effect_id},\"#{SAVE_MUSIC_KEY}\":#{music_id},\"#{SAVE_FOLLOW_KEY}\":#{follow_flag}}"
path = storage_path
ensure_parent_dir(path)
File.open(path, "wb") { |file| file.write(payload) }
true
rescue
false
end
def self.ensure_runtime_state
return if $game_system.nil?
state = nil
if $game_system.noerhome_cat_color_id.nil? || $game_system.noerhome_cat_effect_id.nil? || $game_system.noerhome_cat_music_id.nil?
state = read_persisted_state
end
if $game_system.noerhome_cat_color_id.nil?
$game_system.noerhome_cat_color_id = state[SAVE_COLOR_KEY].to_i
end
if $game_system.noerhome_cat_effect_id.nil?
$game_system.noerhome_cat_effect_id = state[SAVE_EFFECT_KEY].to_i
end
if $game_system.noerhome_cat_music_id.nil?
$game_system.noerhome_cat_music_id = state[SAVE_MUSIC_KEY].to_i
end
if $game_system.noerhome_cat_follow_enabled.nil?
$game_system.noerhome_cat_follow_enabled = state[SAVE_FOLLOW_KEY].to_i != 0
end
rescue
end
def self.current_color_id
ensure_runtime_state
gs = $game_system
return 0 if gs.nil?
id = (gs.noerhome_cat_color_id rescue 0).to_i
valid_color_id?(id) ? id : 0
end
def self.current_effect_id
ensure_runtime_state
gs = $game_system
return 0 if gs.nil?
id = (gs.noerhome_cat_effect_id rescue 0).to_i
valid_effect_id?(id) ? id : 0
end
def self.current_music_id
ensure_runtime_state
gs = $game_system
return 0 if gs.nil?
id = (gs.noerhome_cat_music_id rescue 0).to_i
valid_music_id?(id) ? id : 0
end
def self.current_follow_enabled?
ensure_runtime_state
gs = $game_system
return false if gs.nil?
(gs.noerhome_cat_follow_enabled rescue false) ? true : false
end
def self.follow_menu_title
base = text("CatMenu/Follow", "Follow player")
state = current_follow_enabled? ? text("CatMenu/On", "ВКЛ") : text("CatMenu/Off", "ВЫКЛ")
"#{base} [#{state}]"
end
def self.active_effect_id
id = current_effect_id
return 0 if id.to_i != 0 && !vip_available?
id
rescue
0
end
def self.active_music_id
id = current_music_id
return 0 if id.to_i != 0 && !vip_available?
valid_music_id?(id) ? id.to_i : 0
rescue
0
end
def self.nyan_music_path
entry = music_entry_for_id(1)
music_track_path(entry)
rescue
"ModScripts/_Mods/NoerHome/Music/Nyan_Cat.ogg"
end
def self.capture_bgs_state
last = RPG::BGS.last rescue nil
return { :name => "", :volume => 100, :pitch => 100, :pos => 0 } if last.nil?
{
:name => (last.name rescue "").to_s,
:volume => (last.volume rescue 100).to_i,
:pitch => (last.pitch rescue 100).to_i,
:pos => (last.pos rescue 0).to_i
}
rescue
{ :name => "", :volume => 100, :pitch => 100, :pos => 0 }
end
def self.restore_bgs_state(state)
state = nil if state == false
return if state.nil?
name = state[:name].to_s
volume = (state[:volume] || 100).to_i
pitch = (state[:pitch] || 100).to_i
pos = (state[:pos] || 0).to_i
if name.strip == ""
Audio.bgs_stop rescue nil
begin
RPG::BGS.last.name = ""
RPG::BGS.last.volume = 100
RPG::BGS.last.pitch = 100
RPG::BGS.last.pos = 0
rescue
end
return
end
calculateVOL = (volume * (($data_SNDvol rescue 100) * 0.01)).to_i
Audio.bgs_play("Audio/BGS/#{name}.ogg", calculateVOL, pitch, pos)
begin
RPG::BGS.last.name = name
RPG::BGS.last.volume = volume
RPG::BGS.last.pitch = pitch
RPG::BGS.last.pos = pos
rescue
end
rescue
end
def self.active_cat_audio_target
if current_follow_enabled?
follower_character(false)
else
current_cat_event
end
rescue
nil
end
def self.nyan_distance_tiles
player = $game_player
cat = active_cat_audio_target
return 8 if player.nil? || cat.nil?
dx = if cat.respond_to?(:distance_x_from)
cat.distance_x_from(player.x).abs
else
(cat.x.to_i - player.x.to_i).abs
end
dy = if cat.respond_to?(:distance_y_from)
cat.distance_y_from(player.y).abs
else
(cat.y.to_i - player.y.to_i).abs
end
dx.to_i + dy.to_i
rescue
8
end
def self.nyan_mix_levels
distance = [nyan_distance_tiles.to_i, 0].max
if distance <= 1
effect_percent = 100
game_percent = 0
elsif distance <= 3
effect_percent = 75
game_percent = 25
elsif distance <= 5
effect_percent = 50
game_percent = 50
elsif distance <= 7
effect_percent = 25
game_percent = 75
else
effect_percent = 0
game_percent = 100
end
{
:distance => distance,
:effect_percent => effect_percent,
:game_percent => game_percent
}
rescue
{
:distance => 8,
:effect_percent => 0,
:game_percent => 100
}
end
def self.current_bgm_state
last = RPG::BGM.last rescue nil
return { :name => "", :volume => 100, :pitch => 100, :pos => 0 } if last.nil?
{
:name => (last.name rescue "").to_s,
:volume => (last.volume rescue 100).to_i,
:pitch => (last.pitch rescue 100).to_i,
:pos => ((Audio.bgm_pos rescue nil) || (last.pos rescue 0) || 0).to_i
}
rescue
{ :name => "", :volume => 100, :pitch => 100, :pos => 0 }
end
def self.apply_nyan_bgm_mix(percent, force = false)
percent = [[percent.to_i, 0].max, 100].min
state = current_bgm_state
name = state[:name].to_s
signature = [name, state[:volume].to_i, state[:pitch].to_i, ($data_BGMvol rescue 100).to_i]
if !force && @nyan_music_last_bgm_percent.to_i == percent && @nyan_music_last_bgm_signature == signature
return true
end
@nyan_music_last_bgm_percent = percent
@nyan_music_last_bgm_signature = signature
return true if name.strip == ""
base_volume = state[:volume].to_i
pitch = state[:pitch].to_i
pos = state[:pos].to_i
calculateVOL = (base_volume * (percent * 0.01) * (($data_BGMvol rescue 100) * 0.01)).to_i
Audio.bgm_play("Audio/BGM/#{name}.ogg", calculateVOL, pitch, pos)
begin
RPG::BGM.last.name = name
RPG::BGM.last.volume = base_volume
RPG::BGM.last.pitch = pitch
RPG::BGM.last.pos = pos
rescue
end
true
rescue
false
end
def self.apply_nyan_bgs_mix(percent, restart = false)
percent = [[percent.to_i, 0].max, 100].min
path = nyan_music_path
return false unless File.file?(path)
map_id = ($game_map.map_id rescue nil)
pos = 0
if @nyan_music_playing && !restart
pos = ((Audio.bgs_pos rescue nil) || @nyan_music_last_bgs_pos || 0).to_i
end
signature = [map_id.to_i, percent, ($data_SNDvol rescue 100).to_i]
if !restart && @nyan_music_last_bgs_signature == signature
return true
end
@nyan_music_last_bgs_signature = signature
@nyan_music_last_bgs_pos = pos
calculateVOL = (NYAN_MUSIC_VOLUME.to_i * (percent * 0.01) * (($data_SNDvol rescue 100) * 0.01)).to_i
Audio.bgs_play(path, calculateVOL, NYAN_MUSIC_PITCH.to_i, pos)
@nyan_music_playing = true
@nyan_music_map_id = map_id
true
rescue
false
end
def self.nyan_music_desired?
return false unless active_effect_id == EFFECT_NYAN
return false unless defined?(Scene_Map)
return false unless defined?(SceneManager) && SceneManager.respond_to?(:scene_is?)
return false unless SceneManager.scene_is?(Scene_Map)
!active_cat_audio_target.nil?
rescue
false
end
def self.start_nyan_music
path = nyan_music_path
return false unless File.file?(path)
map_id = ($game_map.map_id rescue nil)
return true if @nyan_music_playing && @nyan_music_map_id.to_i == map_id.to_i
@nyan_music_prev_bgs = capture_bgs_state if @nyan_music_prev_bgs.nil?
@nyan_music_playing = false
@nyan_music_last_bgs_signature = nil
@nyan_music_last_bgm_signature = nil
@nyan_music_last_bgm_percent = nil
mix = nyan_mix_levels
apply_nyan_bgs_mix(mix[:effect_percent].to_i, true)
apply_nyan_bgm_mix(mix[:game_percent].to_i, true)
true
rescue
@nyan_music_playing = false
false
end
def self.stop_nyan_music(restore_previous = true)
state = @nyan_music_prev_bgs
@nyan_music_prev_bgs = nil
@nyan_music_playing = false
@nyan_music_map_id = nil
@nyan_music_last_bgs_signature = nil
@nyan_music_last_bgs_pos = nil
@nyan_music_last_bgm_signature = nil
@nyan_music_last_bgm_percent = nil
Audio.bgs_stop rescue nil
apply_nyan_bgm_mix(100, true)
restore_bgs_state(state) if restore_previous
true
rescue
@nyan_music_prev_bgs = nil
@nyan_music_playing = false
@nyan_music_map_id = nil
@nyan_music_last_bgs_signature = nil
@nyan_music_last_bgs_pos = nil
@nyan_music_last_bgm_signature = nil
@nyan_music_last_bgm_percent = nil
false
end
def self.sync_nyan_music
desired = nyan_music_desired?
if desired
current_map_id = ($game_map.map_id rescue nil)
if @nyan_music_playing && @nyan_music_map_id.to_i != current_map_id.to_i
stop_nyan_music(true)
end
start_nyan_music unless @nyan_music_playing
mix = nyan_mix_levels
apply_nyan_bgs_mix(mix[:effect_percent].to_i)
apply_nyan_bgm_mix(mix[:game_percent].to_i)
elsif @nyan_music_playing || !@nyan_music_prev_bgs.nil?
stop_nyan_music(true)
end
rescue
end
def self.tone_for(id)
row = COLORS.find { |entry| entry[0].to_i == id.to_i } || COLORS[0]
tone = row[2]
Tone.new(tone[0], tone[1], tone[2], tone[3])
end
def self.resource_name
begin
return $noer_home_config["noer_home"]["resourse_name"].to_s
rescue
return "NoerHome"
end
end
def self.text(key, fallback = "")
begin
return fallback if !defined?($game_text) || $game_text.nil?
value = $game_text["#{resource_name}:NoerHome:#{key}", true]
return fallback if value.nil? || value.to_s == ""
value.to_s
rescue
fallback
end
end
def self.color_menu_rows
current = current_color_id
rows = []
selected_suffix = text("CatMenu/Selected", "[selected]")
COLORS.each do |row|
title = text(row[1].to_s, row[1].to_s)
title = "#{title} #{selected_suffix}" if row[0].to_i == current
rows << [title, row[0].to_i]
end
rows
end
def self.effect_menu_rows
current = current_effect_id
rows = []
selected_suffix = text("CatMenu/Selected", "[selected]")
EFFECTS.each do |row|
title = text(row[1].to_s, row[1].to_s)
title = "#{title} #{selected_suffix}" if row[0].to_i == current
rows << [title, row[0].to_i]
end
rows
end
def self.music_menu_rows
current = current_music_id
rows = []
selected_suffix = text("CatMenu/Selected", "[selected]")
none_title = text("CatMenu/Music/None", "No music")
none_title = "#{none_title} #{selected_suffix}" if current.to_i == 0
rows << [none_title, 0]
music_catalog.each do |entry|
title = entry[:title].to_s
title = "#{title} #{selected_suffix}" if entry[:id].to_i == current
rows << [title, entry[:id].to_i]
end
rows
end
def self.vip_available?
return false unless defined?(WebSocket)
return WebSocket.admin_can_style? if WebSocket.respond_to?(:admin_can_style?)
return WebSocket.admin_role_rank.to_i >= 1 if WebSocket.respond_to?(:admin_role_rank)
false
rescue
false
end
def self.set_color(id, send_server = true)
id = valid_color_id?(id) ? id.to_i : 0
$game_system.noerhome_cat_color_id = id if $game_system
write_persisted_state(id, current_effect_id, current_follow_enabled? ? 1 : 0, current_music_id)
begin
if send_server && defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.send_line("cat_color:#{id}")
end
rescue
end
id
end
def self.set_effect(id, send_server = true)
id = valid_effect_id?(id) ? id.to_i : 0
id = 0 if send_server && id != 0 && !vip_available?
$game_system.noerhome_cat_effect_id = id if $game_system
write_persisted_state(current_color_id, id, current_follow_enabled? ? 1 : 0, current_music_id)
begin
if send_server && defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.send_line("cat_effect:#{id}")
end
rescue
end
id
end
def self.set_music(id, send_server = true)
id = valid_music_id?(id) ? id.to_i : 0
id = 0 if send_server && id != 0 && !vip_available?
$game_system.noerhome_cat_music_id = id if $game_system
write_persisted_state(current_color_id, current_effect_id, current_follow_enabled? ? 1 : 0, id)
sync_nyan_music
begin
if send_server && defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.send_line("cat_music:#{id}")
end
rescue
end
id
end
def self.set_follow_enabled(flag, send_server = true)
enabled = flag ? true : false
$game_system.noerhome_cat_follow_enabled = enabled if $game_system
write_persisted_state(current_color_id, current_effect_id, enabled ? 1 : 0, current_music_id)
begin
if enabled
clear_follow_points
reset_follower_position(true)
else
clear_follow_points
follower = follower_character(false)
follower.transparent = true if follower
end
rescue
end
sync_nyan_music
begin
if send_server && defined?(WebSocket) && WebSocket.respond_to?(:connected?) && WebSocket.connected?
WebSocket.send_line("cat_follow:#{enabled ? 1 : 0}")
end
rescue
end
enabled
end
def self.reverse_dir(d)
10 - d.to_i
rescue
2
end
def self.follower_character(create = true)
if @follower_character.nil? && create
@follower_character = Game_NoerHomeCatFollower.new
begin
event = current_cat_event
@follower_character.adopt_visuals_from(event) if event && @follower_character.respond_to?(:adopt_visuals_from)
rescue
end
@follower_map_id = nil
end
@follower_character
rescue
nil
end
def self.follow_points
@follow_points ||= []
rescue
@follow_points = []
end
def self.clear_follow_points
@follow_points = []
rescue
end
def self.record_player_step(x, y, direction = nil, map_id = nil)
return unless current_follow_enabled?
return if x.nil? || y.nil?
map_id = ($game_map.map_id rescue nil) if map_id.nil?
point = { :x => x.to_i, :y => y.to_i, :dir => direction.to_i, :map_id => map_id }
queue = follow_points
last = queue[-1]
return point if last && last[:x].to_i == point[:x] && last[:y].to_i == point[:y] && last[:map_id].to_i == point[:map_id].to_i
queue << point
point
rescue
nil
end
def self.desired_follow_speed
player_speed = ($game_player.real_move_speed rescue ($game_player.move_speed rescue 4)).to_i
player_speed = 4 if player_speed <= 0
follower = follower_character(false)
queue = follow_points
distance = 0
if follower && $game_player
distance = follower.distance_x_from($game_player.x).abs + follower.distance_y_from($game_player.y).abs
end
backlog = queue.size
pressure = [distance, backlog].max
near_speed = [[player_speed - 1, 3].max, 5].min
mid_speed = [[player_speed, near_speed].max, 5].min
far_speed = [[player_speed + 1, mid_speed].max, 6].min
if pressure >= 6
far_speed
elsif pressure >= 3
mid_speed
else
near_speed
end
rescue
4
end
def self.apply_follower_speed
follower = follower_character(false)
return unless follower
follower.move_speed = desired_follow_speed
rescue
end
def self.move_follower_toward(tx, ty)
follower = follower_character(false)
return false if follower.nil? || tx.nil? || ty.nil?
return false if follower.moving?
apply_follower_speed
sx = follower.distance_x_from(tx.to_i)
sy = follower.distance_y_from(ty.to_i)
return true if sx == 0 && sy == 0
if sx != 0 && (sy == 0 || sx.abs >= sy.abs)
follower.move_straight(sx > 0 ? 4 : 6)
elsif sy != 0
follower.move_straight(sy > 0 ? 8 : 2)
end
true
rescue
false
end
def self.drive_follower
return unless current_follow_enabled?
return unless $game_player && $game_map
follower = follower_character
return if follower.nil?
follower.refresh_visuals if follower.respond_to?(:refresh_visuals)
follower.transparent = false
if follower_lost?
reset_follower_position(true)
return
end
current_map_id = ($game_map.map_id rescue nil)
if @follower_map_id != current_map_id
clear_follow_points
reset_follower_position(true)
return
end
queue = follow_points
while !queue.empty? && queue[0][:map_id].to_i != current_map_id.to_i
queue.shift
end
while !queue.empty? && follower.pos?(queue[0][:x].to_i, queue[0][:y].to_i)
follower.set_direction(queue[0][:dir].to_i) if queue[0][:dir].to_i > 0
queue.shift
end
if !queue.empty?
move_follower_toward(queue[0][:x].to_i, queue[0][:y].to_i)
return
end
return if follower.moving?
sx = follower.distance_x_from($game_player.x)
sy = follower.distance_y_from($game_player.y)
if sx == 0 && sy == 0
bx = $game_map.round_x_with_direction($game_player.x, reverse_dir($game_player.direction))
by = $game_map.round_y_with_direction($game_player.y, reverse_dir($game_player.direction))
move_follower_toward(bx, by)
end
rescue
end
def self.cat_sprite_target?(character)
return false if character.nil?
return true if current_follow_enabled? && character.equal?(follower_character)
return true if !current_follow_enabled? && cat_event?(character)
false
rescue
false
end
def self.hidden_cat_event?(character)
current_follow_enabled? && cat_event?(character)
rescue
false
end
def self.trail_target?(character)
cat_sprite_target?(character) && active_effect_id == EFFECT_NYAN
rescue
false
end
def self.current_cat_event
return nil if $game_map.nil? || !$game_map.respond_to?(:events)
$game_map.events.values.find { |ev| cat_event?(ev) }
rescue
nil
end
def self.sync_home_event_visibility
event = current_cat_event
return if event.nil?
event.transparent = current_follow_enabled?
rescue
end
def self.map_tile_valid?(x, y)
return false if $game_map.nil? || x.nil? || y.nil?
return $game_map.valid?(x.to_i, y.to_i) if $game_map.respond_to?(:valid?)
true
rescue
false
end
def self.pick_spawn_tile_near_player
return nil unless $game_player && $game_map
px = $game_player.x.to_i
py = $game_player.y.to_i
d = $game_player.direction.to_i
left = [4, 2, 6, 8][[2, 4, 6, 8].index(d) || 0]
right = [6, 8, 4, 2][[2, 4, 6, 8].index(d) || 0]
back = reverse_dir(d)
candidates = []
[back, left, right, d].each do |dir|
cx = $game_map.round_x_with_direction(px, dir)
cy = $game_map.round_y_with_direction(py, dir)
candidates << [cx, cy, dir]
end
# Fallbacks for tricky transfers / border spawns.
candidates << [px - 1, py, 4]
candidates << [px + 1, py, 6]
candidates << [px, py - 1, 8]
candidates << [px, py + 1, 2]
seen = {}
candidates.each do |cx, cy, dir|
key = "#{cx},#{cy}"
next if seen[key]
seen[key] = true
next unless map_tile_valid?(cx, cy)
next if cx.to_i == px && cy.to_i == py
return [cx.to_i, cy.to_i, dir.to_i]
end
[px, py, back]
rescue
nil
end
def self.follower_lost?
follower = follower_character(false)
return true if follower.nil? || $game_player.nil? || $game_map.nil?
return true if @follower_map_id.to_i != ($game_map.map_id rescue -1).to_i
return true unless map_tile_valid?(follower.x, follower.y)
dist = follower.distance_x_from($game_player.x).abs + follower.distance_y_from($game_player.y).abs
dist >= 8
rescue
true
end
def self.reset_follower_position(force_same_direction = false)
return unless $game_player && $game_map
follower = follower_character
return if follower.nil?
clear_follow_points
spawn = pick_spawn_tile_near_player
px = $game_player.x
py = $game_player.y
d = $game_player.direction
bx = spawn ? spawn[0].to_i : px
by = spawn ? spawn[1].to_i : py
face_dir = if force_same_direction
d
elsif spawn && spawn[2]
reverse_dir(spawn[2].to_i)
else
reverse_dir(d)
end
follower.moveto(bx, by)
follower.set_direction(face_dir)
follower.move_speed = desired_follow_speed
follower.transparent = !current_follow_enabled?
follower.instance_variable_set(:@stop_count, 0) rescue nil
@follower_map_id = ($game_map.map_id rescue nil)
rescue
end
def self.on_player_move
return unless current_follow_enabled?
return unless $game_player && $game_map
if @follower_map_id != ($game_map.map_id rescue nil)
reset_follower_position(true)
end
record_player_step($game_player.x, $game_player.y, $game_player.direction, ($game_map.map_id rescue nil))
drive_follower
rescue
end
def self.player_can_trigger_follower?(player = nil)
return false unless current_follow_enabled?
return false if menu_busy?
player ||= $game_player
return false if player.nil? || $game_map.nil?
follower = follower_character(false)
return false if follower.nil? || follower.transparent
x = player.x
y = player.y
d = player.direction
x2 = $game_map.round_x_with_direction(x, d)
y2 = $game_map.round_y_with_direction(y, d)
follower.pos?(x, y) || follower.pos?(x2, y2)
rescue
false
end
def self.request_menu(target = nil)
return false if menu_busy?
return false if $game_map && $game_map.interpreter && $game_map.interpreter.running?
@menu_fiber = Fiber.new do
Game_Interpreter.new.noerhome_cat_main_menu(target)
end
update_menu_fiber
true
rescue
@menu_fiber = nil
false
end
def self.menu_busy?
!@menu_fiber.nil? && @menu_fiber.alive?
rescue
false
end
def self.update_menu_fiber
return if @menu_fiber.nil?
if @menu_fiber.alive?
@menu_fiber.resume
else
@menu_fiber = nil
end
rescue FiberError
@menu_fiber = nil
rescue
@menu_fiber = nil
end
def self.update_runtime
sync_home_event_visibility
follower = follower_character(false)
if current_follow_enabled?
follower = follower_character
drive_follower
if follower
follower.transparent = false
follower.update
end
elsif follower
follower.transparent = true
follower.update
end
sync_nyan_music
update_menu_fiber
rescue
end
def self.cat_event?(character)
return false unless character
begin
return false unless character.is_a?(Game_Event)
return false unless character.id.to_i == CAT_EVENT_ID
rpg_event = character.event
return false if rpg_event.nil?
current_page = character.page || (rpg_event.pages[0] rescue nil)
return false if current_page.nil?
graphic = current_page.graphic rescue nil
return false if graphic.nil?
return false unless graphic.character_name.to_s == CAT_CHARACTER_NAME
return false unless graphic.character_index.to_i == CAT_CHARACTER_INDEX
true
rescue
false
end
end
def self.nyan_js_path
base = $noerHomeFolder.to_s
base = "ModScripts/_Mods/NoerHome/" if base.to_s.strip == ""
File.join(base, "Scripts/NoerHomeCatEffect.js")
rescue
"ModScripts/_Mods/NoerHome/Scripts/NoerHomeCatEffect.js"
end
def self.duktape_available?
defined?(Duktape) &&
Duktape.respond_to?(:available?) &&
Duktape.respond_to?(:eval) &&
Duktape.available?
rescue
false
end
def self.init_nyan_js
return if @nyan_js_ready
return unless duktape_available?
path = nyan_js_path
return unless File.file?(path)
source = Ruby310Compat.read_text_file(path)
Duktape.eval(source)
@nyan_js_ready = true
@nyan_using_js = true
rescue
@nyan_using_js = false
end
def self.nyan_using_js?
init_nyan_js if @nyan_using_js.nil?
!!@nyan_using_js
end
def self.current_nyan_bucket
frame = (Graphics.frame_count rescue 0).to_i
((frame / NYAN_FRAME_STEP) % 6)
rescue
0
end
def self.build_bitmap_from_bgra(raw_bytes, width, height)
bmp = Bitmap.new(width, height)
if bmp.respond_to?(:set_data)
bmp.set_data(raw_bytes.pack("C*"))
return bmp
end
idx = 0
y = 0
while y < height
x = 0
while x < width
b = raw_bytes[idx] || 0
g = raw_bytes[idx + 1] || 0
r = raw_bytes[idx + 2] || 0
a = raw_bytes[idx + 3] || 0
bmp.set_pixel(x, y, Color.new(r, g, b, a))
idx += 4
x += 1
end
y += 1
end
bmp
rescue
bmp
end
def self.ruby_nyan_bgra(width, height, bucket, vertical = false)
colors = [
[255, 0, 0],
[255, 136, 0],
[255, 240, 0],
[48, 224, 48],
[48, 160, 255],
[96, 80, 255]
]
shift = bucket.to_i * 2
out = []
if vertical
stripe_w = [width / colors.length, 1].max
y = 0
while y < height
x = 0
while x < width
stripe = [x / stripe_w, colors.length - 1].min
rgb = colors[stripe]
notch_left = (((y + shift) / 4) % 3 == 1) && x == 0
notch_right = (((y + shift) / 6) % 4 == 0) && x == width - 1
if notch_left || notch_right
out << 0 << 0 << 0 << 0
else
out << rgb[2] << rgb[1] << rgb[0] << 255
end
x += 1
end
y += 1
end
else
stripe_h = [height / colors.length, 1].max
y = 0
while y < height
stripe = [y / stripe_h, colors.length - 1].min
rgb = colors[stripe]
x = 0
while x < width
notch_bottom = (((x + shift) / 4) % 3 == 1) && y == height - 1
notch_top = (((x + shift) / 6) % 4 == 0) && y == 0
if notch_bottom || notch_top
out << 0 << 0 << 0 << 0
else
out << rgb[2] << rgb[1] << rgb[0] << 255
end
x += 1
end
y += 1
end
end
out
rescue
[]
end
def self.nyan_bitmap(bucket = nil, axis = :horizontal)
@nyan_bitmap_cache ||= {}
bucket = current_nyan_bucket if bucket.nil?
bucket = bucket.to_i % 6
axis = axis.to_sym rescue :horizontal
axis = :vertical if axis == :v
axis = :horizontal if axis == :h
axis = :horizontal unless axis == :vertical
cache_key = [axis, bucket]
return @nyan_bitmap_cache[cache_key] if @nyan_bitmap_cache[cache_key]
vertical = (axis == :vertical)
width = vertical ? NYAN_BITMAP_WIDTH_V : NYAN_BITMAP_WIDTH
height = vertical ? NYAN_BITMAP_HEIGHT_V : NYAN_BITMAP_HEIGHT
raw_bytes = nil
if nyan_using_js?
begin
vertical_flag = vertical ? 1 : 0
raw = Duktape.eval("NoerHomeCatFX.exportNyanTrail(#{width},#{height},#{bucket},#{vertical_flag})")
parts = raw.to_s.split(",").map { |v| v.to_i }
raw_bytes = parts if parts.length >= width * height * 4
rescue
@nyan_using_js = false
end
end
raw_bytes = ruby_nyan_bgra(width, height, bucket, vertical) if raw_bytes.nil?
@nyan_bitmap_cache[cache_key] = build_bitmap_from_bgra(raw_bytes, width, height)
end
def self.world_px_to_screen_x(world_px)
return world_px.to_f if $game_map.nil?
$game_map.adjust_x((world_px.to_f - 16.0) / 32.0) * 32.0 + 16.0
rescue
world_px.to_f
end
def self.world_py_to_screen_y(world_py)
return world_py.to_f if $game_map.nil?
$game_map.adjust_y((world_py.to_f - 32.0) / 32.0) * 32.0 + 32.0
rescue
world_py.to_f
end
def self.copy_cat_visuals(source, target)
return false if source.nil? || target.nil?
begin
target.instance_variable_set(:@tile_id, source.tile_id.to_i)
rescue
target.instance_variable_set(:@tile_id, 0)
end
[
:character_name,
:character_index,
:manual_character_name,
:manual_character_index,
:manual_cw,
:manual_ch,
:opacity,
:blend_type,
:tone,
:charset_index,
:chs_type,
:chs_name,
:chs_name_h,
:chs_default_index
].each do |name|
begin
value = source.send(name)
value = value.clone rescue value
target.send("#{name}=", value)
rescue
end
end
begin
cfg = source.chs_configuration
copied = nil
if cfg.is_a?(Hash)
copied = {}
cfg.each { |k, v| copied[k] = (v.clone rescue v) }
end
target.chs_configuration = copied
rescue
begin
target.chs_configuration = nil
rescue
end
end
begin
target.instance_variable_set(:@chs_need_update, true)
rescue
end
true
rescue
false
end
end
class Game_NoerHomeCatFollower < Game_Character
def initialize
super
@priority_type = 1
@through = true
@move_speed = 4
@move_frequency = 6
@walk_anime = true
@step_anime = false
@direction = 2
@opacity = 255
@blend_type = 0
@transparent = true
@tone = Tone.new(0, 0, 0, 0)
@pattern = 1
@original_pattern = 1
@manual_character_index = NoerHomeCat::CAT_CHARACTER_INDEX
@character_index = NoerHomeCat::CAT_CHARACTER_INDEX
@character_name = NoerHomeCat::CAT_CHARACTER_NAME
setup_cat_graphic
end
def deleted?
false
end
def npc?
false
end
def is_actor?
false
end
def sex_mode?
false
end
def setup_cat_graphic
@tile_id = 0
@pattern = 1 if @pattern.nil? || @pattern >= 3
@original_pattern = 1
@character_name = NoerHomeCat::CAT_CHARACTER_NAME
begin
@chs_type = NoerHomeCat::CAT_CHARACTER_NAME
@charset_index = NoerHomeCat.cat_charset_index
create_chs_configuration(@charset_index) if @chs_configuration.nil? || !@chs_configuration.is_a?(Hash)
set_char_name(@chs_name.to_s == "" ? "NoerHomeLocalCat" : @chs_name)
@character_index = (chs_definition.chs_default_index[@charset_index] rescue NoerHomeCat::CAT_CHARACTER_INDEX)
@manual_character_index = @character_index
@manual_character_name = nil if instance_variable_defined?(:@manual_character_name)
rescue
@character_index = NoerHomeCat::CAT_CHARACTER_INDEX
@manual_character_index = NoerHomeCat::CAT_CHARACTER_INDEX
end
@chs_need_update = true
end
def adopt_visuals_from(event)
copied = NoerHomeCat.copy_cat_visuals(event, self)
if copied
@visual_sync_source = :event
@visual_signature = [
(event.character_name rescue nil),
(event.character_index rescue nil),
(event.respond_to?(:chs_name) ? event.chs_name : nil),
(event.respond_to?(:chs_default_index) ? event.chs_default_index : nil)
]
else
setup_cat_graphic
@visual_signature = nil
end
copied
rescue
setup_cat_graphic
@visual_signature = nil
false
end
def refresh_visuals
begin
event = NoerHomeCat.current_cat_event
current_signature = nil
if event
current_signature = [
(event.character_name rescue nil),
(event.character_index rescue nil),
(event.respond_to?(:chs_name) ? event.chs_name : nil),
(event.respond_to?(:chs_default_index) ? event.chs_default_index : nil)
]
end
adopt_visuals_from(event) if event && (@visual_signature != current_signature || @character_name.to_s == "")
rescue
end
setup_cat_graphic if @character_name.to_s == "" && @tile_id.to_i == 0
@move_speed = NoerHomeCat.desired_follow_speed
@move_frequency = 6
@walk_anime = true
@step_anime = false
@direction_fix = false
@priority_type = 1
@through = true
@opacity = 255
@blend_type = 0
@transparent = !NoerHomeCat.current_follow_enabled?
@chs_need_update = true if @character_name.to_s != ""
rescue
end
def chase_preceding_character(character)
return if character.nil?
refresh_visuals
unless moving?
sx = distance_x_from(character.x)
sy = distance_y_from(character.y)
if sx != 0 && sy != 0
move_diagonal(sx > 0 ? 4 : 6, sy > 0 ? 8 : 2)
elsif sx != 0
move_straight(sx > 0 ? 4 : 6)
elsif sy != 0
move_straight(sy > 0 ? 8 : 2)
end
end
rescue
end
def update
refresh_visuals
super
end
end
class Game_Interpreter
def noerhome_cat_pick_from_sheet(cmd_sheet, target = nil)
wait_for_message if respond_to?(:wait_for_message)
begin
$game_message.background = 0
$game_message.position = 2
rescue
end
begin
$game_message.choices.clear
rescue
end
begin
$game_temp.choice = nil
rescue
end
cmd_sheet.each do |row|
begin
$game_message.choices.push(row[0].to_s.gsub(",", " "))
rescue
end
end
begin
$game_message.choice_cancel_type = 100
$game_message.choice_proc = Proc.new { |n| }
Fiber.yield while $game_message.choice?
rescue
return false
end
picked = false
begin
index = $game_temp.choice
picked = (index.nil? || index.to_i < 0) ? false : cmd_sheet[index.to_i][1]
$game_temp.choice = -1
rescue
picked = false
end
picked
end
def noerhome_cat_pet
resource = $noer_home_config["noer_home"]["resourse_name"]
begin
SndLib.se_play("SE/CatSpot1", 90, 120)
rescue
end
begin
SndLib.sound_QuickDialog
rescue
end
call_msg("#{resource}:NoerHome:NoerHome/Cat")
begin
$game_player.actor.mood += 1
rescue
end
end
def noerhome_cat_change_color_menu(target = nil)
cmd_sheet = NoerHomeCat.color_menu_rows
cmd_sheet << [NoerHomeCat.text("CatMenu/Cancel", "Отмена"), "Cancel"]
picked = noerhome_cat_pick_from_sheet(cmd_sheet, target)
return false if !picked || picked == "Cancel"
NoerHomeCat.set_color(picked.to_i, true)
begin
SndLib.sound_QuickDialog
rescue
end
true
end
def noerhome_cat_effect_menu(target = nil)
unless NoerHomeCat.vip_available?
begin
SndLib.sys_buzzer
rescue
end
call_msg("#{NoerHomeCat.resource_name}:NoerHome:CatMenu/VipOnly")
return false
end
cmd_sheet = NoerHomeCat.effect_menu_rows
cmd_sheet << [NoerHomeCat.text("CatMenu/Cancel", "Отмена"), "Cancel"]
picked = noerhome_cat_pick_from_sheet(cmd_sheet, target)
return false if !picked || picked == "Cancel"
NoerHomeCat.set_effect(picked.to_i, true)
begin
SndLib.sound_QuickDialog
rescue
end
true
end
def noerhome_cat_music_menu(target = nil)
unless NoerHomeCat.vip_available?
begin
SndLib.sys_buzzer
rescue
end
call_msg("#{NoerHomeCat.resource_name}:NoerHome:CatMenu/VipOnly")
return false
end
cmd_sheet = NoerHomeCat.music_menu_rows
cmd_sheet << [NoerHomeCat.text("CatMenu/Cancel", "Отмена"), "Cancel"]
picked = noerhome_cat_pick_from_sheet(cmd_sheet, target)
return false if !picked || picked == "Cancel"
NoerHomeCat.set_music(picked.to_i, true)
begin
SndLib.sound_QuickDialog
rescue
end
true
end
def noerhome_cat_toggle_follow(target = nil)
enabled = NoerHomeCat.set_follow_enabled(!NoerHomeCat.current_follow_enabled?, true)
begin
SndLib.sound_QuickDialog
rescue
end
if enabled
call_msg("#{NoerHomeCat.resource_name}:NoerHome:CatMenu/FollowEnabled")
else
call_msg("#{NoerHomeCat.resource_name}:NoerHome:CatMenu/FollowDisabled")
end
true
end
def noerhome_cat_main_menu(target = nil)
target = get_character(0) if target.nil? && respond_to?(:get_character)
loop do
cmd_sheet = [
[NoerHomeCat.text("CatMenu/Pet", "Погладить"), "Pet"],
[NoerHomeCat.text("CatMenu/ChangeColor", "Поменять цвет"), "Color"],
[NoerHomeCat.text("CatMenu/Effects", "Эффекты"), "Effect"],
[NoerHomeCat.text("CatMenu/Music", "Музыка"), "Music"],
[NoerHomeCat.follow_menu_title, "Follow"],
[NoerHomeCat.text("CatMenu/Decor", "Обустройство дома"), "Decor"],
[NoerHomeCat.text("CatMenu/Cancel", "Отмена"), "Cancel"]
]
picked = noerhome_cat_pick_from_sheet(cmd_sheet, target)
case picked
when "Pet"
noerhome_cat_pet
break
when "Color"
changed = noerhome_cat_change_color_menu(target)
break unless changed
when "Effect"
changed = noerhome_cat_effect_menu(target)
break unless changed
when "Music"
changed = noerhome_cat_music_menu(target)
break unless changed
when "Follow"
changed = noerhome_cat_toggle_follow(target)
break unless changed
when "Decor"
changed = noerhome_decor_menu(target) if respond_to?(:noerhome_decor_menu)
break unless changed
else
break
end
end
end
end
if defined?(WebSocket)
module WebSocket
class << self
unless method_defined?(:noerhome_cat_parse_original)
alias noerhome_cat_parse_original parse
end
def parse(msg)
if msg.is_a?(String) && msg =~ /^cat_color:(-?\d+)$/
NoerHomeCat.set_color($1.to_i, false)
return
end
if msg.is_a?(String) && msg =~ /^cat_effect:(-?\d+)$/
NoerHomeCat.set_effect($1.to_i, false)
return
end
if msg.is_a?(String) && msg =~ /^cat_music:(-?\d+)$/
NoerHomeCat.set_music($1.to_i, false)
return
end
if msg.is_a?(String) && msg =~ /^cat_follow:(-?\d+)$/
NoerHomeCat.set_follow_enabled($1.to_i != 0, false)
return
end
noerhome_cat_parse_original(msg)
begin
if msg.is_a?(String) && msg =~ /^welcome:(\d+)$/
if respond_to?(:connected?) && connected?
send_line("cat_color:#{NoerHomeCat.current_color_id}")
send_line("cat_effect:#{NoerHomeCat.current_effect_id}")
send_line("cat_music:#{NoerHomeCat.active_music_id}")
send_line("cat_follow:#{NoerHomeCat.current_follow_enabled? ? 1 : 0}")
end
end
rescue
end
end
end
end
end
class Sprite_Character < Sprite_Base
unless method_defined?(:noerhome_cat_effects_update_without_trail)
alias noerhome_cat_effects_update_without_trail update
end
def update
noerhome_cat_effects_update_without_trail
begin
if NoerHomeCat.cat_sprite_target?(@character)
self.tone = NoerHomeCat.tone_for(NoerHomeCat.current_color_id)
@noerhome_cat_toned = true
elsif @noerhome_cat_toned
self.tone = Tone.new(0, 0, 0, 0)
@noerhome_cat_toned = false
end
rescue
end
begin
self.visible = false if NoerHomeCat.hidden_cat_event?(@character)
rescue
end
noerhome_cat_update_nyan_trail
end
unless method_defined?(:noerhome_cat_effects_dispose_without_trail)
alias noerhome_cat_effects_dispose_without_trail dispose
end
def dispose
noerhome_cat_dispose_nyan_trail
noerhome_cat_effects_dispose_without_trail
end
def noerhome_cat_trail_active?
NoerHomeCat.trail_target?(@character)
rescue
false
end
def noerhome_cat_spawn_trail_segment(world_x_px, world_y_px, axis)
@noerhome_cat_trail_segments ||= []
axis = axis.to_sym rescue :horizontal
axis = :vertical if axis == :v
axis = :horizontal if axis == :h
bitmap = NoerHomeCat.nyan_bitmap(nil, axis)
sprite = Sprite.new(self.viewport)
sprite.bitmap = bitmap
sprite.ox = bitmap.width / 2
sprite.oy = bitmap.height / 2
sprite.x = NoerHomeCat.world_px_to_screen_x(world_x_px)
sprite.y = NoerHomeCat.world_py_to_screen_y(world_y_px)
sprite.z = self.z - 1
sprite.opacity = 255
sprite.visible = self.visible
sprite.angle = 0
@noerhome_cat_trail_segments << {
:sprite => sprite,
:age => 0,
:life => NoerHomeCat::NYAN_TRAIL_LIFE,
:world_x_px => world_x_px.to_f,
:world_y_px => world_y_px.to_f,
:axis => axis
}
while @noerhome_cat_trail_segments.size > NoerHomeCat::NYAN_TRAIL_LIMIT
old = @noerhome_cat_trail_segments.shift
begin
old[:sprite].dispose if old && old[:sprite] && !old[:sprite].disposed?
rescue
end
end
rescue
end
def noerhome_cat_refresh_trail_segments
@noerhome_cat_trail_segments ||= []
i = 0
while i < @noerhome_cat_trail_segments.size
seg = @noerhome_cat_trail_segments[i]
sprite = seg[:sprite] rescue nil
if sprite.nil? || sprite.disposed?
@noerhome_cat_trail_segments.delete_at(i)
next
end
seg[:age] = seg[:age].to_i + 1
age = seg[:age].to_i
life = [seg[:life].to_i, 1].max
if age >= life
begin
sprite.dispose
rescue
end
@noerhome_cat_trail_segments.delete_at(i)
next
end
axis = (seg[:axis] || :horizontal)
bitmap = NoerHomeCat.nyan_bitmap(nil, axis)
if sprite.respond_to?(:bitmap=)
sprite.bitmap = bitmap
sprite.ox = bitmap.width / 2
sprite.oy = bitmap.height / 2
end
sprite.x = NoerHomeCat.world_px_to_screen_x(seg[:world_x_px])
sprite.y = NoerHomeCat.world_py_to_screen_y(seg[:world_y_px])
sprite.z = self.z - 1
sprite.visible = self.visible
sprite.angle = 0
sprite.opacity = [[255 - (255 * age / life), 0].max, 255].min
i += 1
end
rescue
noerhome_cat_clear_nyan_trail
end
def noerhome_cat_clear_nyan_trail
@noerhome_cat_trail_segments ||= []
@noerhome_cat_trail_segments.each do |seg|
begin
sprite = seg[:sprite]
sprite.dispose if sprite && !sprite.disposed?
rescue
end
end
@noerhome_cat_trail_segments.clear
rescue
@noerhome_cat_trail_segments = []
end
def noerhome_cat_dispose_nyan_trail
noerhome_cat_clear_nyan_trail
@noerhome_cat_trail_prev_real_x = nil
@noerhome_cat_trail_prev_real_y = nil
@noerhome_cat_trail_prev_map_id = nil
@noerhome_cat_trail_distance = 0.0
rescue
end
def noerhome_cat_reset_trail_state
@noerhome_cat_trail_prev_real_x = nil
@noerhome_cat_trail_prev_real_y = nil
@noerhome_cat_trail_prev_map_id = nil
@noerhome_cat_trail_distance = 0.0
rescue
end
def noerhome_cat_update_nyan_trail
unless noerhome_cat_trail_active?
noerhome_cat_clear_nyan_trail
noerhome_cat_reset_trail_state
return
end
rx = (@character.real_x rescue nil)
ry = (@character.real_y rescue nil)
map_id = ($game_map.map_id rescue nil)
if rx.nil? || ry.nil?
noerhome_cat_clear_nyan_trail
noerhome_cat_reset_trail_state
return
end
if !@noerhome_cat_trail_prev_map_id.nil? && @noerhome_cat_trail_prev_map_id.to_i != map_id.to_i
noerhome_cat_clear_nyan_trail
noerhome_cat_reset_trail_state
end
if !@noerhome_cat_trail_prev_real_x.nil? && !@noerhome_cat_trail_prev_real_y.nil?
real_dx = rx.to_f - @noerhome_cat_trail_prev_real_x.to_f
real_dy = ry.to_f - @noerhome_cat_trail_prev_real_y.to_f
moved = real_dx.abs > 0.001 || real_dy.abs > 0.001
if moved
pixel_dx = real_dx * 32.0
pixel_dy = real_dy * 32.0
dist = Math.sqrt(pixel_dx * pixel_dx + pixel_dy * pixel_dy)
@noerhome_cat_trail_distance = (@noerhome_cat_trail_distance || 0.0) + dist
dir_x = 0.0
dir_y = 0.0
axis = :horizontal
if real_dx.abs >= real_dy.abs && real_dx.abs > 0.0
dir_x = real_dx > 0 ? 1.0 : -1.0
axis = :horizontal
elsif real_dy.abs > 0.0
dir_y = real_dy > 0 ? 1.0 : -1.0
axis = :vertical
end
if @noerhome_cat_trail_distance >= NoerHomeCat::NYAN_TRAIL_GAP.to_f
body_x = @noerhome_cat_trail_prev_real_x.to_f * 32.0 + 16.0
body_y = @noerhome_cat_trail_prev_real_y.to_f * 32.0 + 32.0 + NoerHomeCat::NYAN_TRAIL_BODY_Y_OFFSET.to_f
spawn_x = body_x - dir_x * NoerHomeCat::NYAN_TRAIL_BACK_OFFSET.to_f
spawn_y = body_y - dir_y * NoerHomeCat::NYAN_TRAIL_BACK_OFFSET.to_f
noerhome_cat_spawn_trail_segment(spawn_x, spawn_y, axis)
@noerhome_cat_trail_distance = 0.0
end
else
@noerhome_cat_trail_distance = 0.0
end
end
@noerhome_cat_trail_prev_real_x = rx
@noerhome_cat_trail_prev_real_y = ry
@noerhome_cat_trail_prev_map_id = map_id
noerhome_cat_refresh_trail_segments
rescue
noerhome_cat_clear_nyan_trail
noerhome_cat_reset_trail_state
end
end
# ===== /NoerHome cat menu + color + effects =====
class Spriteset_Map
unless method_defined?(:noerhome_cat_create_characters_without_follower)
alias noerhome_cat_create_characters_without_follower create_characters
end
def create_characters
noerhome_cat_create_characters_without_follower
begin
follower = NoerHomeCat.follower_character
@character_sprites.push(Sprite_Character.new(@viewport1, follower)) if follower
rescue
end
end
end
class Scene_Map < Scene_Base
unless method_defined?(:noerhome_cat_music_terminate_without_hook)
alias noerhome_cat_music_terminate_without_hook terminate
end
def terminate
NoerHomeCat.stop_nyan_music(true)
noerhome_cat_music_terminate_without_hook
end
end
class Game_Player
unless method_defined?(:noerhome_cat_follow_update_without_runtime)
alias noerhome_cat_follow_update_without_runtime update
end
def update
noerhome_cat_follow_update_without_runtime
NoerHomeCat.update_runtime
end
unless method_defined?(:noerhome_cat_follow_move_straight_without_hook)
alias noerhome_cat_follow_move_straight_without_hook move_straight
end
def move_straight(d, turn_ok = true)
NoerHomeCat.on_player_move if passable?(@x, @y, d)
noerhome_cat_follow_move_straight_without_hook(d, turn_ok)
end
unless method_defined?(:noerhome_cat_follow_move_diagonal_without_hook)
alias noerhome_cat_follow_move_diagonal_without_hook move_diagonal
end
def move_diagonal(horz, vert)
NoerHomeCat.on_player_move if diagonal_passable?(@x, @y, horz, vert)
noerhome_cat_follow_move_diagonal_without_hook(horz, vert)
end
unless method_defined?(:noerhome_cat_follow_perform_transfer_without_hook)
alias noerhome_cat_follow_perform_transfer_without_hook perform_transfer
end
def perform_transfer
noerhome_cat_follow_perform_transfer_without_hook
NoerHomeCat.clear_follow_points
NoerHomeCat.reset_follower_position(true)
end
unless method_defined?(:noerhome_cat_follow_check_action_event_without_hook)
alias noerhome_cat_follow_check_action_event_without_hook check_action_event
end
def check_action_event(chkItemsPick=false)
if NoerHomeCat.player_can_trigger_follower?(self)
return true if NoerHomeCat.request_menu(NoerHomeCat.follower_character)
end
noerhome_cat_follow_check_action_event_without_hook(chkItemsPick)
end
end
# ===== NoerHome networked cat sync patch =====
module NoerHomeCat
NET_STATE_COLOR_KEY = "NHCatColor"
NET_STATE_EFFECT_KEY = "NHCatEffect"
NET_STATE_FOLLOW_KEY = "NHCatFollow"
NET_STATE_MUSIC_KEY = "NHCatMusic"
REMOTE_CAT_EVENT_ID_OFFSET = 500000
def self.frame_count_safe
Graphics.frame_count rescue 0
end
def self.local_music_id
active_music_id
rescue
0
end
def self.local_cat_state
{
:pid => 0,
:color_id => current_color_id.to_i,
:effect_id => active_effect_id.to_i,
:follow_enabled => current_follow_enabled? ? true : false,
:music_id => local_music_id.to_i,
:updated_at => frame_count_safe
}
rescue
{
:pid => 0,
:color_id => 0,
:effect_id => 0,
:follow_enabled => false,
:music_id => 0,
:updated_at => frame_count_safe
}
end
def self.unpack_stat_pack(raw)
return {} if raw.nil?
if defined?(WebSocket) && WebSocket.respond_to?(:_ps_unpack_kv)
begin
data = WebSocket._ps_unpack_kv(raw.to_s)
return data if data.is_a?(Hash)
rescue
end
end
out = {}
raw.to_s.split("|").each do |pair|
next if pair.nil? || pair == ""
k, v = pair.split("=", 2)
next if k.nil? || k.to_s == ""
out[k.to_s] = v
end
out
rescue
{}
end
def self.pack_stat_pack(hash)
h = hash.is_a?(Hash) ? hash : {}
if defined?(WebSocket) && WebSocket.respond_to?(:_ps_pack_kv)
begin
return WebSocket._ps_pack_kv(h)
rescue
end
end
h.map { |k, v| "#{k}=#{v}" }.join("|")
rescue
""
end
def self.append_cat_state_to_stat_pack(stat_pack)
data = unpack_stat_pack(stat_pack)
data[NET_STATE_COLOR_KEY] = current_color_id.to_i
data[NET_STATE_EFFECT_KEY] = active_effect_id.to_i
data[NET_STATE_FOLLOW_KEY] = current_follow_enabled? ? 1 : 0
data[NET_STATE_MUSIC_KEY] = local_music_id.to_i
pack_stat_pack(data)
rescue
stat_pack.to_s
end
def self.default_remote_state(pid = 0)
{
:pid => pid.to_i,
:color_id => 0,
:effect_id => 0,
:follow_enabled => false,
:music_id => 0,
:updated_at => frame_count_safe
}
end
def self.extract_remote_state_from_stat_pack(pid, stat_pack)
data = unpack_stat_pack(stat_pack)
state = default_remote_state(pid)
color_id = (data[NET_STATE_COLOR_KEY] || data[NET_STATE_COLOR_KEY.to_sym] || 0).to_i
effect_id = (data[NET_STATE_EFFECT_KEY] || data[NET_STATE_EFFECT_KEY.to_sym] || 0).to_i
follow_raw = (data[NET_STATE_FOLLOW_KEY] || data[NET_STATE_FOLLOW_KEY.to_sym] || 0)
music_id = (data[NET_STATE_MUSIC_KEY] || data[NET_STATE_MUSIC_KEY.to_sym] || 0).to_i
state[:color_id] = valid_color_id?(color_id) ? color_id : 0
state[:effect_id] = valid_effect_id?(effect_id) ? effect_id : 0
state[:follow_enabled] = (follow_raw.to_i != 0)
state[:music_id] = valid_music_id?(music_id) ? music_id.to_i : 0
state[:updated_at] = frame_count_safe
state
rescue
default_remote_state(pid)
end
def self.remote_cat_states
@remote_cat_states ||= {}
rescue
@remote_cat_states = {}
end
def self.remote_state(pid)
pid = pid.to_i
remote_cat_states[pid] ||= default_remote_state(pid)
rescue
default_remote_state(pid)
end
def self.clear_remote_follow_points(pid)
@remote_follow_points ||= {}
@remote_follow_points[pid.to_i] = []
rescue
end
def self.remote_follow_queue(pid)
@remote_follow_points ||= {}
@remote_follow_points[pid.to_i] ||= []
rescue
@remote_follow_points = {}
@remote_follow_points[pid.to_i] = []
end
def self.remote_player_last_tiles
@remote_player_last_tiles ||= {}
rescue
@remote_player_last_tiles = {}
end
def self.remote_cat_followers
@remote_cat_followers ||= {}
rescue
@remote_cat_followers = {}
end
def self.remote_player_registry
return {} unless defined?(WebSocket)
players = WebSocket.instance_variable_get(:@players) rescue nil
players.is_a?(Hash) ? players : {}
rescue
{}
end
def self.remote_player(pid)
remote_player_registry[pid.to_i]
rescue
nil
end
def self.remote_cat_follower(pid, create = true)
pid = pid.to_i
cat = remote_cat_followers[pid]
if cat.nil? && create
cat = Game_NoerHomeRemoteCatFollower.new(pid)
remote_cat_followers[pid] = cat
end
if cat && cat.respond_to?(:refresh_visuals)
cat.refresh_visuals
end
cat
rescue
nil
end
def self.drop_remote_player_state(pid)
pid = pid.to_i
remote_cat_states.delete(pid) if remote_cat_states
remote_player_last_tiles.delete(pid) if remote_player_last_tiles
@remote_follow_points.delete(pid) if @remote_follow_points
remote_cat_followers.delete(pid) if remote_cat_followers
rescue
end
def self.apply_remote_state_from_stat_pack(pid, stat_pack)
pid = pid.to_i
return if pid <= 0
old_state = remote_state(pid)
new_state = extract_remote_state_from_stat_pack(pid, stat_pack)
remote_cat_states[pid] = new_state
if !old_state[:follow_enabled] && new_state[:follow_enabled]
clear_remote_follow_points(pid)
remote_player_last_tiles.delete(pid) if remote_player_last_tiles
reset_remote_follower_position(pid, true)
elsif old_state[:follow_enabled] && !new_state[:follow_enabled]
clear_remote_follow_points(pid)
follower = remote_cat_follower(pid, false)
follower.transparent = true if follower
end
follower = remote_cat_follower(pid, false)
follower.refresh_visuals if follower && follower.respond_to?(:refresh_visuals)
true
rescue
false
end
def self.push_state_over_playersync(reason = "noerhome_cat")
return false unless defined?(WebSocket)
return false unless WebSocket.respond_to?(:connected?) && WebSocket.connected?
return false unless WebSocket.respond_to?(:send_playersync_full)
WebSocket.send_playersync_full(reason.to_s, true)
true
rescue
false
end
def self.set_color(id, send_server = true)
id = valid_color_id?(id) ? id.to_i : 0
$game_system.noerhome_cat_color_id = id if $game_system
write_persisted_state(id, current_effect_id, current_follow_enabled? ? 1 : 0, current_music_id)
push_state_over_playersync("noerhome_cat_color") if send_server
id
end
def self.set_effect(id, send_server = true)
id = valid_effect_id?(id) ? id.to_i : 0
id = 0 if send_server && id != 0 && !vip_available?
$game_system.noerhome_cat_effect_id = id if $game_system
write_persisted_state(current_color_id, id, current_follow_enabled? ? 1 : 0, current_music_id)
push_state_over_playersync("noerhome_cat_effect") if send_server
id
end
def self.set_music(id, send_server = true)
id = valid_music_id?(id) ? id.to_i : 0
id = 0 if send_server && id != 0 && !vip_available?
$game_system.noerhome_cat_music_id = id if $game_system
write_persisted_state(current_color_id, current_effect_id, current_follow_enabled? ? 1 : 0, id)
sync_nyan_music
push_state_over_playersync("noerhome_cat_music") if send_server
id
end
def self.set_follow_enabled(flag, send_server = true)
enabled = flag ? true : false
$game_system.noerhome_cat_follow_enabled = enabled if $game_system
write_persisted_state(current_color_id, current_effect_id, enabled ? 1 : 0, current_music_id)
begin
if enabled
clear_follow_points
reset_follower_position(true)
else
clear_follow_points
follower = follower_character(false)
follower.transparent = true if follower
end
rescue
end
sync_nyan_music
push_state_over_playersync("noerhome_cat_follow") if send_server
enabled
end
def self.remote_cat_character?(character)
character.is_a?(Game_NoerHomeRemoteCatFollower) rescue false
end
def self.character_state(character)
return nil if character.nil?
if remote_cat_character?(character)
pid = character.noerhome_owner_pid.to_i rescue 0
return remote_state(pid)
end
return local_cat_state if current_follow_enabled? && character.equal?(follower_character(false))
return local_cat_state if !current_follow_enabled? && cat_event?(character)
nil
rescue
nil
end
def self.color_id_for_character(character)
state = character_state(character)
state ? state[:color_id].to_i : 0
rescue
0
end
def self.effect_id_for_character(character)
state = character_state(character)
state ? state[:effect_id].to_i : 0
rescue
0
end
def self.cat_sprite_target?(character)
!character_state(character).nil?
rescue
false
end
def self.hidden_cat_event?(character)
return false if remote_cat_character?(character)
current_follow_enabled? && cat_event?(character)
rescue
false
end
def self.trail_target?(character)
effect_id_for_character(character).to_i == EFFECT_NYAN
rescue
false
end
def self.pick_spawn_tile_near_character(character)
return nil if character.nil? || $game_map.nil?
px = character.x.to_i
py = character.y.to_i
d = (character.direction rescue 2).to_i
dirs = [2, 4, 6, 8]
d = 2 unless dirs.include?(d)
idx = dirs.index(d) || 0
left = [4, 2, 6, 8][idx]
right = [6, 8, 4, 2][idx]
back = reverse_dir(d)
candidates = []
[back, left, right, d].each do |dir|
cx = $game_map.round_x_with_direction(px, dir)
cy = $game_map.round_y_with_direction(py, dir)
candidates << [cx, cy, dir]
end
candidates << [px - 1, py, 4]
candidates << [px + 1, py, 6]
candidates << [px, py - 1, 8]
candidates << [px, py + 1, 2]
seen = {}
candidates.each do |cx, cy, dir|
key = "#{cx},#{cy}"
next if seen[key]
seen[key] = true
next unless map_tile_valid?(cx, cy)
next if cx.to_i == px && cy.to_i == py
return [cx.to_i, cy.to_i, dir.to_i]
end
[px, py, back]
rescue
nil
end
def self.follow_speed_for(owner, follower, backlog = 0)
owner_speed = (owner.real_move_speed rescue (owner.move_speed rescue 4)).to_i
owner_speed = 4 if owner_speed <= 0
distance = 0
if follower && owner
distance = follower.distance_x_from(owner.x).abs + follower.distance_y_from(owner.y).abs
end
pressure = [distance.to_i, backlog.to_i].max
near_speed = [[owner_speed - 1, 3].max, 5].min
mid_speed = [[owner_speed, near_speed].max, 5].min
far_speed = [[owner_speed + 1, mid_speed].max, 6].min
if pressure >= 6
far_speed
elsif pressure >= 3
mid_speed
else
near_speed
end
rescue
4
end
def self.move_character_toward(character, tx, ty, speed = nil)
return false if character.nil? || tx.nil? || ty.nil?
return false if character.moving?
character.move_speed = speed.to_i if !speed.nil? && character.respond_to?(:move_speed=)
sx = character.distance_x_from(tx.to_i)
sy = character.distance_y_from(ty.to_i)
return true if sx == 0 && sy == 0
if sx != 0 && sy != 0
character.move_diagonal(sx > 0 ? 4 : 6, sy > 0 ? 8 : 2)
elsif sx != 0
character.move_straight(sx > 0 ? 4 : 6)
elsif sy != 0
character.move_straight(sy > 0 ? 8 : 2)
end
true
rescue
false
end
def self.reset_remote_follower_position(pid, force_same_direction = false)
pid = pid.to_i
owner = remote_player(pid)
follower = remote_cat_follower(pid, true)
return if owner.nil? || follower.nil? || $game_map.nil?
spawn = pick_spawn_tile_near_character(owner)
if spawn
follower.moveto(spawn[0], spawn[1])
follower.set_direction(force_same_direction ? (owner.direction rescue spawn[2]).to_i : spawn[2].to_i)
else
follower.moveto(owner.x.to_i, owner.y.to_i)
follower.set_direction((owner.direction rescue 2).to_i)
end
follower.instance_variable_set(:@real_x, follower.x.to_f) rescue nil
follower.instance_variable_set(:@real_y, follower.y.to_f) rescue nil
follower.transparent = false
@remote_cat_follower_map_ids ||= {}
@remote_cat_follower_map_ids[pid] = ($game_map.map_id rescue nil)
remote_player_last_tiles[pid] = {
:x => owner.x.to_i,
:y => owner.y.to_i,
:dir => (owner.direction rescue 2).to_i,
:map_id => ($game_map.map_id rescue nil)
}
clear_remote_follow_points(pid)
follower
rescue
nil
end
def self.remote_follower_lost?(pid, follower, owner)
return true if follower.nil? || owner.nil? || $game_map.nil?
@remote_cat_follower_map_ids ||= {}
return true if @remote_cat_follower_map_ids[pid.to_i].to_i != ($game_map.map_id rescue -1).to_i
return true unless map_tile_valid?(follower.x, follower.y)
dist = follower.distance_x_from(owner.x).abs + follower.distance_y_from(owner.y).abs
dist >= 10
rescue
true
end
def self.scan_remote_player_positions
remote_player_registry.each do |pid, owner|
next if owner.nil?
state = remote_state(pid)
next unless state[:follow_enabled]
current = {
:x => owner.x.to_i,
:y => owner.y.to_i,
:dir => (owner.direction rescue 2).to_i,
:map_id => ($game_map.map_id rescue nil)
}
last = remote_player_last_tiles[pid.to_i]
if last.nil? || last[:map_id].to_i != current[:map_id].to_i
reset_remote_follower_position(pid, true)
remote_player_last_tiles[pid.to_i] = current
next
end
if last[:x].to_i != current[:x].to_i || last[:y].to_i != current[:y].to_i
queue = remote_follow_queue(pid)
tail = queue[-1]
unless tail && tail[:x].to_i == current[:x].to_i && tail[:y].to_i == current[:y].to_i
queue << current
end
remote_player_last_tiles[pid.to_i] = current
end
end
rescue
end
def self.drive_remote_follower(pid)
pid = pid.to_i
state = remote_state(pid)
owner = remote_player(pid)
follower = remote_cat_follower(pid, state[:follow_enabled])
if owner.nil? || follower.nil? || !state[:follow_enabled]
follower.transparent = true if follower
return
end
follower.refresh_visuals if follower.respond_to?(:refresh_visuals)
follower.transparent = false
if remote_follower_lost?(pid, follower, owner)
reset_remote_follower_position(pid, true)
return
end
queue = remote_follow_queue(pid)
while !queue.empty? && follower.x.to_i == queue[0][:x].to_i && follower.y.to_i == queue[0][:y].to_i
follower.set_direction(queue[0][:dir].to_i) if queue[0][:dir].to_i > 0
queue.shift
end
if !queue.empty?
move_character_toward(follower, queue[0][:x].to_i, queue[0][:y].to_i, follow_speed_for(owner, follower, queue.size))
elsif !follower.moving?
bx = $game_map.round_x_with_direction(owner.x, reverse_dir(owner.direction))
by = $game_map.round_y_with_direction(owner.y, reverse_dir(owner.direction))
move_character_toward(follower, bx, by, follow_speed_for(owner, follower, 0))
end
follower.update
rescue
end
def self.cleanup_remote_followers
valid_pids = remote_player_registry.keys.map { |pid| pid.to_i }
remote_cat_followers.keys.each do |pid|
next if valid_pids.include?(pid.to_i) && remote_state(pid)[:follow_enabled]
remote_cat_followers.delete(pid)
remote_player_last_tiles.delete(pid) if remote_player_last_tiles
@remote_follow_points.delete(pid) if @remote_follow_points
@remote_cat_follower_map_ids.delete(pid) if @remote_cat_follower_map_ids
end
remote_cat_states.keys.each do |pid|
next if valid_pids.include?(pid.to_i)
remote_cat_states.delete(pid)
end
rescue
end
def self.renderable_remote_cat_followers
cleanup_remote_followers
list = []
remote_cat_followers.each do |pid, follower|
next if follower.nil?
next unless remote_state(pid)[:follow_enabled]
next if remote_player(pid).nil?
list << follower
end
list
rescue
[]
end
def self.remote_audio_candidates
out = []
renderable_remote_cat_followers.each do |follower|
state = character_state(follower)
next if state.nil?
next if state[:music_id].to_i <= 0
out << { :character => follower, :state => state }
end
out
rescue
[]
end
def self.active_cat_audio_candidates
list = []
begin
local_target = current_follow_enabled? ? follower_character(false) : current_cat_event
local_state = local_cat_state
if local_target && local_state[:music_id].to_i > 0
list << { :character => local_target, :state => local_state }
end
rescue
end
begin
list.concat(remote_audio_candidates)
rescue
end
list
rescue
[]
end
def self.distance_to_character_tiles(character)
player = $game_player
return 999 if player.nil? || character.nil?
dx = if character.respond_to?(:distance_x_from)
character.distance_x_from(player.x).abs
else
(character.x.to_i - player.x.to_i).abs
end
dy = if character.respond_to?(:distance_y_from)
character.distance_y_from(player.y).abs
else
(character.y.to_i - player.y.to_i).abs
end
dx.to_i + dy.to_i
rescue
999
end
def self.active_cat_audio_target
best = nil
best_distance = nil
active_cat_audio_candidates.each do |entry|
distance = distance_to_character_tiles(entry[:character])
if best.nil? || distance < best_distance.to_i
best = entry
best_distance = distance
end
end
best
rescue
nil
end
def self.nyan_distance_tiles(target = nil)
target_character = target
if target_character.nil?
entry = active_cat_audio_target
target_character = entry[:character] if entry
end
distance_to_character_tiles(target_character)
rescue
8
end
def self.nyan_mix_levels(target = nil)
distance = [nyan_distance_tiles(target).to_i, 0].max
if distance <= 1
effect_percent = 100
game_percent = 0
elsif distance <= 3
effect_percent = 75
game_percent = 25
elsif distance <= 5
effect_percent = 50
game_percent = 50
elsif distance <= 7
effect_percent = 25
game_percent = 75
else
effect_percent = 0
game_percent = 100
end
{
:distance => distance,
:effect_percent => effect_percent,
:game_percent => game_percent
}
rescue
{
:distance => 8,
:effect_percent => 0,
:game_percent => 100
}
end
def self.music_track_info_for_music_id(music_id)
entry = music_entry_for_id(music_id)
return nil if entry.nil?
path = music_track_path(entry)
return nil if path.nil? || path.to_s.strip == ""
{
:id => entry[:id].to_i,
:title => entry[:title].to_s,
:path => path.to_s,
:volume => [[entry[:volume].to_i, 0].max, 100].min,
:pitch => [[entry[:pitch].to_i, 50].max, 150].min
}
rescue
nil
end
def self.nyan_music_path_for_music_id(music_id)
info = music_track_info_for_music_id(music_id)
info ? info[:path].to_s : nil
rescue
nil
end
def self.nyan_music_desired?
entry = active_cat_audio_target
return false if entry.nil?
track_info = music_track_info_for_music_id(entry[:state][:music_id])
return false if track_info.nil?
path = track_info[:path].to_s
return false if path.to_s.strip == ""
return false unless defined?(Scene_Map)
return false unless defined?(SceneManager) && SceneManager.respond_to?(:scene_is?)
return false unless SceneManager.scene_is?(Scene_Map)
File.file?(path)
rescue
false
end
def self.apply_nyan_bgs_mix(percent, restart = false, track_info = nil)
percent = [[percent.to_i, 0].max, 100].min
track_info = music_track_info_for_music_id(active_music_id) if track_info.nil?
return false if track_info.nil?
path = track_info[:path].to_s
return false if path.to_s.strip == "" || !File.file?(path)
map_id = ($game_map.map_id rescue nil)
pos = 0
if @nyan_music_playing && !restart
pos = ((Audio.bgs_pos rescue nil) || @nyan_music_last_bgs_pos || 0).to_i
end
signature = [map_id.to_i, percent, ($data_SNDvol rescue 100).to_i, path.to_s, track_info[:volume].to_i, track_info[:pitch].to_i]
if !restart && @nyan_music_last_bgs_signature == signature
return true
end
@nyan_music_last_bgs_signature = signature
@nyan_music_last_bgs_pos = pos
calculateVOL = (track_info[:volume].to_i * (percent * 0.01) * (($data_SNDvol rescue 100) * 0.01)).to_i
Audio.bgs_play(path, calculateVOL, track_info[:pitch].to_i, pos)
@nyan_music_playing = true
@nyan_music_map_id = map_id
@nyan_music_track_path = path.to_s
@nyan_music_track_id = track_info[:id].to_i
true
rescue
false
end
def self.start_nyan_music
entry = active_cat_audio_target
return false if entry.nil?
track_info = music_track_info_for_music_id(entry[:state][:music_id])
return false if track_info.nil?
path = track_info[:path].to_s
return false if path.nil? || !File.file?(path)
map_id = ($game_map.map_id rescue nil)
return true if @nyan_music_playing && @nyan_music_map_id.to_i == map_id.to_i && @nyan_music_track_path.to_s == path.to_s
@nyan_music_prev_bgs = capture_bgs_state if @nyan_music_prev_bgs.nil?
@nyan_music_playing = false
@nyan_music_last_bgs_signature = nil
@nyan_music_last_bgm_signature = nil
@nyan_music_last_bgm_percent = nil
@nyan_music_track_path = path.to_s
@nyan_music_track_id = track_info[:id].to_i
mix = nyan_mix_levels(entry[:character])
apply_nyan_bgs_mix(mix[:effect_percent].to_i, true, track_info)
apply_nyan_bgm_mix(mix[:game_percent].to_i, true)
true
rescue
@nyan_music_playing = false
false
end
def self.sync_nyan_music
entry = active_cat_audio_target
desired = !entry.nil? && nyan_music_desired?
if desired
current_map_id = ($game_map.map_id rescue nil)
track_info = music_track_info_for_music_id(entry[:state][:music_id])
path = track_info ? track_info[:path].to_s : nil
if @nyan_music_playing && (@nyan_music_map_id.to_i != current_map_id.to_i || @nyan_music_track_path.to_s != path.to_s)
stop_nyan_music(true)
end
start_nyan_music unless @nyan_music_playing
mix = nyan_mix_levels(entry[:character])
apply_nyan_bgs_mix(mix[:effect_percent].to_i, false, track_info)
apply_nyan_bgm_mix(mix[:game_percent].to_i)
elsif @nyan_music_playing || !@nyan_music_prev_bgs.nil?
stop_nyan_music(true)
end
rescue
end
def self.update_runtime
sync_home_event_visibility
follower = follower_character(false)
if current_follow_enabled?
follower = follower_character
drive_follower
if follower
follower.transparent = false
follower.update
end
elsif follower
follower.transparent = true
follower.update
end
scan_remote_player_positions
renderable_remote_cat_followers.each do |remote_cat|
next if remote_cat.nil?
pid = remote_cat.noerhome_owner_pid.to_i rescue 0
drive_remote_follower(pid)
end
sync_nyan_music
update_menu_fiber
rescue
end
end
class Game_NoerHomeRemoteCatFollower < Game_Character
attr_reader :noerhome_owner_pid
def initialize(pid)
super()
@noerhome_owner_pid = pid.to_i
@priority_type = 1
@through = true
@move_speed = 4
@move_frequency = 6
@walk_anime = true
@step_anime = false
@direction = 2
@direction_fix = false
@opacity = 255
@blend_type = 0
@transparent = true
@tone = Tone.new(0, 0, 0, 0)
@pattern = 1
@original_pattern = 1
@stop_count = 0
force_cat_visual_state
end
def deleted?
false
end
def npc?
false
end
def is_actor?
false
end
def sex_mode?
false
end
def use_chs?
!@chs_configuration.nil?
rescue
false
end
def force_cat_visual_state
@net_actor = nil
@net_player_id = nil
@tile_id = 0
@pattern = 1
@original_pattern = 1
@character_name = NoerHomeCat::CAT_CHARACTER_NAME
begin
@chs_type = NoerHomeCat::CAT_CHARACTER_NAME
@charset_index = NoerHomeCat.cat_charset_index
create_chs_configuration(@charset_index) if @chs_configuration.nil? || !@chs_configuration.is_a?(Hash)
set_char_name("NoerHomeRemoteCat_#{@noerhome_owner_pid}")
@character_index = (chs_definition.chs_default_index[@charset_index] rescue NoerHomeCat::CAT_CHARACTER_INDEX)
@manual_character_index = @character_index if instance_variable_defined?(:@manual_character_index)
@manual_character_name = nil if instance_variable_defined?(:@manual_character_name)
@chs_default_index = @character_index
rescue
@chs_type = nil
@charset_index = NoerHomeCat::CAT_CHARACTER_INDEX
@character_index = NoerHomeCat::CAT_CHARACTER_INDEX
@manual_character_index = NoerHomeCat::CAT_CHARACTER_INDEX if instance_variable_defined?(:@manual_character_index)
@manual_character_name = NoerHomeCat::CAT_CHARACTER_NAME if instance_variable_defined?(:@manual_character_name)
@chs_configuration = nil
@chs_name = nil
@chs_name_h = nil
end
@single_chs = false if instance_variable_defined?(:@single_chs)
@move_type = 0 if instance_variable_defined?(:@move_type)
@move_speed = 4
@move_frequency = 6
@walk_anime = true
@step_anime = false
@direction_fix = false
@priority_type = 1
@through = true
@opacity = 255
@blend_type = 0
@trigger = 0 if instance_variable_defined?(:@trigger)
@list = nil
@event_name = "NoerHomeRemoteCat"
@chs_need_update = true
rescue
end
def refresh_visuals
force_cat_visual_state
state = NoerHomeCat.remote_state(@noerhome_owner_pid)
@transparent = !state[:follow_enabled]
rescue
end
def update
refresh_visuals
super
rescue
end
end
if defined?(WebSocket)
module WebSocket
class << self
if method_defined?(:_ps_extract_stat_pack) && !method_defined?(:noerhome_cat_extract_stat_pack_original)
alias noerhome_cat_extract_stat_pack_original _ps_extract_stat_pack
end
def _ps_extract_stat_pack(actor, chs_type, charset_index)
packed = noerhome_cat_extract_stat_pack_original(actor, chs_type, charset_index)
NoerHomeCat.append_cat_state_to_stat_pack(packed)
rescue
noerhome_cat_extract_stat_pack_original(actor, chs_type, charset_index)
end
if method_defined?(:apply_playersync) && !method_defined?(:noerhome_cat_apply_playersync_original)
alias noerhome_cat_apply_playersync_original apply_playersync
end
def apply_playersync(pid, actor_id, level, skills_csv, chs_type, charset_index, chs_name, chs_name_h, stat_pack)
noerhome_cat_apply_playersync_original(pid, actor_id, level, skills_csv, chs_type, charset_index, chs_name, chs_name_h, stat_pack)
NoerHomeCat.apply_remote_state_from_stat_pack(pid, stat_pack)
rescue
noerhome_cat_apply_playersync_original(pid, actor_id, level, skills_csv, chs_type, charset_index, chs_name, chs_name_h, stat_pack)
end
if method_defined?(:remove_remote_player) && !method_defined?(:noerhome_cat_remove_remote_player_original)
alias noerhome_cat_remove_remote_player_original remove_remote_player
end
def remove_remote_player(id)
NoerHomeCat.drop_remote_player_state(id)
noerhome_cat_remove_remote_player_original(id)
rescue
noerhome_cat_remove_remote_player_original(id)
end
if method_defined?(:parse) && !method_defined?(:noerhome_cat_ignore_legacy_parse_original)
alias noerhome_cat_ignore_legacy_parse_original parse
end
def parse(msg)
return if msg.is_a?(String) && msg =~ /^cat_(?:color|effect|follow):/
noerhome_cat_ignore_legacy_parse_original(msg)
end
end
end
end
class Sprite_Character < Sprite_Base
def update
noerhome_cat_effects_update_without_trail
begin
if NoerHomeCat.cat_sprite_target?(@character)
self.tone = NoerHomeCat.tone_for(NoerHomeCat.color_id_for_character(@character))
@noerhome_cat_toned = true
elsif @noerhome_cat_toned
self.tone = Tone.new(0, 0, 0, 0)
@noerhome_cat_toned = false
end
rescue
end
begin
self.visible = false if NoerHomeCat.hidden_cat_event?(@character)
rescue
end
noerhome_cat_update_nyan_trail
end
def noerhome_cat_trail_active?
NoerHomeCat.trail_target?(@character)
rescue
false
end
end
class Spriteset_Map
unless method_defined?(:noerhome_cat_remote_sprite_update_without_sync)
alias noerhome_cat_remote_sprite_update_without_sync update
end
unless method_defined?(:noerhome_cat_remote_sprite_dispose_without_sync)
alias noerhome_cat_remote_sprite_dispose_without_sync dispose
end
def noerhome_cat_sync_remote_character_sprites
@noerhome_cat_remote_sprites ||= {}
desired = {}
NoerHomeCat.renderable_remote_cat_followers.each do |character|
next if character.nil?
key = character.object_id
desired[key] = character
next if @noerhome_cat_remote_sprites[key]
sprite = Sprite_Character.new(@viewport1, character)
@character_sprites.push(sprite) if @character_sprites
@noerhome_cat_remote_sprites[key] = sprite
end
(@noerhome_cat_remote_sprites.keys - desired.keys).each do |key|
sprite = @noerhome_cat_remote_sprites.delete(key)
begin
@character_sprites.delete(sprite) if @character_sprites
rescue
end
begin
sprite.dispose if sprite && !sprite.disposed?
rescue
end
end
rescue
end
def update
noerhome_cat_remote_sprite_update_without_sync
noerhome_cat_sync_remote_character_sprites
end
def dispose
begin
if @noerhome_cat_remote_sprites
@noerhome_cat_remote_sprites.each_value do |sprite|
begin
sprite.dispose if sprite && !sprite.disposed?
rescue
end
end
@noerhome_cat_remote_sprites = {}
end
rescue
end
noerhome_cat_remote_sprite_dispose_without_sync
end
end
# ===== /NoerHome networked cat sync patch =====
# ===== NoerHome private estate, garden and decor =====
module NoerHomeEstate
STORY_GARDEN_BLOB = "NoerHomeGardenBlob"
STORY_DECOR_BLOB = "NoerHomeDecorBlob"
MAP_HOUSE = "NoerHome"
MAP_YARD = "NoerHomeOut"
WIRE_BASE = 900_000_000
WIRE_OWNER_MOD = 100_000_000
module_function
def story_hash
if defined?(MPStateInfra) && MPStateInfra.respond_to?(:ensure_story)
return MPStateInfra.ensure_story
end
return $story_stats if defined?($story_stats)
nil
rescue
nil
end
def house_bought?
story = story_hash
local = story && story["NoerHouseBought"].to_i != 0
local || !!@server_bought
rescue
false
end
def server_profile_id
id = @server_profile_id.to_i
id > 0 ? id : 0
rescue
0
end
def guest_context?
!!@guest_context
rescue
false
end
def own_home_context?
current_owner_profile_id.to_i > 0 && !guest_context? && current_owner_profile_id.to_i == server_profile_id.to_i
rescue
false
end
def current_owner_profile_id
id = @current_owner_profile_id.to_i
return id if id > 0
server_profile_id
rescue
0
end
def current_home_kind
@current_home_kind.to_s
rescue
""
end
def map_key(tag)
begin
list = $data_tag_maps[tag]
return list[0] if list.is_a?(Array) && list[0]
rescue
end
base = $noerHomeFolder.to_s
base = "ModScripts/_Mods/NoerHome/" if base.to_s == ""
"#{base}#{tag}.rvdata2"
rescue
tag
end
def local_map_id(tag)
key = map_key(tag)
begin
info = $data_mapinfos[key]
return info.id.to_i if info && info.respond_to?(:id)
rescue
end
begin
$data_mapinfos.each_value do |info|
next unless info
return info.id.to_i if info.name.to_s == tag.to_s
return info.id.to_i if info.filename.to_s.end_with?("#{tag}.rvdata2")
end
rescue
end
0
rescue
0
end
def local_house_id
local_map_id(MAP_HOUSE)
end
def local_yard_id
local_map_id(MAP_YARD)
end
def home_kind_for_local(map_id)
id = map_id.to_i
return "house" if id > 0 && id == local_house_id.to_i
return "yard" if id > 0 && id == local_yard_id.to_i
""
rescue
""
end
def home_map_key?(map_id, tag)
return true if map_id.to_s == map_key(tag).to_s
id = local_map_id(tag)
id > 0 && map_id.to_i == id
rescue
false
end
def home_target_kind(map_id)
return "house" if home_map_key?(map_id, MAP_HOUSE)
return "yard" if home_map_key?(map_id, MAP_YARD)
""
rescue
""
end
def home_map_runtime?
return false unless defined?($game_map) && $game_map
home_kind_for_local($game_map.map_id).to_s != ""
rescue
false
end
def net_escape(text)
text.to_s.gsub("%", "%25").gsub(":", "%3A").gsub("\r", "").gsub("\n", "")
rescue
""
end
def net_unescape(text)
text.to_s.gsub(/%([0-9A-Fa-f]{2})/) do
[$1.to_i(16)].pack("C")
end
rescue
text.to_s
end
def send_line(line)
return false unless defined?(WebSocket) && WebSocket.respond_to?(:send_line)
WebSocket.send_line(line.to_s)
true
rescue
false
end
def send_home_ids
ids = [local_house_id, local_yard_id].map { |v| v.to_i }.select { |v| v > 0 }.uniq
return false if ids.empty?
send_line("home_ids:#{ids.join(':')}")
rescue
false
end
def request_state_from_server
send_home_ids
send_line("home_req")
rescue
false
end
def garden_blob
return @guest_garden_blob.to_s if guest_context?
story = story_hash
story ? story[STORY_GARDEN_BLOB].to_s : ""
rescue
""
end
def decor_blob
return @guest_decor_blob.to_s if guest_context?
story = story_hash
story ? story[STORY_DECOR_BLOB].to_s : ""
rescue
""
end
def set_garden_blob(value)
return false if guest_context?
story = story_hash
story[STORY_GARDEN_BLOB] = value.to_s if story
bump_visual_revision
true
rescue
false
end
def set_decor_blob(value)
return false if guest_context?
story = story_hash
story[STORY_DECOR_BLOB] = value.to_s if story
bump_visual_revision
true
rescue
false
end
def apply_home_state(profile_id, bought, garden, decor)
@server_profile_id = profile_id.to_i if profile_id.to_i > 0
@server_bought = bought.to_i != 0
story = story_hash
if story
story["NoerHouseBought"] = 1 if @server_bought
if !guest_context?
decoded_garden = net_unescape(garden)
decoded_decor = net_unescape(decor)
story[STORY_GARDEN_BLOB] = decoded_garden if decoded_garden.to_s != "" || story[STORY_GARDEN_BLOB].to_s == ""
story[STORY_DECOR_BLOB] = decoded_decor if decoded_decor.to_s != "" || story[STORY_DECOR_BLOB].to_s == ""
end
end
bump_visual_revision
sync_to_server(true) if house_bought? && !@server_bought
true
rescue
false
end
def home_sync_payload
bought = house_bought? ? 1 : 0
"#{bought}:#{net_escape(garden_blob)}:#{net_escape(decor_blob)}"
rescue
"0::"
end
def apply_home_sync_ok(_payload = "")
@home_sync_waiting_ack = false
@home_sync_dirty_payload = ""
true
rescue
false
end
# Apply a live house snapshot sent by the server while this client is
# visiting another player's private house or yard.
def apply_home_update(profile_id, garden, decor)
profile = profile_id.to_i
return false unless guest_context?
return false unless profile > 0 && current_owner_profile_id.to_i == profile
@guest_garden_blob = net_unescape(garden)
@guest_decor_blob = net_unescape(decor)
bump_visual_revision
true
rescue
false
end
def sync_to_server(force = false)
return false if guest_context?
return false unless house_bought?
payload = home_sync_payload
dirty = @home_sync_dirty_payload.to_s
return true if !force && dirty == "" && @last_home_sync_payload.to_s == payload
sent = send_line("home_sync:#{payload}")
if sent
@last_home_sync_payload = payload
@home_sync_dirty_payload = ""
@home_sync_waiting_ack = true
@home_sync_last_sent_frame = (Graphics.frame_count rescue 0).to_i
begin
MPStateInfra.log_line("home_sync_sent", "bytes=#{payload.bytesize rescue payload.size}") if defined?(MPStateInfra) && MPStateInfra.respond_to?(:log_line)
rescue
end
else
@home_sync_dirty_payload = payload
begin
MPStateInfra.log_line("home_sync_pending", "send_failed") if defined?(MPStateInfra) && MPStateInfra.respond_to?(:log_line)
rescue
end
end
sent
rescue
@home_sync_dirty_payload = payload.to_s if defined?(payload)
false
end
def wire_map_id(owner_profile_id, kind)
owner = owner_profile_id.to_i
return 0 if owner <= 0
offset = kind.to_s == "yard" ? 2 : 1
WIRE_BASE + (owner % WIRE_OWNER_MOD) * 4 + offset
rescue
0
end
def map_packet_for_server(map_id = nil)
local_id = map_id.nil? ? ($game_map.map_id rescue 0) : map_id.to_i
kind = home_kind_for_local(local_id)
if kind.to_s != ""
owner = current_owner_profile_id
wire = wire_map_id(owner, kind)
return "home_map:#{wire}:#{local_id}:#{owner}:#{kind}" if wire > 0 && owner > 0
end
"map:#{local_id}"
rescue
"map:#{map_id.to_i rescue 0}"
end
def notify(text)
msg = text.to_s
return if msg == ""
begin
if defined?(System_NotificationOverlay) && System_NotificationOverlay.respond_to?(:notify)
System_NotificationOverlay.notify(msg, :warning)
return
end
rescue
end
begin
$game_message.add(msg) if defined?($game_message) && $game_message
rescue
end
rescue
end
def front_overmap_home_event
return nil unless defined?($game_map) && $game_map && $game_map.respond_to?(:isOverMap) && $game_map.isOverMap
return nil unless defined?($game_player) && $game_player
x2 = $game_map.round_x_with_direction($game_player.x, $game_player.direction)
y2 = $game_map.round_y_with_direction($game_player.y, $game_player.direction)
events = []
begin
events += $game_map.events_xy(x2, y2)
events += $game_map.events_xy($game_player.x, $game_player.y)
rescue
events = []
end
events.find { |event| event && event.respond_to?(:name) && event.name.to_s == "NoerHome" }
rescue
nil
end
def front_overmap_home_event?
!front_overmap_home_event.nil?
rescue
false
end
def start_front_home_event
event = front_overmap_home_event
return false unless event
event.start
begin
$game_map.setup_starting_event if defined?($game_map) && $game_map
rescue
end
true
rescue
false
end
def begin_own_home(kind = "house")
profile = server_profile_id
if profile <= 0
request_state_from_server
notify("Home data is still loading.")
return false
end
@guest_context = false
@current_owner_profile_id = profile
@current_home_kind = kind.to_s
sync_to_server(true)
true
rescue
false
end
def begin_guest_visit(profile_id, nick, garden = "", decor = "")
profile = profile_id.to_i
return false if profile <= 0
@guest_context = true
@current_owner_profile_id = profile
@current_owner_nick = nick.to_s
@current_home_kind = "house"
@guest_garden_blob = net_unescape(garden)
@guest_decor_blob = net_unescape(decor)
true
rescue
false
end
def clear_home_context
@guest_context = false
@current_owner_profile_id = 0
@current_owner_nick = ""
@current_home_kind = ""
@guest_garden_blob = ""
@guest_decor_blob = ""
rescue
end
def transfer_allowed?(map_id)
kind = home_target_kind(map_id)
return true if kind.to_s == ""
return true if guest_context?
unless house_bought?
notify("House is not bought.")
return false
end
begin_own_home(kind)
rescue
false
end
def enter_guest_house(profile_id, nick, garden = "", decor = "")
return false unless begin_guest_visit(profile_id, nick, garden, decor)
begin
# Use the normal tag-map entrance flow. It prepares map state and lets
# the map autorun move the guest to the configured StartPoint.
if defined?(Game_Interpreter)
interpreter = Game_Interpreter.new
if interpreter.respond_to?(:change_map_enter_tag, true)
interpreter.send(:change_map_enter_tag, MAP_HOUSE)
return true
end
end
# Compatibility fallback for builds where the standard helper is absent.
# These coordinates point at NoerHome's current StartPoint instead of the
# empty black area at 10,10 used by the old implementation.
return false unless defined?($game_player) && $game_player
story = story_hash
story["ReRollHalfEvents"] = 1 if story
$game_player.reserve_transfer(map_key(MAP_HOUSE), 34, 33, 2)
true
rescue => error
begin
if defined?(MPStateInfra) && MPStateInfra.respond_to?(:log_line)
MPStateInfra.log_line("home_guest_transfer_error", "#{error.class}: #{error.message}")
end
rescue
end
clear_home_context
false
end
end
def request_visit_list
send_line("home_visit_list")
rescue
false
end
def apply_visit_list(rows)
@visit_rows = rows
request_visit_menu
rescue
false
end
def request_overmap_menu
return false if @menu_fiber && @menu_fiber.alive?
@menu_fiber = Fiber.new { Game_Interpreter.new.noerhome_overmap_house_menu }
update_menu_fiber
true
rescue
@menu_fiber = nil
false
end
def request_visit_menu
return false if @menu_fiber && @menu_fiber.alive?
@menu_fiber = Fiber.new { Game_Interpreter.new.noerhome_visit_house_menu(@visit_rows || []) }
update_menu_fiber
true
rescue
@menu_fiber = nil
false
end
def update_menu_fiber
return if @menu_fiber.nil?
if @menu_fiber.alive?
@menu_fiber.resume
else
@menu_fiber = nil
end
rescue FiberError
@menu_fiber = nil
rescue
@menu_fiber = nil
end
def prepare_home_transfer(kind)
kind = kind.to_s
return false if kind == ""
story = story_hash
return false unless story
story["ReRollHalfEvents"] = 1
if kind == "yard"
point = story["TagSubTrans"]
story["TagSubTrans"] = "StartPoint" if point.nil? || point == 0 || point.to_s == ""
end
true
rescue
false
end
# Recovery for builds where reserve_transfer performs the map change
# immediately and the yard BIOS fails to move the player from (1,1).
# Один раз на вход в карту — без повторного chcg black fade каждый кадр.
def recover_home_spawn_if_needed
return false unless home_map_runtime?
return false unless defined?($game_player) && $game_player
return false unless $game_player.x.to_i == 1 && $game_player.y.to_i == 1
map_token = ($game_map.map_id rescue nil)
if @spawn_recover_map_token == map_token && @spawn_recover_done
return false
end
@spawn_recover_map_token = map_token
@spawn_recover_done = true
kind = home_kind_for_local($game_map.map_id).to_s
prepare_home_transfer(kind)
interpreter = ($game_map.interpreter rescue nil)
if interpreter && interpreter.respond_to?(:enter_static_tag_map, true)
# fadeout=false: не вешаем чёрный chcg overlay при recovery-snap
interpreter.send(:enter_static_tag_map, nil, false)
return true
end
point = kind == "yard" ? [27, 29] : [34, 33]
begin
found = $game_map.get_storypoint("StartPoint")
point = [found[0].to_i, found[1].to_i] if found && found.length >= 2
rescue
end
$game_player.moveto(point[0], point[1])
true
rescue
false
end
def after_map_setup(_map_id = nil)
@spawn_recover_done = false
@spawn_recover_map_token = nil
send_home_ids
if home_map_runtime?
kind = home_kind_for_local($game_map.map_id)
@current_home_kind = kind if kind.to_s != ""
if !guest_context? && @current_owner_profile_id.to_i <= 0 && house_bought?
begin_own_home(kind)
end
send_line(map_packet_for_server($game_map.map_id))
sync_to_server(false)
else
clear_home_context if @current_home_kind.to_s != ""
end
rescue
end
def update_runtime
update_menu_fiber
recover_home_spawn_if_needed
sync_to_server(false) if home_map_runtime? && own_home_context?
rescue
end
def visual_revision
@visual_revision.to_i
rescue
0
end
def bump_visual_revision
@visual_revision = visual_revision + 1
rescue
end
end
module NoerHomeGarden
module_function
STAMINA_PLANT = 4
STAMINA_WATER = 1
STAMINA_HARVEST = 2
HARVEST_COUNT = 3
CROPS = {
"tomato" => { :title => "помидор", :item => "ItemTomato", :image => "tomat.png" },
"potato" => { :title => "картофель", :item => "ItemPotato", :image => "kartofel.png" },
"carrot" => { :title => "морковь", :item => "ItemCarrot", :image => "morkov.png" }
}
def own_yard?
NoerHomeEstate.own_home_context? && NoerHomeEstate.current_home_kind == "yard"
rescue
false
end
def visible_yard?
NoerHomeEstate.home_map_runtime? && NoerHomeEstate.current_home_kind == "yard"
rescue
false
end
def today
return $game_date.dateAmt.to_i if defined?($game_date) && $game_date.respond_to?(:dateAmt)
(Graphics.frame_count rescue 0).to_i / 3600
rescue
0
end
def plots
w = ($game_map.width rescue 24).to_i
h = ($game_map.height rescue 24).to_i
sx = [[w / 2 - 3, 2].max, [w - 8, 2].max].min
sy = [[h / 2, 2].max, [h - 4, 2].max].min
out = []
2.times { |row| 4.times { |col| out << [sx + col * 2, sy + row * 2] } }
out
rescue
[[10, 10], [12, 10], [14, 10], [16, 10], [10, 12], [12, 12], [14, 12], [16, 12]]
end
def decode
out = {}
NoerHomeEstate.garden_blob.to_s.split("|").each do |entry|
parts = entry.split(",", 4)
next if parts.length < 4
slot = parts[0].to_i
crop = parts[1].to_s
next unless CROPS[crop]
out[slot] = { :crop => crop, :watered => parts[2].to_i != 0, :day => parts[3].to_i }
end
out
rescue
{}
end
def encode(state)
rows = []
state.keys.sort.each do |slot|
data = state[slot]
next unless data && CROPS[data[:crop].to_s]
rows << [slot.to_i, data[:crop].to_s, data[:watered] ? 1 : 0, data[:day].to_i].join(",")
end
rows.join("|")
rescue
""
end
def save_state(state)
NoerHomeEstate.set_garden_blob(encode(state))
NoerHomeEstate.sync_to_server(true)
rescue
false
end
def stage_for(data)
return 0 unless data
return 3 if data[:watered] && today > data[:day].to_i
return 2 if data[:watered]
1
rescue
1
end
def crop_image_path(crop)
base = $noerHomeFolder.to_s
base = "ModScripts/_Mods/NoerHome/" if base.to_s == ""
File.join(base, "Graphics/Textute_ogorod", CROPS[crop][:image]).gsub("\\", "/")
rescue
""
end
def ground_image_path
base = $noerHomeFolder.to_s
base = "ModScripts/_Mods/NoerHome/" if base.to_s == ""
File.join(base, "Graphics/Textute_ogorod", "vskopano.png").gsub("\\", "/")
rescue
""
end
def item_by_name(name)
begin
return $data_ItemName[name] if defined?($data_ItemName) && $data_ItemName && $data_ItemName[name]
rescue
end
begin
$data_items.each do |item|
next unless item
return item if item.respond_to?(:item_name) && item.item_name.to_s == name.to_s
end
rescue
end
nil
rescue
nil
end
def item_count(name)
item = item_by_name(name)
return 0 unless item && defined?($game_party) && $game_party
$game_party.item_number(item).to_i
rescue
0
end
def actor
return $game_player.actor if defined?($game_player) && $game_player && $game_player.respond_to?(:actor)
nil
rescue
nil
end
def stamina
a = actor
return 0 unless a
return a.sta.to_i if a.respond_to?(:sta)
a.instance_variable_get(:@sta).to_i
rescue
0
end
def spend_stamina(cost)
cost = cost.to_i
return true if cost <= 0
current = stamina
if current < cost
NoerHomeEstate.notify("Не хватает стамины.")
return false
end
a = actor
if a.respond_to?(:sta=)
a.sta = current - cost
else
a.instance_variable_set(:@sta, current - cost)
end
true
rescue
false
end
def front_slot
return nil unless defined?($game_map) && $game_map && defined?($game_player) && $game_player
coords = plots
fx = $game_map.round_x_with_direction($game_player.x, $game_player.direction)
fy = $game_map.round_y_with_direction($game_player.y, $game_player.direction)
idx = coords.index([fx, fy])
idx = coords.index([$game_player.x, $game_player.y]) if idx.nil?
idx
rescue
nil
end
def request_menu(slot)
return false if @menu_fiber && @menu_fiber.alive?
@menu_fiber = Fiber.new { Game_Interpreter.new.noerhome_garden_menu(slot.to_i) }
update_menu_fiber
true
rescue
@menu_fiber = nil
false
end
def handle_action
return false unless own_yard?
slot = front_slot
return false if slot.nil?
request_menu(slot)
rescue
false
end
def update_menu_fiber
return if @menu_fiber.nil?
if @menu_fiber.alive?
@menu_fiber.resume
else
@menu_fiber = nil
end
rescue FiberError
@menu_fiber = nil
rescue
@menu_fiber = nil
end
def plant(slot, crop)
crop = crop.to_s
cfg = CROPS[crop]
return false unless cfg
item = item_by_name(cfg[:item])
if item.nil? || item_count(cfg[:item]) <= 0
NoerHomeEstate.notify("Нет #{cfg[:title]} для рассады.")
return false
end
return false unless spend_stamina(STAMINA_PLANT)
$game_party.lose_item(item, 1)
state = decode
state[slot.to_i] = { :crop => crop, :watered => false, :day => today }
save_state(state)
true
rescue
false
end
def water(slot)
state = decode
data = state[slot.to_i]
return false unless data
return true if data[:watered]
return false unless spend_stamina(STAMINA_WATER)
data[:watered] = true
save_state(state)
true
rescue
false
end
def harvest(slot)
state = decode
data = state[slot.to_i]
return false unless data && stage_for(data) >= 3
cfg = CROPS[data[:crop].to_s]
item = item_by_name(cfg[:item])
return false unless item
return false unless spend_stamina(STAMINA_HARVEST)
$game_party.gain_item(item, HARVEST_COUNT)
state.delete(slot.to_i)
save_state(state)
true
rescue
false
end
def clear(slot)
state = decode
state.delete(slot.to_i)
save_state(state)
true
rescue
false
end
end
module NoerHomeDecor
module_function
ITEMS = [
{ :id => "bed", :title => "Кровать", :path => "Graphics/Characters/LonaEXT/Bed_sm.png", :x => 8, :y => 8, :z => 80 },
{ :id => "table", :title => "Стол", :path => "Graphics/Characters/NoerTavern/TavernTable.png", :x => 12, :y => 9, :z => 80 },
{ :id => "chair", :title => "Стул", :path => "Graphics/Characters/NoerTransHouse/DedChair.png", :x => 14, :y => 9, :z => 80 },
{ :id => "chest", :title => "Сундук", :path => "Graphics/Characters/$Chest.png", :x => 16, :y => 8, :z => 80 },
{ :id => "fireplace", :title => "Камин", :path => "Graphics/Characters/!$_fireplace.png", :x => 18, :y => 8, :z => 80 },
{ :id => "wall_wood", :title => "Деревянная стена", :path => "Graphics/Tilesets/Inside_B.png", :x => 7, :y => 5, :z => 40, :rect => [0, 0, 192, 96] },
{ :id => "wall_poor", :title => "Бедная стена", :path => "Graphics/Tilesets/Inside_POOR_B.png", :x => 7, :y => 5, :z => 40, :rect => [0, 0, 192, 96] }
]
def house_visible?
NoerHomeEstate.home_map_runtime? && NoerHomeEstate.current_home_kind == "house"
rescue
false
end
def own_house?
house_visible? && NoerHomeEstate.own_home_context?
rescue
false
end
def enabled_ids
NoerHomeEstate.decor_blob.to_s.split(",").map { |v| v.strip }.reject { |v| v == "" }.uniq
rescue
[]
end
def save_ids(ids)
clean = ids.map { |v| v.to_s }.select { |id| ITEMS.any? { |item| item[:id] == id } }.uniq
NoerHomeEstate.set_decor_blob(clean.join(","))
NoerHomeEstate.sync_to_server(true)
rescue
false
end
def toggle(id)
ids = enabled_ids
if ids.include?(id.to_s)
ids.delete(id.to_s)
else
ids << id.to_s
end
save_ids(ids)
rescue
false
end
def active_items
ids = enabled_ids
ITEMS.select { |item| ids.include?(item[:id]) && File.file?(item[:path].to_s) }
rescue
[]
end
end
class Game_Interpreter
def noerhome_pick_rows(rows, target = nil)
if respond_to?(:noerhome_cat_pick_from_sheet)
return noerhome_cat_pick_from_sheet(rows, target)
end
wait_for_message if respond_to?(:wait_for_message)
$game_message.choices.clear
rows.each { |row| $game_message.choices.push(row[0].to_s) }
$game_message.choice_cancel_type = rows.length
picked = nil
$game_message.choice_proc = Proc.new { |n| picked = rows[n] ? rows[n][1] : nil }
Fiber.yield while $game_message.choice?
picked
rescue
nil
end
def noerhome_overmap_house_menu
rows = [["Войти в свой дом", "own"], ["Зайти в гости", "visit"], ["Отмена", "cancel"]]
picked = noerhome_pick_rows(rows)
case picked
when "own"
unless NoerHomeEstate.house_bought?
NoerHomeEstate.start_front_home_event
return true
end
NoerHomeEstate.begin_own_home("house")
NoerHomeEstate.start_front_home_event
when "visit"
NoerHomeEstate.request_visit_list
end
true
rescue
false
end
def noerhome_visit_house_menu(rows)
if rows.nil? || rows.empty?
NoerHomeEstate.notify("Сейчас никто из игроков не находится дома.")
return false
end
sheet = rows.map { |row| ["В гости к #{row[:nick]}", row[:session_id].to_i] }
sheet << ["Отмена", 0]
picked = noerhome_pick_rows(sheet)
NoerHomeEstate.send_line("home_visit:#{picked.to_i}") if picked.to_i > 0
true
rescue
false
end
def noerhome_garden_menu(slot)
state = NoerHomeGarden.decode
data = state[slot.to_i]
if data.nil?
rows = []
NoerHomeGarden::CROPS.each { |crop, cfg| rows << ["Посадить #{cfg[:title]} x#{NoerHomeGarden.item_count(cfg[:item])}", crop] }
rows << ["Отмена", "cancel"]
picked = noerhome_pick_rows(rows)
NoerHomeGarden.plant(slot, picked) if NoerHomeGarden::CROPS[picked.to_s]
return true
end
stage = NoerHomeGarden.stage_for(data)
rows = []
rows << ["Собрать урожай", "harvest"] if stage >= 3
rows << ["Полить", "water"] unless data[:watered]
rows << ["Очистить грядку", "clear"]
rows << ["Отмена", "cancel"]
picked = noerhome_pick_rows(rows)
NoerHomeGarden.harvest(slot) if picked == "harvest"
NoerHomeGarden.water(slot) if picked == "water"
NoerHomeGarden.clear(slot) if picked == "clear"
true
rescue
false
end
def noerhome_decor_menu(_target = nil)
unless NoerHomeDecor.own_house?
NoerHomeEstate.notify("Обустройство доступно только внутри своего дома.")
return false
end
rows = NoerHomeDecor::ITEMS.map do |item|
state = NoerHomeDecor.enabled_ids.include?(item[:id]) ? "Вкл" : "Выкл"
["#{state} #{item[:title]}", item[:id]]
end
rows << ["Отмена", "cancel"]
picked = noerhome_pick_rows(rows)
NoerHomeDecor.toggle(picked) if picked && picked != "cancel"
true
rescue
false
end
end
class Game_Map
unless method_defined?(:noerhome_estate_setup_without_private_home)
alias noerhome_estate_setup_without_private_home setup
end
def setup(map_id)
noerhome_estate_setup_without_private_home(map_id)
NoerHomeEstate.after_map_setup(map_id) if defined?(NoerHomeEstate)
end
end
class Game_Player
unless method_defined?(:noerhome_estate_reserve_transfer_without_private_home)
alias noerhome_estate_reserve_transfer_without_private_home reserve_transfer
end
def reserve_transfer(map_id, x, y, d = 2)
kind = defined?(NoerHomeEstate) ? NoerHomeEstate.home_target_kind(map_id).to_s : ""
NoerHomeEstate.prepare_home_transfer(kind) if defined?(NoerHomeEstate) && kind != ""
return false if defined?(NoerHomeEstate) && !NoerHomeEstate.transfer_allowed?(map_id)
result = noerhome_estate_reserve_transfer_without_private_home(map_id, x, y, d)
NoerHomeEstate.recover_home_spawn_if_needed if defined?(NoerHomeEstate) && kind != ""
result
end
unless method_defined?(:noerhome_estate_check_action_event_without_private_home)
alias noerhome_estate_check_action_event_without_private_home check_action_event
end
def check_action_event(chkItemsPick = false)
if defined?(NoerHomeEstate) && NoerHomeEstate.front_overmap_home_event?
return true if NoerHomeEstate.request_overmap_menu
end
result = noerhome_estate_check_action_event_without_private_home(chkItemsPick)
return true if result
return true if defined?(NoerHomeGarden) && NoerHomeGarden.handle_action
result
end
end
class Scene_Map
unless method_defined?(:noerhome_estate_update_without_private_home)
alias noerhome_estate_update_without_private_home update
end
def update(*args, &block)
noerhome_estate_update_without_private_home(*args, &block)
NoerHomeEstate.update_runtime if defined?(NoerHomeEstate)
NoerHomeGarden.update_menu_fiber if defined?(NoerHomeGarden)
end
end
class Spriteset_Map
unless method_defined?(:noerhome_estate_create_characters_without_private_home)
alias noerhome_estate_create_characters_without_private_home create_characters
end
def create_characters
noerhome_estate_create_characters_without_private_home
@noerhome_estate_sprites = []
@noerhome_estate_signature = nil
refresh_noerhome_estate_sprites
end
unless method_defined?(:noerhome_estate_update_without_private_home)
alias noerhome_estate_update_without_private_home update
end
def update
noerhome_estate_update_without_private_home
refresh_noerhome_estate_sprites
update_noerhome_estate_sprites
end
unless method_defined?(:noerhome_estate_dispose_without_private_home)
alias noerhome_estate_dispose_without_private_home dispose
end
def dispose
dispose_noerhome_estate_sprites
noerhome_estate_dispose_without_private_home
end
def noerhome_estate_signature
[($game_map.map_id rescue 0).to_i, NoerHomeEstate.current_owner_profile_id, NoerHomeEstate.current_home_kind, NoerHomeEstate.garden_blob, NoerHomeEstate.decor_blob, (NoerHomeGarden.today rescue 0), NoerHomeEstate.visual_revision]
rescue
[]
end
def dispose_noerhome_estate_sprites
return unless @noerhome_estate_sprites
@noerhome_estate_sprites.each do |sprite|
begin
sprite.bitmap.dispose if sprite.bitmap && !sprite.bitmap.disposed?
sprite.dispose unless sprite.disposed?
rescue
end
end
@noerhome_estate_sprites = []
rescue
end
def make_noerhome_sprite(path, x, y, z = 80, opacity = 255, rect = nil)
return nil unless File.file?(path.to_s)
sprite = Sprite.new(@viewport1)
sprite.bitmap = Bitmap.new(path.to_s)
sprite.src_rect.set(rect[0].to_i, rect[1].to_i, rect[2].to_i, rect[3].to_i) if rect.is_a?(Array) && rect.length >= 4
sprite.z = z.to_i
sprite.opacity = opacity.to_i
sprite.instance_variable_set(:@noerhome_tile_x, x.to_i)
sprite.instance_variable_set(:@noerhome_tile_y, y.to_i)
@noerhome_estate_sprites << sprite
sprite
rescue
nil
end
def refresh_noerhome_estate_sprites
sig = noerhome_estate_signature
return if @noerhome_estate_signature == sig
@noerhome_estate_signature = sig
dispose_noerhome_estate_sprites
@noerhome_estate_sprites = []
if defined?(NoerHomeGarden) && NoerHomeGarden.visible_yard?
state = NoerHomeGarden.decode
NoerHomeGarden.plots.each_with_index do |xy, index|
make_noerhome_sprite(NoerHomeGarden.ground_image_path, xy[0], xy[1], 72, 255)
data = state[index]
next unless data
stage = NoerHomeGarden.stage_for(data)
opacity = stage >= 3 ? 255 : (stage == 2 ? 210 : 160)
make_noerhome_sprite(NoerHomeGarden.crop_image_path(data[:crop]), xy[0], xy[1], 74, opacity)
end
end
if defined?(NoerHomeDecor) && NoerHomeDecor.house_visible?
NoerHomeDecor.active_items.each { |item| make_noerhome_sprite(item[:path], item[:x], item[:y], item[:z] || 80, 255, item[:rect]) }
end
update_noerhome_estate_sprites
rescue
end
def update_noerhome_estate_sprites
return unless @noerhome_estate_sprites
@noerhome_estate_sprites.each do |sprite|
begin
tx = sprite.instance_variable_get(:@noerhome_tile_x).to_i
ty = sprite.instance_variable_get(:@noerhome_tile_y).to_i
sprite.x = ($game_map.adjust_x(tx) * 32).to_i
sprite.y = ($game_map.adjust_y(ty) * 32).to_i
sprite.visible = true
rescue
end
end
rescue
end
end
if defined?(WebSocket)
module WebSocket
class << self
unless method_defined?(:noerhome_estate_parse_without_private_home)
alias noerhome_estate_parse_without_private_home parse
end
def parse(msg)
line = msg.to_s
if line.start_with?("home_state:")
parts = line.split(":", 5)
NoerHomeEstate.apply_home_state(parts[1].to_i, parts[2].to_i, parts[3].to_s, parts[4].to_s)
return
end
if line.start_with?("home_sync_ok")
NoerHomeEstate.apply_home_sync_ok(line.split(":", 2)[1].to_s)
return
end
if line.start_with?("home_visit_list:")
payload = line.split(":", 2)[1].to_s
rows = []
payload.split("|").each do |entry|
p = entry.split(":", 3)
next if p.length < 3
rows << { :session_id => p[0].to_i, :profile_id => p[1].to_i, :nick => NoerHomeEstate.net_unescape(p[2]) }
end
NoerHomeEstate.apply_visit_list(rows)
return
end
if line.start_with?("home_visit_ok:")
parts = line.split(":", 6)
NoerHomeEstate.enter_guest_house(parts[2].to_i, NoerHomeEstate.net_unescape(parts[3].to_s), parts[4].to_s, parts[5].to_s)
return
end
if line.start_with?("home_update:")
parts = line.split(":", 4)
NoerHomeEstate.apply_home_update(parts[1].to_i, parts[2].to_s, parts[3].to_s)
return
end
if line.start_with?("home_error:")
code = line.split(":", 2)[1].to_s
text = case code
when "not_bought"
"House is not bought."
when "host_offline"
"Host is not inside the house."
when "not_authed"
"Home data is not ready."
when "use_home_map"
"Home map must use private home routing."
else
"Home error: #{code}"
end
NoerHomeEstate.notify(text)
return
end
noerhome_estate_parse_without_private_home(msg)
NoerHomeEstate.request_state_from_server if line == "sync_unlocked" || line.start_with?("auth_ok:")
end
def map_packet_for_server(map_id = nil)
NoerHomeEstate.map_packet_for_server(map_id)
rescue
"map:#{map_id.to_i rescue 0}"
end
end
end
end
NoerHomeEstate.send_home_ids if defined?(NoerHomeEstate)
# ===== /NoerHome private estate, garden and decor =====