Files
LonaRPG-Online-Games/ModScripts/multiplayer/38_pvp_male_grab.rb
T
2026-10-29 21:59:06 +04:00

3997 lines
120 KiB
Ruby

# 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