3997 lines
120 KiB
Ruby
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
|
|
|
|
|
|
|