Files
LonaRPG-Online-Games/ModScripts/_Mods/Tatoo/loader.rb
T

1066 lines
39 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# 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}")