1121 lines
26 KiB
Ruby
1121 lines
26 KiB
Ruby
# encoding: UTF-8
|
|
|
|
module WebSocket
|
|
@player_group_ids ||= {}
|
|
GROUP_LEAVE_TEXT = "\u0412\u044B\u0439\u0442\u0438 \u0438\u0437 \u0433\u0440\u0443\u043F\u043F\u044B"
|
|
GROUP_MENU_TEXT = "\u0413\u0440\u0443\u043F\u043F\u0430"
|
|
GROUP_LEAVE_SHORT_TEXT = "\u041F\u043E\u043A\u0438\u043D\u0443\u0442\u044C"
|
|
GROUP_HELP_TEXT = "\u041F\u043E\u043C\u043E\u0447\u044C"
|
|
GROUP_SELL_TEXT = "\u041F\u0440\u043E\u0434\u0430\u0442\u044C"
|
|
GROUP_HELP_TRANSFER = 10
|
|
GROUP_SELL_REWARD_ITEM = "ItemCoin2"
|
|
GROUP_SELL_REWARD_AMOUNT = 10
|
|
GROUP_SELL_MAP_ID = 63
|
|
GROUP_SELL_POINT = "WakeUp"
|
|
|
|
def self.clear_group_state
|
|
@player_group_ids = {}
|
|
@group_player_cache = {}
|
|
end
|
|
|
|
def self.group_player_cache
|
|
@group_player_cache ||= {}
|
|
rescue
|
|
@group_player_cache = {}
|
|
end
|
|
|
|
def self.cache_group_member_snapshot(player_id, fields={})
|
|
pid = player_id.to_i
|
|
return if pid <= 0
|
|
return unless fields.is_a?(Hash)
|
|
|
|
row = group_player_cache[pid]
|
|
row = {} unless row.is_a?(Hash)
|
|
|
|
fields.each do |k, v|
|
|
next if v.nil?
|
|
if k.to_sym == :nick
|
|
txt = v.to_s.strip
|
|
next if txt == ""
|
|
row[:nick] = txt
|
|
else
|
|
row[k.to_sym] = v
|
|
end
|
|
end
|
|
|
|
group_player_cache[pid] = row
|
|
rescue
|
|
end
|
|
|
|
def self.player_group_id(player_id)
|
|
@player_group_ids ||= {}
|
|
@player_group_ids[player_id.to_i]
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.set_player_group(player_id, group_id)
|
|
@player_group_ids ||= {}
|
|
pid = player_id.to_i
|
|
gid = group_id.to_i
|
|
if pid <= 0 || gid <= 0
|
|
@player_group_ids.delete(pid)
|
|
begin
|
|
group_player_cache.delete(pid)
|
|
rescue
|
|
end
|
|
else
|
|
@player_group_ids[pid] = gid
|
|
end
|
|
rescue
|
|
end
|
|
|
|
def self.grouped_with_me?(player_id)
|
|
pid = player_id.to_i
|
|
return false if pid <= 0
|
|
return false if @my_id.nil?
|
|
|
|
my_gid = player_group_id(@my_id)
|
|
other_gid = player_group_id(pid)
|
|
return false if my_gid.nil? || other_gid.nil?
|
|
|
|
my_gid.to_i > 0 && my_gid.to_i == other_gid.to_i && pid != @my_id.to_i
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.group_request(target_id)
|
|
return unless @connected
|
|
tid = target_id.to_i
|
|
return if tid <= 0
|
|
return if !@my_id.nil? && tid == @my_id.to_i
|
|
send_line("group_join:#{tid}")
|
|
end
|
|
|
|
def self.in_group?
|
|
return false if @my_id.nil?
|
|
gid = player_group_id(@my_id)
|
|
!gid.nil? && gid.to_i > 0
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.group_leave
|
|
return unless @connected
|
|
return unless in_group?
|
|
send_line("group_leave")
|
|
rescue
|
|
end
|
|
|
|
def self.remote_player_event(player_id)
|
|
return nil unless @players.is_a?(Hash)
|
|
@players[player_id.to_i]
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.remote_player_actor(player_id)
|
|
ev = remote_player_event(player_id)
|
|
return nil if ev.nil?
|
|
ev.instance_variable_get(:@net_actor)
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.player_sta(player_id)
|
|
pid = player_id.to_i
|
|
return nil if pid <= 0
|
|
|
|
if !@my_id.nil? && pid == @my_id.to_i
|
|
actor = nil
|
|
begin
|
|
actor = $game_player.actor if $game_player
|
|
rescue
|
|
actor = nil
|
|
end
|
|
begin
|
|
return actor.sta if actor && actor.respond_to?(:sta)
|
|
rescue
|
|
end
|
|
return nil
|
|
end
|
|
|
|
actor = remote_player_actor(pid)
|
|
begin
|
|
return actor.sta if actor && actor.respond_to?(:sta)
|
|
rescue
|
|
end
|
|
begin
|
|
cached = group_player_cache[pid]
|
|
return cached[:sta] if cached.is_a?(Hash) && cached.has_key?(:sta)
|
|
rescue
|
|
end
|
|
nil
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.group_member_row(pid)
|
|
pid = pid.to_i
|
|
return nil if pid <= 0
|
|
return nil if @my_id && pid == @my_id.to_i
|
|
return nil unless grouped_with_me?(pid)
|
|
|
|
ev = nil
|
|
actor = nil
|
|
stat = nil
|
|
begin
|
|
ev = @players[pid] if @players.is_a?(Hash)
|
|
rescue
|
|
ev = nil
|
|
end
|
|
|
|
begin
|
|
actor = ev.instance_variable_get(:@net_actor) if ev
|
|
rescue
|
|
actor = nil
|
|
end
|
|
|
|
begin
|
|
stat = actor.stat if actor && actor.respond_to?(:stat)
|
|
rescue
|
|
stat = nil
|
|
end
|
|
|
|
cached = nil
|
|
begin
|
|
cached = group_player_cache[pid]
|
|
rescue
|
|
cached = nil
|
|
end
|
|
|
|
nick = nil
|
|
begin
|
|
nick = nickname_for(pid)
|
|
rescue
|
|
nick = nil
|
|
end
|
|
nick = cached[:nick].to_s if (nick.nil? || nick.to_s.strip == "") && cached.is_a?(Hash) && cached[:nick]
|
|
nick = "Player #{pid}" if nick.nil? || nick.to_s.strip == ""
|
|
|
|
row = {
|
|
:pid => pid,
|
|
:nick => nick.to_s,
|
|
:health => _group_actor_stat_value(actor, stat, "health"),
|
|
:sta => _group_actor_stat_value(actor, stat, "sta"),
|
|
:sat => _group_actor_stat_value(actor, stat, "sat")
|
|
}
|
|
|
|
if cached.is_a?(Hash)
|
|
row[:health] = cached[:health] if row[:health].nil?
|
|
row[:sta] = cached[:sta] if row[:sta].nil?
|
|
row[:sat] = cached[:sat] if row[:sat].nil?
|
|
row[:nick] = cached[:nick].to_s if cached[:nick] && row[:nick].to_s =~ /\APlayer \d+\z/
|
|
end
|
|
|
|
cache_group_member_snapshot(pid, row)
|
|
row
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.snapshot_group_member(player_id)
|
|
pid = player_id.to_i
|
|
return if pid <= 0
|
|
|
|
actor = remote_player_actor(pid)
|
|
stat = nil
|
|
begin
|
|
stat = actor.stat if actor && actor.respond_to?(:stat)
|
|
rescue
|
|
stat = nil
|
|
end
|
|
|
|
cache_group_member_snapshot(pid, {
|
|
:nick => (nickname_for(pid) rescue nil),
|
|
:health => _group_actor_stat_value(actor, stat, "health"),
|
|
:sta => _group_actor_stat_value(actor, stat, "sta"),
|
|
:sat => _group_actor_stat_value(actor, stat, "sat")
|
|
})
|
|
rescue
|
|
end
|
|
|
|
def self._group_wire_stat_value(value)
|
|
s = value.to_s.strip
|
|
return nil if s == "" || s == "nil" || s == "NA"
|
|
begin
|
|
return s.to_i if s =~ /\A-?\d+(?:\.\d+)?\z/
|
|
rescue
|
|
end
|
|
s
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.apply_group_stat(player_id, nick, health, sta, sat)
|
|
pid = player_id.to_i
|
|
return if pid <= 0
|
|
|
|
cache_group_member_snapshot(pid, {
|
|
:nick => nick,
|
|
:health => _group_wire_stat_value(health),
|
|
:sta => _group_wire_stat_value(sta),
|
|
:sat => _group_wire_stat_value(sat)
|
|
})
|
|
rescue
|
|
end
|
|
|
|
def self.can_help_group_member?(player_id)
|
|
pid = player_id.to_i
|
|
return false unless grouped_with_me?(pid)
|
|
sta = player_sta(pid)
|
|
return false if sta.nil?
|
|
sta.to_f <= 0.0
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.can_sell_group_member?(player_id)
|
|
can_help_group_member?(player_id)
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.player_menu_group_label(player_id)
|
|
pid = player_id.to_i
|
|
return GROUP_MENU_TEXT unless grouped_with_me?(pid)
|
|
return GROUP_HELP_TEXT if can_help_group_member?(pid)
|
|
GROUP_LEAVE_SHORT_TEXT
|
|
rescue
|
|
GROUP_MENU_TEXT
|
|
end
|
|
|
|
def self.group_help_request(target_id)
|
|
return false unless @connected
|
|
tid = target_id.to_i
|
|
return false if tid <= 0
|
|
return false if @my_id.nil? || tid == @my_id.to_i
|
|
return false unless can_help_group_member?(tid)
|
|
|
|
actor = nil
|
|
begin
|
|
actor = $game_player.actor if $game_player
|
|
rescue
|
|
actor = nil
|
|
end
|
|
return false if actor.nil? || !actor.respond_to?(:sta)
|
|
|
|
current_sta = 0.0
|
|
begin
|
|
current_sta = actor.sta.to_f
|
|
rescue
|
|
current_sta = 0.0
|
|
end
|
|
return false if current_sta < GROUP_HELP_TRANSFER
|
|
|
|
send_line("group_help:#{tid}")
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.group_sell_request(target_id)
|
|
return false unless @connected
|
|
tid = target_id.to_i
|
|
return false if tid <= 0
|
|
return false if @my_id.nil? || tid == @my_id.to_i
|
|
return false unless can_sell_group_member?(tid)
|
|
|
|
send_line("group_sell:#{tid}")
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.apply_group_sell_reward(amount)
|
|
qty = amount.to_i
|
|
return if qty <= 0
|
|
|
|
begin
|
|
optain_item(GROUP_SELL_REWARD_ITEM, qty)
|
|
return
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
$game_party.gain_item(GROUP_SELL_REWARD_ITEM, qty)
|
|
rescue
|
|
end
|
|
end
|
|
|
|
def self.apply_group_sale_capture(seller_id)
|
|
begin
|
|
notify_network("Тебя продали в рабство.") if defined?(notify_network)
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
apply_slave_states
|
|
rescue
|
|
end
|
|
begin
|
|
whole_event_end
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
actor = $game_player.actor if defined?($game_player) && $game_player
|
|
actor.sta = -100 if actor && actor.respond_to?(:sta=)
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
$story_stats["Captured"] = 1
|
|
$story_stats["RapeLoop"] = 1
|
|
$story_stats["BackStreetArrearsPrincipal"] = 0
|
|
$story_stats["BackStreetArrearsInterest"] = 0
|
|
$story_stats["BackStreetArrearsWhorePrincipal"] = 0
|
|
$story_stats["SlaveOwner"] = "NoerBackStreet"
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
rape_loop_drop_item(false, false)
|
|
rescue
|
|
end
|
|
begin
|
|
load_script("Data/Batch/Put_HeavyestBondage_no_dialog.rb")
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
actor = $game_player.actor if defined?($game_player) && $game_player
|
|
actor.update_lonaStat if actor && actor.respond_to?(:update_lonaStat)
|
|
rescue
|
|
end
|
|
begin
|
|
$game_player.update if defined?($game_player) && $game_player
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
SndLib.me_play("SE/Move", 75, 120 + rand(31))
|
|
rescue
|
|
end
|
|
begin
|
|
call_timer_off
|
|
rescue
|
|
end
|
|
begin
|
|
$game_timer.update
|
|
rescue
|
|
end
|
|
begin
|
|
change_map_weather_cleaner
|
|
rescue
|
|
end
|
|
begin
|
|
$story_stats["TagSubTrans"] = GROUP_SELL_POINT
|
|
rescue
|
|
end
|
|
begin
|
|
$game_boxes.box(System_Settings::STORAGE_TEMP_MAP).clear
|
|
rescue
|
|
end
|
|
begin
|
|
$game_player.reserve_transfer(GROUP_SELL_MAP_ID, 1, 1, $game_player.direction)
|
|
rescue
|
|
end
|
|
begin
|
|
change_map_captured_story_stats_fix
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
send_playersync_full("group_sell", true) if respond_to?(:send_playersync_full)
|
|
rescue
|
|
end
|
|
end
|
|
|
|
def self._group_refresh_local_actor(actor)
|
|
return if actor.nil?
|
|
|
|
begin
|
|
if actor.respond_to?(:actor_ForceUpdate)
|
|
actor.actor_ForceUpdate
|
|
else
|
|
actor.update_state_frames if actor.respond_to?(:update_state_frames)
|
|
end
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
actor.determine_death if actor.respond_to?(:determine_death)
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
$game_player.update if defined?($game_player) && $game_player
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
send_playersync_full("group_help", true) if respond_to?(:send_playersync_full)
|
|
rescue
|
|
end
|
|
end
|
|
|
|
def self.apply_group_sta_delta(player_id, delta)
|
|
pid = player_id.to_i
|
|
return if pid <= 0
|
|
delta_v = delta.to_f
|
|
return if delta_v == 0.0
|
|
|
|
if !@my_id.nil? && pid == @my_id.to_i
|
|
actor = nil
|
|
begin
|
|
actor = $game_player.actor if $game_player
|
|
rescue
|
|
actor = nil
|
|
end
|
|
return if actor.nil? || !actor.respond_to?(:sta) || !actor.respond_to?(:sta=)
|
|
|
|
begin
|
|
actor.sta = actor.sta.to_f + delta_v
|
|
rescue
|
|
return
|
|
end
|
|
|
|
_group_refresh_local_actor(actor)
|
|
return
|
|
end
|
|
|
|
actor = remote_player_actor(pid)
|
|
if actor && actor.respond_to?(:sta) && actor.respond_to?(:sta=)
|
|
begin
|
|
actor.sta = actor.sta.to_f + delta_v
|
|
rescue
|
|
end
|
|
else
|
|
begin
|
|
cache = group_player_cache[pid] || {}
|
|
current = cache[:sta].to_f
|
|
cache[:sta] = current + delta_v
|
|
group_player_cache[pid] = cache
|
|
rescue
|
|
end
|
|
end
|
|
end
|
|
|
|
def self.apply_group_help(from_id, to_id, amount)
|
|
transfer = amount.to_f
|
|
return if transfer <= 0.0
|
|
apply_group_sta_delta(from_id, -transfer)
|
|
apply_group_sta_delta(to_id, transfer)
|
|
rescue
|
|
end
|
|
|
|
def self.group_icon_bitmap
|
|
return @group_icon_bitmap if @group_icon_bitmap && !@group_icon_bitmap.disposed?
|
|
@group_icon_bitmap = Cache.load_bitmap("Graphics/Online/", "group")
|
|
rescue
|
|
@group_icon_bitmap = nil
|
|
end
|
|
|
|
def self._group_stat_value(stat_hash, key_name)
|
|
return nil unless stat_hash.is_a?(Hash)
|
|
|
|
begin
|
|
return stat_hash[key_name] if stat_hash.has_key?(key_name)
|
|
rescue
|
|
end
|
|
begin
|
|
sym = key_name.to_sym
|
|
return stat_hash[sym] if stat_hash.has_key?(sym)
|
|
rescue
|
|
end
|
|
|
|
begin
|
|
low = key_name.to_s.downcase
|
|
stat_hash.each do |k, v|
|
|
return v if k.to_s.downcase == low
|
|
end
|
|
rescue
|
|
end
|
|
|
|
nil
|
|
end
|
|
|
|
def self._group_actor_stat_value(actor, stat_hash, key_name)
|
|
begin
|
|
if actor && actor.respond_to?(key_name)
|
|
value = actor.send(key_name)
|
|
return value unless value.nil?
|
|
end
|
|
rescue
|
|
end
|
|
|
|
_group_stat_value(stat_hash, key_name)
|
|
end
|
|
|
|
def self.group_hud_rows
|
|
rows = []
|
|
list = []
|
|
|
|
begin
|
|
if @player_group_ids.is_a?(Hash)
|
|
@player_group_ids.each_key { |pid| list << pid.to_i }
|
|
end
|
|
rescue
|
|
list = []
|
|
end
|
|
|
|
list.uniq.sort.each do |pid|
|
|
row = group_member_row(pid)
|
|
rows << row unless row.nil?
|
|
end
|
|
|
|
rows
|
|
rescue
|
|
[]
|
|
end
|
|
|
|
class << self
|
|
if method_defined?(:set_nickname) && !method_defined?(:mp_group_cache_old_set_nickname)
|
|
alias_method :mp_group_cache_old_set_nickname, :set_nickname
|
|
def set_nickname(player_id, nick)
|
|
mp_group_cache_old_set_nickname(player_id, nick)
|
|
cache_group_member_snapshot(player_id, :nick => nick)
|
|
rescue
|
|
mp_group_cache_old_set_nickname(player_id, nick) rescue nil
|
|
end
|
|
end
|
|
|
|
if method_defined?(:apply_playersync) && !method_defined?(:mp_group_cache_old_apply_playersync)
|
|
alias_method :mp_group_cache_old_apply_playersync, :apply_playersync
|
|
def apply_playersync(pid, actor_id, level, skills_csv, chs_type, charset_index, chs_name, chs_name_h, stat_pack)
|
|
result = mp_group_cache_old_apply_playersync(pid, actor_id, level, skills_csv, chs_type, charset_index, chs_name, chs_name_h, stat_pack)
|
|
|
|
actor = nil
|
|
begin
|
|
ev = @players[pid.to_i] if @players.is_a?(Hash)
|
|
actor = ev.instance_variable_get(:@net_actor) if ev
|
|
rescue
|
|
actor = nil
|
|
end
|
|
|
|
stat = nil
|
|
begin
|
|
stat = actor.stat if actor && actor.respond_to?(:stat)
|
|
rescue
|
|
stat = nil
|
|
end
|
|
|
|
cache_group_member_snapshot(pid, {
|
|
:nick => (nickname_for(pid) rescue nil),
|
|
:health => _group_actor_stat_value(actor, stat, "health"),
|
|
:sta => _group_actor_stat_value(actor, stat, "sta"),
|
|
:sat => _group_actor_stat_value(actor, stat, "sat")
|
|
})
|
|
|
|
result
|
|
end
|
|
end
|
|
|
|
unless method_defined?(:mp_group_parse_without_layer)
|
|
alias_method :mp_group_parse_without_layer, :parse
|
|
end
|
|
|
|
def parse(msg)
|
|
if msg.start_with?("group_stat:")
|
|
parts = msg.split(":", 6)
|
|
if parts.size >= 6
|
|
pid = parts[1].to_i
|
|
nick = unesc(parts[2].to_s) rescue parts[2].to_s
|
|
apply_group_stat(pid, nick, parts[3], parts[4], parts[5])
|
|
end
|
|
return
|
|
end
|
|
|
|
if msg.start_with?("quit:")
|
|
pid = msg.split(":", 2)[1].to_i rescue 0
|
|
if pid > 0 && grouped_with_me?(pid)
|
|
snapshot_group_member(pid)
|
|
begin
|
|
remove_remote_player(pid)
|
|
rescue
|
|
end
|
|
return
|
|
end
|
|
end
|
|
|
|
if msg.start_with?("group_set:")
|
|
parts = msg.split(":")
|
|
if parts.size >= 3
|
|
set_player_group(parts[1].to_i, parts[2].to_i)
|
|
end
|
|
return
|
|
end
|
|
|
|
if msg.start_with?("group_clear:")
|
|
parts = msg.split(":")
|
|
if parts.size >= 2
|
|
set_player_group(parts[1].to_i, 0)
|
|
end
|
|
return
|
|
end
|
|
|
|
if msg.start_with?("group_help_apply:")
|
|
parts = msg.split(":")
|
|
if parts.size >= 4
|
|
apply_group_help(parts[1].to_i, parts[2].to_i, parts[3].to_f)
|
|
end
|
|
return
|
|
end
|
|
|
|
if msg.start_with?("group_sell_reward:")
|
|
parts = msg.split(":")
|
|
if parts.size >= 3
|
|
apply_group_sell_reward(parts[2].to_i)
|
|
end
|
|
return
|
|
end
|
|
|
|
if msg.start_with?("group_sold:")
|
|
parts = msg.split(":")
|
|
if parts.size >= 3
|
|
apply_group_sale_capture(parts[1].to_i)
|
|
end
|
|
return
|
|
end
|
|
|
|
mp_group_parse_without_layer(msg)
|
|
end
|
|
|
|
unless method_defined?(:mp_group_connect_without_layer)
|
|
alias_method :mp_group_connect_without_layer, :connect
|
|
end
|
|
|
|
def connect(*args, &block)
|
|
clear_group_state
|
|
mp_group_connect_without_layer(*args, &block)
|
|
end
|
|
|
|
unless method_defined?(:mp_group_disconnect_without_layer)
|
|
alias_method :mp_group_disconnect_without_layer, :disconnect
|
|
end
|
|
|
|
def disconnect(*args, &block)
|
|
mp_group_disconnect_without_layer(*args, &block)
|
|
ensure
|
|
clear_group_state
|
|
end
|
|
end
|
|
end
|
|
|
|
class Menu_System < Menu_ContentBase
|
|
unless method_defined?(:mp_group_menu_old_create_load_game_sprite)
|
|
alias mp_group_menu_old_create_load_game_sprite create_load_game_sprite
|
|
end
|
|
|
|
def create_load_game_sprite
|
|
spr = Sprite.new(@viewport)
|
|
spr.bitmap = Bitmap.new(240, 30)
|
|
begin
|
|
if defined?(FONT_MOD) && FONT_MOD.const_defined?(:TITLE_MENU)
|
|
spr.bitmap.font.name = FONT_MOD::TITLE_MENU
|
|
spr.bitmap.font.size = FONT_MOD::TITLE_MENU_S if FONT_MOD.const_defined?(:TITLE_MENU_S)
|
|
elsif defined?(MPSafeFont)
|
|
spr.bitmap.font.name = MPSafeFont.server_name
|
|
end
|
|
rescue
|
|
end
|
|
begin
|
|
if defined?(FM_ST) && FM_ST.const_defined?(:SYS)
|
|
spr.bitmap.font.color = FM_ST::SYS
|
|
else
|
|
spr.bitmap.font.color.set(*FONT_COLOR)
|
|
end
|
|
rescue
|
|
spr.bitmap.font.color.set(*FONT_COLOR)
|
|
end
|
|
spr.bitmap.font.size = 28 if !(defined?(FONT_MOD) && FONT_MOD.const_defined?(:TITLE_MENU_S))
|
|
spr.bitmap.font.bold = true
|
|
spr.x = 198
|
|
spr.y = 2 + EACH_TOP_OPT_HEIGHT * 2
|
|
spr.z = 3
|
|
spr.bitmap.font.outline = false
|
|
tmpTarText = (defined?(WebSocket) && WebSocket.const_defined?(:GROUP_LEAVE_TEXT)) ? WebSocket::GROUP_LEAVE_TEXT : "Leave Group"
|
|
spr.bitmap.draw_text(spr.bitmap.rect, tmpTarText)
|
|
spr.visible = true
|
|
spr.opacity = OPACITY_INACTIVE
|
|
if Mouse.usable?
|
|
textWitdh = spr.bitmap.text_size(tmpTarText).width
|
|
textHeight = spr.bitmap.text_size(tmpTarText).height
|
|
@mouse_all_rects << [[spr.x, spr.y, textWitdh, textHeight]]
|
|
end
|
|
@all_sprites << spr
|
|
[spr]
|
|
end
|
|
|
|
unless method_defined?(:mp_group_menu_old_load_command_handler)
|
|
alias mp_group_menu_old_load_command_handler load_command_handler
|
|
end
|
|
|
|
def load_command_handler
|
|
return SndLib.sys_buzzer unless defined?(WebSocket) && WebSocket.respond_to?(:group_leave)
|
|
return SndLib.sys_buzzer unless WebSocket.in_group?
|
|
WebSocket.group_leave
|
|
SceneManager.goto(Scene_Map)
|
|
rescue
|
|
SndLib.sys_buzzer rescue nil
|
|
end
|
|
end
|
|
|
|
module MPGroupHUD
|
|
MIN_WIDTH = 112
|
|
MAX_WIDTH = 156
|
|
ROW_H = 114
|
|
START_Y = 98
|
|
PADDING = 8
|
|
|
|
def self.nick_font_name
|
|
return MPSafeFont.nick_name if defined?(MPSafeFont) && MPSafeFont.respond_to?(:nick_name)
|
|
return FONT_MOD::NPCSTAT if defined?(FONT_MOD) && FONT_MOD.const_defined?(:NPCSTAT)
|
|
"VL Gothic"
|
|
rescue
|
|
"VL Gothic"
|
|
end
|
|
|
|
def self.stat_font_name
|
|
return MPSafeFont.server_meta_name if defined?(MPSafeFont) && MPSafeFont.respond_to?(:server_meta_name)
|
|
return FONT_MOD::OPT_INPUT if defined?(FONT_MOD) && FONT_MOD.const_defined?(:OPT_INPUT)
|
|
return FONT_MOD::STAT_INFO if defined?(FONT_MOD) && FONT_MOD.const_defined?(:STAT_INFO)
|
|
"VL Gothic"
|
|
rescue
|
|
"VL Gothic"
|
|
end
|
|
|
|
def self.ensure_hud
|
|
return if @sprite && !@sprite.disposed?
|
|
|
|
z = 500
|
|
begin
|
|
z = System_Settings::MAP_HUD_Z + 10 if defined?(System_Settings) && System_Settings.const_defined?(:MAP_HUD_Z)
|
|
rescue
|
|
z = 500
|
|
end
|
|
|
|
@viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
|
|
@viewport.z = z
|
|
@sprite = Sprite.new(@viewport)
|
|
@signature = nil
|
|
@rows = []
|
|
update_position
|
|
rescue
|
|
dispose
|
|
end
|
|
|
|
def self.dispose
|
|
begin
|
|
@sprite.bitmap.dispose if @sprite && @sprite.bitmap
|
|
rescue
|
|
end
|
|
begin
|
|
@sprite.dispose if @sprite
|
|
rescue
|
|
end
|
|
begin
|
|
@viewport.dispose if @viewport
|
|
rescue
|
|
end
|
|
@sprite = nil
|
|
@viewport = nil
|
|
@signature = nil
|
|
@rows = []
|
|
end
|
|
|
|
def self.update
|
|
ensure_hud
|
|
return unless @sprite
|
|
|
|
rows = []
|
|
begin
|
|
rows = WebSocket.group_hud_rows if defined?(WebSocket)
|
|
rescue
|
|
rows = []
|
|
end
|
|
|
|
sig = rows.map { |row|
|
|
[
|
|
row[:pid].to_i,
|
|
row[:nick].to_s,
|
|
row[:health].to_s,
|
|
row[:sta].to_s,
|
|
row[:sat].to_s
|
|
].join("|")
|
|
}.join("/")
|
|
|
|
if @signature != sig
|
|
@rows = rows
|
|
redraw
|
|
@signature = sig
|
|
end
|
|
|
|
update_position
|
|
@sprite.visible = !rows.empty?
|
|
rescue
|
|
dispose
|
|
end
|
|
|
|
def self.update_position
|
|
return unless @sprite
|
|
begin
|
|
@viewport.rect.set(0, 0, Graphics.width, Graphics.height) if @viewport && @viewport.respond_to?(:rect)
|
|
rescue
|
|
end
|
|
width = MIN_WIDTH
|
|
begin
|
|
width = @sprite.bitmap.width if @sprite.bitmap && !@sprite.bitmap.disposed?
|
|
rescue
|
|
width = MIN_WIDTH
|
|
end
|
|
@sprite.x = Graphics.width - width - 8
|
|
@sprite.y = START_Y
|
|
@sprite.z = (@viewport ? @viewport.z : 500)
|
|
rescue
|
|
end
|
|
|
|
def self.measure_width(rows)
|
|
width = MIN_WIDTH
|
|
bmp = nil
|
|
|
|
begin
|
|
bmp = Bitmap.new(1, 1)
|
|
begin
|
|
bmp.font.name = nick_font_name
|
|
rescue
|
|
end
|
|
bmp.font.outline = false
|
|
bmp.font.shadow = false
|
|
|
|
icon = nil
|
|
begin
|
|
icon = WebSocket.group_icon_bitmap if defined?(WebSocket)
|
|
rescue
|
|
icon = nil
|
|
end
|
|
if icon && !icon.disposed?
|
|
width = [width, icon.width.to_i + (PADDING * 2)].max
|
|
end
|
|
|
|
rows.each do |row|
|
|
bmp.font.name = nick_font_name
|
|
bmp.font.size = 20
|
|
bmp.font.bold = true
|
|
width = [width, bmp.text_size(row[:nick].to_s).width.to_i + (PADDING * 2)].max
|
|
|
|
bmp.font.name = stat_font_name
|
|
bmp.font.size = 18
|
|
bmp.font.bold = false
|
|
["HP #{group_stat_text(row[:health])}",
|
|
"STA #{group_stat_text(row[:sta])}",
|
|
"SAT #{group_stat_text(row[:sat])}"].each do |text|
|
|
width = [width, bmp.text_size(text).width.to_i + (PADDING * 2)].max
|
|
end
|
|
end
|
|
rescue
|
|
width = MIN_WIDTH
|
|
ensure
|
|
begin
|
|
bmp.dispose if bmp
|
|
rescue
|
|
end
|
|
end
|
|
|
|
[[width, MIN_WIDTH].max, MAX_WIDTH].min
|
|
end
|
|
|
|
def self.redraw
|
|
return unless @sprite
|
|
|
|
height = [@rows.size, 1].max * ROW_H
|
|
width = measure_width(@rows)
|
|
begin
|
|
@sprite.bitmap.dispose if @sprite.bitmap
|
|
rescue
|
|
end
|
|
@sprite.bitmap = Bitmap.new(width, height)
|
|
bmp = @sprite.bitmap
|
|
|
|
begin
|
|
bmp.font.name = nick_font_name
|
|
rescue
|
|
end
|
|
bmp.font.outline = false
|
|
bmp.font.shadow = false
|
|
|
|
@rows.each_with_index do |row, idx|
|
|
top = idx * ROW_H
|
|
draw_row(bmp, top, row)
|
|
end
|
|
rescue
|
|
end
|
|
|
|
def self.draw_row(bmp, top, row)
|
|
width = bmp.width
|
|
bmp.fill_rect(0, top, width, ROW_H - 2, Color.new(0, 0, 0, 144))
|
|
bmp.fill_rect(0, top, width, 1, Color.new(255, 255, 255, 56))
|
|
|
|
icon = nil
|
|
begin
|
|
icon = WebSocket.group_icon_bitmap if defined?(WebSocket)
|
|
rescue
|
|
icon = nil
|
|
end
|
|
if icon && !icon.disposed?
|
|
begin
|
|
icon_x = ((width - icon.width) / 2).to_i
|
|
bmp.blt(icon_x, top + 6, icon, Rect.new(0, 0, icon.width, icon.height))
|
|
rescue
|
|
end
|
|
end
|
|
|
|
bmp.font.name = nick_font_name
|
|
bmp.font.size = 20
|
|
bmp.font.bold = true
|
|
bmp.font.color = Color.new(255, 255, 255)
|
|
bmp.draw_text(0, top + 24, width, 22, row[:nick].to_s, 1)
|
|
|
|
bmp.font.name = stat_font_name
|
|
bmp.font.size = 18
|
|
bmp.font.bold = false
|
|
bmp.font.color = Color.new(255, 110, 110)
|
|
bmp.draw_text(0, top + 50, width, 20, "HP #{group_stat_text(row[:health])}", 1)
|
|
|
|
bmp.font.color = Color.new(120, 255, 120)
|
|
bmp.draw_text(0, top + 72, width, 20, "STA #{group_stat_text(row[:sta])}", 1)
|
|
|
|
bmp.font.color = Color.new(255, 210, 120)
|
|
bmp.draw_text(0, top + 92, width, 20, "SAT #{group_stat_text(row[:sat])}", 1)
|
|
rescue
|
|
end
|
|
|
|
def self.group_stat_text(value)
|
|
return "--" if value.nil?
|
|
s = value.to_s
|
|
return "--" if s.strip == "" || s == "nil"
|
|
begin
|
|
return value.to_i.to_s if s =~ /\A-?\d+(?:\.\d+)?\z/
|
|
rescue
|
|
end
|
|
s
|
|
end
|
|
end
|
|
|
|
class Sprite_Character < Sprite_Base
|
|
unless method_defined?(:mp_group_overlay_update)
|
|
alias mp_group_overlay_update update
|
|
end
|
|
|
|
def update
|
|
mp_group_overlay_update
|
|
mp_update_group_marker
|
|
end
|
|
|
|
def mp_update_group_marker
|
|
pid = nil
|
|
begin
|
|
if @character && @character.instance_variable_defined?(:@net_player_id)
|
|
pid = @character.instance_variable_get(:@net_player_id)
|
|
end
|
|
rescue
|
|
pid = nil
|
|
end
|
|
|
|
unless pid && defined?(WebSocket) && WebSocket.respond_to?(:grouped_with_me?) && WebSocket.grouped_with_me?(pid)
|
|
mp_dispose_group_marker
|
|
return
|
|
end
|
|
|
|
bmp = WebSocket.group_icon_bitmap
|
|
if bmp.nil? || bmp.disposed?
|
|
mp_dispose_group_marker
|
|
return
|
|
end
|
|
|
|
if @mp_group_sprite.nil?
|
|
@mp_group_sprite = Sprite.new(self.viewport)
|
|
@mp_group_sprite.bitmap = bmp
|
|
@mp_group_sprite.ox = bmp.width / 2
|
|
@mp_group_sprite.oy = bmp.height
|
|
end
|
|
|
|
nick_y = self.y - height - 1
|
|
nick_h = 0
|
|
if @mp_nick_sprite
|
|
begin
|
|
nick_h = @mp_nick_sprite.bitmap ? @mp_nick_sprite.bitmap.height.to_i : 0
|
|
rescue
|
|
nick_h = 0
|
|
end
|
|
@mp_nick_sprite.y = nick_y
|
|
@mp_nick_sprite.z = self.z + 1
|
|
end
|
|
|
|
@mp_group_sprite.x = self.x
|
|
@mp_group_sprite.y = nick_y - nick_h - 2
|
|
@mp_group_sprite.z = self.z + 2
|
|
@mp_group_sprite.visible = self.visible
|
|
rescue
|
|
mp_dispose_group_marker
|
|
end
|
|
|
|
def mp_dispose_group_marker
|
|
return unless @mp_group_sprite
|
|
begin
|
|
@mp_group_sprite.dispose
|
|
rescue
|
|
end
|
|
@mp_group_sprite = nil
|
|
end
|
|
|
|
unless method_defined?(:mp_group_overlay_dispose)
|
|
alias mp_group_overlay_dispose dispose
|
|
end
|
|
|
|
def dispose
|
|
mp_dispose_group_marker
|
|
mp_group_overlay_dispose
|
|
end
|
|
end
|
|
|
|
class Scene_Map < Scene_Base
|
|
unless method_defined?(:mp_group_hud_layer_start)
|
|
alias mp_group_hud_layer_start start
|
|
end
|
|
|
|
def start(*args, &block)
|
|
mp_group_hud_layer_start(*args, &block)
|
|
MPGroupHUD.ensure_hud if defined?(MPGroupHUD)
|
|
end
|
|
|
|
unless method_defined?(:mp_group_hud_layer_update)
|
|
alias mp_group_hud_layer_update update
|
|
end
|
|
|
|
def update(*args, &block)
|
|
mp_group_hud_layer_update(*args, &block)
|
|
MPGroupHUD.update if defined?(MPGroupHUD)
|
|
end
|
|
|
|
unless method_defined?(:mp_group_hud_layer_terminate)
|
|
alias mp_group_hud_layer_terminate terminate
|
|
end
|
|
|
|
def terminate(*args, &block)
|
|
MPGroupHUD.dispose if defined?(MPGroupHUD)
|
|
mp_group_hud_layer_terminate(*args, &block)
|
|
end
|
|
end
|