1067 lines
39 KiB
Ruby
1067 lines
39 KiB
Ruby
# encoding: UTF-8
|
|
# Tatoo 1.6.0 — tattoo master and Oleg memorial for LonaRPG/MKXP-Z.
|
|
|
|
unless defined?(MPPortraitPersistence)
|
|
module MPPortraitPersistence
|
|
@keys = {}
|
|
def self.register(key); @keys[key.to_s] = true; true; rescue; false; end
|
|
def self.key?(key); !!@keys[key.to_s]; rescue; false; end
|
|
end
|
|
end
|
|
|
|
module Tatoo
|
|
extend self
|
|
|
|
VERSION = "1.6.0"
|
|
MAP_ID = 62
|
|
SPAWN_X = 49
|
|
SPAWN_Y = 38
|
|
EVENT_ID = 9902
|
|
STAT_KEY = "TatooStyle"
|
|
SHOP_NAME = "TatooViktor"
|
|
TATTOO_PRICE = 4_000 # 2 medium copper coins (ItemCoin2 costs 2,000)
|
|
MASTER_GRAPHIC = "!$_TatooMaster"
|
|
MASTER_FILE = "ModScripts/_Mods/Tatoo/!$_TatooMaster.png"
|
|
TATTOO_ICON = "ModScripts/_Mods/Tatoo/Tato_icon.png"
|
|
CEMETERY_MAP_ID = 20
|
|
MEMORIAL_X = 50
|
|
MEMORIAL_Y = 22
|
|
MEMORIAL_EVENT_ID = 9910
|
|
MEMORIAL_GRAPHIC = "!$OlegMemorial"
|
|
MEMORIAL_FILE = "ModScripts/_Mods/Tatoo/!$OlegMemorial.png"
|
|
CEMETERY_VIKTOR_X = 50
|
|
CEMETERY_VIKTOR_Y = 24
|
|
CEMETERY_VIKTOR_EVENT_ID = 9911
|
|
CHS_ROOT = "ModScripts/_Mods/Tatoo/Assets/CharacterCharsets/LonaMCC"
|
|
PORTRAIT_ROOT = "ModScripts/_Mods/Tatoo/Assets/Portrait"
|
|
VIKTOR_PORTRAIT_ROOT = "ModScripts/_Mods/Tatoo/Assets/Portrait/Viktor"
|
|
VIKTOR_NPC_TEMPLATE = "NeutralHumanCommonM"
|
|
VIKTOR_NEUTRAL_PORTRAIT = "TatooViktorNeutral"
|
|
VIKTOR_SMILE_PORTRAIT = "TatooViktorSmile"
|
|
VIKTOR_ANGRY_PORTRAIT = "TatooViktorAngry"
|
|
MET_KEY = "TatooViktorMet"
|
|
CHASE_KEY = "TatooViktorChasing"
|
|
ESCAPED_KEY = "TatooViktorEscaped"
|
|
|
|
STYLE_NAMES = [
|
|
"Без татуировки",
|
|
"Багровая метка",
|
|
"Чёрная метка",
|
|
"Лазурная метка"
|
|
]
|
|
|
|
STYLE_SHOP_ITEMS = [
|
|
["TatooServiceRemove", 0, "Снять татуировку", "Удаление старой татуировки Виктором."],
|
|
["TatooServiceCrimson", 1, "Багровая метка", "Багровая татуировка на нижней части живота."],
|
|
["TatooServiceBlack", 2, "Чёрная метка", "Чёрная татуировка на нижней части живота."],
|
|
["TatooServiceAzure", 3, "Лазурная метка", "Лазурная татуировка на нижней части живота."]
|
|
]
|
|
|
|
# Positions are aligned to the centre of the stock WoundBelly skin region.
|
|
# The old coordinates mixed local bitmap and global canvas coordinates,
|
|
# putting most tattoos partly (or completely) outside the abdomen.
|
|
PORTRAIT_PARTS = {
|
|
"chcg1" => [384, 262, 1699, false],
|
|
"chcg2" => [385, 382, 1999, false],
|
|
"chcg3" => [325, 237, 699, true],
|
|
"chcg4" => [357, 375, 1699, false],
|
|
"chcg5" => [612, 563, 2499, true],
|
|
"pose1" => [111, 296, 599, false],
|
|
"pose4" => [255, 367, 5999, false],
|
|
"pose5" => [132, 255, 599, false]
|
|
}
|
|
|
|
def log(message)
|
|
p "[Tatoo] #{message}" rescue nil
|
|
end
|
|
|
|
def day?
|
|
return true unless defined?($game_date) && $game_date
|
|
return $game_date.day? if $game_date.respond_to?(:day?)
|
|
return !$game_date.night? if $game_date.respond_to?(:night?)
|
|
true
|
|
rescue
|
|
true
|
|
end
|
|
|
|
# Use the game's authoritative night predicate directly. This matters in
|
|
# multiplayer, where the server can override the local Game_Date cycle.
|
|
def night?
|
|
begin
|
|
if defined?(WebSocket) && WebSocket.respond_to?(:server_day_night_mode)
|
|
mode = WebSocket.server_day_night_mode
|
|
return mode == :night unless mode.nil?
|
|
end
|
|
rescue
|
|
end
|
|
return false unless defined?($game_date) && $game_date
|
|
return $game_date.night? if $game_date.respond_to?(:night?)
|
|
return !$game_date.day? if $game_date.respond_to?(:day?)
|
|
false
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def actor
|
|
return nil unless defined?($game_player) && $game_player
|
|
$game_player.actor
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def current_style
|
|
target = actor
|
|
return 0 unless target && target.respond_to?(:stat) && target.stat
|
|
value = target.stat[STAT_KEY].to_i
|
|
value.between?(0, 3) ? value : 0
|
|
rescue
|
|
0
|
|
end
|
|
|
|
def set_style(style)
|
|
target = actor
|
|
return false unless target && target.respond_to?(:stat) && target.stat
|
|
style = [[style.to_i, 0].max, 3].min
|
|
target.stat[STAT_KEY] = style
|
|
refresh_lona
|
|
begin
|
|
if defined?(MPImmediateLiveSync) && MPImmediateLiveSync.respond_to?(:trigger)
|
|
MPImmediateLiveSync.trigger("tattoo_style", true, false)
|
|
elsif defined?(MP_Save14) && MP_Save14.respond_to?(:request)
|
|
MP_Save14.request("tattoo_style", 0, true)
|
|
end
|
|
rescue => sync_error
|
|
log("tattoo sync request failed: #{sync_error.class}: #{sync_error.message}")
|
|
end
|
|
true
|
|
rescue => error
|
|
log("cannot set tattoo: #{error.class}: #{error.message}")
|
|
false
|
|
end
|
|
|
|
def refresh_lona
|
|
Cache.clear_chs_character if defined?(Cache) && Cache.respond_to?(:clear_chs_character)
|
|
if defined?($game_player) && $game_player && $game_player.respond_to?(:refresh_chs)
|
|
$game_player.refresh_chs
|
|
end
|
|
target = actor
|
|
if target && target.respond_to?(:portrait) && target.portrait
|
|
target.portrait.refresh if target.portrait.respond_to?(:refresh)
|
|
target.portrait.force_update if target.portrait.respond_to?(:force_update)
|
|
target.portrait.update if target.portrait.respond_to?(:update)
|
|
end
|
|
rescue => error
|
|
log("refresh failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def story_value(key)
|
|
return 0 unless defined?($story_stats) && $story_stats
|
|
$story_stats[key].to_i
|
|
rescue
|
|
0
|
|
end
|
|
|
|
def set_story_value(key, value)
|
|
$story_stats[key] = value if defined?($story_stats) && $story_stats
|
|
rescue => error
|
|
log("story state write failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def current_interaction_event(interpreter)
|
|
interpreter.get_character(0)
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def install_viktor_portraits
|
|
return unless defined?($data_npc_portraits) && $data_npc_portraits
|
|
portraits = {
|
|
VIKTOR_NEUTRAL_PORTRAIT => "Victot_display.png",
|
|
VIKTOR_SMILE_PORTRAIT => "Victot_smile_display.png",
|
|
VIKTOR_ANGRY_PORTRAIT => "Victot_angry_display.png"
|
|
}
|
|
portraits.each do |name, filename|
|
|
portrait = $data_npc_portraits.find { |entry| entry && entry.charName == name }
|
|
unless portrait
|
|
portrait = NPC_Portrait.fromHash({
|
|
"char_name" => name,
|
|
"statMap" => {
|
|
"canvas" => {"default" => [370, 408, 0, 18]},
|
|
"NPCportrait" => name
|
|
},
|
|
"parts" => [{
|
|
"part_name" => "NPCportrait",
|
|
"layer" => 65535,
|
|
"x" => 0,
|
|
"y" => 71,
|
|
"bmps" => {name => filename},
|
|
"root_folder" => VIKTOR_PORTRAIT_ROOT
|
|
}]
|
|
})
|
|
$data_npc_portraits << portrait
|
|
end
|
|
if defined?($game_portraits) && $game_portraits && !$game_portraits.hasPortrait?(name)
|
|
$game_portraits.addPortrait(portrait)
|
|
end
|
|
end
|
|
rescue => error
|
|
log("Viktor portrait install failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def show_dialogue_portraits(viktor_portrait = VIKTOR_NEUTRAL_PORTRAIT)
|
|
install_viktor_portraits
|
|
return unless defined?($game_portraits) && $game_portraits
|
|
$game_portraits.setRprt("Lona")
|
|
$game_portraits.setLprt(viktor_portrait)
|
|
end
|
|
|
|
def set_viktor_portrait(name)
|
|
install_viktor_portraits
|
|
$game_portraits.setLprt(name) if defined?($game_portraits) && $game_portraits
|
|
end
|
|
|
|
def viktor_line(interpreter, text, portrait = nil)
|
|
set_viktor_portrait(portrait) if portrait
|
|
if defined?($game_portraits) && $game_portraits
|
|
$game_portraits.lprt.focus
|
|
$game_portraits.rprt.fade
|
|
end
|
|
interpreter.call_msg("\\c[4]Виктор:\\C[0] #{text}")
|
|
end
|
|
|
|
def lona_line(interpreter, text)
|
|
if defined?($game_portraits) && $game_portraits
|
|
$game_portraits.lprt.fade
|
|
$game_portraits.rprt.focus
|
|
end
|
|
interpreter.call_msg("\\c[6]Лона:\\C[0] #{text}")
|
|
end
|
|
|
|
def close_dialogue_portraits(interpreter)
|
|
interpreter.portrait_off
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def first_meeting(interpreter)
|
|
show_dialogue_portraits(VIKTOR_NEUTRAL_PORTRAIT)
|
|
viktor_line(interpreter, "Хули тебе надо, малолетка?")
|
|
lona_line(interpreter, "А вы кто такой?")
|
|
viktor_line(interpreter, "Виктор. Тату-мастер с большой тату-машинкой. Ещё вопросы?")
|
|
lona_line(interpreter, "А у вас можно сделать татуировку?")
|
|
viktor_line(interpreter, "Можно. А ну-ка, покажи паспорт.")
|
|
lona_line(interpreter, "Вот... Пожалуйста.")
|
|
viktor_line(interpreter, "Хм... Впадлу считать. Допустим.", VIKTOR_SMILE_PORTRAIT)
|
|
set_story_value(MET_KEY, 1)
|
|
viktor_line(interpreter, "Ну что, малая, выбирай рисунок!")
|
|
end
|
|
|
|
def escaped_meeting(interpreter)
|
|
show_dialogue_portraits(VIKTOR_ANGRY_PORTRAIT)
|
|
viktor_line(interpreter, "А я вас раньше не видал... Хм, странно.")
|
|
lona_line(interpreter, "Наверное, обознались...")
|
|
set_story_value(ESCAPED_KEY, 0)
|
|
set_story_value(CHASE_KEY, 0)
|
|
set_story_value(MET_KEY, 1)
|
|
viktor_line(interpreter, "Ладно. Выбирай рисунок, пока я добрый.", VIKTOR_SMILE_PORTRAIT)
|
|
end
|
|
|
|
def interact(interpreter)
|
|
install_runtime_data
|
|
event = current_interaction_event(interpreter)
|
|
# A chase that started during the day must be allowed to finish even if
|
|
# the clock flips to night before Viktor reaches Lona.
|
|
if event && event.instance_variable_get(:@tatoo_attack_intro)
|
|
event.instance_variable_set(:@tatoo_attack_intro, false)
|
|
run_attack_intro(interpreter, event)
|
|
return
|
|
end
|
|
if event && (event.instance_variable_get(:@tatoo_caught_pending) || event.instance_variable_get(:@tatoo_chasing))
|
|
run_caught_scene(interpreter, event)
|
|
return
|
|
end
|
|
return unless day?
|
|
|
|
if story_value(ESCAPED_KEY) > 0
|
|
escaped_meeting(interpreter)
|
|
elsif story_value(MET_KEY) == 0
|
|
first_meeting(interpreter)
|
|
else
|
|
show_dialogue_portraits(VIKTOR_SMILE_PORTRAIT)
|
|
viktor_line(interpreter, "Ну что, малая, выбирай рисунок. Любая работа — два средних медяка.")
|
|
end
|
|
close_dialogue_portraits(interpreter)
|
|
interpreter.manual_barters(SHOP_NAME)
|
|
apply_purchased_service(interpreter)
|
|
rescue => error
|
|
log("interaction failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def make_service_item(base, key, style, display_name, description)
|
|
item = base.clone
|
|
new_id = $data_items.length
|
|
item.instance_variable_set(:@id, new_id)
|
|
item.instance_variable_set(:@item_name, key)
|
|
item.instance_variable_set(:@name, display_name)
|
|
item.instance_variable_set(:@description, description)
|
|
item.instance_variable_set(:@price, TATTOO_PRICE)
|
|
item.instance_variable_set(:@weight, 0.0)
|
|
item.instance_variable_set(:@type, "SurgeryCoupon")
|
|
item.instance_variable_set(:@type_tag, "SurgeryTricket")
|
|
item.instance_variable_set(:@key_item, false)
|
|
item.instance_variable_set(:@consumable, true)
|
|
item.instance_variable_set(:@max_stacks, 1)
|
|
item.instance_variable_set(:@common_tags, {"TatooStyle" => style})
|
|
# LonaRPG supports a String icon_index and loads it through Cache.normal_bitmap.
|
|
# Use the mod's tattoo icon instead of inheriting the hair/head icon from
|
|
# the SurgeryCoupon template item.
|
|
item.instance_variable_set(:@icon_index, TATTOO_ICON)
|
|
item.instance_variable_set(:@lona_effect, nil)
|
|
item.instance_variable_set(:@use_item_effect, nil)
|
|
$data_items[new_id] = item
|
|
$data_ItemName[key] = item
|
|
item
|
|
end
|
|
|
|
def install_service_items
|
|
return unless defined?($data_items) && $data_items && defined?($data_ItemName) && $data_ItemName
|
|
base = $data_ItemName["AddHairRed"] ||
|
|
$data_ItemName["AidFeelsSick"] ||
|
|
$data_items.compact.find { |item| item.respond_to?(:type) && item.type == "SurgeryCoupon" }
|
|
return log("cannot register tattoo services: no suitable base item") unless base
|
|
|
|
STYLE_SHOP_ITEMS.each do |key, style, display_name, description|
|
|
next if $data_ItemName[key]
|
|
make_service_item(base, key, style, display_name, description)
|
|
end
|
|
rescue => error
|
|
log("service item install failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def install_shop
|
|
return unless defined?($data_barters) && $data_barters
|
|
items = STYLE_SHOP_ITEMS.map do |key, _style, _display_name, _description|
|
|
{"item_name" => key, "price" => TATTOO_PRICE, "amount" => 1}
|
|
end
|
|
items << {"item_name" => "ItemCoin3", "price" => "(itemPrice)", "amount" => 200}
|
|
items << {"item_name" => "ItemCoin1", "price" => "(itemPrice)", "amount" => 50}
|
|
$data_barters[SHOP_NAME] = {
|
|
"name" => SHOP_NAME,
|
|
"charStoreHashName" => false,
|
|
"charStoreExpireDate" => false,
|
|
"charStoreTP" => 4_010_000,
|
|
"noSell" => false,
|
|
"noBuy" => false,
|
|
"items" => items
|
|
}
|
|
rescue => error
|
|
log("shop install failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def install_runtime_data
|
|
install_visuals
|
|
install_viktor_portraits
|
|
install_service_items
|
|
install_shop
|
|
end
|
|
|
|
def apply_purchased_service(interpreter)
|
|
purchased = []
|
|
STYLE_SHOP_ITEMS.each do |key, style, _display_name, _description|
|
|
item = $data_ItemName[key]
|
|
next unless item
|
|
amount = $game_party.item_number(item).to_i
|
|
next if amount <= 0
|
|
purchased << style
|
|
$game_party.lose_item(item, amount)
|
|
end
|
|
return if purchased.empty?
|
|
|
|
picked = purchased.last
|
|
if set_style(picked)
|
|
show_dialogue_portraits(VIKTOR_SMILE_PORTRAIT)
|
|
if picked == 0
|
|
viktor_line(interpreter, "Готово. Кожа снова чистая. Не ссы, шрама не останется!")
|
|
else
|
|
viktor_line(interpreter, "Готово. Не ссы, под дождём не растечётся!")
|
|
end
|
|
close_dialogue_portraits(interpreter)
|
|
else
|
|
interpreter.call_msg("\\c[4]Виктор:\\C[0] Не получилось нанести рисунок. Подойди ещё раз.")
|
|
end
|
|
rescue => error
|
|
log("purchased service apply failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def viktor_attacked(event)
|
|
return unless master?(event) && day?
|
|
return if event.instance_variable_get(:@tatoo_chasing)
|
|
event.instance_variable_set(:@tatoo_attack_intro, false)
|
|
event.instance_variable_set(:@tatoo_chasing, true)
|
|
event.instance_variable_set(:@tatoo_chase_origin_x, event.x)
|
|
event.instance_variable_set(:@tatoo_chase_origin_y, event.y)
|
|
if defined?($game_player) && $game_player
|
|
event.instance_variable_set(:@tatoo_chase_player_x, $game_player.x)
|
|
event.instance_variable_set(:@tatoo_chase_player_y, $game_player.y)
|
|
end
|
|
event.direction_fix = false
|
|
event.move_type = 2
|
|
event.move_speed = 5
|
|
event.move_frequency = 5
|
|
set_story_value(CHASE_KEY, 1)
|
|
rescue => error
|
|
log("Viktor hit reaction failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def run_attack_intro(interpreter, event)
|
|
show_dialogue_portraits(VIKTOR_ANGRY_PORTRAIT)
|
|
viktor_line(interpreter, "Иди сюда, малая!")
|
|
lona_line(interpreter, "Простиииите!")
|
|
close_dialogue_portraits(interpreter)
|
|
event.direction_fix = false
|
|
event.move_type = 2
|
|
event.move_speed = 5
|
|
event.move_frequency = 5
|
|
event.instance_variable_set(:@tatoo_chasing, true)
|
|
set_story_value(CHASE_KEY, 1)
|
|
rescue => error
|
|
log("Viktor chase intro failed: #{error.class}: #{error.message}")
|
|
reset_chase(event)
|
|
end
|
|
|
|
def drop_all_worn_equipment(interpreter)
|
|
target = actor
|
|
return 0 unless target && target.respond_to?(:equips)
|
|
removed = 0
|
|
(target.equips.length - 1).downto(0) do |slot|
|
|
next unless interpreter.equip_slot_removetable?(slot)
|
|
item = target.equips[slot]
|
|
next unless item && item.respond_to?(:item_name) && item.item_name
|
|
interpreter.combat_remove_random_equip_exec(item.item_name, slot, true)
|
|
removed += 1
|
|
interpreter.wait(8)
|
|
end
|
|
removed
|
|
rescue => error
|
|
log("equipment drop failed: #{error.class}: #{error.message}")
|
|
0
|
|
end
|
|
|
|
def increment_story_counter(key, amount)
|
|
set_story_value(key, story_value(key) + amount.to_i)
|
|
end
|
|
|
|
# Mirrors the stat bookkeeping used by the stock cave blackout encounter,
|
|
# but keeps Viktor recorded as the partner and does not start the HCG frames.
|
|
def apply_viktor_caught_stats
|
|
target = actor
|
|
return unless target && defined?($story_stats) && $story_stats
|
|
|
|
was_vag_virgin = story_value("dialog_vag_virgin") == 1 && story_value("sex_record_vaginal_count") == 0
|
|
was_anal_virgin = story_value("dialog_anal_virgin") == 1 && story_value("sex_record_anal_count") == 0
|
|
partner = ["DataNpcName:race/Human", "DataNpcName:name/TatooViktor", "DataNpcName:part/penis"]
|
|
|
|
$story_stats.sex_record_vag(partner) if $story_stats.respond_to?(:sex_record_vag)
|
|
$story_stats.sex_record_anal(partner) if $story_stats.respond_to?(:sex_record_anal)
|
|
$story_stats.sex_record_mouth(partner) if $story_stats.respond_to?(:sex_record_mouth)
|
|
|
|
increment_story_counter("sex_record_vaginal_count", rand(10) + 1)
|
|
increment_story_counter("sex_record_anal_count", rand(10) + 1)
|
|
increment_story_counter("sex_record_mouth_count", rand(10) + 1)
|
|
increment_story_counter("sex_record_cumin_anal", rand(5) + 1)
|
|
increment_story_counter("sex_record_cumin_mouth", rand(5) + 1)
|
|
increment_story_counter("sex_record_cumin_vaginal", rand(5) + 1)
|
|
increment_story_counter("sex_record_cumshotted", rand(20) + 1)
|
|
|
|
# Resolve the stock one-time virgin flags without invoking their explicit
|
|
# HCG over-events; the blackout scene itself is the event here.
|
|
if was_vag_virgin
|
|
set_story_value("dialog_vag_virgin", 0)
|
|
target.record_lona_title = "main_stats/title_secondhand" if target.respond_to?(:record_lona_title=)
|
|
target.add_state(37) if target.respond_to?(:add_state)
|
|
end
|
|
if was_anal_virgin
|
|
set_story_value("dialog_anal_virgin", 0)
|
|
target.add_state(40) if target.respond_to?(:add_state)
|
|
end
|
|
|
|
target.update_sex_exp if target.respond_to?(:update_sex_exp)
|
|
target.update_sex_sensitivity if target.respond_to?(:update_sex_sensitivity)
|
|
target.update_melanin_eff if target.respond_to?(:update_melanin_eff)
|
|
target.update_melanin if target.respond_to?(:update_melanin)
|
|
rescue => error
|
|
log("caught stat update failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def play_viktor_blackout(interpreter)
|
|
interpreter.portrait_hide if interpreter.respond_to?(:portrait_hide)
|
|
interpreter.portrait_off if interpreter.respond_to?(:portrait_off)
|
|
interpreter.command_221
|
|
interpreter.wait(24)
|
|
|
|
if defined?(SndLib)
|
|
SndLib.Breathing_Goblin(80, 110) if SndLib.respond_to?(:Breathing_Goblin)
|
|
SndLib.Breathing_Orc if SndLib.respond_to?(:Breathing_Orc)
|
|
end
|
|
5.times do
|
|
if defined?(SndLib)
|
|
SndLib.sound_chcg_fapper(80) if SndLib.respond_to?(:sound_chcg_fapper)
|
|
SndLib.sound_chcg_full(80) if SndLib.respond_to?(:sound_chcg_full)
|
|
end
|
|
interpreter.wait(45)
|
|
end
|
|
interpreter.wait(90)
|
|
end
|
|
|
|
def apply_caught_stamina_loss
|
|
target = actor
|
|
return 0 unless target && target.respond_to?(:sta) && target.respond_to?(:sta=)
|
|
loss = 30 + rand(21)
|
|
target.sta -= loss
|
|
loss
|
|
rescue => error
|
|
log("stamina loss failed: #{error.class}: #{error.message}")
|
|
0
|
|
end
|
|
|
|
def show_stamina_loss_popup(loss)
|
|
return unless loss.to_i > 0
|
|
return unless defined?($game_damage_popups) && $game_damage_popups && defined?($game_player) && $game_player
|
|
$game_damage_popups.add(loss.to_i, $game_player.x, $game_player.y, 0, 2)
|
|
rescue => error
|
|
log("stamina popup failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def run_caught_scene(interpreter, event)
|
|
return if event.instance_variable_get(:@tatoo_catch_running)
|
|
event.instance_variable_set(:@tatoo_catch_running, true)
|
|
event.instance_variable_set(:@tatoo_caught_pending, false)
|
|
event.move_type = 0
|
|
old_player_move_type = $game_player.move_type if $game_player.respond_to?(:move_type)
|
|
$game_player.move_type = 0 if $game_player.respond_to?(:move_type=)
|
|
|
|
play_viktor_blackout(interpreter)
|
|
apply_viktor_caught_stats
|
|
drop_all_worn_equipment(interpreter)
|
|
stamina_loss = apply_caught_stamina_loss
|
|
interpreter.command_222
|
|
show_stamina_loss_popup(stamina_loss)
|
|
interpreter.wait(30)
|
|
log("Viktor caught scene: stamina -#{stamina_loss}") if stamina_loss > 0
|
|
reset_chase(event)
|
|
rescue => error
|
|
log("caught scene failed: #{error.class}: #{error.message}")
|
|
interpreter.command_222 rescue nil
|
|
reset_chase(event)
|
|
ensure
|
|
if defined?($game_player) && $game_player && $game_player.respond_to?(:move_type=) && defined?(old_player_move_type) && !old_player_move_type.nil?
|
|
$game_player.move_type = old_player_move_type
|
|
end
|
|
event.instance_variable_set(:@tatoo_catch_running, false) if event
|
|
end
|
|
|
|
def reset_chase(event)
|
|
set_story_value(CHASE_KEY, 0)
|
|
event.instance_variable_set(:@tatoo_chasing, false) if event
|
|
event.instance_variable_set(:@tatoo_attack_intro, false) if event
|
|
event.instance_variable_set(:@tatoo_caught_pending, false) if event
|
|
event.instance_variable_set(:@tatoo_chase_origin_x, nil) if event
|
|
event.instance_variable_set(:@tatoo_chase_origin_y, nil) if event
|
|
event.instance_variable_set(:@tatoo_chase_player_x, nil) if event
|
|
event.instance_variable_set(:@tatoo_chase_player_y, nil) if event
|
|
return unless event
|
|
event.moveto(SPAWN_X, SPAWN_Y)
|
|
event.turn_down
|
|
event.direction_fix = false
|
|
event.move_type = 1
|
|
event.move_speed = 3
|
|
event.move_frequency = 3
|
|
rescue => error
|
|
log("chase reset failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def update_master_chase(event)
|
|
return unless event.instance_variable_get(:@tatoo_chasing)
|
|
return if event.instance_variable_get(:@tatoo_catch_running)
|
|
return if event.instance_variable_get(:@tatoo_caught_pending)
|
|
# The hit itself happens at close range. Starting the event immediately
|
|
# therefore treated that same hit as a capture. Arm capture only after the
|
|
# player has actually moved away or Viktor has taken a chase step.
|
|
player_moved = false
|
|
viktor_moved = false
|
|
begin
|
|
player_moved = $game_player &&
|
|
($game_player.x != event.instance_variable_get(:@tatoo_chase_player_x) ||
|
|
$game_player.y != event.instance_variable_get(:@tatoo_chase_player_y))
|
|
viktor_moved = event.x != event.instance_variable_get(:@tatoo_chase_origin_x) ||
|
|
event.y != event.instance_variable_get(:@tatoo_chase_origin_y)
|
|
rescue
|
|
end
|
|
return unless player_moved || viktor_moved
|
|
return unless event.super_near_the_player?
|
|
return if $game_map.interpreter.running?
|
|
return if defined?($game_message) && $game_message && $game_message.busy?
|
|
event.instance_variable_set(:@tatoo_caught_pending, true)
|
|
event.start
|
|
rescue => error
|
|
log("chase update failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def record_escape(game_map, new_map_id)
|
|
return unless game_map && game_map.map_id.to_i == MAP_ID
|
|
return if new_map_id.to_i == MAP_ID
|
|
return unless story_value(CHASE_KEY) > 0
|
|
set_story_value(CHASE_KEY, 0)
|
|
set_story_value(ESCAPED_KEY, 1)
|
|
rescue => error
|
|
log("escape state failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def interact_memorial(interpreter)
|
|
interpreter.call_msg("\\c[6]Лона:\\C[0] Спасибо тебе за всё, родной. Я никогда тебя не забуду.")
|
|
interpreter.call_msg("\\c[6]Лона:\\C[0] Покойся с миром, Олег. Ты навсегда останешься в моём сердце.")
|
|
rescue => error
|
|
log("memorial interaction failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def tattoo_bitmap_map
|
|
{
|
|
"TatooStyle01" => "Tatoo_1.png",
|
|
"TatooStyle02" => "Tatoo_2.png",
|
|
"TatooStyle03" => "Tatoo_3.png"
|
|
}
|
|
end
|
|
|
|
def install_chs_parts
|
|
return unless defined?($chs_data) && $chs_data && $chs_data["Lona"]
|
|
data = $chs_data["Lona"]
|
|
parts = data.instance_variable_get(:@lonaParts)
|
|
return unless parts.is_a?(Array)
|
|
return if parts.any? { |part| part && part.instance_variable_get(:@part_name) == "Tatoo_body" }
|
|
|
|
data.name_order["Tatoo_body"] = [STAT_KEY]
|
|
part = Tatoo_CHS_Part.new(tattoo_bitmap_map, 0, 0, 450, "Tatoo_body", 0, false)
|
|
part.name_order = data.name_order
|
|
part.root_folder = CHS_ROOT
|
|
part.generate_h_bitmaps
|
|
parts << part
|
|
parts.sort_by! { |entry| entry.layer }
|
|
data.parts[0] = parts if data.parts && data.parts[0] != parts
|
|
log("CHS tattoo layer installed")
|
|
rescue => error
|
|
log("CHS install failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def portrait_bitmap_map(pose, grounded)
|
|
result = {}
|
|
1.upto(3) do |style|
|
|
filename = "#{pose}_tatoo_#{style}.png"
|
|
if grounded
|
|
result["TatooStyle#{format('%02d', style)},HeadGround00"] = filename
|
|
else
|
|
result["TatooStyle#{format('%02d', style)}"] = filename
|
|
end
|
|
end
|
|
result
|
|
end
|
|
|
|
def install_portrait_parts
|
|
return unless defined?($data_lona_portrait) && $data_lona_portrait
|
|
name_order = $data_lona_portrait[0]
|
|
poses = $data_lona_portrait[1]
|
|
return unless name_order.is_a?(Hash) && poses.is_a?(Hash)
|
|
|
|
PORTRAIT_PARTS.each do |pose, values|
|
|
next unless poses[pose].is_a?(Array)
|
|
x, y, layer, grounded = values
|
|
part_name = "#{pose}_Tatoo"
|
|
next if poses[pose].any? { |part| part && part.instance_variable_get(:@part_name) == part_name }
|
|
|
|
order = grounded ? [STAT_KEY, "HeadGround"] : [STAT_KEY]
|
|
name_order[part_name] = order
|
|
part = Lona_Part.new(portrait_bitmap_map(pose, grounded), x, y, layer, part_name, part_name, false)
|
|
part.root_folder = PORTRAIT_ROOT
|
|
part.set_name_order(name_order)
|
|
poses[pose] << part
|
|
|
|
if grounded
|
|
grounded_name = "#{pose}_Tatoo_HeadGround"
|
|
name_order[grounded_name] = order
|
|
grounded_map = {}
|
|
1.upto(3) do |style|
|
|
grounded_map["TatooStyle#{format('%02d', style)},HeadGround01"] = "#{pose}_tatoo_#{style}.png"
|
|
end
|
|
grounded_part = Lona_Part.new(grounded_map, x + 11, y + (pose == "chcg3" ? 47 : 4), layer, grounded_name, grounded_name, false)
|
|
grounded_part.root_folder = PORTRAIT_ROOT
|
|
grounded_part.set_name_order(name_order)
|
|
poses[pose] << grounded_part
|
|
end
|
|
poses[pose].sort_by! { |entry| entry.layer }
|
|
end
|
|
log("portrait tattoo layers installed")
|
|
rescue => error
|
|
log("portrait install failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def install_visuals
|
|
install_chs_parts
|
|
install_portrait_parts
|
|
end
|
|
|
|
def make_event_page
|
|
page = RPG::Event::Page.new
|
|
page.graphic.character_name = MASTER_GRAPHIC
|
|
page.graphic.character_index = 0
|
|
page.graphic.direction = 2
|
|
page.graphic.pattern = 1
|
|
page.move_type = 1
|
|
page.move_speed = 3
|
|
page.move_frequency = 3
|
|
page.walk_anime = true
|
|
page.step_anime = false
|
|
page.direction_fix = false
|
|
page.through = false
|
|
page.priority_type = 1
|
|
page.trigger = 0
|
|
page.list = [
|
|
RPG::EventCommand.new(355, 0, ["Tatoo.interact(self)"]),
|
|
RPG::EventCommand.new(0, 0, [])
|
|
]
|
|
page
|
|
end
|
|
|
|
def make_memorial_page
|
|
page = RPG::Event::Page.new
|
|
page.graphic.character_name = MEMORIAL_GRAPHIC
|
|
page.graphic.character_index = 0
|
|
page.graphic.direction = 2
|
|
page.graphic.pattern = 1
|
|
page.move_type = 0
|
|
page.walk_anime = false
|
|
page.step_anime = false
|
|
page.direction_fix = true
|
|
page.through = false
|
|
page.priority_type = 1
|
|
page.trigger = 0
|
|
page.list = [
|
|
RPG::EventCommand.new(355, 0, ["Tatoo.interact_memorial(self)"]),
|
|
RPG::EventCommand.new(0, 0, [])
|
|
]
|
|
page
|
|
end
|
|
|
|
def make_cemetery_viktor_page(event_id)
|
|
page = RPG::Event::Page.new
|
|
page.graphic.character_name = MASTER_GRAPHIC
|
|
page.graphic.character_index = 0
|
|
page.graphic.direction = 8
|
|
page.graphic.pattern = 1
|
|
page.move_type = 0
|
|
page.move_speed = 3
|
|
page.move_frequency = 3
|
|
page.walk_anime = true
|
|
page.step_anime = false
|
|
page.direction_fix = false
|
|
page.through = false
|
|
page.priority_type = 1
|
|
# Viktor must remain physically present for the whole night. A parallel
|
|
# page used to start as soon as the map/camera saw him and erased the event
|
|
# before the player reached the memorial. Run the scene only on interaction.
|
|
page.trigger = 0
|
|
page.list = [
|
|
RPG::EventCommand.new(355, 0, ["Tatoo.run_cemetery_viktor(self, #{event_id})"]),
|
|
RPG::EventCommand.new(0, 0, [])
|
|
]
|
|
page
|
|
end
|
|
|
|
def install_master(game_map)
|
|
return unless game_map && game_map.map_id.to_i == MAP_ID
|
|
return if game_map.events.values.any? { |event| event && event.instance_variable_get(:@tatoo_master) }
|
|
event_id = EVENT_ID
|
|
event_id += 1 while game_map.events[event_id]
|
|
source = RPG::Event.new(SPAWN_X, SPAWN_Y)
|
|
source.id = event_id
|
|
source.name = "TatooMaster"
|
|
source.pages = [make_event_page]
|
|
master = Game_Event.new(MAP_ID, source)
|
|
master.instance_variable_set(:@tatoo_master, true)
|
|
master.instance_variable_set(:@tatoo_day_visible, nil)
|
|
game_map.events[event_id] = master
|
|
if defined?($data_npcs) && $data_npcs && $data_npcs[VIKTOR_NPC_TEMPLATE]
|
|
master.set_npc(VIKTOR_NPC_TEMPLATE)
|
|
master.force_update_actor = false
|
|
master.npc.no_aggro = true if master.npc
|
|
else
|
|
log("Viktor NPC template is missing; hit reaction is unavailable")
|
|
end
|
|
update_master_visibility(master, true)
|
|
game_map.add_event_to_pos_hash(master) if game_map.respond_to?(:add_event_to_pos_hash)
|
|
log("master spawned on NoerMarket at #{SPAWN_X},#{SPAWN_Y}")
|
|
rescue => error
|
|
log("master spawn failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def install_cemetery(game_map)
|
|
return unless game_map && game_map.map_id.to_i == CEMETERY_MAP_ID
|
|
|
|
unless game_map.events.values.any? { |event| event && event.instance_variable_get(:@tatoo_memorial) }
|
|
event_id = MEMORIAL_EVENT_ID
|
|
event_id += 1 while game_map.events[event_id]
|
|
source = RPG::Event.new(MEMORIAL_X, MEMORIAL_Y)
|
|
source.id = event_id
|
|
source.name = "OlegMemorial"
|
|
source.pages = [make_memorial_page]
|
|
memorial = Game_Event.new(CEMETERY_MAP_ID, source)
|
|
memorial.instance_variable_set(:@tatoo_memorial, true)
|
|
game_map.events[event_id] = memorial
|
|
game_map.add_event_to_pos_hash(memorial) if game_map.respond_to?(:add_event_to_pos_hash)
|
|
log("Oleg memorial installed at #{MEMORIAL_X},#{MEMORIAL_Y}")
|
|
end
|
|
|
|
update_cemetery_viktor_presence(game_map)
|
|
rescue => error
|
|
log("cemetery install failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def cemetery_viktors(game_map)
|
|
return [] unless game_map && game_map.respond_to?(:events)
|
|
game_map.events.values.select { |event| event && event.instance_variable_get(:@tatoo_cemetery_viktor) }
|
|
end
|
|
|
|
def remove_cemetery_viktors(game_map)
|
|
cemetery_viktors(game_map).each do |event|
|
|
game_map.delete_event_from_pos_hash(event) if game_map.respond_to?(:delete_event_from_pos_hash)
|
|
# Mark the object deleted first so an already-created Sprite_Character is
|
|
# disposed by Spriteset_Map instead of lingering as a ghost sprite.
|
|
event.delete if event.respond_to?(:delete) && !event.deleted?
|
|
game_map.events.delete(event.id)
|
|
end
|
|
rescue => error
|
|
log("cemetery Viktor cleanup failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def spawn_cemetery_viktor(game_map)
|
|
event_id = CEMETERY_VIKTOR_EVENT_ID
|
|
event_id += 1 while game_map.events[event_id]
|
|
source = RPG::Event.new(CEMETERY_VIKTOR_X, CEMETERY_VIKTOR_Y)
|
|
source.id = event_id
|
|
source.name = "ViktorAtOlegMemorial"
|
|
source.pages = [make_cemetery_viktor_page(event_id)]
|
|
viktor = Game_Event.new(CEMETERY_MAP_ID, source)
|
|
viktor.instance_variable_set(:@tatoo_cemetery_viktor, true)
|
|
if defined?($data_npcs) && $data_npcs && $data_npcs[VIKTOR_NPC_TEMPLATE]
|
|
viktor.set_npc(VIKTOR_NPC_TEMPLATE)
|
|
viktor.force_update_actor = false
|
|
viktor.npc.no_aggro = true if viktor.npc
|
|
end
|
|
viktor.force_update = true if viktor.respond_to?(:force_update=)
|
|
viktor.opacity = 255 if viktor.respond_to?(:opacity=)
|
|
viktor.transparent = false if viktor.respond_to?(:transparent=)
|
|
viktor.set_graphic(MASTER_GRAPHIC, 0) if viktor.respond_to?(:set_graphic)
|
|
viktor.refresh if viktor.respond_to?(:refresh)
|
|
game_map.events[event_id] = viktor
|
|
game_map.add_event_to_pos_hash(viktor) if game_map.respond_to?(:add_event_to_pos_hash)
|
|
|
|
# Dynamic events created after Spriteset_Map already exists need to be put
|
|
# into the game's append queue. Without this the event exists in
|
|
# $game_map.events but has no Sprite_Character, so Viktor is invisible.
|
|
if game_map.respond_to?(:added_ev_ids) && game_map.added_ev_ids
|
|
game_map.added_ev_ids << event_id unless game_map.added_ev_ids.include?(event_id)
|
|
end
|
|
|
|
game_map.instance_variable_set(:@tatoo_cemetery_viktor_spawned_this_night, true)
|
|
log("night Viktor installed near Oleg memorial at #{CEMETERY_VIKTOR_X},#{CEMETERY_VIKTOR_Y}")
|
|
end
|
|
|
|
# Keep cemetery Viktor synchronized with the actual night state every frame.
|
|
# Do not trust a one-shot "spawned" flag: if an earlier dynamic spawn failed
|
|
# to acquire a sprite, the watcher must be able to repair it.
|
|
def update_cemetery_viktor_presence(game_map)
|
|
return unless game_map && game_map.map_id.to_i == CEMETERY_MAP_ID
|
|
|
|
existing = cemetery_viktors(game_map)
|
|
unless night?
|
|
remove_cemetery_viktors(game_map) unless existing.empty?
|
|
game_map.instance_variable_set(:@tatoo_cemetery_viktor_spawned_this_night, false)
|
|
return
|
|
end
|
|
|
|
return unless existing.empty?
|
|
|
|
spawn_cemetery_viktor(game_map)
|
|
rescue => error
|
|
log("cemetery Viktor presence update failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def on_screen?(event)
|
|
return false unless event
|
|
x = event.screen_x
|
|
y = event.screen_y
|
|
x >= 0 && x <= Graphics.width && y >= 0 && y <= Graphics.height
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def run_cemetery_viktor(interpreter, event_id)
|
|
event = $game_map.events[event_id]
|
|
return unless event
|
|
|
|
until on_screen?(event)
|
|
if !night? || $game_map.map_id.to_i != CEMETERY_MAP_ID
|
|
return
|
|
end
|
|
Fiber.yield
|
|
end
|
|
|
|
event.turn_up
|
|
event.direction_fix = true
|
|
interpreter.call_msg_popup("Олег... Спасибо тебе за всё.", event_id)
|
|
interpreter.wait(150)
|
|
interpreter.call_msg_popup("Ты всегда был рядом, когда это было нужнее всего.", event_id)
|
|
interpreter.wait(190)
|
|
interpreter.call_msg_popup("Ты был самым лучшим братишкой. Я тебя не забуду.", event_id)
|
|
interpreter.wait(210)
|
|
|
|
# Do not walk away or erase the event. The map watcher removes Viktor only
|
|
# when authoritative time changes to day, so he remains visible all night.
|
|
event.direction_fix = false
|
|
event.turn_down
|
|
rescue => error
|
|
log("cemetery Viktor scene failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def master?(event)
|
|
event && event.instance_variable_get(:@tatoo_master) == true
|
|
end
|
|
|
|
def update_master_visibility(event, force = false)
|
|
visible = day? || event.instance_variable_get(:@tatoo_chasing) || event.instance_variable_get(:@tatoo_attack_intro) || event.instance_variable_get(:@tatoo_caught_pending)
|
|
previous = event.instance_variable_get(:@tatoo_day_visible)
|
|
return if !force && previous == visible
|
|
event.instance_variable_set(:@tatoo_day_visible, visible)
|
|
event.set_graphic(visible ? MASTER_GRAPHIC : "", 0)
|
|
event.through = !visible
|
|
event.move_type = visible ? 1 : 0
|
|
event.opacity = visible ? 255 : 0
|
|
rescue => error
|
|
log("visibility update failed: #{error.class}: #{error.message}")
|
|
end
|
|
|
|
def front_only_charset_bitmap(source)
|
|
return source if source.nil?
|
|
@front_only_charset_cache ||= {}
|
|
cached = @front_only_charset_cache[source]
|
|
return cached if cached && (!cached.respond_to?(:disposed?) || !cached.disposed?)
|
|
return source unless source.width.to_i == 768 && source.height.to_i == 512
|
|
result = Bitmap.new(source.width, source.height)
|
|
result.blt(0, 0, source, Rect.new(0, 0, source.width, 64))
|
|
result.blt(0, 256, source, Rect.new(0, 256, source.width, 64))
|
|
@front_only_charset_cache[source] = result
|
|
result
|
|
rescue => error
|
|
log("front-only charset failed: #{error.class}: #{error.message}")
|
|
source
|
|
end
|
|
end
|
|
|
|
class Tatoo_CHS_Part < Lona_CHS_Part
|
|
def get_bitmap(target, h_mode=-1, position=-1)
|
|
source = super(target, h_mode, position)
|
|
return source if source.nil? || h_mode.to_i >= 0
|
|
Tatoo.front_only_charset_bitmap(source)
|
|
end
|
|
end
|
|
|
|
module Cache
|
|
class << self
|
|
unless method_defined?(:tatoo_character_without_mod)
|
|
alias_method :tatoo_character_without_mod, :character
|
|
end
|
|
|
|
def character(filename)
|
|
return normal_bitmap(Tatoo::MASTER_FILE) if filename.to_s == Tatoo::MASTER_GRAPHIC
|
|
return normal_bitmap(Tatoo::MEMORIAL_FILE) if filename.to_s == Tatoo::MEMORIAL_GRAPHIC
|
|
tatoo_character_without_mod(filename)
|
|
end
|
|
end
|
|
end
|
|
|
|
class Game_Map
|
|
unless method_defined?(:tatoo_setup_without_master)
|
|
alias_method :tatoo_setup_without_master, :setup
|
|
end
|
|
|
|
def setup(map_id)
|
|
Tatoo.record_escape(self, map_id)
|
|
tatoo_setup_without_master(map_id)
|
|
instance_variable_set(:@tatoo_cemetery_viktor_spawned_this_night, false) if map_id.to_i == Tatoo::CEMETERY_MAP_ID
|
|
Tatoo.install_master(self)
|
|
Tatoo.install_cemetery(self)
|
|
end
|
|
|
|
unless method_defined?(:tatoo_update_without_cemetery_watch)
|
|
alias_method :tatoo_update_without_cemetery_watch, :update
|
|
end
|
|
|
|
def update(*args, &block)
|
|
result = tatoo_update_without_cemetery_watch(*args, &block)
|
|
Tatoo.update_cemetery_viktor_presence(self)
|
|
result
|
|
end
|
|
end
|
|
|
|
class Game_Event
|
|
unless method_defined?(:tatoo_update_without_day_check)
|
|
alias_method :tatoo_update_without_day_check, :update
|
|
end
|
|
|
|
def update
|
|
Tatoo.update_master_visibility(self) if Tatoo.master?(self)
|
|
tatoo_update_without_day_check
|
|
Tatoo.update_master_chase(self) if Tatoo.master?(self)
|
|
end
|
|
|
|
unless method_defined?(:tatoo_start_without_day_check)
|
|
alias_method :tatoo_start_without_day_check, :start
|
|
end
|
|
|
|
def start
|
|
if Tatoo.master?(self) && !Tatoo.day? && !instance_variable_get(:@tatoo_chasing) && !instance_variable_get(:@tatoo_caught_pending) && !instance_variable_get(:@tatoo_attack_intro)
|
|
return
|
|
end
|
|
tatoo_start_without_day_check
|
|
end
|
|
end
|
|
|
|
class Game_NonPlayerCharacter
|
|
unless method_defined?(:tatoo_take_skill_effect_without_viktor)
|
|
alias_method :tatoo_take_skill_effect_without_viktor, :take_skill_effect
|
|
end
|
|
|
|
def take_skill_effect(user, skill, can_sap = false, force_hit = false)
|
|
if event && Tatoo.master?(event)
|
|
Tatoo.viktor_attacked(event) unless skill && skill.respond_to?(:is_support) && skill.is_support
|
|
return
|
|
end
|
|
tatoo_take_skill_effect_without_viktor(user, skill, can_sap, force_hit)
|
|
end
|
|
end
|
|
|
|
module DataManager
|
|
class << self
|
|
unless method_defined?(:tatoo_load_mod_database_without_runtime_data)
|
|
alias_method :tatoo_load_mod_database_without_runtime_data, :load_mod_database
|
|
end
|
|
|
|
def load_mod_database
|
|
tatoo_load_mod_database_without_runtime_data
|
|
Tatoo.install_runtime_data
|
|
end
|
|
end
|
|
end
|
|
|
|
Tatoo.install_runtime_data
|
|
MPPortraitPersistence.register(Tatoo::STAT_KEY) if defined?(MPPortraitPersistence)
|
|
Tatoo.log("loaded v#{Tatoo::VERSION}")
|