# 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}")