# encoding: UTF-8 #============================================================================== # 38_pvp_male_grab.rb — male-skin "Сбор Сока" (attacker grab) #------------------------------------------------------------------------------ # Male skin ⇒ BasicFuckerGrab as NpcFuckerGrab attacker (not Lona femdom). # # Phases: # grab_start — receiver/grab proxy + hide NetPlayer + local grab # sex_begin — snap, set_chs_sex, spawn visuals, sex_sync pose packet # sex_tick — rehide NetPlayer, Lona_H, fucker_visual, frame copy, periodic sync # sex_end — destroy proxies/visual, restore NetPlayer + GP # # Visual contract (stock receiver-leads-frame): # Attacker: GP hidden; fucker_visual Event + receiver_proxy Lona_H # Target: GP Lona + grab_proxy male; attacker NetPlayer hidden #============================================================================== return unless defined?(WebSocket) module WebSocket MP_MALE_SKIN_KEY = "MP_MaleSkin" unless const_defined?(:MP_MALE_SKIN_KEY) MP_MALE_CHS_KEY = "MP_MaleSkinCHS" unless const_defined?(:MP_MALE_CHS_KEY) MP_MALE_CHS_IDX_KEY = "MP_MaleSkinIdx" unless const_defined?(:MP_MALE_CHS_IDX_KEY) MP_MALE_SKILL = "BasicFuckerGrab" unless const_defined?(:MP_MALE_SKILL) MP_MALE_PROXY_NPC = "NeutralHumanCommonM" unless const_defined?(:MP_MALE_PROXY_NPC) MP_MALE_RECEIVER_PROXY_NPC = "NeutralHumanCommonF" unless const_defined?(:MP_MALE_RECEIVER_PROXY_NPC) MP_MALE_GRAB_ACTION = "pvp_sex_grab" unless const_defined?(:MP_MALE_GRAB_ACTION) # Proven relay channel (combat already uses it). Custom pvp_sex_grab may be dropped. MP_MALE_GRAB_HIT_ACTION = "pvp_skill_hit" unless const_defined?(:MP_MALE_GRAB_HIT_ACTION) # Default random pool for /maleskin and "Random" cheat entry. MP_MALE_VILLAGER_SHEETS = %w[ -char-M-REGULAR01 -char-M-REGULAR02 -char-M-REGULAR03 -char-M-REGULAR04 ].freeze unless const_defined?(:MP_MALE_VILLAGER_SHEETS) # All male CHS sheets the player may wear (cheat categories + ensure). MP_MALE_ALLOWED_SHEETS = %w[ -char-M-REGULAR01 -char-M-REGULAR02 -char-M-REGULAR03 -char-M-REGULAR04 -char-M-FAT01 -char-M-FAT-ABOM01 -char-M-FAT-FISHKIND01 -char-M-FAT-FROGMAN01 -char-M-TEEN01 -char-M-TEEN-FISHKIND01 -char-M-TEEN-FROGMAN01 -char-M-TEEN_UNDEAD01 -char-M-REG_UNDEAD01 -char-M-ORC01 -char-M-OGRE01 -char-M-GOBLIN01 -char-M-HOBGOBLIN01 -char-M-HOBGOBLIN-RD01 -char-M-FISHKIND01 -char-M-FROGMAN01 -char-M-GAINT01 -char-M-GAINT-FISHKIND01 ].freeze unless const_defined?(:MP_MALE_ALLOWED_SHEETS) @mp_male_grab_proxies ||= {} @mp_male_receiver_proxies ||= {} @mp_male_remote_flags ||= {} @mp_male_chs_backup ||= nil class << self begin alias_method :mp_male_grab_parse_without, :parse unless method_defined?(:mp_male_grab_parse_without) rescue end begin alias_method :mp_male_grab_update_without, :update unless method_defined?(:mp_male_grab_update_without) rescue end begin if method_defined?(:handle_remote_deistvia) && !method_defined?(:mp_male_grab_deistvia_without) alias_method :mp_male_grab_deistvia_without, :handle_remote_deistvia end rescue end end def self.mp_male_notify(msg, error=false) text = msg.to_s begin if defined?(System_NotificationOverlay) if error && System_NotificationOverlay.respond_to?(:error) System_NotificationOverlay.error(text) return elsif System_NotificationOverlay.respond_to?(:success) System_NotificationOverlay.success(text) unless error return end end rescue end begin $game_map.popup(0, text, 0, 0) if $game_map rescue puts("[MP_MALE] #{text}") end end def self.mp_male_skin_active? # Module flag survives Story_Stats rebuilds (map transfer / MP state infra). begin return true if @mp_male_skin_local.to_i > 0 rescue end begin # $story_stats is Story_Stats (NOT Hash). Never require is_a?(Hash). return true if $story_stats && $story_stats[MP_MALE_SKIN_KEY].to_i > 0 rescue end false end def self.mp_male_set_flag(value) v = value.to_i > 0 ? 1 : 0 @mp_male_skin_local = v begin if $story_stats $story_stats[MP_MALE_SKIN_KEY] = v end rescue end v end def self.mp_male_remote_is_male?(player_id) pid = player_id.to_i return false if pid <= 0 begin return true if @mp_male_remote_flags[pid].to_i > 0 rescue end false end def self.mp_male_set_remote_flag(player_id, value) pid = player_id.to_i return if pid <= 0 @mp_male_remote_flags ||= {} if value.to_i > 0 @mp_male_remote_flags[pid] = 1 else @mp_male_remote_flags.delete(pid) end rescue end def self.mp_male_local_actor begin return $game_player.actor if $game_player && $game_player.respond_to?(:actor) rescue end nil end def self.mp_male_apply_sex_stat(male) actor = mp_male_local_actor return if actor.nil? val = male ? 1 : 0 # Only write when value differs — battle_stat.set_stat / report_portrait_stat # every frame otherwise keeps portrait/CHS dirty forever. begin if actor.respond_to?(:battle_stat) && actor.battle_stat && actor.battle_stat.respond_to?(:get_stat) cur = actor.battle_stat.get_stat("sex") if cur.to_i != val && actor.battle_stat.respond_to?(:set_stat) actor.battle_stat.set_stat("sex", val) end elsif actor.respond_to?(:battle_stat) && actor.battle_stat && actor.battle_stat.respond_to?(:set_stat) actor.battle_stat.set_stat("sex", val) end rescue end begin if actor.respond_to?(:stat) && actor.stat cur_p = nil begin cur_p = actor.stat["sex"] rescue cur_p = nil end if cur_p.to_i != val actor.stat["sex"] = val end end rescue end end def self.mp_male_grant_skill actor = mp_male_local_actor return false if actor.nil? begin actor.learn_skill(MP_MALE_SKILL) if actor.respond_to?(:learn_skill) true rescue false end end def self.mp_male_revoke_skill actor = mp_male_local_actor return false if actor.nil? begin # Keep Succubus trait skill if the player earned it normally. has_succubus = false begin has_succubus = actor.state_stack("Succubus").to_i > 0 if actor.respond_to?(:state_stack) rescue has_succubus = false end return true if has_succubus if actor.respond_to?(:forget_skill) actor.forget_skill(MP_MALE_SKILL) end true rescue false end end # Prefer stable "villager" outfits (indices 0..7). High indices are often # chained/special NPCs whose sheets look empty at character_index 0. MP_MALE_SAFE_PICKS = [ ["-char-M-REGULAR01", 0], ["-char-M-REGULAR01", 1], ["-char-M-REGULAR01", 3], ["-char-M-REGULAR02", 0], ["-char-M-REGULAR03", 0], ["-char-M-REGULAR04", 0], ["-char-M-REGULAR04", 3], ["-char-M-REGULAR04", 6] ].freeze unless const_defined?(:MP_MALE_SAFE_PICKS) def self.mp_male_sheet_allowed?(sheet) s = sheet.to_s return false if s.empty? return true if MP_MALE_ALLOWED_SHEETS.include?(s) s.start_with?("-char-M-") rescue false end def self.mp_male_available_villager_sheets sheets = [] MP_MALE_VILLAGER_SHEETS.each do |sheet| begin sheets << sheet if defined?($chs_data) && $chs_data && $chs_data[sheet] rescue end end sheets end def self.mp_male_available_allowed_sheets sheets = [] MP_MALE_ALLOWED_SHEETS.each do |sheet| begin sheets << sheet if defined?($chs_data) && $chs_data && $chs_data[sheet] rescue end end sheets end def self.mp_male_valid_part_indices(sheet, max_index=nil) indices = [] begin parts = $chs_data[sheet].parts return indices unless parts limit = max_index.nil? ? (parts.length - 1) : max_index.to_i parts.each_with_index do |part, i| next if part.nil? next if i > limit indices << i end rescue end indices end def self.mp_male_pick_has_body?(sheet, idx) begin parts = $chs_data[sheet].parts[idx.to_i] return false if parts.nil? parts.each do |part| next if part.nil? return true if part.part_name.to_s == "body" end rescue end false end def self.mp_male_pick_villager_chs sheets = mp_male_available_villager_sheets begin if $story_stats stored = $story_stats[MP_MALE_CHS_KEY].to_s stored_idx = $story_stats[MP_MALE_CHS_IDX_KEY].to_i if !stored.empty? && mp_male_sheet_allowed?(stored) && defined?($chs_data) && $chs_data && $chs_data[stored] && mp_male_pick_has_body?(stored, stored_idx) return [stored, stored_idx] end end rescue end return nil if sheets.empty? pool = [] MP_MALE_SAFE_PICKS.each do |sheet, idx| next unless sheets.include?(sheet) next unless mp_male_pick_has_body?(sheet, idx) pool << [sheet, idx] end return pool.sample unless pool.empty? sheet = sheets.sample valid = mp_male_valid_part_indices(sheet, 7) return nil if valid.empty? [sheet, valid.sample] end def self.mp_male_invalidate_chs_cache(player) return if player.nil? begin name = player.chs_name.to_s chars = Cache.instance_variable_get(:@chs_chars) chars.delete(name) if chars.is_a?(Hash) && !name.empty? chars.delete("Lona") if chars.is_a?(Hash) chars.delete("Lona_H") if chars.is_a?(Hash) last = Cache.instance_variable_get(:@last_parts) last.delete(player) if last.is_a?(Hash) rescue end end def self.mp_male_force_player_sprite_refresh return unless $game_player $game_player.instance_variable_set(:@chs_need_update, true) found = 0 begin scene = SceneManager.scene ss = scene.instance_variable_get(:@spriteset) if scene sprites = ss.instance_variable_get(:@character_sprites) if ss if sprites.is_a?(Array) sprites.each do |sp| next if sp.nil? || (sp.respond_to?(:disposed?) && sp.disposed?) next unless sp.character.equal?($game_player) found += 1 begin # Force graphic_changed path sp.instance_variable_set(:@character_name, "__mp_male_force__") sp.instance_variable_set(:@character_index, -1) sp.update if sp.respond_to?(:update) rescue end end end rescue end found end # Build NPC-style config; never pick NA/nil filenames (stock sampler can). def self.mp_male_build_chs_configuration(player, sheet, idx) cfg = { "sex_pos" => -1, "sex_position" => -1 } begin parts = $chs_data[sheet.to_s].parts[idx.to_i] if parts parts.each do |part| next if part.nil? pname = part.part_name.to_s next if pname.empty? || pname == "name" candidates = [] begin part.bitmaps.each do |_k, v| s = v.to_s next if s.empty? || s == "NA" || s == "nil" next unless s.include?(".png") candidates << s end rescue end cfg[pname] = candidates.sample unless candidates.empty? end end rescue end player.instance_variable_set(:@chs_configuration, cfg) cfg end def self.mp_male_backup_lona_chs return unless $game_player return if @mp_male_chs_backup.is_a?(Hash) cfg = nil begin cfg = $game_player.chs_configuration cfg = cfg.dup if cfg.is_a?(Hash) rescue cfg = nil end actor_cname = "" actor_cindex = 0 begin if $game_player.actor actor_cname = $game_player.actor.character_name.to_s actor_cindex = $game_player.actor.character_index.to_i end rescue end @mp_male_chs_backup = { "chs_type" => ($game_player.instance_variable_get(:@chs_type) rescue nil), "charset_index" => ($game_player.charset_index rescue 0), "chs_configuration" => cfg, "chs_name" => ($game_player.instance_variable_get(:@chs_name) rescue nil), "chs_name_h" => ($game_player.instance_variable_get(:@chs_name_h) rescue nil), "character_name" => ($game_player.instance_variable_get(:@character_name).to_s rescue ""), "character_index" => ($game_player.instance_variable_get(:@character_index).to_i rescue 0), "actor_character_name" => actor_cname, "actor_character_index" => actor_cindex } rescue @mp_male_chs_backup = { "chs_type" => nil, "charset_index" => 0 } end # Sprite_Character treats names with '$' as 3x4 sheets. NPC CHS is 12x8 — # leaving Lona's $ name makes the male sheet sample empty cells (invisible). def self.mp_male_fix_chs_sprite_name return unless $game_player begin $game_player.instance_variable_set(:@character_name, "") rescue end begin $game_player.instance_variable_set(:@manual_character_name, "") if $game_player.instance_variable_defined?(:@manual_character_name) rescue end end def self.mp_male_resolve_display_char_index(sheet, charset_idx) begin chs_def = $chs_data && $chs_data[sheet.to_s] ? $chs_data[sheet.to_s] : nil if chs_def && chs_def.respond_to?(:chs_default_index) arr = chs_def.chs_default_index if arr && !arr[charset_idx.to_i].nil? return arr[charset_idx.to_i].to_i end end rescue end 0 end def self.mp_male_apply_villager_skin(force_reroll=false) return false unless $game_player return false if mp_male_available_villager_sheets.empty? if force_reroll begin if $story_stats $story_stats[MP_MALE_CHS_KEY] = "" if $story_stats.respond_to?(:[]=) $story_stats[MP_MALE_CHS_IDX_KEY] = -1 if $story_stats.respond_to?(:[]=) $story_stats.delete(MP_MALE_CHS_KEY) if $story_stats.respond_to?(:delete) $story_stats.delete(MP_MALE_CHS_IDX_KEY) if $story_stats.respond_to?(:delete) end rescue end end pick = mp_male_pick_villager_chs return false if pick.nil? sheet, idx = pick mp_male_backup_lona_chs begin if $story_stats $story_stats[MP_MALE_CHS_KEY] = sheet.to_s $story_stats[MP_MALE_CHS_IDX_KEY] = idx.to_i end rescue end begin $game_player.instance_variable_set(:@charset_index, idx.to_i) $game_player.instance_variable_set(:@chs_type, sheet.to_s) begin if $game_player.respond_to?(:set_char_type) $game_player.set_char_type(sheet.to_s, false) end rescue $game_player.instance_variable_set(:@chs_type, sheet.to_s) end # Unique cache key so we don't reuse Lona/Lona_H bitmap slots. cache_key = "MP_MaleLocal_#{sheet}_#{idx}" begin my = @my_id.to_i cache_key = "MP_MaleLocal_#{my}_#{sheet}_#{idx}" if my > 0 rescue end $game_player.instance_variable_set(:@chs_name, cache_key) $game_player.instance_variable_set(:@chs_name_h, cache_key + "_H") mp_male_build_chs_configuration($game_player, sheet, idx) display_idx = mp_male_resolve_display_char_index(sheet, idx) $game_player.instance_variable_set(:@character_index, display_idx) $game_player.instance_variable_set(:@ps_sync_character_index, display_idx) rescue nil mp_male_fix_chs_sprite_name begin $game_player.transparent = false if $game_player.respond_to?(:transparent=) $game_player.opacity = 255 if $game_player.respond_to?(:opacity=) rescue end mp_male_invalidate_chs_cache($game_player) $game_player.instance_variable_set(:@chs_need_update, true) rebuild = lambda do $game_player.refresh_chs if $game_player.respond_to?(:refresh_chs) end begin if defined?(LonaPaletteStudio) && LonaPaletteStudio.respond_to?(:without_palette_rendering) LonaPaletteStudio.without_palette_rendering(&rebuild) else rebuild.call end rescue rebuild.call end rescue => e begin puts("[MP_MALE] apply skin error: #{e.class}: #{e.message}") rescue end return false end begin mp_male_force_player_sprite_refresh rescue end begin send_playersync_full("male_skin_on", true) if respond_to?(:send_playersync_full) rescue end true end def self.mp_male_restore_lona_skin return false unless $game_player backup = @mp_male_chs_backup begin if backup.is_a?(Hash) $game_player.instance_variable_set(:@chs_type, backup["chs_type"]) $game_player.instance_variable_set(:@charset_index, backup["charset_index"].to_i) $game_player.instance_variable_set(:@chs_configuration, backup["chs_configuration"]) $game_player.instance_variable_set(:@chs_name, backup["chs_name"]) $game_player.instance_variable_set(:@chs_name_h, backup["chs_name_h"]) cname = backup["character_name"].to_s cname = backup["actor_character_name"].to_s if cname.empty? $game_player.instance_variable_set(:@character_name, cname) cindex = backup.has_key?("character_index") ? backup["character_index"].to_i : backup["actor_character_index"].to_i $game_player.instance_variable_set(:@character_index, cindex) else $game_player.instance_variable_set(:@chs_type, nil) $game_player.instance_variable_set(:@chs_configuration, nil) $game_player.instance_variable_set(:@charset_index, 0) begin if $game_player.actor $game_player.instance_variable_set(:@character_name, $game_player.actor.character_name.to_s) $game_player.instance_variable_set(:@character_index, $game_player.actor.character_index.to_i) end rescue end end rescue end begin if $story_stats $story_stats.delete(MP_MALE_CHS_KEY) if $story_stats.respond_to?(:delete) $story_stats.delete(MP_MALE_CHS_IDX_KEY) if $story_stats.respond_to?(:delete) end rescue end @mp_male_chs_backup = nil begin actor = mp_male_local_actor if actor && actor.respond_to?(:stat) && actor.stat.is_a?(Hash) actor.stat["sex_pos"] = -1 if actor.stat["sex_pos"].to_i >= 0 && !($game_player.respond_to?(:sex_mode?) && $game_player.sex_mode?) end rescue end begin $game_player.instance_variable_set(:@chs_need_update, true) # Stock refresh restores Lona $ character_name from actor. $game_player.refresh if $game_player.respond_to?(:refresh) $game_player.refresh_chs if $game_player.respond_to?(:refresh_chs) if $game_player.respond_to?(:actor) && $game_player.actor && $game_player.actor.respond_to?(:update_chs) $game_player.actor.update_chs end rescue end begin send_playersync_full("male_skin_off", true) if respond_to?(:send_playersync_full) rescue end true rescue false end def self.mp_male_player_in_sex_flow? return false unless $game_player && $game_player.actor begin return true if $game_player.respond_to?(:sex_mode?) && $game_player.sex_mode? rescue end begin st = $game_player.actor.action_state return true if st == :sex || st == :grabber || st == :grabbed rescue end false rescue false end def self.mp_male_ensure_villager_skin return false unless mp_male_skin_active? return false unless $game_player # Re-write story flag if MP infra rebuilt Story_Stats without our key. begin mp_male_set_flag(1) rescue end # During grab/sex, do NOT rebuild CHS / force sprite — that blinks every frame # because sex bitmaps use a different cache path than the walk key. return true if mp_male_player_in_sex_flow? current = "" begin current = $game_player.instance_variable_get(:@chs_type).to_s rescue current = "" end ok = mp_male_sheet_allowed?(current) && $game_player.chs_configuration.is_a?(Hash) unless ok return mp_male_apply_villager_skin(false) end # refresh()/map transfer may put Lona's '$' name back → invisible male CHS. begin cname = $game_player.instance_variable_get(:@character_name).to_s if cname != "" && (cname.include?("$") || cname[0, 1] == "!") mp_male_fix_chs_sprite_name $game_player.instance_variable_set(:@chs_need_update, true) end rescue end # After Cache.clear_chs on map change, rebuild if cache slot is missing. # Throttle: at most once per ~30 frames to avoid blink loops. begin @mp_male_cache_fix_cd = @mp_male_cache_fix_cd.to_i - 1 if @mp_male_cache_fix_cd.to_i > 0 chars = Cache.instance_variable_get(:@chs_chars) key = $game_player.chs_name.to_s if @mp_male_cache_fix_cd.to_i <= 0 && chars.is_a?(Hash) && (key.empty? || chars[key].nil?) @mp_male_cache_fix_cd = 30 mp_male_invalidate_chs_cache($game_player) $game_player.instance_variable_set(:@chs_need_update, true) $game_player.refresh_chs if $game_player.respond_to?(:refresh_chs) mp_male_force_player_sprite_refresh end rescue end true rescue false end # Repair OverMapID if wiped/invalid (exit to overmap → setup(0)). # Never treat a non-overmap id (e.g. 2) as valid just because it is > 0. def self.mp_male_repair_overmap_id(reference_map_id=nil) before = 0 begin before = $story_stats["OverMapID"].to_i if $story_stats rescue before = 0 end begin if before > 0 && respond_to?(:overmap_map_id?) && overmap_map_id?(before) return before end rescue end repaired = 0 begin if respond_to?(:ensure_overmap_story_location) repaired = ensure_overmap_story_location(reference_map_id).to_i end rescue repaired = 0 end begin if repaired > 0 && respond_to?(:overmap_map_id?) && !overmap_map_id?(repaired) repaired = 0 end rescue end repaired.to_i rescue 0 end def self.mp_male_transfer_is_tag_key?(map_id) s = map_id.to_s return false if s.empty? # Numeric ids are fine; string keys like "NoerHome" must not be rewritten. return true if map_id.is_a?(String) && s !~ /\A\d+\z/ false rescue false end # Called after map transfer — Cache.clear_chs wipes male bitmaps. def self.mp_male_on_map_transfer return false unless mp_male_skin_active? mp_male_set_flag(1) begin mp_male_apply_villager_skin(false) rescue end true rescue false end # Apply a concrete male sheet/index (cheat menu / explicit pick). def self.mp_male_apply_specific_skin(sheet, idx) return false unless $game_player sheet = sheet.to_s idx = idx.to_i return false unless mp_male_sheet_allowed?(sheet) begin return false unless defined?($chs_data) && $chs_data && $chs_data[sheet] rescue return false end return false unless mp_male_pick_has_body?(sheet, idx) begin if $story_stats $story_stats[MP_MALE_CHS_KEY] = sheet $story_stats[MP_MALE_CHS_IDX_KEY] = idx end rescue end mp_male_apply_villager_skin(false) rescue false end # CheatFramework / admin: enable male skin with a fixed SAFE_PICKS entry. def self.mp_male_menu_apply_pick(sheet, idx) sheet = sheet.to_s idx = idx.to_i was_on = mp_male_skin_active? mp_male_set_flag(1) begin mp_male_repair_overmap_id($game_map ? $game_map.map_id : nil) rescue end mp_male_apply_sex_stat(true) mp_male_grant_skill ok = mp_male_apply_specific_skin(sheet, idx) mp_male_broadcast_flag(1) if ok if ok label = sheet.sub(/^-char-M-/, "") msg = was_on ? "Мужской скин: #{label} ##{idx}" : "Мужской скин: ВКЛ (#{label} ##{idx}). Умение «Сбор Сока» выдано." mp_male_notify(msg) else mp_male_notify("Не удалось применить скин #{sheet} ##{idx}.", true) end ok rescue false end def self.mp_male_menu_current_pick return nil unless mp_male_skin_active? sheet = "" idx = -1 begin sheet = $story_stats[MP_MALE_CHS_KEY].to_s if $story_stats idx = $story_stats[MP_MALE_CHS_IDX_KEY].to_i if $story_stats rescue return nil end return nil if sheet.empty? [sheet, idx] rescue nil end def self.mp_male_skin_enable mp_male_set_flag(1) begin # Heal OverMapID if an older buggy enable wiped Story_Stats keys. mp_male_repair_overmap_id($game_map ? $game_map.map_id : nil) rescue end mp_male_apply_sex_stat(true) mp_male_grant_skill skin_ok = mp_male_apply_villager_skin(true) mp_male_broadcast_flag(1) if skin_ok sheet = "" begin sheet = $story_stats[MP_MALE_CHS_KEY].to_s if $story_stats rescue sheet = "" end label = sheet.empty? ? "житель" : sheet.sub(/^-char-M-/, "") mp_male_notify("Мужской скин: ВКЛ (#{label}). Умение «Сбор Сока» выдано.") else mp_male_notify("Мужской скин: ВКЛ. Умение «Сбор Сока» выдано.") end true rescue false end def self.mp_male_skin_disable mp_male_set_flag(0) begin if $story_stats $story_stats.delete(MP_MALE_CHS_KEY) if $story_stats.respond_to?(:delete) $story_stats.delete(MP_MALE_CHS_IDX_KEY) if $story_stats.respond_to?(:delete) end rescue end mp_male_apply_sex_stat(false) mp_male_revoke_skill mp_male_restore_lona_skin mp_male_broadcast_flag(0) mp_male_cleanup_local_attacker mp_male_notify("Мужской скин: ВЫКЛ.") true rescue false end def self.mp_male_skin_toggle mp_male_skin_active? ? mp_male_skin_disable : mp_male_skin_enable end def self.mp_male_broadcast_flag(value) return unless @connected && !@my_id.nil? begin if respond_to?(:send_deistvia) send_deistvia(MP_MALE_GRAB_ACTION, "flag", { "male" => value.to_i }) end rescue end end def self.mp_male_front_tile tx = $game_player.x.to_i ty = $game_player.y.to_i case $game_player.direction.to_i when 2 then ty += 1 when 4 then tx -= 1 when 6 then tx += 1 when 8 then ty -= 1 end [tx, ty] rescue nil end def self.mp_male_net_player_id(ev) return 0 if ev.nil? begin return ev.instance_variable_get(:@net_player_id).to_i if ev.instance_variable_defined?(:@net_player_id) rescue end 0 rescue 0 end # NetPlayers are valid grab targets for male skin (female or male — vanilla males # can grab each other when CHS supports receiver slots). # Prefer exact front tile; fall back to facing cone (range 1) like 98_pvp_skill_sync # — NetPlayer coords can lag one tile off the strict front cell. def self.mp_male_front_net_player return nil unless @players.is_a?(Hash) tile = mp_male_front_tile px = $game_player ? $game_player.x.to_i : 0 py = $game_player ? $game_player.y.to_i : 0 dir = $game_player ? $game_player.direction.to_i : 2 exact = nil facing = nil if tile tx, ty = tile @players.each do |pid, ev| next if ev.nil? begin ex = ev.x.to_i ey = ev.y.to_i if ex == tx && ey == ty exact = [pid.to_i, ev] break end dx = ex - px dy = ey - py dist = dx.abs + dy.abs next if dist < 1 || dist > 1 ok = case dir when 2 then dy > 0 && dx.abs <= 1 when 4 then dx < 0 && dy.abs <= 1 when 6 then dx > 0 && dy.abs <= 1 when 8 then dy < 0 && dx.abs <= 1 else false end facing = [pid.to_i, ev] if ok && facing.nil? rescue next end end end exact || facing rescue nil end def self.mp_male_resolve_net_target(summon_target) if summon_target begin pid = mp_male_net_player_id(summon_target) return [pid, summon_target] if pid > 0 rescue end begin sx = summon_target.x.to_i sy = summon_target.y.to_i if @players.is_a?(Hash) @players.each do |pid, ev| next if ev.nil? begin return [pid.to_i, ev] if ev.x.to_i == sx && ev.y.to_i == sy rescue end end end rescue end end mp_male_front_net_player end def self.mp_male_has_receiver_slots?(ev) defn = nil begin defn = ev.chs_definition if ev.respond_to?(:chs_definition) rescue defn = nil end return false if defn.nil? sr = nil begin sr = defn.supported_receiver if defn.respond_to?(:supported_receiver) rescue sr = nil end return false unless sr.is_a?(Array) sr.any? { |pose| pose.is_a?(Array) && !pose.empty? && pose != [0] } rescue false end def self.mp_male_event_grabbable_npc?(ev) return false if ev.nil? || ev == $game_player return false if mp_male_net_player_id(ev) > 0 begin return false if ev.respond_to?(:mp_male_grab_proxy) && ev.mp_male_grab_proxy rescue end begin return false if ev.respond_to?(:mp_male_receiver_proxy) && ev.mp_male_receiver_proxy rescue end begin sd = ev.instance_variable_get(:@summon_data) return false if sd.is_a?(Hash) && (sd[:mp_male_grab_proxy] || sd[:mp_male_receiver_proxy]) rescue end actor = nil begin actor = ev.actor if ev.respond_to?(:actor) rescue actor = nil end return false if actor.nil? begin return false if actor.is_object return false if defined?(Game_PorjectileCharacter) && actor.is_a?(Game_PorjectileCharacter) return false if defined?(Game_DestroyableObject) && actor.is_a?(Game_DestroyableObject) return false if defined?(GameTrap) && actor.is_a?(GameTrap) return false if actor.action_state == :death rescue return false end begin return false unless ev.respond_to?(:use_chs?) && ev.use_chs? rescue return false end mp_male_has_receiver_slots?(ev) rescue false end def self.mp_male_resolve_npc_target(summon_target) if mp_male_event_grabbable_npc?(summon_target) return summon_target end sx = nil sy = nil begin if summon_target sx = summon_target.x.to_i sy = summon_target.y.to_i end rescue sx = nil sy = nil end if sx.nil? tile = mp_male_front_tile return nil if tile.nil? sx, sy = tile end begin npcs = $game_map.npcs if $game_map && $game_map.respond_to?(:npcs) if npcs.is_a?(Array) hit = npcs.select { |ev| begin next false unless mp_male_event_grabbable_npc?(ev) ev.respond_to?(:pos?) ? ev.pos?(sx, sy) : (ev.x.to_i == sx && ev.y.to_i == sy) rescue false end } return hit.sample unless hit.nil? || hit.empty? end rescue end nil end def self.mp_male_pose_hint begin return $game_player.instance_variable_get(:@femdonMode).to_s if $game_player rescue end "" end def self.mp_male_grab_skill begin return $data_arpgskills["NpcFuckerGrab"] if defined?($data_arpgskills) && $data_arpgskills && $data_arpgskills["NpcFuckerGrab"] rescue end begin return $data_arpgskills[MP_MALE_SKILL] if defined?($data_arpgskills) && $data_arpgskills rescue end nil end # Mirror Game_NonPlayerCharacter#set_fucker_target_attacker for Game_Actor. def self.mp_male_start_local_attacker_grab(target, effect_ev=nil) actor = mp_male_local_actor return false if actor.nil? || target.nil? mp_male_apply_sex_stat(true) begin actor.holding_efx = effect_ev if effect_ev && actor.respond_to?(:holding_efx=) rescue end begin if target.respond_to?(:grabbed?) && target.grabbed? if target.respond_to?(:add_sex_gang) && target.add_sex_gang($game_player) actor.fucker_target = target if actor.respond_to?(:fucker_target=) actor.set_action_state(:sex) if actor.respond_to?(:set_action_state) return true end target.add_fapper($game_player) if target.respond_to?(:add_fapper) return false end if target.respond_to?(:sex?) && target.sex? if target.respond_to?(:add_sex_gang) && target.add_sex_gang($game_player) actor.fucker_target = target if actor.respond_to?(:fucker_target=) actor.set_action_state(:sex) if actor.respond_to?(:set_action_state) return true end target.add_fapper($game_player) if target.respond_to?(:add_fapper) return false end rescue => e begin puts("[MP_MALE] local grab join err: #{e.class}: #{e.message}") rescue end end # Fresh grab — passive=true so Game_Event#grab accepts us as fucker. ok = false begin # Fresh QTE counter; stale grab_count can skip straight to cancel (>boundary). target.instance_variable_set(:@grab_count, 0) if target.respond_to?(:instance_variable_set) target.grab_boundary = 1 if target.respond_to?(:grab_boundary=) ok = target.grab($game_player, true) rescue => e begin puts("[MP_MALE] target.grab err: #{e.class}: #{e.message}") rescue end ok = false end return false unless ok begin actor.fucker_target = target if actor.respond_to?(:fucker_target=) actor.set_action_state(:grabber) if actor.respond_to?(:set_action_state) rescue end begin # Mirror EffectGrabHit / femdom link so NPC sex updates keep a partner ref. target.actor.fucker_target = $game_player if target.actor && target.actor.respond_to?(:fucker_target=) rescue end begin $game_player.call_balloon(3) if $game_player.respond_to?(:call_balloon) rescue end begin if target.actor && !target.actor.no_aggro && defined?($data_arpgskills) target.actor.set_aggro(actor, $data_arpgskills["BasicNormal"], 600, true) end rescue end begin $game_player.moveto($game_player.x, $game_player.y) if $game_player.respond_to?(:moveto) target.moveto(target.x, target.y) if target.respond_to?(:moveto) rescue end # Defer set_chs_sex_group until after BasicFuckerGrab's reset_skill — that # stock call would release_chs_group while action_state is :grabber/:sex. @mp_male_pending_sex_npc = target @mp_male_pending_sex_frames = 0 true end def self.mp_male_tick_pending_sex return false if @mp_male_pending_sex_npc.nil? @mp_male_pending_sex_frames = @mp_male_pending_sex_frames.to_i + 1 target = @mp_male_pending_sex_npc actor = mp_male_local_actor # Wait until local skill fully ended (reset_skill already ran). skill_busy = false begin skill_busy = !actor.nil? && !actor.skill.nil? rescue skill_busy = false end if skill_busy return false end begin alive = target && !(target.respond_to?(:deleted?) && target.deleted?) grabbed = alive && target.respond_to?(:grabbed?) && target.grabbed? already_sex = false begin already_sex = (actor && actor.action_state == :sex) || (target.respond_to?(:sex_mode?) && target.sex_mode?) || (target.actor && target.actor.action_state == :sex) rescue already_sex = false end rescue alive = false grabbed = false already_sex = false end # sex_begin: snap + Lona_H + fucker_visual Event; never build sex on GP male. if already_sex mp_male_sex_begin_attacker(target) mp_male_send_sex_pose_sync(@mp_male_net_grab_tid) @mp_male_pending_sex_npc = nil return true end unless alive && grabbed @mp_male_pending_sex_npc = nil return false end begin actor.fucker_target = target if actor && actor.respond_to?(:fucker_target=) actor.set_action_state(:grabber) if actor && actor.respond_to?(:set_action_state) rescue end begin target.set_chs_sex_group if target.respond_to?(:set_chs_sex_group) rescue @mp_male_pending_sex_npc = nil return false end mp_male_sex_begin_attacker(target) # Broadcast pose + stage/frame so the target client matches. mp_male_send_sex_pose_sync(@mp_male_net_grab_tid) @mp_male_pending_sex_npc = nil true rescue @mp_male_pending_sex_npc = nil false end # Phase sex_begin (attacker): receiver drives frames; GP male sprite hidden. def self.mp_male_sex_begin_attacker(recv_ev) return false if recv_ev.nil? || $game_player.nil? begin sx = recv_ev.x.to_i sy = recv_ev.y.to_i mp_male_snap_xy(recv_ev, sx, sy) mp_male_snap_xy($game_player, sx, sy) recv_ev.opacity = 255 if recv_ev.respond_to?(:opacity=) mp_male_apply_lona_sex_chs(recv_ev, true) mp_male_refresh_sex_animation(recv_ev) # Do NOT refresh GP male sex animation — peach/static source. mp_male_ensure_fucker_visual(sx, sy) mp_male_sync_fucker_visual(recv_ev) mp_male_set_local_fucker_visible(false) mp_male_dedupe_character_sprites(recv_ev) @mp_male_pose_sync_cd = 0 rescue return false end true rescue false end def self.mp_male_sex_state_and_frame gp = $game_player sex_state = 1 aframe = 0 recv = nil begin if @mp_male_receiver_proxies.is_a?(Hash) tid = @mp_male_net_grab_tid.to_i recv = @mp_male_receiver_proxies[tid] if tid > 0 recv = @mp_male_receiver_proxies.values.first if recv.nil? end rescue recv = nil end begin # Receiver owns sex_state/stages (stock). if recv sex_state = recv.instance_variable_get(:@sex_state).to_i elsif gp sex_state = gp.instance_variable_get(:@sex_state).to_i end sex_state = 1 if sex_state < 1 rescue sex_state = 1 end begin if recv && recv.animation aframe = recv.animation.frame.to_i elsif gp && gp.animation aframe = gp.animation.frame.to_i end rescue aframe = 0 end [sex_state, aframe] rescue [1, 0] end # Pose lock (and optional periodic stage/frame). Attacker → target. def self.mp_male_send_sex_pose_sync(tid, periodic=false) tid = tid.to_i return false if tid <= 0 return false unless respond_to?(:send_deistvia) gp = $game_player return false if gp.nil? cfg = gp.chs_configuration.is_a?(Hash) ? gp.chs_configuration : {} sex_pos = cfg["sex_pos"].to_i sex_position = cfg["sex_position"].to_i return false if sex_pos < 0 sex_state, aframe = mp_male_sex_state_and_frame send_deistvia(MP_MALE_GRAB_HIT_ACTION, "hit", { "target" => tid, "skill_name" => MP_MALE_SKILL.to_s, "sex_grab" => 1, "sex_sync" => 1, "sex_pos" => sex_pos, "sex_position" => sex_position, "sex_state" => sex_state, "aframe" => aframe, "hp" => 0, "sta" => 0, "dmg" => 0 }) @mp_male_last_pose_sync_sig = "#{sex_pos}:#{sex_position}:#{sex_state}:#{aframe}" true rescue false end # ~12 Hz pose/stage/frame keepalive while attacker sex is active. def self.mp_male_tick_sex_pose_sync tid = @mp_male_net_grab_tid.to_i return false if tid <= 0 return false unless mp_male_skin_active? gp = $game_player return false if gp.nil? begin return false unless gp.sex_mode? || (gp.actor && gp.actor.action_state == :sex) rescue return false end @mp_male_pose_sync_cd = @mp_male_pose_sync_cd.to_i - 1 return false if @mp_male_pose_sync_cd > 0 @mp_male_pose_sync_cd = 5 sex_state, aframe = mp_male_sex_state_and_frame cfg = gp.chs_configuration.is_a?(Hash) ? gp.chs_configuration : {} sig = "#{cfg["sex_pos"].to_i}:#{cfg["sex_position"].to_i}:#{sex_state}:#{aframe}" return false if sig == @mp_male_last_pose_sync_sig.to_s && aframe == @mp_male_last_aframe_sent.to_i @mp_male_last_aframe_sent = aframe mp_male_send_sex_pose_sync(tid, true) rescue false end def self.mp_male_online_pvp_ok? return false unless @connected && @worldsync && !@my_id.nil? return false if defined?(MPSafeZone) && MPSafeZone.active? true rescue false end # Called from EffectLonaGrabHit when local male skin is active. # Always consumes the hit (skip stock femdom) — BasicFuckerGrab must behave # like NpcFuckerGrab (attacker grabs receiver), including male↔male. def self.mp_male_try_handle_grab_hit(effect_ev) return false unless mp_male_skin_active? tar = nil begin sd = effect_ev.summon_data if effect_ev.respond_to?(:summon_data) tar = sd[:target] if sd.is_a?(Hash) rescue tar = nil end # 1) Exact summon target first (do not steal an NPC hit for a front NetPlayer). if tar && mp_male_online_pvp_ok? pid = mp_male_net_player_id(tar) if pid > 0 mp_male_start_attacker_grab(pid, tar, effect_ev) return true end end if mp_male_event_grabbable_npc?(tar) mp_male_start_local_attacker_grab(tar, effect_ev) return true end # 2) Same-tile / front fallbacks. if mp_male_online_pvp_ok? begin pair = mp_male_resolve_net_target(tar) if pair && pair[0].to_i > 0 && pair[1] mp_male_start_attacker_grab(pair[0].to_i, pair[1], effect_ev) return true end rescue => e begin puts("[MP_MALE] net grab err: #{e.class}: #{e.message}") rescue end end end npc = mp_male_resolve_npc_target(tar) if npc mp_male_start_local_attacker_grab(npc, effect_ev) return true end # No valid target — still consume so femdom path does not grab males wrongly. true rescue => e begin puts("[MP_MALE] grab hit error: #{e.class}: #{e.message}") rescue end true end # When only a NetPlayer stands in front, stock SexSkillFront.scan never sees # them — EffectLonaGrabHit is never summoned. Fire grab manually after cast. def self.mp_male_after_skill_result(skill) return false unless mp_male_skin_active? return false if skill.nil? sname = "" begin sname = skill.name.to_s if skill.respond_to?(:name) sname = skill.item_name.to_s if sname.empty? && skill.respond_to?(:item_name) rescue sname = "" end return false unless sname == MP_MALE_SKILL || sname == "BasicFuckerGrab" actor = mp_male_local_actor return false if actor.nil? begin st = actor.action_state return false if st == :grabber || st == :sex rescue end if @connected && @worldsync && !@my_id.nil? begin unless defined?(MPSafeZone) && MPSafeZone.active? pair = mp_male_front_net_player if pair && pair[0].to_i > 0 return mp_male_start_attacker_grab(pair[0].to_i, pair[1], nil) end end rescue end end npc = mp_male_resolve_npc_target(nil) return mp_male_start_local_attacker_grab(npc, nil) if npc false rescue false end def self.mp_male_start_attacker_grab(tid, net_ev, effect_ev=nil) actor = mp_male_local_actor return false if actor.nil? mx = $game_player ? $game_player.x.to_i : 0 my = $game_player ? $game_player.y.to_i : 0 begin mx = net_ev.x.to_i if net_ev my = net_ev.y.to_i if net_ev rescue end @mp_male_net_grab_tid = tid.to_i # Local sex uses a stand-in that copies the NetPlayer's CHS look. receiver = mp_male_ensure_receiver_proxy(tid.to_i, mx, my, net_ev) local_ok = receiver ? mp_male_start_local_attacker_grab(receiver, effect_ev) : false pose = mp_male_pose_hint sent = false begin if respond_to?(:send_deistvia) # Start grab on target immediately; pose sync follows after local sex picks pose. send_deistvia(MP_MALE_GRAB_HIT_ACTION, "hit", { "target" => tid.to_i, "skill_name" => MP_MALE_SKILL.to_s, "sex_grab" => 1, "hp" => 0, "sta" => 0, "dmg" => 0, "pose" => pose.to_s, "tx" => mx, "ty" => my }) sent = true end rescue end begin mp_male_notify("Сбор Сока → игрок ##{tid.to_i}") rescue end local_ok || sent end def self.mp_male_cleanup_local_attacker actor = mp_male_local_actor return if actor.nil? begin if actor.respond_to?(:action_state) && actor.action_state == :grabber actor.set_action_state(:none) if actor.respond_to?(:set_action_state) end rescue end begin actor.fucker_target = nil if actor.respond_to?(:fucker_target=) rescue end end #-------------------------------------------------------------------------- # Target client: NPC-style grab via temporary male proxy #-------------------------------------------------------------------------- def self.mp_male_proxy_npc_name name = MP_MALE_PROXY_NPC.to_s begin return name if defined?($data_npcs) && $data_npcs && $data_npcs[name] rescue end %w[NeutralHumanCommonM MobHumanRaperM NeutralHumanCommonRageM UniqueAdam].each do |n| begin return n if defined?($data_npcs) && $data_npcs && $data_npcs[n] rescue end end name end def self.mp_male_receiver_proxy_npc_name name = MP_MALE_RECEIVER_PROXY_NPC.to_s begin return name if defined?($data_npcs) && $data_npcs && $data_npcs[name] rescue end %w[NeutralHumanCommonF NeutralHumanCommonRageF NeutralHumanCommonHoboF NeutralHumanSlaveF NeutralHumanPrisonerF].each do |n| begin return n if defined?($data_npcs) && $data_npcs && $data_npcs[n] rescue end end name end # Game_Event#use_chs? => current_page_charset? => page graphic must contain "-char-". # Empty RPG::Event::Page graphics make grab() return false immediately. def self.mp_male_assign_proxy_chs_page(page, sheet) return if page.nil? name = sheet.to_s name = "-char-F-REGULAR01" if name.empty? begin page.graphic.character_name = name page.graphic.character_index = 0 rescue end end def self.mp_male_finish_proxy_chs(ev, sheet) return if ev.nil? begin ev.instance_variable_set(:@force_update_actor, true) ev.force_update_actor = true if ev.respond_to?(:force_update_actor=) rescue end begin ev.instance_variable_set(:@immue_grab, false) rescue end begin # Ensure page graphic still has -char- after set_npc/refresh. pg = ev.instance_variable_get(:@page) rescue nil if pg && pg.graphic && !pg.graphic.character_name.to_s.include?("-char-") pg.graphic.character_name = sheet.to_s pg.graphic.character_index = 0 end rescue end begin if ev.respond_to?(:setup_charset_page_settings) ev.setup_charset_page_settings elsif ev.respond_to?(:refresh) ev.refresh end rescue end begin if ev.respond_to?(:use_chs?) && !ev.use_chs? && ev.respond_to?(:create_chs_configuration) ev.instance_variable_set(:@chs_type, sheet.to_s) ev.instance_variable_set(:@charset_index, 0) ev.create_chs_configuration(0) ev.instance_variable_set(:@chs_need_update, true) end rescue end end # Attacker client must see the TARGET's look, not NeutralHumanCommonF. # Copy CHS from the NetPlayer event onto the local receiver stand-in. def self.mp_male_copy_netplayer_look(ev, net_ev) return false if ev.nil? || net_ev.nil? chs_type = "" begin chs_type = net_ev.instance_variable_get(:@chs_type).to_s chs_type = net_ev.chs_type.to_s if chs_type.empty? && net_ev.respond_to?(:chs_type) rescue chs_type = "" end chs_type = "Lona" if chs_type.empty? cfg = nil begin cfg = net_ev.instance_variable_get(:@chs_configuration) rescue cfg = nil end cfg = cfg.is_a?(Hash) ? cfg.dup : {} # Do not wipe an active sex pose — re-copy during sex would force walk Lona sheets. in_sex = false begin prev_cfg = ev.instance_variable_get(:@chs_configuration) in_sex = prev_cfg.is_a?(Hash) && prev_cfg["sex_pos"].to_i >= 0 rescue in_sex = false end unless in_sex cfg["sex_pos"] = -1 cfg["sex_position"] = -1 else begin cfg["sex_pos"] = prev_cfg["sex_pos"] cfg["sex_position"] = prev_cfg["sex_position"] rescue end end charset_index = 0 character_index = 0 begin charset_index = net_ev.instance_variable_get(:@charset_index).to_i rescue end begin character_index = net_ev.instance_variable_get(:@character_index).to_i rescue end begin ev.instance_variable_set(:@chs_type, chs_type) ev.instance_variable_set(:@charset_index, charset_index) ev.instance_variable_set(:@character_index, character_index) ev.instance_variable_set(:@chs_configuration, cfg) ev.instance_variable_set(:@character_name, "") cache = "MP_MaleRecvLook_#{ev.id.to_i}_#{chs_type}" ev.instance_variable_set(:@chs_name, cache) ev.instance_variable_set(:@chs_name_h, cache + "_H") ev.instance_variable_set(:@chs_need_update, true) # Game_Event#use_chs? normally requires page "-char-"; Lona/custom need force. ev.instance_variable_set(:@mp_male_force_use_chs, true) rescue return false end begin pg = ev.instance_variable_get(:@page) if pg && pg.graphic if chs_type.include?("-char-") pg.graphic.character_name = chs_type else # Keep a -char- token so stock gates pass; look comes from @chs_type/cfg. pg.graphic.character_name = "-char-F-REGULAR01" unless pg.graphic.character_name.to_s.include?("-char-") end pg.graphic.character_index = character_index end rescue end # Pull HairColor / RaceRecord / Race from NetPlayer actor if cfg lacks them # (BitmapChanger skin tone comes from these — missing → default uncolored). begin net_actor = net_ev.instance_variable_get(:@net_actor) if net_ev if net_actor if !cfg.has_key?("HairColor") hc = nil begin hc = net_actor.record_HairColor if net_actor.respond_to?(:record_HairColor) rescue hc = nil end begin hc = net_actor.instance_variable_get(:@record_HairColor) if hc.nil? rescue end cfg["HairColor"] = hc.to_i unless hc.nil? end st = nil begin st = net_actor.stat if net_actor.respond_to?(:stat) rescue st = nil end if st.is_a?(Hash) %w[RaceRecord Race].each do |rk| next if cfg.has_key?(rk) && !cfg[rk].nil? && cfg[rk].to_s != "" cfg[rk] = st[rk] if st.has_key?(rk) && !st[rk].nil? end # Merge remaining CHS keys that affect body/skin palettes. st.each do |k, v| ks = k.to_s next if cfg.has_key?(ks) next if v.nil? cfg[ks] = v end end end ev.instance_variable_set(:@chs_configuration, cfg) rescue end # NetPlayer Lona works because NetSyncActor#stat is a Hash of CHS keys. # Receiver proxy is a normal NPC — Lona_CHS_Part still reads actor.stat, so # bind a Hash render layer (same shape as playersync) without touching NpcStat. begin if chs_type.to_s == "Lona" || chs_type.to_s == "Lona_H" render = cfg.dup ev.instance_variable_set(:@mp_male_lona_render, render) actor = ev.actor if actor && !actor.instance_variable_get(:@mp_male_stat_bound) actor.instance_variable_set(:@mp_male_stat_bound, true) actor.instance_variable_set(:@mp_male_stat_ev, ev) def actor.stat ev = instance_variable_get(:@mp_male_stat_ev) r = ev ? ev.instance_variable_get(:@mp_male_lona_render) : nil return r if r.is_a?(Hash) st = instance_variable_get(:@stat) st end end end rescue end true rescue false end def self.mp_male_hide_netplayer(net_ev, target_id) return if net_ev.nil? pid = target_id.to_i @mp_male_hidden_net ||= {} begin prev = @mp_male_hidden_net[pid] keep_op = prev.is_a?(Hash) ? prev["opacity"] : (net_ev.opacity.to_i rescue 255) @mp_male_hidden_net[pid] = { "opacity" => keep_op.to_i, "ev" => net_ev } # Sprite_Character: visible = !transparent. Opacity alone loses to playersync # races; transparent reliably hides the NetPlayer under the receiver proxy. net_ev.opacity = 0 if net_ev.respond_to?(:opacity=) begin net_ev.transparent = true if net_ev.respond_to?(:transparent=) rescue end rescue end end # playersync/_ps_force_netplayer_visual resets opacity to 255 every apply — # re-assert hide while sex/grab proxies are active. def self.mp_male_rehide_netplayers return false unless @mp_male_hidden_net.is_a?(Hash) @mp_male_hidden_net.each do |_pid, info| next unless info.is_a?(Hash) ev = info["ev"] next if ev.nil? begin ev.opacity = 0 if ev.respond_to?(:opacity=) ev.transparent = true if ev.respond_to?(:transparent=) rescue end end true rescue false end def self.mp_male_net_hidden?(pid) @mp_male_hidden_net.is_a?(Hash) && @mp_male_hidden_net[pid.to_i] rescue false end # Sex sheets stack via animation frame_data[3]/[4] pixel offsets. If animation # is built while real_x/real_y still interpolate from moveto, those offsets bake # in a permanent 1-tile shift (attacker "ghost" beside the pair). # IMPORTANT: Luna Game_CharacterBase uses TILE units for @real_x/@real_y # (moveto sets @real_x=@x). Stock Ace *256 here throws sprites off-screen; # Sprite_Character#need_update? then forces visible=false → "invisible" sex. def self.mp_male_snap_xy(ch, x, y) return false if ch.nil? tx = x.to_i ty = y.to_i begin ch.moveto(tx, ty) if ch.respond_to?(:moveto) rescue end begin ch.instance_variable_set(:@x, tx) ch.instance_variable_set(:@y, ty) ch.instance_variable_set(:@real_x, tx) ch.instance_variable_set(:@real_y, ty) rescue end true rescue false end def self.mp_male_sync_lona_render_sex(ch) return false if ch.nil? render = nil cfg = nil begin render = ch.instance_variable_get(:@mp_male_lona_render) cfg = ch.instance_variable_get(:@chs_configuration) rescue return false end return false unless render.is_a?(Hash) && cfg.is_a?(Hash) begin # Always overwrite sex keys — "unless has_key" left stale sex_pos=-1 from copy_look. render["sex_pos"] = cfg["sex_pos"] render["sex_position"] = cfg["sex_position"] cfg.each { |k, v| render[k] = v } rescue end true rescue false end def self.mp_male_refresh_sex_animation(ch) return false if ch.nil? return false unless ch.respond_to?(:animation=) begin mp_male_sync_lona_render_sex(ch) rescue end begin if ch.respond_to?(:setup_npc_sex) && ch.respond_to?(:sex_receiver?) && ch.sex_receiver? ch.setup_npc_sex elsif ch.respond_to?(:animation_sex) ch.animation = ch.animation_sex end rescue return false end # After snap, force zero tile offsets (keep stock +2 y polish). begin anim = ch.animation if anim && anim.respond_to?(:frames) && anim.frames.is_a?(Array) anim.frames.each do |fr| next unless fr.is_a?(Array) && fr.length >= 5 fr[3] = 0 fr[4] = 2 end end rescue end begin ch.chs_need_update = true if ch.respond_to?(:chs_need_update=) rescue end true rescue false end # Dynamic Game_Event proxies need a Sprite_Character or they are invisible. # ONLY use add_net_sprite — also pushing added_ev_ids created a SECOND sprite # for the same event. First sprite clears chs_need_update; second keeps the # walk bitmap (768x512) while sex uses 240x696 → "two characters". def self.mp_male_dedupe_character_sprites(ev) return 0 if ev.nil? removed = 0 begin sc = SceneManager.scene if defined?(SceneManager) return 0 unless sc && sc.respond_to?(:spriteset) && sc.spriteset arr = sc.spriteset.instance_variable_get(:@character_sprites) return 0 unless arr.is_a?(Array) keep = nil arr.each do |s| next unless s && s.character == ev if keep.nil? keep = s else begin s.dispose if s.respond_to?(:dispose) rescue end removed += 1 end end arr.delete_if { |s| s.nil? || (s.character == ev && !s.equal?(keep)) || (s.respond_to?(:disposed?) && s.disposed?) } rescue end removed rescue 0 end def self.mp_male_ensure_event_sprite(ev) return 0 if ev.nil? added = 0 # Prefer immediate deduped add; do NOT also queue added_ev_ids (double sprite). begin sc = SceneManager.scene if defined?(SceneManager) if sc && sc.respond_to?(:add_net_sprite) sc.add_net_sprite(ev) added = 2 elsif $game_map && $game_map.respond_to?(:added_ev_ids) && ev.respond_to?(:id) ids = $game_map.added_ev_ids if ids.is_a?(Array) && !ids.include?(ev.id) ids.push(ev.id) added = 1 end end rescue end dupes = mp_male_dedupe_character_sprites(ev) added rescue 0 end def self.mp_male_restore_netplayer(target_id) pid = target_id.to_i @mp_male_hidden_net ||= {} info = @mp_male_hidden_net.delete(pid) ev = nil begin ev = info["ev"] if info.is_a?(Hash) rescue ev = nil end begin ev = @players[pid] if ev.nil? && @players rescue end return if ev.nil? begin op = 255 op = info["opacity"].to_i if info.is_a?(Hash) && info["opacity"] op = 255 if op <= 0 ev.opacity = op if ev.respond_to?(:opacity=) ev.transparent = false if ev.respond_to?(:transparent=) ev.chs_need_update = true if ev.respond_to?(:chs_need_update=) rescue end rescue end # Target client (OK): local Lona uses chs_type/chs_name "Lona_H" during sex # (separate Cache slot from walk "Lona"). Receiver proxy must mirror that or # it keeps walk clothes while male fucker draws peach sex → "two characters". # Only flip + chs_need_update when the slot actually changes — per-tick rebuild # freezes CharsetAnimation at frame 0 and flashes default (uncolored) skin. def self.mp_male_apply_lona_sex_chs(ev, sex_on) return false if ev.nil? begin cur = ev.instance_variable_get(:@chs_type).to_s return false unless cur == "Lona" || cur == "Lona_H" || ev.instance_variable_get(:@mp_male_lona_render).is_a?(Hash) rescue return false end begin eid = ev.id.to_i want = sex_on ? "Lona_H" : "Lona" want_name = sex_on ? "MP_MaleRecvLook_#{eid}_Lona_H" : "MP_MaleRecvLook_#{eid}_Lona" cur_name = "" begin cur_name = ev.instance_variable_get(:@chs_name).to_s rescue cur_name = "" end changed = (cur != want) || (cur_name != want_name) if changed ev.instance_variable_set(:@chs_type, want) ev.instance_variable_set(:@chs_name, want_name) ev.instance_variable_set(:@chs_name_h, "MP_MaleRecvLook_#{eid}_Lona_H") ev.instance_variable_set(:@chs_need_update, true) end mp_male_sync_lona_render_sex(ev) rescue return false end true rescue false end # Attacker Game_Player male sex sheet renders peach/static; the same look as a # Game_Event proxy on the target client is correct. Hide GP during sex and # draw a local Event fucker visual (same path as target's male proxy). def self.mp_male_set_local_fucker_visible(visible) @mp_male_hide_local_fucker = !visible gp = $game_player return false if gp.nil? begin if visible gp.opacity = 255 if gp.respond_to?(:opacity=) gp.transparent = false if gp.respond_to?(:transparent=) else gp.opacity = 0 if gp.respond_to?(:opacity=) gp.transparent = true if gp.respond_to?(:transparent=) end rescue end true rescue false end def self.mp_male_hide_local_fucker? @mp_male_hide_local_fucker == true rescue false end def self.mp_male_destroy_fucker_visual ev = @mp_male_fucker_visual @mp_male_fucker_visual = nil return if ev.nil? begin mp_male_dedupe_character_sprites(ev) rescue end begin ev.delete if ev.respond_to?(:delete) rescue end begin $game_map.events.delete(ev.id) if $game_map && $game_map.events && ev.respond_to?(:id) rescue end rescue end def self.mp_male_copy_local_male_look(ev) return false if ev.nil? || $game_player.nil? gp = $game_player sheet = "" idx = 0 cfg = {} begin sheet = gp.instance_variable_get(:@chs_type).to_s sheet = gp.chs_type.to_s if sheet.empty? idx = gp.instance_variable_get(:@charset_index).to_i cfg = gp.chs_configuration.is_a?(Hash) ? gp.chs_configuration.dup : {} rescue return false end return false if sheet.empty? begin ev.instance_variable_set(:@chs_type, sheet) ev.instance_variable_set(:@charset_index, idx) ev.instance_variable_set(:@character_index, gp.character_index.to_i) ev.instance_variable_set(:@chs_configuration, cfg) eid = ev.id.to_i sex_on = cfg["sex_pos"].to_i >= 0 key = "MP_MaleFuckerVis_#{eid}_#{sheet}" key = "#{key}_H" if sex_on ev.instance_variable_set(:@chs_name, key) ev.instance_variable_set(:@chs_name_h, key.end_with?("_H") ? key : key + "_H") ev.instance_variable_set(:@mp_male_force_use_chs, true) ev.instance_variable_set(:@mp_male_fucker_visual, true) ev.instance_variable_set(:@chs_need_update, true) ev.opacity = 255 if ev.respond_to?(:opacity=) ev.transparent = false if ev.respond_to?(:transparent=) rescue return false end true rescue false end def self.mp_male_ensure_fucker_visual(x, y) existing = @mp_male_fucker_visual begin if existing && !(existing.respond_to?(:deleted?) && existing.deleted?) # Do NOT copy_look / chs_need_update every tick — resets sex sheet & flash. mp_male_snap_xy(existing, x, y) return existing end rescue end mp_male_destroy_fucker_visual return nil unless $game_map gp = $game_player return nil if gp.nil? sheet = "" begin sheet = gp.instance_variable_get(:@chs_type).to_s sheet = "-char-M-REGULAR03" if sheet.empty? rescue sheet = "-char-M-REGULAR03" end event_id = nil begin event_id = ($game_map.events.keys.max || 0) + 1 rescue event_id = 920000 + (@my_id.to_i) end dummy = RPG::Event.new(x.to_i, y.to_i) dummy.id = event_id dummy.name = "MP_MaleFuckerVis_#{@my_id.to_i}" page = RPG::Event::Page.new page.trigger = -1 page.priority_type = 1 page.through = true page.list = [RPG::EventCommand.new(0, 0, [])] mp_male_assign_proxy_chs_page(page, sheet) dummy.pages = [page] ev = nil begin ev = Game_Event.new($game_map.map_id, dummy, { :mp_male_fucker_visual => true }) rescue begin ev = Game_Event.new($game_map.map_id, dummy) rescue return nil end end begin ev.instance_variable_set(:@mp_male_fucker_visual, true) def ev.mp_male_fucker_visual; true; end rescue end begin npc_name = mp_male_proxy_npc_name ev.set_npc(npc_name) if ev.respond_to?(:set_npc) rescue end begin ev.instance_variable_set(:@mp_male_fucker_visual, true) rescue end mp_male_finish_proxy_chs(ev, sheet) mp_male_copy_local_male_look(ev) begin $game_map.events[event_id] = ev $game_map.add_event_to_pos_hash(ev) if $game_map.respond_to?(:add_event_to_pos_hash) rescue end mp_male_ensure_event_sprite(ev) @mp_male_fucker_visual = ev ev rescue nil end def self.mp_male_sync_fucker_visual(recv_ev) vis = @mp_male_fucker_visual gp = $game_player return false if vis.nil? || gp.nil? || recv_ev.nil? begin sx = gp.x.to_i sy = gp.y.to_i mp_male_snap_xy(vis, sx, sy) cfg = gp.chs_configuration.is_a?(Hash) ? gp.chs_configuration : {} pose = cfg["sex_pos"].to_i fpos = cfg["sex_position"].to_i fpos = 1 if fpos < 1 # Wire fucker_target BEFORE set_chs_sex / animation_sex (stock requires it). # NEVER set_action_state(:sex, true) with force every tick — that sets # action_state_changed and setup_npc_sex rebuilds animation at frame 0. begin if vis.actor && vis.actor.respond_to?(:fucker_target=) vis.actor.fucker_target = recv_ev end if vis.actor && vis.actor.respond_to?(:set_action_state) st = nil begin st = vis.actor.action_state rescue st = nil end vis.actor.set_action_state(:sex) if st != :sex end if recv_ev.respond_to?(:fuckers) && recv_ev.fuckers.is_a?(Array) recv_ev.fuckers << vis unless recv_ev.fuckers.include?(vis) end # Keep hidden GP in fuckers too (stock drop check); visual is display-only. if gp.respond_to?(:sex_mode?) && gp.sex_mode? && recv_ev.fuckers.is_a?(Array) recv_ev.fuckers << gp unless recv_ev.fuckers.include?(gp) end vis.receiver = recv_ev if vis.respond_to?(:receiver=) rescue end # Refresh CHS look only when pose changes (avoid thrashing cache every tick). prev_pose = -99 begin vcfg = vis.chs_configuration prev_pose = vcfg["sex_pos"].to_i if vcfg.is_a?(Hash) rescue end if pose >= 0 && pose != prev_pose mp_male_copy_local_male_look(vis) vis.set_chs_sex(pose, fpos) if vis.respond_to?(:set_chs_sex) vis.instance_variable_set(:@sex_state, 1) vis.instance_variable_set(:@move_type, 0) mp_male_refresh_sex_animation(vis) elsif pose >= 0 && vis.animation.nil? mp_male_copy_local_male_look(vis) vis.set_chs_sex(pose, fpos) if vis.respond_to?(:set_chs_sex) mp_male_refresh_sex_animation(vis) end # Mirror receiver sex stage → fucker animation set (stock Player path). begin st = recv_ev.instance_variable_get(:@sex_state).to_i if st > 0 && st != vis.instance_variable_get(:@mp_male_synced_sex_state).to_i vis.instance_variable_set(:@mp_male_synced_sex_state, st) vis.instance_variable_set(:@sex_state, st) case st when 2 vis.animation = vis.animation_sex_fast if vis.respond_to?(:animation_sex_fast) when 3 vis.animation = vis.animation_sex_cumming if vis.respond_to?(:animation_sex_cumming) else vis.animation = vis.animation_sex if vis.respond_to?(:animation_sex) end end rescue end # Stock: fucker frame follows receiver (also update_animation_synced). if vis.animation && recv_ev.animation vis.animation.frame = recv_ev.animation.frame elsif vis.animation && gp && gp.animation vis.animation.frame = gp.animation.frame end vis.opacity = 255 if vis.respond_to?(:opacity=) vis.transparent = false if vis.respond_to?(:transparent=) mp_male_dedupe_character_sprites(vis) rescue return false end true rescue false end def self.mp_male_destroy_proxy(attacker_id) pid = attacker_id.to_i # Target client hides the attacker's NetPlayer during sex; without restore # rehide keeps opacity=0 forever → invisible body + blinking nickname. mp_male_restore_netplayer(pid) @mp_male_grab_proxies ||= {} ev = @mp_male_grab_proxies.delete(pid) return if ev.nil? begin ev.delete if ev.respond_to?(:delete) rescue end begin $game_map.events.delete(ev.id) if $game_map && $game_map.events && ev.respond_to?(:id) rescue end rescue end def self.mp_male_destroy_receiver_proxy(target_id) pid = target_id.to_i fx_x = nil fx_y = nil begin prev = @mp_male_receiver_proxies[pid] if @mp_male_receiver_proxies.is_a?(Hash) if prev fx_x = prev.x.to_i fx_y = prev.y.to_i end rescue end mp_male_restore_netplayer(pid) mp_male_destroy_fucker_visual mp_male_set_local_fucker_visible(true) @mp_male_receiver_proxies ||= {} ev = @mp_male_receiver_proxies.delete(pid) begin if ev fx_x = ev.x.to_i if fx_x.nil? fx_y = ev.y.to_i if fx_y.nil? end rescue end begin ev.delete if ev && ev.respond_to?(:delete) rescue end begin $game_map.events.delete(ev.id) if ev && $game_map && $game_map.events && ev.respond_to?(:id) rescue end mp_male_cleanup_sex_fx(fx_x, fx_y) unless fx_x.nil? rescue end # Drop leftover sex-stage / struggle VFX at the grab tile (attacker + target). MP_MALE_SEX_FX_NAME_RE = /EfxSexStage|EffectSexStruggle|EffectPunchHit|GeneralAppetizer|GeneralCHCG|MP_MaleFuckerVis|Appetizer/i unless const_defined?(:MP_MALE_SEX_FX_NAME_RE) def self.mp_male_cleanup_sex_fx(x=nil, y=nil) sx = x.nil? ? nil : x.to_i sy = y.nil? ? nil : y.to_i if sx.nil? && $game_player sx = $game_player.x.to_i sy = $game_player.y.to_i end # Cancel pending reserved summons so stage FX don't spawn after stop. begin if $game_map list = $game_map.instance_variable_get(:@summoned_evs) if list.is_a?(Array) list.reject! do |entry| nm = entry.is_a?(Array) ? entry[0].to_s : entry.to_s !!(nm =~ /EfxSexStage|EffectSexStruggle|EffectPunchHit|GeneralAppetizer|GeneralCHCG/i) end end end rescue end begin if $game_map && $game_map.events $game_map.events.keys.dup.each do |eid| ev = $game_map.events[eid] next if ev.nil? begin next if ev.instance_variable_get(:@mp_male_grab_proxy) next if ev.instance_variable_get(:@mp_male_receiver_proxy) rescue end name = "" begin name = ev.event.name.to_s if ev.respond_to?(:event) && ev.event rescue name = "" end begin name = ev.instance_variable_get(:@event).name.to_s if name.empty? && ev.instance_variable_get(:@event) rescue end next if name.empty? next unless name =~ MP_MALE_SEX_FX_NAME_RE if sx && sy && !(name =~ /MP_MaleFuckerVis/i) begin ex = ev.x.to_i ey = ev.y.to_i next if (ex - sx).abs > 1 || (ey - sy).abs > 1 rescue next end end begin ev.delete if ev.respond_to?(:delete) rescue end begin $game_map.events.delete(eid) rescue end end end rescue end begin gp = $game_player if gp ge = gp.grabbing_ev if gp.respond_to?(:grabbing_ev) if ge begin ge.delete if ge.respond_to?(:delete) rescue end begin gp.grabbing_ev = nil rescue end end gp.cancel_sex_snd if gp.respond_to?(:cancel_sex_snd) end rescue end rescue end def self.mp_male_ensure_receiver_proxy(target_id, x, y, net_ev=nil) pid = target_id.to_i @mp_male_receiver_proxies ||= {} existing = @mp_male_receiver_proxies[pid] begin if existing && !(existing.respond_to?(:deleted?) && existing.deleted?) mp_male_copy_netplayer_look(existing, net_ev) if net_ev return existing end rescue end mp_male_destroy_receiver_proxy(pid) return nil unless $game_map npc_name = mp_male_receiver_proxy_npc_name event_id = nil begin event_id = ($game_map.events.keys.max || 0) + 1 rescue event_id = 910000 + pid end chs_sheet = "-char-F-REGULAR01" begin nt = net_ev.instance_variable_get(:@chs_type).to_s if net_ev chs_sheet = nt if nt.to_s.include?("-char-") rescue end dummy = RPG::Event.new(x.to_i, y.to_i) dummy.id = event_id dummy.name = "MP_MaleRecvProxy_#{pid}" page = RPG::Event::Page.new page.trigger = -1 page.priority_type = 1 page.through = true page.list = [RPG::EventCommand.new(0, 0, [])] mp_male_assign_proxy_chs_page(page, chs_sheet) dummy.pages = [page] ev = nil begin ev = Game_Event.new($game_map.map_id, dummy, { :mp_male_receiver_proxy => true, :mp_male_target => pid }) rescue begin ev = Game_Event.new($game_map.map_id, dummy) rescue return nil end end begin ev.set_npc(npc_name) if ev.respond_to?(:set_npc) rescue => e begin puts("[MP_MALE] receiver set_npc failed: #{e.class}: #{e.message}") rescue end return nil end mp_male_finish_proxy_chs(ev, chs_sheet) mp_male_copy_netplayer_look(ev, net_ev) if net_ev mp_male_hide_netplayer(net_ev, pid) if net_ev begin # Visible stand-in for local sex (attacker client). ev.opacity = 255 if ev.respond_to?(:opacity=) ev.through = true if ev.respond_to?(:through=) ev.moveto(x.to_i, y.to_i) if ev.respond_to?(:moveto) rescue end begin $game_map.events[event_id] = ev $game_map.add_event_to_pos_hash(ev) if $game_map.respond_to?(:add_event_to_pos_hash) $game_map.register_npc(ev) if $game_map.respond_to?(:register_npc) && ev.npc? rescue end begin if ev.respond_to?(:instance_variable_set) ev.instance_variable_set(:@mp_male_receiver_proxy, true) # Used by LonaPaletteStudio remote skin lookup (pid of NetPlayer stand-in). ev.instance_variable_set(:@mp_male_target, pid) end def ev.mp_male_receiver_proxy; true; end rescue end mp_male_ensure_event_sprite(ev) @mp_male_receiver_proxies[pid] = ev ev rescue => e begin puts("[MP_MALE] receiver proxy spawn error: #{e.class}: #{e.message}") rescue end nil end def self.mp_male_ensure_proxy(attacker_id, x, y) pid = attacker_id.to_i @mp_male_grab_proxies ||= {} existing = @mp_male_grab_proxies[pid] begin return existing if existing && !(existing.respond_to?(:deleted?) && existing.deleted?) rescue end mp_male_destroy_proxy(pid) return nil unless $game_map npc_name = mp_male_proxy_npc_name event_id = nil begin event_id = ($game_map.events.keys.max || 0) + 1 rescue event_id = 900000 + pid end chs_sheet = "-char-M-REGULAR01" dummy = RPG::Event.new(x.to_i, y.to_i) dummy.id = event_id dummy.name = "MP_MaleGrabProxy_#{pid}" page = RPG::Event::Page.new page.trigger = -1 page.priority_type = 1 page.through = true page.list = [RPG::EventCommand.new(0, 0, [])] mp_male_assign_proxy_chs_page(page, chs_sheet) dummy.pages = [page] ev = nil begin ev = Game_Event.new($game_map.map_id, dummy, { :mp_male_grab_proxy => true, :mp_male_owner => pid }) rescue begin ev = Game_Event.new($game_map.map_id, dummy) rescue return nil end end begin ev.set_npc(npc_name) if ev.respond_to?(:set_npc) rescue => e begin puts("[MP_MALE] set_npc failed: #{e.class}: #{e.message}") rescue end return nil end mp_male_finish_proxy_chs(ev, chs_sheet) begin ev.opacity = 0 ev.through = true ev.moveto(x.to_i, y.to_i) if ev.respond_to?(:moveto) rescue end begin $game_map.events[event_id] = ev $game_map.add_event_to_pos_hash(ev) if $game_map.respond_to?(:add_event_to_pos_hash) $game_map.register_npc(ev) if $game_map.respond_to?(:register_npc) && ev.npc? rescue end @mp_male_grab_proxies[pid] = ev ev rescue => e begin puts("[MP_MALE] proxy spawn error: #{e.class}: #{e.message}") rescue end nil end def self.mp_male_force_shared_sex_pose(attacker_id, payload_hash) pose = 0 fpos = 0 begin pose = payload_hash["sex_pos"].to_i fpos = payload_hash["sex_position"].to_i rescue return false end return false if pose < 0 fpos = 1 if fpos < 1 aid = attacker_id.to_i proxy = nil begin proxy = @mp_male_grab_proxies[aid] if @mp_male_grab_proxies rescue proxy = nil end return false if proxy.nil? || $game_player.nil? male_ev = nil begin male_ev = @players[aid] if @players rescue male_ev = nil end # Show animated proxy; hide NetPlayer (playersync would otherwise keep a static sex frame). begin mp_male_copy_netplayer_look(proxy, male_ev) if male_ev mp_male_hide_netplayer(male_ev, aid) if male_ev proxy.opacity = 255 if proxy.respond_to?(:opacity=) begin proxy.transparent = false if proxy.respond_to?(:transparent=) rescue end mp_male_ensure_event_sprite(proxy) rescue end # Reset grab_count only on first pose lock — periodic sync must not wipe # QTE / struggle progress or re-arm grab timers. begin unless @mp_male_tgt_pose_locked.is_a?(Hash) && @mp_male_tgt_pose_locked[aid] $game_player.instance_variable_set(:@grab_count, 0) if $game_player.respond_to?(:instance_variable_set) @mp_male_tgt_pose_locked ||= {} @mp_male_tgt_pose_locked[aid] = true end rescue end begin if $game_player.respond_to?(:fuckers) && $game_player.fuckers.is_a?(Array) $game_player.fuckers << proxy unless $game_player.fuckers.include?(proxy) end rescue end begin if proxy.actor && proxy.actor.respond_to?(:fucker_target=) proxy.actor.fucker_target = $game_player end proxy.receiver = $game_player if proxy.respond_to?(:receiver=) proxy.set_chs_sex(pose, fpos) if proxy.respond_to?(:set_chs_sex) if proxy.actor && proxy.actor.respond_to?(:set_action_state) # force=false: avoid setup_npc_sex every sync packet (frame reset). st = (proxy.actor.action_state rescue nil) proxy.actor.set_action_state(:sex) if st != :sex end rescue end begin $game_player.set_chs_sex(pose, 0) if $game_player.respond_to?(:set_chs_sex) if $game_player.actor && $game_player.actor.respond_to?(:set_action_state) st = ($game_player.actor.action_state rescue nil) $game_player.actor.set_action_state(:sex) if st != :sex end rescue end # Colocate then rebuild animations so fucker pixel offsets are 0. begin sx = $game_player.x.to_i sy = $game_player.y.to_i mp_male_snap_xy($game_player, sx, sy) mp_male_snap_xy(proxy, sx, sy) mp_male_refresh_sex_animation($game_player) mp_male_refresh_sex_animation(proxy) mp_male_dedupe_character_sprites(proxy) rescue end # Apply remote stage/frame from attacker sex_sync (receiver leads locally after). begin sex_state = payload_hash["sex_state"].to_i aframe = payload_hash["aframe"].to_i if sex_state > 0 $game_player.instance_variable_set(:@sex_state, sex_state) proxy.instance_variable_set(:@sex_state, sex_state) if proxy.respond_to?(:instance_variable_set) end if aframe >= 0 $game_player.animation.frame = aframe if $game_player.animation proxy.animation.frame = aframe if proxy.animation end rescue end true rescue false end def self.mp_male_apply_grab_as_target(attacker_id, payload_hash) tid = 0 begin tid = (payload_hash["target"] || payload_hash["tgt"]).to_i rescue tid = 0 end if @my_id.nil? || tid != @my_id.to_i return false end if defined?(MPSafeZone) && MPSafeZone.active? return false end aid = attacker_id.to_i sex_sync = false begin sex_sync = payload_hash["sex_sync"].to_s == "1" || (!payload_hash["sex_pos"].nil? && payload_hash["sex_pos"].to_s != "") rescue sex_sync = false end already_grabbed = false begin already_grabbed = $game_player.grabbed? || $game_player.sex_mode? rescue already_grabbed = false end # Periodic/pose sex_sync must NEVER re-start grab after struggle escape. # Only the initial sex_grab (no sex_sync) may begin a new capture. if sex_sync && !already_grabbed return false end male_ev = nil begin male_ev = @players[aid] if @players rescue male_ev = nil end mx = $game_player.x.to_i my = $game_player.y.to_i begin mx = male_ev.x.to_i if male_ev my = male_ev.y.to_i if male_ev rescue end proxy = mp_male_ensure_proxy(aid, mx, my) if proxy.nil? || proxy.actor.nil? return false end # Force hole if the attacker sent a pose hint (vag/anal/mouth). begin pose = payload_hash["pose"].to_s if !pose.empty? && pose != "nil" && $game_player.respond_to?(:instance_variable_set) $game_player.instance_variable_set(:@femdonMode, pose) end rescue end unless already_grabbed # Fresh grab start — clear prior pose-lock / escape markers for this atk. begin @mp_male_tgt_pose_locked ||= {} @mp_male_tgt_pose_locked.delete(aid) @mp_male_tgt_session ||= {} @mp_male_tgt_session[aid] = true rescue end skill = nil begin skill = $data_arpgskills["NpcFuckerGrab"] if defined?($data_arpgskills) skill = $data_arpgskills[MP_MALE_SKILL] if skill.nil? && defined?($data_arpgskills) rescue skill = nil end begin if proxy.actor.respond_to?(:set_fuck_target) && skill proxy.actor.set_fuck_target(skill, $game_player) elsif $game_player.respond_to?(:grab) $game_player.grab(proxy, true) end rescue => e begin puts("[MP_MALE] set_fuck_target error: #{e.class}: #{e.message}") rescue end return false end end if sex_sync # First sync locks pose; later packets only nudge sex_state/aframe. need_pose = true begin pcfg = proxy.chs_configuration.is_a?(Hash) ? proxy.chs_configuration : {} want = payload_hash["sex_pos"].to_i need_pose = !(already_grabbed && $game_player.sex_mode? && pcfg["sex_pos"].to_i == want && want >= 0 && proxy.animation && $game_player.animation) rescue need_pose = true end if need_pose mp_male_force_shared_sex_pose(aid, payload_hash) else mp_male_apply_sex_frame_sync(aid, proxy, payload_hash) end end mp_male_notify("Вас захватили (Сбор Сока).") unless sex_sync true rescue false end # Light sex_tick sync on target: stage + animation.frame only. def self.mp_male_apply_sex_frame_sync(attacker_id, proxy, payload_hash) return false if proxy.nil? || $game_player.nil? begin sex_state = payload_hash["sex_state"].to_i aframe = payload_hash["aframe"].to_i if sex_state > 0 $game_player.instance_variable_set(:@sex_state, sex_state) proxy.instance_variable_set(:@sex_state, sex_state) end if aframe >= 0 $game_player.animation.frame = aframe if $game_player.animation proxy.animation.frame = aframe if proxy.animation end male_ev = nil begin male_ev = @players[attacker_id.to_i] if @players rescue male_ev = nil end mp_male_hide_netplayer(male_ev, attacker_id) if male_ev rescue return false end true rescue false end def self.mp_male_apply_stop(peer_id, payload_hash=nil) pid = peer_id.to_i ph = payload_hash.is_a?(Hash) ? payload_hash : {} struggle = false begin struggle = ph["struggle"].to_i == 1 || !ph["stun"].to_s.empty? rescue struggle = false end fx_x = nil fx_y = nil begin recv = @mp_male_receiver_proxies[pid] if @mp_male_receiver_proxies.is_a?(Hash) if recv fx_x = recv.x.to_i fx_y = recv.y.to_i end rescue end begin if fx_x.nil? && $game_player fx_x = $game_player.x.to_i fx_y = $game_player.y.to_i end rescue end # Target side: drop male grab_proxy. Attacker side: drop receiver proxy. had_recv = @mp_male_receiver_proxies.is_a?(Hash) && @mp_male_receiver_proxies[pid] mp_male_destroy_proxy(pid) if had_recv mp_male_destroy_receiver_proxy(pid) else mp_male_destroy_fucker_visual mp_male_set_local_fucker_visible(true) mp_male_cleanup_sex_fx(fx_x, fx_y) end begin @mp_male_tgt_pose_locked.delete(pid) if @mp_male_tgt_pose_locked.is_a?(Hash) @mp_male_tgt_session.delete(pid) if @mp_male_tgt_session.is_a?(Hash) rescue end begin @mp_male_net_grab_tid = 0 if @mp_male_net_grab_tid.to_i == pid rescue end begin gp = $game_player if gp if (gp.respond_to?(:grabbed?) && gp.grabbed?) || (gp.respond_to?(:sex_mode?) && gp.sex_mode?) gp.release_chs_group if gp.respond_to?(:release_chs_group) end gp.unset_chs_sex if gp.respond_to?(:unset_chs_sex) && gp.respond_to?(:sex_mode?) && gp.sex_mode? gp.cancel_sex_snd if gp.respond_to?(:cancel_sex_snd) gp.animation = nil if gp.respond_to?(:animation=) end rescue end begin actor = mp_male_local_actor if actor && [:grabber, :sex, :grabbed].include?(actor.action_state) actor.set_action_state(:none) if actor.respond_to?(:set_action_state) actor.fucker_target = nil if actor.respond_to?(:fucker_target=) end rescue end # Stun must run AFTER sex/grabber state is cleared (apply_stun blocks on :sex). mp_male_apply_struggle_stun if struggle rescue end def self.mp_male_apply_struggle_stun actor = mp_male_local_actor return false if actor.nil? begin st = actor.action_state if [:sex, :grabbed, :grabber].include?(st) actor.set_action_state(:none) if actor.respond_to?(:set_action_state) end rescue end begin actor.add_state("Stun3") if actor.respond_to?(:add_state) rescue end begin actor.apply_stun_effect("Stun3") if actor.respond_to?(:apply_stun_effect) rescue end true rescue false end # Target: mark that BasicSexStruggle threshold fired (vs natural sex end). def self.mp_male_note_struggle_success @mp_male_local_struggle = true return false unless @mp_male_tgt_session.is_a?(Hash) sent = false @mp_male_tgt_session.keys.dup.each do |pid| sent = true if mp_male_send_struggle_stop(pid) begin @mp_male_tgt_session.delete(pid) @mp_male_tgt_pose_locked.delete(pid) if @mp_male_tgt_pose_locked.is_a?(Hash) rescue end begin fx_x = nil fx_y = nil proxy = @mp_male_grab_proxies[pid] if @mp_male_grab_proxies.is_a?(Hash) if proxy fx_x = proxy.x.to_i fx_y = proxy.y.to_i elsif $game_player fx_x = $game_player.x.to_i fx_y = $game_player.y.to_i end mp_male_destroy_proxy(pid) mp_male_cleanup_sex_fx(fx_x, fx_y) rescue mp_male_destroy_proxy(pid) end end begin gp = $game_player if gp && ((gp.respond_to?(:grabbed?) && gp.grabbed?) || (gp.respond_to?(:sex_mode?) && gp.sex_mode?)) gp.release_chs_group if gp.respond_to?(:release_chs_group) end rescue end sent rescue false end # Target → attacker: struggle / local release ended the capture. def self.mp_male_send_struggle_stop(attacker_id) aid = attacker_id.to_i return false if aid <= 0 return false unless respond_to?(:send_deistvia) struggle = @mp_male_local_struggle == true @mp_male_local_struggle = false send_deistvia(MP_MALE_GRAB_HIT_ACTION, "stop", { "target" => (@my_id.to_i rescue 0), "skill_name" => MP_MALE_SKILL.to_s, "sex_grab" => 1, "struggle" => struggle ? 1 : 0, "stun" => struggle ? "Stun3" : "", "hp" => 0, "sta" => 0, "dmg" => 0 }) true rescue false end def self.mp_male_tick_proxies # sex_tick: playersync restores NetPlayer opacity=255 — keep hidden ones down. mp_male_rehide_netplayers # Attacker → target periodic stage/frame (~12 Hz). mp_male_tick_sex_pose_sync if @mp_male_grab_proxies.is_a?(Hash) && !@mp_male_grab_proxies.empty? @mp_male_grab_proxies.keys.each do |pid| ev = @mp_male_grab_proxies[pid] male = nil begin male = @players[pid.to_i] if @players rescue male = nil end if male.nil? mp_male_destroy_proxy(pid) next end local = $game_player local_sex = false begin st = (local && local.actor) ? local.actor.action_state : :none local_sex = (st == :sex || st == :grabbed) || (local.respond_to?(:sex_mode?) && local.sex_mode?) rescue local_sex = false end begin if local_sex && local mp_male_snap_xy(local, local.x, local.y) mp_male_snap_xy(ev, local.x, local.y) ev.opacity = 255 if ev.respond_to?(:opacity=) begin ev.transparent = false if ev.respond_to?(:transparent=) rescue end mp_male_hide_netplayer(male, pid) mp_male_dedupe_character_sprites(ev) if ev && ev.animation.nil? mp_male_refresh_sex_animation(ev) end # Keep fucker frame locked to local receiver (stock sync path). begin if local.animation && ev.animation ev.animation.frame = local.animation.frame end rescue end else ev.moveto(male.x, male.y) if ev && ev.respond_to?(:moveto) # Pre-sex: logic proxy only; NetPlayer still carries walk look. ev.opacity = 0 if ev.respond_to?(:opacity=) end rescue end # Drop proxy when local sex/grab ended (struggle / release_chs_group). begin if local && local.respond_to?(:actor) && local.actor st = local.actor.action_state if st != :grabbed && st != :sex && !(local.respond_to?(:sex_mode?) && local.sex_mode?) was_session = @mp_male_tgt_session.is_a?(Hash) && @mp_male_tgt_session[pid.to_i] mp_male_send_struggle_stop(pid) if was_session begin @mp_male_tgt_session.delete(pid.to_i) if @mp_male_tgt_session.is_a?(Hash) @mp_male_tgt_pose_locked.delete(pid.to_i) if @mp_male_tgt_pose_locked.is_a?(Hash) rescue end mp_male_destroy_proxy(pid) end end rescue end end end if @mp_male_receiver_proxies.is_a?(Hash) && !@mp_male_receiver_proxies.empty? @mp_male_receiver_proxies.keys.each do |pid| ev = @mp_male_receiver_proxies[pid] remote = nil begin remote = @players[pid.to_i] if @players rescue remote = nil end busy = false begin busy = true if ev && ev.respond_to?(:grabbed?) && ev.grabbed? busy = true if ev && ev.respond_to?(:sex?) && ev.sex? rescue busy = false end begin actor = mp_male_local_actor st = actor ? actor.action_state : :none if !busy && st != :grabber && st != :sex mp_male_destroy_receiver_proxy(pid) next end rescue end if remote.nil? && !busy mp_male_destroy_receiver_proxy(pid) next end begin # Always keep remote NetPlayer hidden while receiver proxy lives. mp_male_hide_netplayer(remote, pid) if remote if remote && ev && ev.respond_to?(:moveto) && !busy ev.moveto(remote.x, remote.y) end if busy && $game_player && ev begin loc_actor = mp_male_local_actor if $game_player.sex_mode? || (loc_actor && loc_actor.action_state == :sex) sx = $game_player.x.to_i sy = $game_player.y.to_i mp_male_snap_xy($game_player, sx, sy) mp_male_snap_xy(ev, sx, sy) # Mirror Game_Player: Lona_H cache slot during sex (not walk Lona). mp_male_apply_lona_sex_chs(ev, true) # Hide broken GP male sheet; draw Event fucker visual (target path). mp_male_ensure_fucker_visual(sx, sy) mp_male_sync_fucker_visual(ev) mp_male_set_local_fucker_visible(false) mp_male_dedupe_character_sprites(ev) if ev.animation.nil? mp_male_refresh_sex_animation(ev) end # Do not build sex animation on GP male (peach). Frame lives on # receiver_proxy + fucker_visual only. else mp_male_apply_lona_sex_chs(ev, false) mp_male_destroy_fucker_visual mp_male_set_local_fucker_visible(true) end rescue end elsif !busy mp_male_apply_lona_sex_chs(ev, false) mp_male_destroy_fucker_visual mp_male_set_local_fucker_visible(true) end if ev && ev.respond_to?(:opacity=) ev.opacity = 255 end rescue end end end rescue end #-------------------------------------------------------------------------- # Chat: /maleskin [on|off|toggle] #-------------------------------------------------------------------------- def self.mp_male_try_chat_command(raw) s = raw.to_s.strip matched = !!(s =~ /\A\/(maleskin|male|мужскин|мужской)(\s+|\z)/i) return false unless matched arg = "" begin arg = s.split(/\s+/, 2)[1].to_s.downcase rescue arg = "" end case arg when "on", "1", "вкл", "enable" mp_male_skin_enable when "off", "0", "выкл", "disable" mp_male_skin_disable else mp_male_skin_toggle end true rescue false end def self.parse(*args) msg = args[0].to_s # Chat lines sometimes arrive as chat:... — also catch plain commands if wired begin if msg =~ /\Achat:/i || msg =~ /\A\/(maleskin|male|муж)/i # actual chat body handled elsewhere; see hook below end rescue end if respond_to?(:mp_male_grab_parse_without) mp_male_grab_parse_without(*args) end end def self.update(*args) begin # Keep skill while male skin is on (after load / death etc.) if mp_male_skin_active? mp_male_grant_skill mp_male_apply_sex_stat(true) mp_male_ensure_villager_skin mp_male_tick_pending_sex end mp_male_tick_proxies rescue end if respond_to?(:mp_male_grab_update_without) mp_male_grab_update_without(*args) end end def self.mp_male_payload_sex_grab?(payload_hash) return false unless payload_hash.is_a?(Hash) # Only the explicit sex_grab flag — do not steal normal pvp_skill_hit packets. payload_hash["sex_grab"].to_s == "1" rescue false end def self.handle_remote_deistvia(player_id, action_id, phase, payload) act = action_id.to_s if act == MP_MALE_GRAB_ACTION payload_hash = {} begin payload_hash = respond_to?(:_deistvia_unpack) ? _deistvia_unpack(payload.to_s) : {} rescue payload_hash = {} end case phase.to_s when "flag" mp_male_set_remote_flag(player_id, payload_hash["male"].to_i) return when "start" mp_male_apply_grab_as_target(player_id.to_i, payload_hash) return when "stop" mp_male_apply_stop(player_id.to_i, payload_hash) return end return end # Preferred path: sex grab piggybacks on proven pvp_skill_hit relay. if act == MP_MALE_GRAB_HIT_ACTION || act == "pvp_skill_hit" payload_hash = {} begin payload_hash = respond_to?(:_deistvia_unpack) ? _deistvia_unpack(payload.to_s) : {} rescue payload_hash = {} end if mp_male_payload_sex_grab?(payload_hash) if phase.to_s == "stop" mp_male_apply_stop(player_id.to_i, payload_hash) return end mp_male_apply_grab_as_target(player_id.to_i, payload_hash) return end # Non-sex pvp_skill_hit → fall through to 98 damage handler. end if respond_to?(:mp_male_grab_deistvia_without) mp_male_grab_deistvia_without(player_id, action_id, phase, payload) end end end #------------------------------------------------------------------------------ # Patch EffectLonaGrabHit: male skin → attacker grab (NPC + NetPlayer) #------------------------------------------------------------------------------ if defined?(Game_Event) class Game_Event # Receiver proxies may use Lona/custom CHS (not page "-char-"). unless method_defined?(:mp_male_use_chs_original) if method_defined?(:use_chs?) alias mp_male_use_chs_original use_chs? def use_chs? begin return true if instance_variable_get(:@mp_male_force_use_chs) return true if instance_variable_get(:@mp_male_receiver_proxy) return true if instance_variable_get(:@mp_male_fucker_visual) rescue end mp_male_use_chs_original end end end # Local fucker visual is display-only; stock update_npc_sex unsets when # fucker_target/gang checks fail → walk sheet + standing peach body. unless method_defined?(:mp_male_update_npc_sex_visual_original) if method_defined?(:update_npc_sex) alias mp_male_update_npc_sex_visual_original update_npc_sex def update_npc_sex(*args) begin return if instance_variable_get(:@mp_male_fucker_visual) rescue end mp_male_update_npc_sex_visual_original(*args) end end end unless method_defined?(:mp_male_unset_chs_sex_visual_original) if method_defined?(:unset_chs_sex) alias mp_male_unset_chs_sex_visual_original unset_chs_sex def unset_chs_sex(*args) begin return if instance_variable_get(:@mp_male_fucker_visual) rescue end mp_male_unset_chs_sex_visual_original(*args) end end end unless method_defined?(:mp_male_batch_EffectLonaGrabHit_original) if method_defined?(:batch_EffectLonaGrabHit) alias mp_male_batch_EffectLonaGrabHit_original batch_EffectLonaGrabHit def batch_EffectLonaGrabHit begin if defined?(WebSocket) && WebSocket.respond_to?(:mp_male_try_handle_grab_hit) && WebSocket.mp_male_try_handle_grab_hit(self) begin self.delete rescue end return end rescue end mp_male_batch_EffectLonaGrabHit_original end end end end end # Stock hit_detection.scan = NPCs + local player only. NetPlayers never trigger # EffectLonaGrabHit — fire male grab manually after BasicFuckerGrab resolves. if defined?(Battle_System) module Battle_System unless method_defined?(:mp_male_process_skill_result_original) alias mp_male_process_skill_result_original process_skill_result def process_skill_result(skill) result = mp_male_process_skill_result_original(skill) begin if defined?(WebSocket) && WebSocket.respond_to?(:mp_male_after_skill_result) WebSocket.mp_male_after_skill_result(skill) end rescue end result end end end end # Sex.rb treats fuckers as NPCs. Male attacker puts Game_Player/Game_Actor in # @fuckers — stub the NPC-only APIs Sex.rb touches. if defined?(Game_Actor) class Game_Actor # Sex.rb:241 fgroup[i].actor.fapping = false attr_accessor :fapping unless method_defined?(:fapping) unless method_defined?(:npc_dead?) def npc_dead? begin return true if respond_to?(:health) && self.health.to_i <= 0 return true if respond_to?(:sta) && self.sta.to_i <= -100 rescue end begin return true if respond_to?(:action_state) && action_state == :death rescue end false end end # Sex.rb may call fucker.actor.masturbate_skill if pose slot is empty. unless method_defined?(:masturbate_skill) def masturbate_skill begin return $data_arpgskills["NpcMasturbationMale"] if defined?($data_arpgskills) && $data_arpgskills rescue end nil end end # Stock Game_Actor#reset_skill calls release_chs_group whenever state is # :grabber/:sex/:grabbed — that instantly cancels male BasicFuckerGrab sex # at the end of the cast. Clear skill fields only; keep sex/grab state. unless method_defined?(:mp_male_reset_skill_original) alias mp_male_reset_skill_original reset_skill def reset_skill(force=false) preserve = false begin if defined?(WebSocket) && WebSocket.respond_to?(:mp_male_skin_active?) && WebSocket.mp_male_skin_active? && [:grabber, :sex, :grabbed].include?(@action_state) preserve = true end rescue preserve = false end if preserve @skill = nil @skill_wait = 0 @current_skill_launched = false @skill_charging_state = 0 @blocked = false @holding_count = -1 return end mp_male_reset_skill_original(force) end end end end #------------------------------------------------------------------------------ # Chat command hook — wrap singleton send_chat like slavery/clans do #------------------------------------------------------------------------------ if defined?(WebSocket) module WebSocket class << self unless method_defined?(:mp_male_send_chat_without_commands) if method_defined?(:send_chat) alias mp_male_send_chat_without_commands send_chat end end if method_defined?(:mp_male_send_chat_without_commands) && !method_defined?(:mp_male_send_chat_wrapped) def send_chat(text, channel = nil) begin return if mp_male_try_chat_command(text) rescue end arity = (method(:mp_male_send_chat_without_commands).arity rescue -1) if arity == 1 mp_male_send_chat_without_commands(text) else mp_male_send_chat_without_commands(text, channel) end end def mp_male_send_chat_wrapped; true; end end end end end #------------------------------------------------------------------------------ # Game_Player CHS overrides — Lona hardcodes chs_type/chs_name/chs_definition. # Male skin must use villager NPC sheets (-char-M-REGULAR*) + @chs_configuration. #------------------------------------------------------------------------------ if defined?(Game_Player) class Game_Player def mp_male_chs_override_active? return false unless defined?(WebSocket) && WebSocket.respond_to?(:mp_male_skin_active?) return false unless WebSocket.mp_male_skin_active? t = nil begin t = @chs_type.to_s rescue t = "" end return false if t.nil? || t.empty? || t == "Lona" || t == "Lona_H" begin return true if defined?($chs_data) && $chs_data && $chs_data[t] rescue end false rescue false end unless method_defined?(:mp_male_chs_type_original) alias mp_male_chs_type_original chs_type def chs_type return @chs_type.to_s if mp_male_chs_override_active? mp_male_chs_type_original end end unless method_defined?(:mp_male_chs_definition_original) alias mp_male_chs_definition_original chs_definition def chs_definition if mp_male_chs_override_active? begin return $chs_data[@chs_type.to_s] if $chs_data && $chs_data[@chs_type.to_s] rescue end end mp_male_chs_definition_original end end unless method_defined?(:mp_male_chs_name_original) alias mp_male_chs_name_original chs_name def chs_name if mp_male_chs_override_active? # NPCs switch to *_H cache key in sex_mode — do the same or the # walk/sex cell sizes fight each other and the sprite flickers. begin if sex_mode? h = @chs_name_h.to_s return h unless h.empty? base = @chs_name.to_s return base + "_H" unless base.empty? end rescue end begin name = @chs_name.to_s return name unless name.empty? rescue end begin return "#{@chs_type}_i_#{charset_index}" rescue return @chs_type.to_s end end mp_male_chs_name_original end end # refresh() restores actor.character_name ("$Lona…") every time — sprite # then toggles between normal sheet and CHS → permanent blink. Hide it. unless method_defined?(:mp_male_character_name_original) alias mp_male_character_name_original character_name def character_name return "" if mp_male_chs_override_active? mp_male_character_name_original end end # Sex.rb state spread: tmpFucker.report_distance_to_vol_close (NPC API). unless method_defined?(:report_distance_to_vol_close) def report_distance_to_vol_close 90 end end unless method_defined?(:report_distance_to_vol_close_npc_vol) def report_distance_to_vol_close_npc_vol 65 end end unless method_defined?(:mp_male_chs_config_original) alias mp_male_chs_config_original chs_config def chs_config if mp_male_chs_override_active? && @chs_configuration.is_a?(Hash) return @chs_configuration end mp_male_chs_config_original end end unless method_defined?(:mp_male_statMap_original) if method_defined?(:statMap) alias mp_male_statMap_original statMap end def statMap if mp_male_chs_override_active? && @chs_configuration.is_a?(Hash) return @chs_configuration end if respond_to?(:mp_male_statMap_original, true) || method_defined?(:mp_male_statMap_original) return mp_male_statMap_original end @chs_configuration end end unless method_defined?(:mp_male_max_chs_capacity_original) alias mp_male_max_chs_capacity_original max_chs_capacity def max_chs_capacity if mp_male_chs_override_active? begin return chs_definition.max_capacity if chs_definition rescue end end mp_male_max_chs_capacity_original end end unless method_defined?(:mp_male_refresh_chs_original) alias mp_male_refresh_chs_original refresh_chs def refresh_chs if mp_male_chs_override_active? begin # Keep $ out of character_name while on NPC CHS sheets. if defined?(WebSocket) && WebSocket.respond_to?(:mp_male_fix_chs_sprite_name) WebSocket.mp_male_fix_chs_sprite_name end Cache.chs_character(self, true) if !@cancel_refresh rescue end @cancel_refresh = false # Always mark update for normal walk; during sex the sex system already # drives frames — forcing here every call causes visible flicker. in_sex = false begin in_sex = WebSocket.mp_male_player_in_sex_flow? if defined?(WebSocket) && WebSocket.respond_to?(:mp_male_player_in_sex_flow?) rescue in_sex = false end @chs_need_update = true unless in_sex # Stock refresh_chs clears this. Without it, hom_chk_portrait_idle # keeps calling setRprt every second → right portrait never auto-hides. begin actor.stat_changed = false if actor rescue end return end mp_male_refresh_chs_original end end unless method_defined?(:mp_male_refresh_original) alias mp_male_refresh_original refresh def refresh prev_idx = @character_index prev_type = nil begin prev_type = @chs_type rescue prev_type = nil end mp_male_refresh_original # refresh() pulls Lona character_index from actor — that flips # graphic_changed? every refresh and rebuilds the sprite (blink). begin if mp_male_chs_override_active? @character_index = prev_idx unless prev_idx.nil? @chs_type = prev_type if prev_type && !prev_type.to_s.empty? if defined?(WebSocket) && WebSocket.respond_to?(:mp_male_fix_chs_sprite_name) WebSocket.mp_male_fix_chs_sprite_name end end rescue end end end unless method_defined?(:mp_male_perform_transfer_original) alias mp_male_perform_transfer_original perform_transfer def perform_transfer # Only rewrite a true numeric 0 destination (broken OverMapID exit). # Clan house / NoerHome use STRING keys → to_i == 0; rewriting those # sent the player to OverMapID (often polluted as map 2) instead of the house. begin if @transferring && defined?(WebSocket) && WebSocket.respond_to?(:mp_male_repair_overmap_id) && !WebSocket.mp_male_transfer_is_tag_key?(@new_map_id) && @new_map_id.to_i <= 0 ref = ($game_map ? $game_map.map_id : nil) repaired = WebSocket.mp_male_repair_overmap_id(ref).to_i if repaired > 0 @new_map_id = repaired begin if $story_stats lx = $story_stats["LastOverMapX"].to_i ly = $story_stats["LastOverMapY"].to_i @new_x = lx if lx >= 0 @new_y = ly if ly >= 0 end rescue end end end rescue end mp_male_perform_transfer_original begin if defined?(WebSocket) && WebSocket.respond_to?(:mp_male_on_map_transfer) WebSocket.mp_male_on_map_transfer end rescue end end end # Stock Game_Player#set_chs_sex always forces sex_position=0 (Lona receiver) # and writes actor.stat only. As male fucker we must keep the real slot and # sync @chs_configuration — otherwise sex_mode? stays false and the NPC # drops us from @fuckers on the next update_npc_sex tick. unless method_defined?(:mp_male_set_chs_sex_original) alias mp_male_set_chs_sex_original set_chs_sex def set_chs_sex(pose, position=0) if mp_male_chs_override_active? begin set_chs_sex_prev_zoomXY if respond_to?(:set_chs_sex_prev_zoomXY) rescue end begin actor.remove_stun_verbs if actor && actor.respond_to?(:remove_stun_verbs) rescue end @chs_configuration = {} unless @chs_configuration.is_a?(Hash) @chs_configuration["sex_pos"] = pose @chs_configuration["sex_position"] = position begin if actor && actor.stat.is_a?(Hash) actor.stat["sex_pos"] = pose actor.stat["sex_position"] = position end rescue end @sex_state = 1 @sex_count = 0 begin @tile_id = 0 rescue end begin @move_type = 0 rescue end @chs_need_update = true # NPC fuckers get animation via setup_npc_sex; Game_Player does not. # Without sex animation, walk patterns sample the sex sheet → flicker. begin self.animation = animation_sex if respond_to?(:animation_sex) rescue end return end result = mp_male_set_chs_sex_original(pose, position) result end end unless method_defined?(:mp_male_set_event_chs_sex_original) alias mp_male_set_event_chs_sex_original set_event_chs_sex def set_event_chs_sex(pose, position=0) if mp_male_chs_override_active? @chs_configuration = {} unless @chs_configuration.is_a?(Hash) changed = (@chs_configuration["sex_pos"] != pose) || (@chs_configuration["sex_position"] != position) @chs_configuration["sex_pos"] = pose @chs_configuration["sex_position"] = position begin if actor && actor.stat.is_a?(Hash) actor.stat["sex_pos"] = pose actor.stat["sex_position"] = position end rescue end @chs_need_update = true if changed return end mp_male_set_event_chs_sex_original(pose, position) end end unless method_defined?(:mp_male_update_sex_original) alias mp_male_update_sex_original update_sex def update_sex # As male fucker, stock update_sex early-returns on !sex_receiver? every # frame (only clears skill). Sync animation stages from the NPC receiver. if mp_male_chs_override_active? && !sex_receiver? begin actor.skill = nil if actor rescue end begin tgt = actor.fucker_target if actor if tgt && tgt.respond_to?(:sex_state) st = tgt.instance_variable_get(:@sex_state).to_i if st != @mp_male_synced_sex_state.to_i @mp_male_synced_sex_state = st case st when 2 self.animation = animation_sex_fast if respond_to?(:animation_sex_fast) when 3 self.animation = animation_sex_cumming if respond_to?(:animation_sex_cumming) when 1 self.animation = animation_sex if respond_to?(:animation_sex) end @chs_need_update = true end end rescue end return end mp_male_update_sex_original end end unless method_defined?(:mp_male_unset_chs_sex_original) alias mp_male_unset_chs_sex_original unset_chs_sex def unset_chs_sex(release=false) if mp_male_chs_override_active? && @chs_configuration.is_a?(Hash) begin @chs_configuration["sex_pos"] = -1 @chs_configuration["sex_position"] = -1 rescue end end mp_male_unset_chs_sex_original(release) end end unless method_defined?(:mp_male_sex_mode_original) alias mp_male_sex_mode_original sex_mode? def sex_mode? if mp_male_chs_override_active? begin if @chs_configuration.is_a?(Hash) && !@chs_configuration["sex_pos"].nil? return @chs_configuration["sex_pos"].to_i != -1 end rescue end begin return actor.stat["sex_pos"] != -1 if actor && actor.stat.is_a?(Hash) rescue end end mp_male_sex_mode_original end end unless method_defined?(:mp_male_sex_receiver_original) alias mp_male_sex_receiver_original sex_receiver? def sex_receiver? if mp_male_chs_override_active? begin if @chs_configuration.is_a?(Hash) && !@chs_configuration["sex_position"].nil? return @chs_configuration["sex_position"].to_i == 0 end rescue end begin return actor.stat["sex_position"] == 0 if actor && actor.stat.is_a?(Hash) rescue end end mp_male_sex_receiver_original end end end end # Keep Lona render Hash sex_pos in sync when Sex#set_chs_sex runs on receiver proxy. if defined?(Game_Event) class Game_Event unless method_defined?(:mp_male_event_set_chs_sex_lona_original) if method_defined?(:set_chs_sex) alias mp_male_event_set_chs_sex_lona_original set_chs_sex def set_chs_sex(pose, position) result = mp_male_event_set_chs_sex_lona_original(pose, position) begin if instance_variable_get(:@mp_male_receiver_proxy) || (respond_to?(:mp_male_receiver_proxy) && mp_male_receiver_proxy) if defined?(WebSocket) && WebSocket.respond_to?(:mp_male_sync_lona_render_sex) WebSocket.mp_male_sync_lona_render_sex(self) end @chs_need_update = true end rescue end result end end end end end # Draw-time hide for local GP while fucker visual Event is shown. if defined?(Sprite_Character) class Sprite_Character < Sprite_Base unless method_defined?(:mp_male_update_other_hide_original) alias mp_male_update_other_hide_original update_other def update_other(*args) mp_male_update_other_hide_original(*args) begin if @character && @character == $game_player && defined?(WebSocket) && WebSocket.respond_to?(:mp_male_hide_local_fucker?) && WebSocket.mp_male_hide_local_fucker? self.opacity = 0 self.visible = false end rescue end end end end end # Detect BasicSexStruggle threshold on the captured player and notify attacker. if defined?(Game_Character) class Game_Character unless method_defined?(:mp_male_player_sex_mode_control_orig) if method_defined?(:player_sex_mode_control) alias mp_male_player_sex_mode_control_orig player_sex_mode_control def player_sex_mode_control(*args) prev = @sex_fight_count_struggle.to_i thresh = @sex_fucker_total_con.to_i result = mp_male_player_sex_mode_control_orig(*args) begin if thresh > 0 && prev == thresh && @sex_fight_count_struggle.to_i == 0 && defined?(WebSocket) && WebSocket.respond_to?(:mp_male_note_struggle_success) WebSocket.mp_male_note_struggle_success end rescue end result end end end unless method_defined?(:mp_male_player_anti_grab_mode_control_orig) if method_defined?(:player_anti_grab_mode_control) alias mp_male_player_anti_grab_mode_control_orig player_anti_grab_mode_control def player_anti_grab_mode_control(*args) fire = (@sex_grabbed_count_struggle.to_i == @sex_grabber_total_con.to_i && @sex_grabber_total_con.to_i > 0) result = mp_male_player_anti_grab_mode_control_orig(*args) begin if fire && defined?(WebSocket) && WebSocket.respond_to?(:mp_male_note_struggle_success) WebSocket.mp_male_note_struggle_success end rescue end result end end end end end