# encoding: UTF-8 # Shared LonaCraft camp permissions. The server stores authenticated profile # IDs in the canonical camp record; clients display the matching names. module LonaCraft module CampAccess MAX_MEMBERS = 12 def self.normal_name(value) LonaCraft::OnlineSync.owner_name(value).downcase end def self.members(rec) return [] unless rec.is_a?(Hash) Array(rec['lc_access']).select { |entry| entry.is_a?(Hash) }. map { |entry| LonaCraft::OnlineSync.owner_name(entry['name']) }. reject { |name| name.empty? }. uniq { |name| name.downcase }.first(MAX_MEMBERS) end def self.entries(rec) return [] unless rec.is_a?(Hash) Array(rec['lc_access']).select do |entry| entry.is_a?(Hash) && entry['profile'].to_i > 0 && !entry['name'].to_s.empty? end.first(MAX_MEMBERS) end def self.owner?(rec) LonaCraft::OnlineSync.owns_camp?(rec) end def self.allowed?(rec) return true unless rec.is_a?(Hash) && rec['lc_shared'] return true if owner?(rec) return false unless LonaCraft::OnlineSync.ready? local = normal_name((::WebSocket.local_nickname rescue nil)) !local.empty? && members(rec).any? { |name| normal_name(name) == local } rescue false end def self.online_players return [] unless defined?(::WebSocket) && ::WebSocket.respond_to?(:nickname_for) players = ::WebSocket.instance_variable_get(:@players) return [] unless players.respond_to?(:each) names = [] players.each do |pid, _player| name = LonaCraft::OnlineSync.owner_name(::WebSocket.nickname_for(pid)) names << [pid.to_i, name] unless name.empty? || pid.to_i <= 0 end names.uniq { |pair| pair[0] }.sort_by { |pair| pair[1].downcase } rescue [] end def self.sender_allowed?(rec, sender) return true unless rec.is_a?(Hash) && rec['lc_shared'] return true if sender.to_i == 0 # server-originated canonical state return false if sender.to_i <= 0 nick = normal_name((::WebSocket.nickname_for(sender.to_i) rescue nil)) return false if nick.empty? nick == normal_name(rec['owner']) || members(rec).any? { |name| normal_name(name) == nick } rescue false end def self.refuse SndLib.sys_buzzer if defined?(SndLib) $game_map.popup(0, LonaCraft::Bases.text_key('Access/denied'), 0, 0) if $game_map false end def self.creation_block_reason(map) return nil unless map && !map.isOverMap && LonaCraft::OnlineSync.ready? entry = LonaCraft::Bases.entry return nil unless entry.is_a?(Hash) && entry['om'].is_a?(Array) && entry['om'].size == 3 coords = entry['om'].map(&:to_i) owner = normal_name((::WebSocket.local_nickname rescue nil)) LonaCraft::Bases.list.each do |base| next unless base.is_a?(Hash) && base['lc_shared'] && base['om'].is_a?(Array) return LonaCraft::Bases.text_key('Access/one_camp') if normal_name(base['owner']) == owner && !owner.empty? other = base['om'].map(&:to_i) if other[0] == coords[0] && (other[1] - coords[1]).abs <= 2 && (other[2] - coords[2]).abs <= 2 return LonaCraft::Bases.text_key('Access/near_camp') end end reason = LonaCraft::OnlineSync.camp_creation_reason(coords) return nil if reason == 'ok' LonaCraft::Bases.text_key('Access/' + (reason == 'already_owned' ? 'one_camp' : reason == 'too_close' ? 'near_camp' : 'checking')) rescue StandardError LonaCraft::Bases.text_key('Access/checking') end end end module LonaCraft module Bases class << self alias_method :lc_access_previous_can_build_here, :can_build_here? def can_build_here?(map = $game_map) rec = record_for_map(map) if map return text_key('Access/denied') if rec && !LonaCraft::CampAccess.allowed?(rec) reason = lc_access_previous_can_build_here(map) return reason unless reason.nil? LonaCraft::CampAccess.creation_block_reason(map) end alias_method :lc_access_previous_place_block_reason, :place_block_reason def place_block_reason(map, code) rec = record_for_map(map) if map return text_key('Access/denied') if rec && !LonaCraft::CampAccess.allowed?(rec) reason = LonaCraft::CampAccess.creation_block_reason(map) unless rec return reason if reason lc_access_previous_place_block_reason(map, code) end alias_method :lc_access_previous_place_piece, :place_piece def place_piece(map, code, x, y) rec = record_for_map(map) if map return nil if rec && !LonaCraft::CampAccess.allowed?(rec) lc_access_previous_place_piece(map, code, x, y) end alias_method :lc_access_previous_take_down, :take_down def take_down(map, x, y, part) rec = record_for_map(map) if map return nil if rec && !LonaCraft::CampAccess.allowed?(rec) lc_access_previous_take_down(map, x, y, part) end alias_method :lc_access_previous_repair_piece, :repair_piece def repair_piece(map, x, y, interp) rec = record_for_map(map) if map return LonaCraft::CampAccess.refuse if rec && !LonaCraft::CampAccess.allowed?(rec) lc_access_previous_repair_piece(map, x, y, interp) end alias_method :lc_access_previous_action_on_piece, :action_on_piece def action_on_piece(player) map = $game_map rec = record_for_map(map) if map && !map.isOverMap if rec && !LonaCraft::CampAccess.allowed?(rec) x, y = front_tile(player) pieces = pieces_of(rec) x, y = owner_tile(pieces, map, x, y) value = pieces[piece_key(x, y)] if wall?(value) || (floor?(value) && !door?(value)) LonaCraft::CampAccess.refuse return true end end lc_access_previous_action_on_piece(player) end alias_method :lc_access_previous_furniture_map_ok, :furniture_map_ok? def furniture_map_ok?(map) rec = record_for_map(map) if map return false if rec && !LonaCraft::CampAccess.allowed?(rec) lc_access_previous_furniture_map_ok(map) end end end end module LonaCraft module Furniture class << self alias_method :lc_access_previous_map_allowed, :map_allowed? def map_allowed?(map = $game_map) rec = LonaCraft::Bases.record_for_map(map) if map return false if rec && !LonaCraft::CampAccess.allowed?(rec) lc_access_previous_map_allowed(map) end alias_method :lc_access_previous_block_reason, :block_reason def block_reason(map = $game_map) rec = LonaCraft::Bases.record_for_map(map) if map return LonaCraft::Bases.text_key('Access/denied') if rec && !LonaCraft::CampAccess.allowed?(rec) reason = LonaCraft::CampAccess.creation_block_reason(map) unless rec return reason if reason lc_access_previous_block_reason(map) end alias_method :lc_access_previous_place, :place def place(map, item_name, x, y) rec = LonaCraft::Bases.record_for_map(map) if map return nil if rec && !LonaCraft::CampAccess.allowed?(rec) && !LonaCraft::OnlineSync.applying_remote_access? lc_access_previous_place(map, item_name, x, y) end alias_method :lc_access_previous_remove, :remove def remove(map, uid) rec = LonaCraft::Bases.record_for_map(map) if map return nil if rec && !LonaCraft::CampAccess.allowed?(rec) && !LonaCraft::OnlineSync.applying_remote_access? lc_access_previous_remove(map, uid) end end end end module LonaCraft module OnlineSync def self.camp_creation_reason(coords) return nil unless ready? && coords.is_a?(Array) && coords.size == 3 token = map_token time = now state = @lc_camp_check if !state || state['token'] != token || state['om'] != coords || (state['reason'].nil? && time - state['sent'].to_f > 3.0) @lc_camp_check = {'token'=>token, 'om'=>coords, 'sent'=>time, 'reason'=>nil} send_now({'v'=>1, 'm'=>token, 'o'=>'camp_check', 'd'=>{'om'=>coords}}) end @lc_camp_check['reason'] end def self.receive_camp_check(packet, sender) return false unless sender.to_i == 0 && @lc_camp_check info = packet['d'] return false unless info.is_a?(Hash) && packet['m'] == @lc_camp_check['token'] return false unless info['om'] == @lc_camp_check['om'] return false unless %w[ok already_owned too_close].include?(info['reason']) @lc_camp_check['reason'] = info['reason'] true end def self.receive_camp_reject(packet, sender) return false unless sender.to_i == 0 info = packet['d'] return false unless info.is_a?(Hash) && info['om'].is_a?(Array) return false unless %w[already_owned too_close].include?(info['reason']) key = camp_ack_key(info['om'], info['id']) return false unless @pending_new_camps[key] rec = LonaCraft::Bases.record_for_tile(*info['om']) return false unless rec && rec['id'].to_i == info['id'].to_i && owns_camp?(rec) unless defined?(LonaCraft::Debug) && LonaCraft::Debug.free? rec['pieces'].each_value do |value| names = [] names << (LonaCraft::Bases.stone?(value) ? LonaCraft::Bases::STONE_ITEM : LonaCraft::Bases::WALL_ITEM) if LonaCraft::Bases.wall?(value) names << LonaCraft::Bases::FLOOR_ITEM if LonaCraft::Bases.floor?(value) names << LonaCraft::Bases::DOOR_ITEM if LonaCraft::Bases.door?(value) names.each do |name| item = $data_ItemName[name] $game_party.gain_item(item, 1) if item end end if rec['pieces'].is_a?(Hash) end @pending_new_camps.delete(key) @pending_camp_meta.delete(key) @saved_camps.delete(key) @outbox.clear @observed = {} LonaCraft::Bases.destroy_records!([rec]) reason = info['reason'] == 'already_owned' ? 'one_camp' : 'near_camp' SndLib.sys_buzzer if defined?(SndLib) $game_map.popup(0, LonaCraft::Bases.text_key('Access/' + reason), 0, 0) if $game_map true end def self.applying_remote_access? @lc_access_remote_depth.to_i > 0 end def self.request_camp_access(rec, operation, target) return false unless ready? && LonaCraft::CampAccess.owner?(rec) return false unless %w[access_add access_remove].include?(operation) return false unless rec.is_a?(Hash) && rec['om'].is_a?(Array) data = {'id'=>rec['id'].to_i, 'om'=>rec['om'].map(&:to_i)} data[operation == 'access_add' ? 'target_session' : 'target_profile'] = target.to_i send_now({'v'=>1, 'm'=>map_token, 'o'=>operation, 'd'=>data}) end def self.request_online_players(rec) return false unless ready? && LonaCraft::CampAccess.owner?(rec) return false unless rec.is_a?(Hash) && rec['om'].is_a?(Array) @lc_online_request = [map_token, rec['id'].to_i] @lc_online_total = nil @lc_online_parts = {} send_now({'v'=>1, 'm'=>map_token, 'o'=>'access_online', 'd'=>{'id'=>rec['id'].to_i, 'om'=>rec['om'].map(&:to_i)}}) end def self.receive_online_players(packet, sender) return false unless sender.to_i == 0 && @lc_online_request return false unless packet['m'] == @lc_online_request[0] info = packet['d'] return false unless info.is_a?(Hash) && info['id'] == @lc_online_request[1] part, total = info['part'], info['total'] return false unless part.is_a?(Integer) && total.is_a?(Integer) && total > 0 && total <= 100 return false unless part >= 0 && part < total && info['players'].is_a?(Array) && info['players'].size <= 12 return false if @lc_online_total && @lc_online_total != total @lc_online_total = total @lc_online_parts[part] = info['players'].map do |player| next unless player.is_a?(Hash) && player['session'].is_a?(Integer) && player['session'] > 0 name = LonaCraft::OnlineSync.owner_name(player['name']) [player['session'], name] unless name.empty? end.compact true end def self.online_players_ready? @lc_online_request && @lc_online_request[0] == map_token && @lc_online_total && @lc_online_parts && @lc_online_parts.size == @lc_online_total end def self.server_online_players return [] unless online_players_ready? (0...@lc_online_total).flat_map { |part| @lc_online_parts[part] || [] }. uniq { |pair| pair[0] }.sort_by { |pair| pair[1].downcase } end class << self alias_method :lc_access_previous_receive, :receive def receive(sender, phase, payload) return lc_access_previous_receive(sender, phase, payload) unless phase == 'msg' && ready? packet = decode(payload) return lc_access_previous_receive(sender, phase, payload) unless packet.is_a?(Hash) return receive_camp_check(packet, sender) if packet['o'] == 'camp_check' return receive_camp_reject(packet, sender) if packet['o'] == 'base_reject' if packet['o'] == 'access_online' return receive_online_players(packet, sender) end if %w[base base_new].include?(packet['o']) return false unless sender.to_i == 0 end if %w[put del].include?(packet['o']) && packet['m'] == map_token rec = LonaCraft::Bases.record_for_map($game_map) return false if rec && !LonaCraft::CampAccess.sender_allowed?(rec, sender) @lc_access_remote_depth = @lc_access_remote_depth.to_i + 1 begin return lc_access_previous_receive(sender, phase, payload) ensure @lc_access_remote_depth -= 1 end end lc_access_previous_receive(sender, phase, payload) end end end end class Game_Interpreter if method_defined?(:lonacraft_furniture_pickup) alias_method :lc_access_previous_furniture_pickup, :lonacraft_furniture_pickup def lonacraft_furniture_pickup(rec, kind) camp = LonaCraft::Bases.record_for_map($game_map) if $game_map return LonaCraft::CampAccess.refuse if camp && !LonaCraft::CampAccess.allowed?(camp) lc_access_previous_furniture_pickup(rec, kind) end end def lonacraft_base_access_choice(prompt, labels) text = "#{prompt}\\optB[#{labels.join(',')},]" key = LonaCraft::RuntimeText.key('Bases', 'rt_access_choice', text) call_msg(key) choice = $game_temp.choice $game_temp.choice = -1 choice end def lonacraft_base_access_menu(rec) return unless LonaCraft::CampAccess.owner?(rec) loop do choice = lonacraft_base_access_choice('Доступ к лагерю', ['Добавить игрока', 'Удалить игрока', 'Назад']) case choice when 0 if LonaCraft::CampAccess.entries(rec).size >= LonaCraft::CampAccess::MAX_MEMBERS call_msg(LonaCraft::RuntimeText.key('Bases', 'rt_access_full', 'Список доступа заполнен.')) next end unless LonaCraft::OnlineSync.request_online_players(rec) call_msg(LonaCraft::RuntimeText.key('Bases', 'rt_access_unavailable', 'Не удалось запросить список игроков.')) next end 180.times do break if LonaCraft::OnlineSync.online_players_ready? wait(1) end unless LonaCraft::OnlineSync.online_players_ready? call_msg(LonaCraft::RuntimeText.key('Bases', 'rt_access_unavailable', 'Сервер не ответил. Доступ пока нельзя изменить.')) next end online = LonaCraft::OnlineSync.server_online_players current = LonaCraft::CampAccess.members(rec) owner = LonaCraft::CampAccess.normal_name(rec['owner']) available = online.reject do |pair| normalized = LonaCraft::CampAccess.normal_name(pair[1]) normalized == owner || current.any? { |member| LonaCraft::CampAccess.normal_name(member) == normalized } end if available.empty? key = LonaCraft::RuntimeText.key('Bases', 'rt_access_empty', 'Нет игроков онлайн для добавления.') call_msg(key) next end lonacraft_base_access_pick_online(rec, available) when 1 entries = LonaCraft::CampAccess.entries(rec) if entries.empty? key = LonaCraft::RuntimeText.key('Bases', 'rt_access_empty', 'Список доступа пуст.') call_msg(key) next end pick = lonacraft_base_access_choice('Удалить игрока', entries.map { |entry| entry['name'] } + ['Назад']) if pick && pick >= 0 && pick < entries.size LonaCraft::OnlineSync.request_camp_access(rec, 'access_remove', entries[pick]['profile']) end else break end end end def lonacraft_base_access_pick_online(rec, available) page = 0 pages = (available.size + 9) / 10 loop do current = available[page * 10, 10] || [] labels = current.map { |pair| pair[1] } labels << 'Далее' if page + 1 < pages labels << 'Назад к списку' if page > 0 labels << 'Закрыть' pick = lonacraft_base_access_choice("Добавить игрока (#{page + 1}/#{pages})", labels) break unless pick && pick >= 0 if pick < current.size LonaCraft::OnlineSync.request_camp_access(rec, 'access_add', current[pick][0]) break end offset = current.size if page + 1 < pages if pick == offset page += 1 next end offset += 1 end if page > 0 && pick == offset page -= 1 next end break end end end