4478 lines
122 KiB
Ruby
4478 lines
122 KiB
Ruby
$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 =====
|