Files
LonaRPG-Online-Games/ModScripts/_Mods/NoerHome/Scripts/NoerHome.rb
T

4477 lines
122 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
$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 =====