259 lines
7.3 KiB
Ruby
259 lines
7.3 KiB
Ruby
module WebSocket
|
|
# WORLD: Drops
|
|
#--------------------------------------------------------------------------
|
|
def self.net_drop_event_id(drop_id)
|
|
DROP_EVENT_ID_BASE + drop_id
|
|
end
|
|
|
|
def self.find_drop_on_tile(x, y)
|
|
@map_drops.each do |drop_id, ev|
|
|
next unless ev
|
|
return drop_id if ev.x == x && ev.y == y
|
|
end
|
|
nil
|
|
end
|
|
|
|
def self.net_drop_item_object(item_type, item_id)
|
|
iid = item_id.to_i
|
|
return nil if iid <= 0
|
|
|
|
case item_type.to_s
|
|
when "item"
|
|
($data_items && $data_items[iid]) rescue nil
|
|
when "weapon"
|
|
($data_weapons && $data_weapons[iid]) rescue nil
|
|
when "armor"
|
|
($data_armors && $data_armors[iid]) rescue nil
|
|
else
|
|
nil
|
|
end
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.net_drop_event_template(item_type, item_id)
|
|
item = net_drop_item_object(item_type, item_id)
|
|
return nil unless item && item.respond_to?(:item_name)
|
|
|
|
item_name = item.item_name.to_s
|
|
return nil if item_name.empty?
|
|
|
|
lib = nil
|
|
begin
|
|
lib = $game_map.event_lib if $game_map && $game_map.respond_to?(:event_lib)
|
|
rescue
|
|
lib = nil
|
|
end
|
|
begin
|
|
lib = $data_EventLib if lib.nil? && defined?($data_EventLib)
|
|
rescue
|
|
lib = nil
|
|
end
|
|
return nil unless lib
|
|
|
|
entry = lib[item_name] rescue nil
|
|
return nil unless entry.is_a?(Array)
|
|
entry[1]
|
|
rescue
|
|
nil
|
|
end
|
|
|
|
def self.apply_net_drop_template_graphic(page, item_type, item_id)
|
|
template = net_drop_event_template(item_type, item_id)
|
|
return false unless template && template.respond_to?(:pages) && template.pages
|
|
|
|
src_page = nil
|
|
template.pages.each do |candidate|
|
|
next unless candidate && candidate.graphic
|
|
graphic = candidate.graphic
|
|
if graphic.tile_id.to_i > 0 || graphic.character_name.to_s != ""
|
|
src_page = candidate
|
|
break
|
|
end
|
|
end
|
|
src_page ||= template.pages[0]
|
|
return false unless src_page && src_page.graphic
|
|
|
|
graphic = src_page.graphic
|
|
page.graphic.tile_id = graphic.tile_id rescue nil
|
|
page.graphic.character_name = graphic.character_name.to_s rescue ""
|
|
page.graphic.character_index = graphic.character_index.to_i rescue 0
|
|
page.graphic.direction = graphic.direction.to_i rescue 2
|
|
page.graphic.pattern = graphic.pattern.to_i rescue 0
|
|
true
|
|
rescue
|
|
false
|
|
end
|
|
|
|
def self.create_map_drop(drop_id, item_type, item_id, x, y, qty, dropped_by)
|
|
return if drop_id.nil? || @map_drops[drop_id]
|
|
return unless $game_map
|
|
|
|
event_id = net_drop_event_id(drop_id)
|
|
|
|
dummy = RPG::Event.new(0, 0)
|
|
dummy.id = event_id
|
|
dummy.name = "NetDrop_#{drop_id}"
|
|
|
|
page = RPG::Event::Page.new
|
|
page.trigger = 0
|
|
page.priority_type = 1
|
|
page.move_type = 0
|
|
page.walk_anime = false
|
|
page.step_anime = false
|
|
page.direction_fix = true
|
|
page.through = true
|
|
|
|
unless WebSocket.apply_net_drop_template_graphic(page, item_type, item_id)
|
|
gname = WebSocket.net_drop_graphic(item_type)
|
|
page.graphic.character_name = gname
|
|
page.graphic.character_index = 0
|
|
end
|
|
|
|
page.list = [RPG::EventCommand.new(0, 0, [])]
|
|
dummy.pages = [page]
|
|
|
|
ev = Game_Event.new($game_map.map_id, dummy)
|
|
ev.moveto(x, y)
|
|
ev.transparent = false
|
|
|
|
ev.instance_variable_set(:@net_drop_id, drop_id)
|
|
ev.instance_variable_set(:@net_item_type, item_type)
|
|
ev.instance_variable_set(:@net_item_id, item_id)
|
|
ev.instance_variable_set(:@net_qty, qty)
|
|
ev.instance_variable_set(:@net_dropped_by, dropped_by)
|
|
|
|
$game_map.events[event_id] = ev
|
|
@map_drops[drop_id] = ev
|
|
|
|
sc = respond_to?(:scene_with_map_spriteset) ? scene_with_map_spriteset : nil
|
|
if sc.nil? && SceneManager.scene_is?(Scene_Map)
|
|
sc = SceneManager.scene
|
|
end
|
|
sc.add_net_sprite(ev) if sc && sc.respond_to?(:add_net_sprite)
|
|
|
|
puts "[DROP] spawn #{drop_id} #{item_type}##{item_id} x=#{x} y=#{y} qty=#{qty}"
|
|
end
|
|
|
|
def self.remove_map_drop(drop_id)
|
|
drop_id = drop_id.to_i
|
|
clear_pickup_inflight(drop_id)
|
|
@map_drops ||= {}
|
|
ev = @map_drops[drop_id]
|
|
return unless $game_map
|
|
|
|
event_id = ev ? ev.id : net_drop_event_id(drop_id)
|
|
ev ||= ($game_map.events[event_id] rescue nil)
|
|
$game_map.events.delete(event_id) rescue nil
|
|
|
|
sc = respond_to?(:scene_with_map_spriteset) ? scene_with_map_spriteset : nil
|
|
if sc.nil? && SceneManager.scene_is?(Scene_Map) && SceneManager.scene.spriteset
|
|
sc = SceneManager.scene
|
|
end
|
|
if sc && sc.spriteset
|
|
sprites = sc.spriteset.instance_variable_get(:@character_sprites)
|
|
sprites.delete_if do |sprite|
|
|
ch = (sprite.character rescue nil)
|
|
if ch == ev || (ch && ch.respond_to?(:id) && ch.id == event_id)
|
|
sprite.dispose rescue nil
|
|
true
|
|
else
|
|
false
|
|
end
|
|
end
|
|
end
|
|
|
|
@map_drops.delete(drop_id)
|
|
$game_map.need_refresh = true rescue nil
|
|
puts "[DROP] removed #{drop_id}"
|
|
end
|
|
|
|
# --- pickup in-flight: антиспам pickup: по drop_id ---
|
|
def self.pickup_inflight?(drop_id)
|
|
drop_id = drop_id.to_i
|
|
return false if drop_id <= 0
|
|
@pickup_inflight ||= {}
|
|
!!@pickup_inflight[drop_id]
|
|
end
|
|
|
|
def self.mark_pickup_inflight(drop_id)
|
|
drop_id = drop_id.to_i
|
|
return if drop_id <= 0
|
|
@pickup_inflight ||= {}
|
|
@pickup_inflight[drop_id] = true
|
|
end
|
|
|
|
def self.clear_pickup_inflight(drop_id = nil)
|
|
@pickup_inflight ||= {}
|
|
if drop_id.nil?
|
|
@pickup_inflight.clear
|
|
else
|
|
@pickup_inflight.delete(drop_id.to_i)
|
|
end
|
|
end
|
|
|
|
# Запрос подбора: только debounce, без локального remove до ответа сервера
|
|
def self.request_map_drop_pickup(drop_id)
|
|
drop_id = drop_id.to_i
|
|
return false if drop_id <= 0
|
|
return false if pickup_inflight?(drop_id)
|
|
@map_drops ||= {}
|
|
return false unless @map_drops[drop_id]
|
|
mark_pickup_inflight(drop_id)
|
|
send_line("pickup:#{drop_id}")
|
|
true
|
|
rescue => e
|
|
clear_pickup_inflight(drop_id) rescue nil
|
|
puts "[DROP] request_map_drop_pickup error: #{e.class}: #{e}"
|
|
false
|
|
end
|
|
|
|
def self.play_net_pickup_animation
|
|
return unless $game_player
|
|
$game_player.animation = $game_player.animation_mc_pick_up
|
|
rescue => e
|
|
puts "[DROP] pickup anim error: #{e.class}: #{e}"
|
|
end
|
|
|
|
# Успешный подбор: сразу убрать дроп, выдать предмет, анимация как у vanilla
|
|
def self.apply_pickup_ok(drop_id, item_type, item_id, qty)
|
|
drop_id = drop_id.to_i
|
|
remove_map_drop(drop_id)
|
|
clear_pickup_inflight(drop_id)
|
|
gain_pickup_item(item_type, item_id, qty)
|
|
play_net_pickup_animation
|
|
end
|
|
|
|
# authoritative inventory grant (only from pickup_ok)
|
|
def self.gain_pickup_item(item_type, item_id, qty)
|
|
return unless $game_party
|
|
qty = qty.to_i
|
|
return if qty <= 0
|
|
|
|
begin
|
|
obj =
|
|
case item_type
|
|
when "item"
|
|
($data_items && item_id > 0) ? $data_items[item_id] : nil
|
|
when "weapon"
|
|
($data_weapons && item_id > 0) ? $data_weapons[item_id] : nil
|
|
when "armor"
|
|
($data_armors && item_id > 0) ? $data_armors[item_id] : nil
|
|
else
|
|
nil
|
|
end
|
|
|
|
if obj.nil?
|
|
puts "[INV] pickup_ok invalid data: type=#{item_type} id=#{item_id} qty=#{qty}"
|
|
return
|
|
end
|
|
|
|
$game_party.gain_item(obj, qty)
|
|
rescue => e
|
|
puts "[INV] pickup_ok error: #{e.class}: #{e}"
|
|
end
|
|
end
|
|
|
|
#--------------------------------------------------------------------------
|
|
end
|