# encoding: UTF-8 # ClanEstate client 1.4.4 FIXED — passport service is a top-level guild-worker action. module MPClanEstate VERSION = '1.4.4-guild-passport-menu' CLAN_CHEST_BOX_ID = 65_532 ERRORS = { 'access_denied'=>'Нет доступа к этому клановому дому.', 'not_in_estate'=>'Вы не относитесь к этому клановому дому.', 'clan_frozen'=>'Клан заморожен до оплаты штрафа.', 'creator_only'=>'Менять интерьер может только создатель клана или администрация.', 'slaves_only'=>'Грядками могут пользоваться только рабы клана.', 'not_your_crop'=>'Эту грядку обрабатывает другой раб.', 'not_ready'=>'Урожай ещё не созрел.', 'stock_empty'=>'В клановом сундуке не хватает предметов.', 'withdrawal_forbidden'=>'Этот предмет или количество вам сейчас недоступны.', 'not_enough_items'=>'У вас не хватает предметов.', 'child_forbidden'=>'Ребёнка нельзя поместить в клановый сундук.', 'apply_pending_inventory'=>'Сначала дождитесь подтверждения предыдущей выдачи.', 'visit_banker'=>'Для этого нужно находиться у банкира.', 'visit_guild_employee'=>'Передать раба клану можно только у работника гильдии.', 'not_your_slave'=>'Можно передать клану только собственного раба.', 'passport_pending'=>'Паспорт раба ещё не подтверждён сервером.', 'slave_already_assigned'=>'Этот раб уже закреплён за кланом.', 'passport_not_with_owner'=>'Паспорт раба сейчас не находится у владельца.', 'passport_mismatch'=>'Данные паспорта не совпали. Обновите состояние и повторите.', 'already_have_passport'=>'У вас уже есть оригинальный паспорт.', 'passport_requested'=>'Заявление уже подано. Дождитесь срока выдачи.', 'passport_not_ready'=>'Срок выдачи паспорта ещё не наступил.', 'passport_in_custody'=>'Паспорт находится у владельца раба. Его вернут после освобождения.', 'slave_documents_forbidden'=>'Я не могу восстановить ваши документы, пока вы находитесь в рабстве у игрока или клана. Сначала получите освобождение.', 'reputation_is_average'=>'Репутация клана рассчитывается автоматически по участникам.', 'clock_not_ready'=>'Серверное игровое время ещё не готово.', 'stale_request'=>'Запрос устарел. Состояние будет обновлено.', 'revision_changed'=>'Состояние изменилось. Дождитесь синхронизации.', 'estate_busy'=>'Клановый дом временно занят обработкой запроса. Повторите через несколько секунд.' } @queue = [] @state = {} class << self attr_reader :state attr_accessor :home_kind attr_accessor :return_point def install return true if @installed return false unless defined?(NoerHomeGarden) && WebSocket.respond_to?(:noerhome_estate_parse_without_private_home) WebSocket.singleton_class.prepend(PreserveInventory) WebSocket.singleton_class.prepend(Network) # Multiplayer's generic portal synchronizer assumes numeric map ids. # NoerHome uses string/path tag-map ids, which the portal layer coerces # to 0 and then blocks/rewrites the transfer. Bypass that layer for any # NoerHome/NoerHomeOut destination (private house OR clan estate). # ClanEstate still publishes the virtual room with map: after # the local tag map has finished loading when a clan house is active. WebSocket.singleton_class.prepend(PortalBypass) if WebSocket.respond_to?(:portal_on_reserve_transfer) Game_Actor.prepend(LevelRewards) Game_Party.prepend(PassportLock) Game_Interpreter.prepend(Menus) Game_Interpreter.prepend(MapTravel) Game_Player.prepend(ReturnPoint) Game_Player.prepend(LocalNpcInteractionPriority) Scene_ItemStorage.prepend(StorageLock) Scene_TradeStorage.prepend(StorageLock) Window_ChoiceList.prepend(ChestChoiceCancelPriority) if defined?(Window_ChoiceList) Scene_Map.prepend(PursuitView) MPSlavePatrolReturn.singleton_class.prepend(Patrol) MPClanGuild.singleton_class.prepend(GuildMenu) NoerHomeEstate.singleton_class.prepend(EstateHome) NoerHomeGarden.singleton_class.prepend(Garden) NoerHomeDecor.singleton_class.prepend(SharedAmenities) if defined?(NoerHomeDecor) NoerHomeDecorEditor.singleton_class.prepend(EditorPermission) if defined?(NoerHomeDecorEditor) @installed=true end # Ruby modules survive Scene_Title -> New Game inside the same process. # The game objects do not. Reset only ClanEstate's transient network state # when a fresh Game_Party/Game_Player pair appears, otherwise a request/state # from the previous session can block the first estate action of the new game. def ensure_game_session return false unless defined?($game_party) && $game_party && defined?($game_player) && $game_player key=[$game_party.object_id,$game_player.object_id] return false if @game_session_key==key @game_session_key=key @hello_at=nil @request=nil @request_op=nil @request_context=nil @request_started_at=nil @sent_at=nil @sequence=0 @document_check_result=nil @state={} @home_kind=nil @return_point=nil @applied_revision=nil @deferred_state=nil @worker_dialogue_queue=[] @worker_dialogue_fiber=nil @menu_fiber=nil @queue.clear true rescue => e puts "[ClanEstate session reset] #{e.class}: #{e.message}" false end def active?; @home_kind && @state['clan'].to_i > 0; end def virtual_map_id(kind=@home_kind) clan=@state['clan'].to_i return 0 if clan<=0 1_000_000_000 + clan*2 + (kind.to_s=='yard' ? 1 : 0) rescue 0 end # Keep a tiny routing marker separate from the volatile estate payload. # The normal disconnect path clears @state/@home_kind before Save14 can make # its final cloud commit. Without this marker map_packet_for_server falls # back to the local NoerHome map id, which is the PRIVATE-home room. The # server then stores that id in player_live_state and the next login appears # in the private house even though the slave logged out from the clan estate. # # @resume_clan/@resume_kind survive only as routing metadata. They are also # copied into the cloud stats snapshot, so even a hard reconnect can restore # the clan room before the first estate state refresh arrives. def remember_estate_route(kind=@home_kind, clan=nil) k=kind.to_s return false unless k=='house' || k=='yard' cid=(clan || (@state && @state['clan'])).to_i return false if cid<=0 @resume_clan=cid @resume_kind=k true rescue false end def clear_estate_route @resume_clan=nil @resume_kind=nil true end def resume_clan_id @resume_clan.to_i rescue 0 end def resume_kind k=@resume_kind.to_s (k=='house' || k=='yard') ? k : '' rescue '' end def resume_virtual_map_id(kind=nil) cid=resume_clan_id k=(kind || resume_kind).to_s return 0 if cid<=0 || (k!='house' && k!='yard') 1_000_000_000 + cid*2 + (k=='yard' ? 1 : 0) rescue 0 end def local_estate_kind(map_id=nil) return '' unless defined?(NoerHomeEstate) id=map_id.nil? ? (($game_map.map_id rescue 0).to_i) : map_id.to_i NoerHomeEstate.home_kind_for_local(id).to_s rescue '' end def worker_context?; @worker_context_depth.to_i > 0; end def with_worker_context @worker_context_depth = @worker_context_depth.to_i + 1 yield ensure @worker_context_depth = [@worker_context_depth.to_i - 1, 0].max end def queue_worker_dialogue(text) @worker_dialogue_queue ||= [] @worker_dialogue_queue << text.to_s end def update_worker_dialogue if @worker_dialogue_fiber && @worker_dialogue_fiber.alive? @worker_dialogue_fiber.resume return end @worker_dialogue_fiber=nil text=(@worker_dialogue_queue ||= []).shift return if text.to_s.empty? @worker_dialogue_fiber=Fiber.new do interpreter=Game_Interpreter.new begin interpreter.send(:call_msg,"\\CBmp[GuildEmpolyee,20]\\c[4]Работник:\\C[0] #{text}") ensure restore_worker_view(interpreter) end end @worker_dialogue_fiber.resume rescue FiberError @worker_dialogue_fiber=nil rescue => e @worker_dialogue_fiber=nil puts "[ClanEstate worker dialogue] #{e.class}: #{e.message}" end def restore_worker_view(interpreter=nil) target=interpreter target=$game_map.interpreter if !target && defined?($game_map) && $game_map && $game_map.respond_to?(:interpreter) target.send(:cam_center,0) if target && target.respond_to?(:cam_center,true) target.send(:portrait_hide) if target && target.respond_to?(:portrait_hide,true) $game_temp.choice=-1 if defined?($game_temp) && $game_temp true rescue => e puts "[ClanEstate worker cleanup] #{e.class}: #{e.message}" false end # Guild mission persistence is owned by 14_autosave. Do not perform a # second immediate sync_state here: the employee script is already wrapped # in one atomic quest transaction and will commit the final story/inventory # state once, after all dialogue/reward mutations are complete. def save_guild_progress if defined?(MP_Save14) && MP_Save14.respond_to?(:quest_commit) return MP_Save14.quest_commit('guild_worker') end if defined?(MPCloudOnlySave) && MPCloudOnlySave.respond_to?(:request) MPCloudOnlySave.request('guild_worker_progress', 0) return true end false rescue => e puts "[ClanEstate guild save] #{e.class}: #{e.message}" false end def capture_home_return_point if defined?($game_map) && $game_map && $game_map.respond_to?(:isOverMap) && $game_map.isOverMap map_id=$game_map.map_id.to_i x=$game_player.x.to_i y=$game_player.y.to_i direction=$game_player.direction.to_i # The in-memory return point is lost on reconnect. The door then uses # LastOverMap, which still points at the previous location. if defined?(WebSocket) && WebSocket.respond_to?(:capture_overmap_location) WebSocket.capture_overmap_location(map_id, x, y, "clan_house_door") elsif defined?($story_stats) && $story_stats $story_stats["OverMapID"]=map_id $story_stats["LastOverMapX"]=x $story_stats["LastOverMapY"]=y end return [map_id,x,y,direction] end if defined?($story_stats) && $story_stats map_id=$story_stats['OverMapID'].to_i x=$story_stats['LastOverMapX'].to_i y=$story_stats['LastOverMapY'].to_i direction=(defined?($game_player) && $game_player ? $game_player.direction.to_i : 2) return [map_id,x,y,direction] if map_id>0 end if defined?($game_map) && $game_map && defined?($game_player) && $game_player return [$game_map.map_id.to_i,$game_player.x.to_i,$game_player.y.to_i,$game_player.direction.to_i] end nil rescue nil end def chest_choice_active?; @chest_choice_depth.to_i > 0; end def with_chest_choices @chest_choice_depth = @chest_choice_depth.to_i + 1 yield ensure @chest_choice_depth = [@chest_choice_depth.to_i - 1, 0].max end def slave?; @state['slave'].is_a?(Hash); end def clan_slave? slave? || @state['clan_slave'] == true rescue slave? end # Interaction permissions must not depend on the full estate payload being # committed to the local inventory yet. During fresh-game bootstrap the # server can already authoritatively mark the player as a clan slave while # BankGuard still delays inventory application. def garden_slave_access? return true if clan_slave? begin return true if defined?($story_stats) && $story_stats && $story_stats['MPClanEstateSlave'].to_i > 0 rescue end false rescue false end def player_slave_for_documents? begin return true if defined?($story_stats) && $story_stats && $story_stats['MPClanEstateSlave'].to_i > 0 rescue end return true if clan_slave? begin return true if defined?($game_player) && $game_player && $game_player.respond_to?(:player_slave?) && $game_player.player_slave? rescue end begin if defined?(MPSlavePatrolReturn) && MPSlavePatrolReturn.respond_to?(:active_local_contract?) return true if MPSlavePatrolReturn.active_local_contract? end rescue end begin if defined?($story_stats) && $story_stats owner=$story_stats['SlaveOwner'].to_s contract_id=$story_stats['MPPlayerSlaveContract'].to_i return true if contract_id>0 && owner.index('MP:')==0 end rescue end begin return true if defined?(WebSocket) && WebSocket.respond_to?(:mp_player_owned?) && WebSocket.mp_player_owned? rescue end begin if defined?(WebSocket) && WebSocket.respond_to?(:slave_active_contract) contract=WebSocket.slave_active_contract('slave') return true if contract && contract[:status].to_s=='ACTIVE' end rescue end false rescue clan_slave? end def authoritative_document_slave_status(timeout_frames=180) return true if player_slave_for_documents? return nil unless defined?(WebSocket) && WebSocket.connected? @document_check_result = :waiting WebSocket.send_line('ce_doc_check') timeout_frames.to_i.times do result=@document_check_result if result != :waiting @document_check_result=nil return nil if result==:unknown return !!result end Fiber.yield end @document_check_result=nil nil rescue => e @document_check_result=nil puts "[ClanEstate document check] #{e.class}: #{e.message}" nil end def incite_map_npcs_against_player return 0 unless defined?($game_map) && $game_map && defined?($game_player) && $game_player events=[] begin raw=$game_map.events events.concat(raw.respond_to?(:values) ? raw.values : Array(raw)) if raw rescue end begin raw=$game_map.npcs events.concat(raw.respond_to?(:values) ? raw.values : Array(raw)) if raw rescue end events=events.compact.uniq.reject do |event| begin event.equal?($game_player) || !!event.instance_variable_get(:@net_player_id) rescue false end end begin if defined?(MPSlaveEscapeAction) && MPSlaveEscapeAction.respond_to?(:force_witness_attack) return MPSlaveEscapeAction.force_witness_attack(events,$game_player).to_i end rescue end target=($game_player.actor rescue nil) skill=(defined?($data_arpgskills) && $data_arpgskills ? $data_arpgskills['BasicNormal'] : nil) rescue nil return 0 unless target && skill count=0 events.each do |event| begin next if event.respond_to?(:erased) && event.erased next if event.respond_to?(:deleted?) && event.deleted? next if event.respond_to?(:opacity) && event.opacity.to_i<255 rescue end actor=(event.actor rescue nil) next unless actor && actor.respond_to?(:set_aggro) next if (actor.action_state rescue nil)==:death next if actor.respond_to?(:is_object) && actor.is_object begin actor.set_aggro(target,skill,1800) event.turn_toward_character($game_player) if event.respond_to?(:turn_toward_character) count+=1 rescue end end count rescue 0 end def editable?; active? && @state['can_edit'] && !@state['frozen']; end def enqueue(text); @queue << text; end def bank_ready? !defined?(MPBankGuard) || MPBankGuard.ready? rescue true end def merge_routing_state(value) return unless value.is_a?(Hash) @state ||= {} # These fields are interaction/visual metadata only. They are safe to # consume immediately, even while generic cloud bootstrap or BankGuard # intentionally delays the inventory delta contained in the same ce_state. # Without this, 1.2.5 could enter the estate early but show an empty # "Взять разрешённое" list and an unusable garden until a later sync. %w[profile clan clan_name creator clan_slave slave house_map yard_map can_edit frozen fine fine_due reputation decor plots chest locked clock last_request passport_due owned_slaves pursuit].each do |key| @state[key]=value[key] if value.key?(key) end true rescue false end def defer_state(value) return unless value.is_a?(Hash) merge_routing_state(value) current=@deferred_state if !current.is_a?(Hash) || value['revision'].to_i >= current['revision'].to_i @deferred_state=value end true end def flush_deferred_state return false unless bank_ready? value=@deferred_state return false unless value.is_a?(Hash) @deferred_state=nil apply_state(value) true rescue => e @deferred_state=value puts "[ClanEstate deferred state] #{e.class}: #{e.message}" false end def notify(text, context=nil) if context=='guild_worker' || worker_context? queue_worker_dialogue(text) else NoerHomeEstate.notify(text) end end def error_text(code) ERRORS[code.to_s] || code.to_s.tr('_',' ') end def pass_active?(value=@state) bond=value.is_a?(Hash) ? value['slave'] : nil bond.is_a?(Hash) && bond['passUntil'].to_i > value['clock'].to_i end def game_days(units) value=[units.to_i,0].max (value + 1) / 2 end def slave_status_text bond=@state['slave'] return 'Вы не закреплены за кланом как раб.' unless bond.is_a?(Hash) clock=@state['clock'].to_i if bond['passUntil'].to_i > clock pass="пропуск активен, осталось #{game_days(bond['passUntil'].to_i-clock)} дн." else pass="следующий пропуск через #{game_days(bond['nextPass'].to_i-clock)} дн." end "План урожая: #{bond['cropValue'].to_i}/4000. Прошлый период: #{bond['previousCropValue'].to_i}/4000. #{pass} Неоплаченных зарплат: #{bond['unpaidWages'].to_i}. Штраф за побеги: #{bond['escapeDebt'].to_i} зарплат." end def notify_pass_start(previous,value) return unless value.is_a?(Hash) && value['slave'].is_a?(Hash) return unless previous.is_a?(Hash) && previous['profile'].to_i==value['profile'].to_i && previous['slave'].is_a?(Hash) if !pass_active?(previous) && pass_active?(value) notify("Выдан пропуск на свободное перемещение на #{game_days(value['slave']['passUntil'].to_i-value['clock'].to_i)} игровых суток.") end end def send_action(op, data = {}) # Interaction can happen on the first playable frames of a brand-new game, # before the regular ClanEstate tick has observed the new game objects. ensure_game_session frame=Graphics.frame_count if @request age=frame-@request_started_at.to_i if age < 600 notify('Дождитесь ответа сервера.') return false end # Never let one lost estate reply block every later action forever. @request=nil;@request_op=nil;@request_context=nil;@request_started_at=nil end bootstrap_enter=(op.to_s=='enter' && !@state['profile']) unless @state['profile'] || bootstrap_enter notify('Данные клана ещё загружаются.') return false end # Enter must never be blocked just because ce_state/BankGuard is still # bootstrapping. Seed the request id from wall-clock milliseconds when no # authoritative last_request is available, so the server still sees a # strictly newer id after reconnect. seed = bootstrap_enter ? (Time.now.to_f*1000).to_i : 0 @sequence = [@sequence.to_i, @state['last_request'].to_i, seed].max + 1 # Do not inject a generic sync_state immediately before ce_action. The # server may reject that sync_state with revision_changed while the estate # action is already in flight; older clients then mistook the unrelated # ce_error for the action response and cleared @request. Save14 already # owns normal cloud persistence, while ce_result performs the inventory ACK # after authoritative estate mutations. flush_deferred_state if bank_ready? && @deferred_state payload = WebSocket._live_sync_blob_from_object(data.merge('op' => op), nil, 'clan_estate') @request = "ce_action:#{@sequence}:#{payload}" @request_op = op.to_s @request_context = worker_context? ? 'guild_worker' : nil @sent_at = frame @request_started_at = frame WebSocket.send_line(@request) true end def request_pending?; !!@request; end def request_op; @request_op.to_s; end def resolve_item(name) return MPPlayerDocuments.from_name(name) if name.start_with?(MPPlayerDocuments::PREFIX) $data_ItemName[name] end def item_key(item) who = MPPlayerDocuments.owner(item) who ? MPPlayerDocuments.stable_name(who) : item.item_name end def child_item?(item) object = item.is_a?(String) ? resolve_item(item.to_s) : item return false if object.nil? # This is the game's own semantic definition used by the rebirth scan. object.type_tag.to_s == 'Child' || (object.type_tag.to_s == 'Key' && object.type.to_s == 'Baby') rescue false end # Apply only the inventory targets confirmed by a ClanEstate ce_result. # This is intentionally narrower than apply_state: chest transfer ACKs must be # visible immediately even if BankGuard is temporarily delaying unrelated estate # state. The targets are absolute quantities, so applying them again later via # apply_state is idempotent. def apply_confirmed_chest_inventory(value) return false unless value.is_a?(Hash) && value['inventory'].is_a?(Hash) changed=false value['inventory'].each do |name,quantity| item=resolve_item(name.to_s) next unless item target=quantity.to_i current=$game_party.item_number(item).to_i next if current==target @applying=true begin $game_party.gain_item(item,target-current) changed=true ensure @applying=false end end changed rescue => e puts "[ClanEstate chest inventory] #{e.class}: #{e.message}" false end def soup_item_name?(name) name.to_s.start_with?('ItemSop') end # Client-side mirror of the server's aggregate ration counters. It does not # grant access by itself; it only prevents stale storage UI from allowing a # second click after the daily category limit has already been consumed. def slave_withdraw_remaining(item_name) return nil unless clan_slave? bond=@state['slave'] return nil unless bond.is_a?(Hash) name=item_name.to_s if name=='ItemBread' return [2-bond['breadTaken'].to_i,0].max elsif soup_item_name?(name) prev=bond['previousCropValue'].to_i limit = prev < 4000 ? 0 : (prev > 4000 ? 2 : 1) return [limit-bond['soupTaken'].to_i,0].max end nil rescue nil end def setup_chest_box return false unless defined?(Storage_Boxes_Setting) && defined?($game_boxes) && $game_boxes title = clan_slave? ? 'Клановый сундук — доступно рабу' : 'Клановый сундук' Storage_Boxes_Setting::BOXES[CLAN_CHEST_BOX_ID] = { :name=>title, :size=>0, :open_sound=>nil, :close_sound=>nil } true rescue => e puts "[ClanEstate chest setup] #{e.class}: #{e.message}" false end def chest_fingerprint chest=@state['chest'] return '' unless chest.is_a?(Hash) chest.keys.sort.map{|k| "#{k}=#{chest[k].to_i}"}.join('|') + "|slave=#{clan_slave? ? 1 : 0}" rescue '' end def sync_chest_box(force=false) return false unless setup_chest_box fp=chest_fingerprint return false if !force && fp==@chest_box_fingerprint box={} (@state['chest']||{}).each do |name,count| next if count.to_i<=0 item=resolve_item(name.to_s) if item box[item]=box.fetch(item,0)+count.to_i else puts "[ClanEstate chest] unknown item #{name}" end end $game_boxes.write_box(CLAN_CHEST_BOX_ID,box) @chest_box_fingerprint=fp true rescue => e puts "[ClanEstate chest sync] #{e.class}: #{e.message}" false end def refresh_open_chest_ui sync_chest_box(true) if defined?(Scene_ClanEstateStorage) && SceneManager.scene_is?(Scene_ClanEstateStorage) scene=SceneManager.scene scene.ce_server_refresh if scene.respond_to?(:ce_server_refresh) return true end false rescue => e puts "[ClanEstate chest refresh] #{e.class}: #{e.message}" false end def launch_chest_scene setup_chest_box sync_chest_box(true) return true if refresh_open_chest_ui SceneManager.goto(Scene_ClanEstateStorage) SceneManager.scene.prepare(CLAN_CHEST_BOX_ID) if SceneManager.scene.respond_to?(:prepare) true end def open_chest_scene return notify('Сундук доступен только внутри кланового дома.') unless active? && @home_kind.to_s=='house' # 1.3.3: chest_open MUST be a real server action. # The server repairs/migrates the assigned slave's daily food/work allowance # immediately before it builds the authoritative filtered chest view. # ce_hello is intentionally NOT enough for this path. @open_chest_after_refresh=false ok=send_action('chest_open') puts "[ClanEstate chest] chest_open requested" if ok ok rescue => e @open_chest_after_refresh=false puts "[ClanEstate chest open] #{e.class}: #{e.message}" notify('Не удалось открыть клановый сундук.') false end def apply_state(value) return unless value.is_a?(Hash) && $game_party @sequence = [@sequence.to_i,value['last_request'].to_i].max revision = value['revision'].to_i current = $game_party.instance_variable_get(:@clan_estate_revision).to_i # Estate metadata (clan id, slave bond, map ids, permissions) must never be # discarded just because the locally persisted inventory revision is newer. # A stale inventory payload is skipped below, but the authoritative estate # routing/status still has to refresh after reconnect. stale_inventory = revision < current previous=@state @state = value begin if defined?($story_stats) && $story_stats && value.key?('clan_slave') was_clan_slave = (previous.is_a?(Hash) && (previous['clan_slave'] == true || previous['slave'].is_a?(Hash))) || $story_stats['MPClanEstateSlave'].to_i > 0 clan_slave_now = (value['clan_slave'] == true) $story_stats['MPClanEstateSlave'] = clan_slave_now ? 1 : 0 if clan_slave_now clan_id = value['clan'].to_i $story_stats['MPClanEstateClan'] = clan_id # The personal MP contract is intentionally closed after transfer to # the estate. The persisted clan bond is now the authority, so rebuild # gameplay slave markers whenever estate state is restored. $story_stats['Captured'] = 1 $story_stats['SlaveOwner'] = "CLAN:#{clan_id}" if clan_id > 0 $story_stats['MPPlayerSlaveOrigin'] = 'clan_estate' begin WebSocket.slave_apply_brand_only(false) if defined?(WebSocket) && WebSocket.respond_to?(:slave_apply_brand_only) rescue end elsif was_clan_slave $story_stats['MPClanEstateClan'] = 0 begin personal = defined?(WebSocket) && WebSocket.respond_to?(:slave_active_contract) ? WebSocket.slave_active_contract('slave') : nil personal_active = personal && personal[:status].to_s == 'ACTIVE' if !personal_active && $story_stats['SlaveOwner'].to_s.start_with?('CLAN:') $story_stats['SlaveOwner'] = 0 $story_stats['Captured'] = 0 $story_stats['OverMapForceTrans'] = 0 changed = WebSocket.slave_clear_local_marks_and_bondage if defined?(WebSocket) && WebSocket.respond_to?(:slave_clear_local_marks_and_bondage) WebSocket.slave_sync_inventory('clan_slave_release') if changed && WebSocket.respond_to?(:slave_sync_inventory) end rescue end end end rescue end notify_pass_start(previous,value) earned=$game_party.instance_variable_get(:@clan_estate_earned).to_i $game_party.instance_variable_set(:@clan_estate_earned,[earned,value['earned_floor'].to_i].max) if !stale_inventory && (value['force_inventory'] || revision != current || (value['inventory'].is_a?(Hash) && !value['inventory'].empty? && !@applied_revision)) items = value['inventory'] || {} items.each do |name, quantity| item = resolve_item(name) raise "Не найден предмет кланового склада: #{name}" unless item @applying = true begin $game_party.gain_item(item, quantity.to_i - $game_party.item_number(item)) ensure @applying = false end end actor = $game_player.actor reward_total = value['skill_total'].to_i applied = $game_party.instance_variable_get(:@clan_estate_skill_total).to_i applied=[applied,value['skill_baseline'].to_i].max if value.key?('skill_baseline') actor.trait_point += reward_total - applied if reward_total > applied $game_party.instance_variable_set(:@clan_estate_skill_total, [reward_total, applied].max) $game_party.instance_variable_set(:@clan_estate_revision, revision) @applied_revision = revision # Never send an inventory ACK while a ce_action request is pending. # A sync error has no ce_action request id, so interleaving it with an # estate action used to clear the wrong request and desynchronise access. if @request @inventory_ack_pending = true else WebSocket.live_sync_send_now('cloud_clan_estate_apply', true, false) @inventory_ack_pending = false end end NoerHomeEstate.bump_visual_revision if active? end def enter(value) state=value['state'] if state.is_a?(Hash) bank_ready? ? apply_state(state) : defer_state(state) end # ce_enter also carries the resolved clan explicitly. Merge it immediately # so map_packet_for_server can compute the virtual room even while the full # inventory state is intentionally deferred behind BankGuard. @state['clan']=value['clan'].to_i if value['clan'].to_i>0 reason=value['reason'] notify({'assigned'=>'Вы направлены в клановый дом.', 'pass_expired'=>'Пропуск закончился. Вас возвращают в клановый дом.', 'collectors'=>'Коллекторы поймали вас. Штраф: 10 зарплат.'}[reason]) if reason @home_kind = value['kind'] == 'yard' ? 'yard' : 'house' remember_estate_route(@home_kind, @state['clan']) # A clan house behaves like a normal tag-map house. Even when opened # through the guild worker inside the Hot Barrel, its door exits to the # last OverMap position instead of returning inside the tavern. @return_point=capture_home_return_point tag = @home_kind == 'yard' ? 'NoerHomeOut' : 'NoerHome' xy = @home_kind == 'yard' ? [27,29] : [34,33] $game_player.reserve_transfer(NoerHomeEstate.map_key(tag), xy[0], xy[1], 2) SceneManager.goto(Scene_Map) unless SceneManager.scene_is?(Scene_Map) end def tick update_worker_dialogue unless WebSocket.connected? # Preserve only the clan-room identity until Save14's final disconnect # snapshot/map preflight has run. The full estate state remains volatile. # This is what prevents a clan slave from being persisted as if the local # NoerHome map were their private house. begin kind=local_estate_kind remember_estate_route(kind, @state['clan']) unless kind.empty? rescue end @hello_at = nil; @request = nil; @request_op = nil; @request_context = nil; @request_started_at = nil; @document_check_result = nil; @state = {}; @home_kind = nil; @applied_revision = nil; @deferred_state=nil; @game_session_key=nil; @open_chest_after_refresh=false return end return unless $game_party && $game_player ensure_game_session frame = Graphics.frame_count # Do NOT gate the ClanEstate control queue behind bootstrap_sync_unlocked?. # A brand-new game can already be interactive while the generic cloud # bootstrap is still locked. In that window the server may answer ce_enter, # and leaving it queued forever is exactly what caused the first entry to # show "Дождитесь ответа сервера" until returning to the title screen. bootstrap_ready = begin !WebSocket.respond_to?(:bootstrap_sync_unlocked?) || WebSocket.bootstrap_sync_unlocked? rescue true end # ce_hello is lightweight and its estate routing reply is safe before the # generic bootstrap finishes. Inventory application remains deferred below. if !@hello_at || frame - @hello_at >= 300 WebSocket.send_line('ce_hello'); @hello_at = frame end ready=bank_ready? && bootstrap_ready while (message = @queue.shift) command, payload = message.split(':',2) decoded = WebSocket.bootstrap_decode_json_blob(payload) case command when 'ce_state' ready ? apply_state(decoded) : defer_state(decoded) if @open_chest_after_refresh @open_chest_after_refresh=false launch_chest_scene end when 'ce_doc_status' if decoded.is_a?(Hash) && decoded['unknown'] @document_check_result=:unknown elsif decoded.is_a?(Hash) @document_check_result=(decoded['slave']==true) begin if defined?($story_stats) && $story_stats && decoded.key?('clan_slave') $story_stats['MPClanEstateSlave']=decoded['clan_slave'] ? 1 : 0 end rescue end else @document_check_result=:unknown end when 'ce_result' context=@request_context completed_op=decoded['op'].to_s @sequence = [@sequence.to_i,decoded['request'].to_i].max @request = nil @request_op = nil @request_context = nil @request_started_at = nil state=decoded['state'] # Chest visibility is safe routing/UI metadata and must update immediately; # inventory deltas inside the same state still stay deferred behind BankGuard. if state.is_a?(Hash) if completed_op=='chest_open' # Keep inventory application behind BankGuard, but merge safe routing/UI # metadata (including the freshly repaired filtered chest) immediately. defer_state(state) puts "[ClanEstate chest] repaired view=#{(@state['chest']||{}).inspect}" launch_chest_scene elsif completed_op=='deposit' || completed_op=='withdraw' # Storage must react on the server ACK itself. Apply the exact confirmed # inventory targets immediately, then merge the authoritative filtered # chest and refresh both panes before any background/deferred state work. # This removes the old "закрыл сундук — только тогда применилось" effect. merge_routing_state(state) inventory_changed=apply_confirmed_chest_inventory(state) if ready apply_state(state) else defer_state(state) # Even while unrelated estate state is deferred, the server requires # this just-confirmed inventory target to be echoed before the next # deposit/withdraw. This is not a second mutation, only its ACK. if inventory_changed && defined?(WebSocket) && WebSocket.respond_to?(:live_sync_send_now) unlocked = !WebSocket.respond_to?(:bootstrap_sync_unlocked?) || WebSocket.bootstrap_sync_unlocked? if unlocked if @request @inventory_ack_pending = true else WebSocket.live_sync_send_now('cloud_clan_estate_apply', true, false) @inventory_ack_pending = false end end end end refresh_open_chest_ui else ready ? apply_state(state) : defer_state(state) end end # A slave's allowed chest view is dynamic. After a confirmed transfer, # ask the server for a fresh filtered view so food/seed deposited or # withdrawn in this same open session appears without closing the chest. if (completed_op=='deposit' || completed_op=='withdraw') && clan_slave? && !request_pending? send_action('chest_open') end notify('Заявление принято. Паспорт будет готов через 21 игровой день.',context) if completed_op=='passport_request' notify('Ваш оригинальный паспорт восстановлен и выдан вам.',context) if completed_op=='passport_collect' when 'ce_enter' @request = nil @request_op = nil @request_context = nil @request_started_at = nil enter(decoded) when 'ce_error' code=decoded['error'].to_s # revision_changed / inventory_not_applied / skills_not_applied are # emitted by ClanEstate's sync_state validator, not by ce_action. # They have no action request id. Never clear an in-flight estate # request because of one of these background sync responses. if %w[revision_changed inventory_not_applied skills_not_applied].include?(code) puts "[ClanEstate sync] #{code}; refreshing authoritative estate state" refresh_state @inventory_ack_pending = true if code!='revision_changed' else context=@request_context failed_op=@request_op.to_s @request = nil @request_op = nil @request_context = nil @request_started_at = nil @open_chest_after_refresh=false if failed_op=='chest_open' text=error_text(code) notify(context=='guild_worker' ? text : "Клан: #{text}",context) end end end flush_deferred_state if ready && @deferred_state if @inventory_ack_pending && !@request && ready && defined?(WebSocket) && WebSocket.respond_to?(:live_sync_send_now) begin WebSocket.live_sync_send_now('cloud_clan_estate_apply', true, false) @inventory_ack_pending=false rescue => e puts "[ClanEstate inventory ack] #{e.class}: #{e.message}" end end if @request && frame - @request_started_at.to_i >= 600 context=@request_context op=@request_op @request=nil;@request_op=nil;@request_context=nil;@request_started_at=nil refresh_state notify(op=='enter' ? 'Клановый дом не ответил вовремя. Запрос сброшен, попробуйте войти ещё раз.' : 'Сервер не ответил вовремя. Запрос сброшен, повторите действие.',context) elsif @request && frame - @sent_at >= 180 @sent_at = frame;WebSocket.send_line(@request) end rescue => e @request = nil @request_op = nil @request_context = nil @request_started_at = nil puts "[ClanEstate] #{e.class}: #{e.message}" end def local_clan_id direct=@state['clan'].to_i return direct if direct>0 if defined?(WebSocket) && WebSocket.respond_to?(:clan_info) info=WebSocket.clan_info if info.is_a?(Hash) value=(info[:id] || info['id']).to_i return value if value>0 end end 0 rescue 0 end def local_clan_name state_name=(@state && @state['clan_name']).to_s.strip return state_name unless state_name.empty? return '' unless defined?(WebSocket) && WebSocket.respond_to?(:clan_display_name) WebSocket.clan_display_name.to_s.strip rescue '' end def player_slave_owner_name if defined?(WebSocket) && WebSocket.respond_to?(:slave_active_contract) contract=WebSocket.slave_active_contract('slave') if contract.is_a?(Hash) %w[owner_nick ownerNick owner].each do |key| value=(contract[key] || contract[key.to_sym]).to_s.strip rescue '' return value unless value.empty? end end end if defined?($story_stats) && $story_stats value=$story_stats['MPPlayerSlaveOwnerNick'].to_s.strip return value unless value.empty? end '' rescue '' end def player_slave_label? return false if clan_slave? if defined?(WebSocket) return true if WebSocket.respond_to?(:mp_player_owned?) && WebSocket.mp_player_owned? if WebSocket.respond_to?(:slave_active_contract) contract=WebSocket.slave_active_contract('slave') return true if contract.is_a?(Hash) end end if defined?($story_stats) && $story_stats return true if $story_stats['SlaveOwner'].to_s.start_with?('MP:') return true if $story_stats['MPPlayerSlaveContract'].to_i > 0 end if defined?($game_player) && $game_player && $game_player.respond_to?(:player_slave?) return true if $game_player.player_slave? end false rescue false end def slave_role_label if clan_slave? clan_name=local_clan_name clan_id=local_clan_id.to_i return "Раб клана #{clan_name}" unless clan_name.empty? return clan_id>0 ? "Раб клана ##{clan_id}" : 'Раб клана' end if player_slave_label? owner_name=player_slave_owner_name return "Раб игрока #{owner_name}" unless owner_name.empty? return 'Раб игрока' end nil rescue 'Раб' end def refresh_state return false unless WebSocket.respond_to?(:connected?) && WebSocket.connected? WebSocket.send_line('ce_hello') @hello_at=Graphics.frame_count true rescue false end def request_menu return if @menu_fiber && @menu_fiber.alive? @menu_fiber = Fiber.new { Game_Interpreter.new.clan_estate_menu } end def update_menu return if @resuming_menu @resuming_menu = true begin @menu_fiber.resume if @menu_fiber && @menu_fiber.alive? ensure @resuming_menu = false end end end # Preserve physical restraints removed by legacy multiplayer slavery. Capture the # whole equipped quantity so duplicate items in different slots are not lost. def self.preserve_removed_equipment actor = $game_player.actor if defined?($game_player) && $game_player return yield unless actor && $game_party before = Hash.new(0) actor.equips.compact.each { |item| before[item] += 1 } inventory = before.keys.to_h { |item| [item, $game_party.item_number(item)] } result = yield after = Hash.new(0) actor.equips.compact.each { |item| after[item] += 1 } before.each do |item, count| removed = [count - after[item], 0].max missing = inventory[item] + removed - $game_party.item_number(item) $game_party.gain_item(item, missing) if removed > 0 && missing > 0 end result end module PreserveInventory def slave_apply_force_work(contract_id,owner_profile,owner_nick,origin,work_key,allow_transfer=true) if MPClanEstate.slave? result=super(contract_id,owner_profile,owner_nick,origin,work_key,false) $story_stats['OverMapForceTrans']=0 return result end super end def slave_apply_brand_only(sync_inventory = true) # The base slavery script periodically verifies the slave brand. The old # wrapper queued an inventory sync on EVERY verification, even when the # actor/equipment was unchanged. While enslaved that happens forever and # creates needless sync/serialization work. Sync only after a real change. result = MPClanEstate.preserve_removed_equipment { super(false) } slave_sync_inventory('clan_slave_brand_preserve') if sync_inventory && result result end def slave_clear_local_marks_and_bondage MPClanEstate.preserve_removed_equipment { super } end end module Network def parse(message) if message.to_s.start_with?('bootstrap_map:','bootstrap_state:') fields=message.split(':',-1) remote=fields[1].to_i if remote>=1_000_000_000 clan=(remote-1_000_000_000)/2 kind=(remote-1_000_000_000).odd? ? 'yard' : 'house' MPClanEstate.state.merge!('clan'=>clan,'house_map'=>1_000_000_000+clan*2,'yard_map'=>1_000_000_001+clan*2) MPClanEstate.home_kind=kind MPClanEstate.remember_estate_route(kind, clan) fields[1]=(kind=='yard' ? NoerHomeEstate.local_yard_id : NoerHomeEstate.local_house_id).to_s message=fields.join(':') elsif message.to_s.start_with?('bootstrap_map:') # A genuine non-estate bootstrap is authoritative: do not let a route # marker from a previous character/session hijack an ordinary map. MPClanEstate.home_kind=nil MPClanEstate.clear_estate_route end end if message.to_s.start_with?('ce_') MPClanEstate.enqueue(message.to_s.strip);return end super end def apply_bootstrap_state(value) result=super if result && value.is_a?(Hash) && !value['server_spawn_only'] stats=value['stats_json'].is_a?(Hash) ? value['stats_json'] : bootstrap_decode_json_blob(value['stats_blob']) if stats.is_a?(Hash) ['revision','earned','skill_total'].each do |key| $game_party.instance_variable_set("@clan_estate_#{key}",stats["clan_estate_#{key}"].to_i) end resume_clan=stats['clan_estate_resume_clan'].to_i resume_kind=stats['clan_estate_resume_kind'].to_s if resume_clan>0 && (resume_kind=='house' || resume_kind=='yard') MPClanEstate.state.merge!('clan'=>resume_clan,'house_map'=>1_000_000_000+resume_clan*2,'yard_map'=>1_000_000_001+resume_clan*2) MPClanEstate.home_kind=resume_kind MPClanEstate.remember_estate_route(resume_kind,resume_clan) # Repair old saves made before 1.4.3: they may bootstrap the physical # NoerHome map id (private-home namespace) even though the cloud stats # prove the player logged out inside a clan estate. Re-advertise the # correct virtual clan room immediately; no transfer is needed because # house/yard use the same local tag map. begin local_kind=MPClanEstate.local_estate_kind if !local_kind.empty? && local_kind==resume_kind virtual=MPClanEstate.resume_virtual_map_id(resume_kind) send_line("map:#{virtual}") if virtual>0 && respond_to?(:send_line) end rescue => e puts "[ClanEstate resume bootstrap] #{e.class}: #{e.message}" end end end end result end def _live_sync_collect_stats(actor) out=super out['clan_estate_revision']=$game_party.instance_variable_get(:@clan_estate_revision).to_i out['clan_estate_earned']=$game_party.instance_variable_get(:@clan_estate_earned).to_i out['clan_estate_skill_total']=$game_party.instance_variable_get(:@clan_estate_skill_total).to_i # Persist the virtual-room identity together with the player snapshot. # This survives process restarts and also repairs legacy snapshots that # accidentally stored the physical/private NoerHome map id. cid=MPClanEstate.resume_clan_id kind=MPClanEstate.resume_kind if cid>0 && !kind.empty? out['clan_estate_resume_clan']=cid out['clan_estate_resume_kind']=kind else out.delete('clan_estate_resume_clan') if out.respond_to?(:delete) out.delete('clan_estate_resume_kind') if out.respond_to?(:delete) end out end end module LevelRewards def level_up before=trait_point result=super earned=trait_point-before if earned>0 && $game_party total=$game_party.instance_variable_get(:@clan_estate_earned).to_i $game_party.instance_variable_set(:@clan_estate_earned,total+earned) end result end end module PassportLock def gain_item(item,amount=1,include_equip=false) if amount<0 && !MPClanEstate.instance_variable_get(:@applying) object=item.is_a?(String) ? $data_ItemName[item] : item if object minimum=(MPClanEstate.state['locked']||{})[MPClanEstate.item_key(object)].to_i if minimum>0 && item_number(object)+amount0 SndLib.sys_buzzer return false end super end end module Patrol def active_local_contract?; MPClanEstate.slave? ? false : super; end end module MapTravel def change_map_overmap_force_point_trans(*args) return if MPClanEstate.slave? super end end module ReturnPoint def reserve_transfer(map_id,x,y,d=2,*rest) if MPClanEstate.active? house=(NoerHomeEstate.local_house_id rescue -1).to_i yard=(NoerHomeEstate.local_yard_id rescue -1).to_i leaving=[house,yard].include?($game_map.map_id.to_i) # Tag-map transitions use string keys ("NoerHome"/"NoerHomeOut"), so # map_id.to_i becomes 0. Treat both local numeric ids and tag keys as # internal house<->yard travel; only a real external destination should # consume the captured OverMap return point. target_kind=(NoerHomeEstate.home_target_kind(map_id) rescue '').to_s point=MPClanEstate.return_point if leaving && target_kind.empty? && point.is_a?(Array) && point.length>=4 map_id,x,y,d=point[0].to_i,point[1].to_i,point[2].to_i,point[3].to_i MPClanEstate.home_kind=nil MPClanEstate.return_point=nil MPClanEstate.clear_estate_route end end super(map_id,x,y,d,*rest) end end # Remote players are represented as map events. When one stands on the # player's tile, the engine normally starts that event before checking the # local NPC in front. Temporarily make remote-player events non-triggering # whenever a real local action event is available at the interaction point. module LocalNpcInteractionPriority def check_action_event(chkItemsPick=false) return super unless clan_estate_local_action_available? remote_events=($game_map.events.values rescue []).select{|event|event.instance_variable_get(:@net_player_id)} saved=remote_events.map{|event|[event,event.instance_variable_get(:@trigger)]} remote_events.each{|event|event.instance_variable_set(:@trigger,-1)} super ensure saved.each{|event,trigger|event.instance_variable_set(:@trigger,trigger)} if defined?(saved) && saved end def clan_estate_local_action_available? return false unless $game_map x1=$game_map.round_x_with_direction(@x,@direction) y1=$game_map.round_y_with_direction(@y,@direction) here=($game_map.events_xy(@x,@y) rescue []) front=($game_map.events_xy(x1,y1) rescue []) return true if here.any?{|event|clan_estate_local_trigger?(event,[0],false)} return true if front.any?{|event|clan_estate_local_trigger?(event,[0,1,2],true)} if $game_map.counter?(x1,y1) x2=$game_map.round_x_with_direction(x1,@direction) y2=$game_map.round_y_with_direction(y1,@direction) beyond=($game_map.events_xy(x2,y2) rescue []) return true if beyond.any?{|event|clan_estate_local_trigger?(event,[0,1,2],true)} end false rescue false end def clan_estate_local_trigger?(event,triggers,normal) return false unless event return false if event.instance_variable_get(:@net_player_id) event.trigger_in?(triggers) && event.normal_priority? == normal && checkNpcAbleTrigger(event) rescue false end end module PursuitView def update(*args) result=super pursuit=MPClanEstate.state['pursuit'] if pursuit && $game_map.isOverMap unless @clan_collector @clan_collector=Sprite.new @clan_collector.bitmap=Bitmap.new(140,48) @clan_collector.bitmap.font.size=18 @clan_collector.bitmap.font.color=Color.new(255,100,80) @clan_collector.bitmap.draw_text(0,0,140,24,'Коллекторы',1) @clan_collector.bitmap.fill_rect(63,27,14,19,Color.new(200,50,35)) @clan_collector.ox=70;@clan_collector.oy=48;@clan_collector.z=180 end @clan_collector.x=$game_map.adjust_x(pursuit[0])*32+16 @clan_collector.y=$game_map.adjust_y(pursuit[1])*32+32 @clan_collector.visible=true elsif @clan_collector @clan_collector.visible=false end result end def terminate(*args) if @clan_collector @clan_collector.bitmap.dispose;@clan_collector.dispose;@clan_collector=nil end super end end module PortalBypass def portal_on_reserve_transfer(src_map,event_id,dst_map,x,y,dir,fade) begin # Личный дом и клановый двор/дом — оба tag-map ("NoerHome"/"NoerHomeOut"). # Generic portal делает dst_map.to_i => 0 и вешает переход (чёрный экран). if defined?(NoerHomeEstate) kind = NoerHomeEstate.home_target_kind(dst_map).to_s unless kind.empty? # Drop any stale generic-portal wait/cache created by an earlier # broken home attempt. The local tag-map transfer itself was # already reserved by Game_Player#reserve_transfer before this hook. clear_portal_wait if respond_to?(:clear_portal_wait) if respond_to?(:portal_key) && instance_variable_defined?(:@portal_routes) routes = instance_variable_get(:@portal_routes) key = portal_key(src_map, event_id) routes.delete(key) if routes.respond_to?(:delete) end return nil end end rescue => e puts "[NoerHome portal bypass] #{e.class}: #{e.message}" end super end end module EstateHome def house_bought?; MPClanEstate.active? ? true : super; end def own_home_context?; MPClanEstate.active? ? MPClanEstate.editable? : super; end def guest_context?; MPClanEstate.active? ? !MPClanEstate.editable? : super; end def current_home_kind; MPClanEstate.active? ? MPClanEstate.home_kind : super; end def decor_blob; MPClanEstate.active? ? MPClanEstate.state['decor'].to_s : super; end def set_decor_blob(value) return super unless MPClanEstate.active? return false unless MPClanEstate.editable? MPClanEstate.send_action('decor', 'decor'=>value.to_s) end def sync_to_server(*args); MPClanEstate.active? ? false : super; end def transfer_allowed?(map_id); MPClanEstate.active? ? true : super; end def prepare_home_transfer(kind) return super unless MPClanEstate.active? MPClanEstate.home_kind=kind MPClanEstate.remember_estate_route(kind) super end def after_map_setup(map_id=nil) # If full estate state was cleared during a disconnect but we are still on # the physical house/yard map, keep publishing the remembered virtual clan # room. This prevents a final autosave from becoming a private-home save. kind=home_kind_for_local($game_map.map_id) if MPClanEstate.active? if kind.empty? MPClanEstate.home_kind=nil MPClanEstate.clear_estate_route return end MPClanEstate.home_kind=kind MPClanEstate.remember_estate_route(kind) send_line(map_packet_for_server($game_map.map_id)) return end if !kind.empty? && MPClanEstate.resume_clan_id>0 && MPClanEstate.resume_kind==kind send_line(map_packet_for_server($game_map.map_id)) return end super end def map_packet_for_server(map_id) kind=home_kind_for_local(map_id) return super if kind.empty? if MPClanEstate.active? MPClanEstate.remember_estate_route(kind) # Compute the virtual room id from the authoritative clan id instead of # trusting an optional/stale map field. This prevents accidental "map:" # packets after reconnect and keeps every client in the same clan room. virtual=MPClanEstate.virtual_map_id(kind) return "map:#{virtual}" if virtual.to_i>0 end # Disconnect-safe fallback: @state/@home_kind may already be cleared while # Save14 is still performing the final map preflight/cloud commit. if MPClanEstate.resume_clan_id>0 && MPClanEstate.resume_kind==kind virtual=MPClanEstate.resume_virtual_map_id(kind) return "map:#{virtual}" if virtual.to_i>0 end super end end module Garden def own_yard? return super unless MPClanEstate.active? MPClanEstate.home_kind=='yard' && MPClanEstate.garden_slave_access? end def decode return super unless MPClanEstate.active? out={} (MPClanEstate.state['plots']||{}).each do |slot,p| crop=NoerHomeGarden::CROPS.find{|_,cfg|cfg[:item]==p['crop']} next unless crop out[slot.to_i]={:crop=>crop[0],:watered=>p['watered'],:day=>p['planted'].to_i,:farmer=>p['farmer'].to_i} end out end # The original NoerHome garden matures on the NEXT dateAmt unit: # stage 3 when watered && today > planted_day # ClanEstate server base used EstateRules::DAY (2 units) for harvest, which # doubled the original garden wait. The server compatibility plugin shipped # with this client translates only harvest validation back to the original # one-unit rule; wages/passes/fines keep their existing DAY=2 semantics. # # The live server time packet is authoritative. @last_server_date is the # integer dateAmt unit; @last_server_total is the current 0...steps phase. def clan_server_now begin if defined?(WebSocket) raw = WebSocket.instance_variable_get(:@last_server_date) rescue nil return raw.to_i if !raw.nil? && raw.to_i > 0 end rescue end begin if defined?($game_date) && $game_date && $game_date.respond_to?(:dateAmt) raw = $game_date.dateAmt.to_i return raw if raw > 0 end rescue end (MPClanEstate.state['clock'] || 0).to_i rescue 0 end # If WorldState was restarted behind the persisted ClanEstate clock, rebase # only the DISPLAYED planting timestamp to the live clock. The companion # server plugin performs the same rebase before harvest validation. def clan_effective_planted(data) planted = data ? data[:day].to_i : 0 now = clan_server_now begin estate_clock = (MPClanEstate.state['clock'] || 0).to_i if planted > now && estate_clock > now shift = estate_clock - now planted = [planted - shift, 0].max end rescue end planted rescue data ? data[:day].to_i : 0 end def clan_growth_remaining(data) return 0 unless data planted = clan_effective_planted(data) [1 - (clan_server_now - planted), 0].max rescue 1 end def clan_harvest_ready?(data) !!data && !!data[:watered] && clan_growth_remaining(data) <= 0 rescue false end def clan_server_phase total = 0.0 steps = 100.0 begin if defined?(WebSocket) raw_total = WebSocket.instance_variable_get(:@last_server_total) rescue nil raw_steps = WebSocket.instance_variable_get(:@steps_per_cycle) rescue nil total = raw_total.to_f unless raw_total.nil? steps = raw_steps.to_f if !raw_steps.nil? && raw_steps.to_f > 0.0 end rescue end total %= steps if steps > 0.0 [total, steps] rescue [0.0, 100.0] end def clan_growth_seconds_remaining(data) return 0 unless data now = clan_server_now planted = clan_effective_planted(data) target = planted + 1 units = target - now return 0 if units <= 0 phase, steps = clan_server_phase # Client sends time_init rate=1.0, so one cycle step is one real second. seconds = ((units - 1) * steps) + (steps - phase) [seconds.ceil, 0].max rescue 0 end def clan_growth_text(data) sec = clan_growth_seconds_remaining(data) return 'Урожай созрел.' if sec <= 0 if sec >= 60 m = sec / 60 s = sec % 60 "Созревает — примерно #{m}:#{format('%02d', s)}" else "Созревает — примерно #{sec} сек." end rescue 'Урожай созревает.' end def stage_for(data) return super unless MPClanEstate.active? return 0 unless data return 3 if clan_harvest_ready?(data) data[:watered] ? 2 : 1 end def clan_bed_density(crop) crop.to_s=='tomato' ? 2 : 4 end def plant(slot,crop) return super unless MPClanEstate.active? MPClanEstate.send_action('plant','slot'=>slot,'item'=>NoerHomeGarden::CROPS.fetch(crop.to_s)[:item]) end def water(slot); MPClanEstate.active? ? MPClanEstate.send_action('water','slot'=>slot) : super; end def harvest(slot) return super unless MPClanEstate.active? data=decode[slot.to_i] return false unless data unless data[:watered] MPClanEstate.notify('Сначала полейте грядку.') return false end unless clan_harvest_ready?(data) MPClanEstate.notify(clan_growth_text(data)) return false end MPClanEstate.send_action('harvest','slot'=>slot) end # Clan plots are server-owned. Hide the fake local clear action. def clear(slot); MPClanEstate.active? ? false : super; end end module SharedAmenities def own_house? return super unless MPClanEstate.active? MPClanEstate.home_kind=='house' && !MPClanEstate.state['frozen'] end def open_storage return super unless MPClanEstate.active? Game_Interpreter.new.clan_estate_chest end def save_placements(rows) return false if MPClanEstate.active? && !MPClanEstate.editable? super end def reset_placements return super unless MPClanEstate.active? return false unless MPClanEstate.editable? NoerHomeEstate.set_decor_blob('') end # Estate furnishings are configured by the creator; the personal-house # buy/refund wallet must not run against asynchronous shared estate state. def item_price(item);MPClanEstate.active? ? 0 : super;end def apply_price_delta(*args);MPClanEstate.active? ? MPClanEstate.editable? : super;end end # The engine checks OK before Cancel in Window_ChoiceList. Some keyboard # layouts report ESC as both commands for one frame, which used to execute # the highlighted chest operation. Clan chest dialogs always consume Cancel # first, including the amount selector. module ChestChoiceCancelPriority def process_handling if MPClanEstate.chest_choice_active? && open? && active cancel_pressed = Input.trigger?(:B) || WolfPad.trigger?(:X_LINK) return process_cancel if cancel_enabled? && cancel_pressed end super end end module EditorPermission def start return false if MPClanEstate.active? && !MPClanEstate.editable? super end end module Menus # LonaRPG passes every choice label through Text#[], where an ASCII colon # means "translation_file:translation_id". ClanEstate labels are already # localized/raw text, so sanitize colons before the engine sees them. This # also protects dynamic clan names, nicknames and item labels containing ':'. def clan_estate_pick_rows(rows, target = nil) safe_rows = rows.map do |row| copy = row.dup copy[0] = copy[0].to_s.gsub(':', ':') copy end picked=noerhome_pick_rows(safe_rows, target) # NoerHome's sheet picker returns false for ESC. Normalize it to the # same explicit cancel value used by every ClanEstate menu so it can # never reach to_i or be mistaken for the highlighted action. picked.nil? || picked==false ? 'cancel' : picked end def noerhome_garden_menu(slot) return super unless MPClanEstate.active? state=NoerHomeGarden.decode data=state[slot.to_i] if data.nil? rows=[] NoerHomeGarden::CROPS.each do |crop,cfg| density = NoerHomeGarden.respond_to?(:clan_bed_density) ? NoerHomeGarden.clan_bed_density(crop) : (crop.to_s=='tomato' ? 2 : 4) rows << ["Посадить #{cfg[:title]} — грядка на #{density} растения (есть x#{NoerHomeGarden.item_count(cfg[:item])})",crop] end rows << ['Отмена','cancel'] picked=clan_estate_pick_rows(rows) NoerHomeGarden.plant(slot,picked) if NoerHomeGarden::CROPS[picked.to_s] return true end rows=[] if data[:watered] if NoerHomeGarden.clan_harvest_ready?(data) rows << ['Собрать урожай','harvest'] else rows << [NoerHomeGarden.clan_growth_text(data),'wait'] end else rows << ['Полить','water'] end rows << ['Отмена','cancel'] picked=clan_estate_pick_rows(rows) NoerHomeGarden.harvest(slot) if picked=='harvest' NoerHomeGarden.water(slot) if picked=='water' if picked=='wait' MPClanEstate.notify(NoerHomeGarden.clan_growth_text(data)) end true rescue => e puts "[ClanEstate garden menu] #{e.class}: #{e.message}" false end def noerhome_decor_menu(*args) if MPClanEstate.active? && !MPClanEstate.editable? MPClanEstate.notify('Менять интерьер может только создатель клана или администрация.') return false end super end def command_355 if MPClanEstate.active? && @list[@index].parameters[0].to_s.strip == 'SceneManager.goto(Scene_NoerHomeStorage)' @index += 1 while next_event_code == 655 clan_estate_chest return true end super end def clan_estate_enter_own_home # Do not block the door on ce_state. The plugin can resolve both an # ordinary clan member and an assigned clan slave directly from profile. # A background hello still refreshes the full estate state/inventory. MPClanEstate.refresh_state clan=MPClanEstate.local_clan_id.to_i data={'kind'=>'house'} data['clan']=clan if clan>0 MPClanEstate.send_action('enter',data) true end def noerhome_overmap_house_menu # ClanEstate is shown even before the estate state arrives. Selecting it # now enters the current clan's house immediately, with no ID/submenu step. clan_name=MPClanEstate.local_clan_name clan_label=clan_name.empty? ? 'Клановый дом' : "Клановый дом — #{clan_name}" picked=clan_estate_pick_rows([[clan_label,'clan'],['Личный дом и гости','personal'],['Отмена','cancel']]) return clan_estate_enter_own_home if picked=='clan' return super if picked=='personal' true end def load_script(path) guild_worker_path=(path=='Data/HCGframes/event/NoerTavernGuildEmpolyee.rb') if path=='Data/HCGframes/event/NoerBankMaani.rb' && MPClanEstate.state['clan'].to_i>0 loop do picked=clan_estate_pick_rows([['Частный клиент','bank'],['Юр. лицо','legal'],['Отмена','cancel']]) # Обычные банковские услуги игры. break if picked=='bank' return if picked!='legal' # Отдельное меню операций клана. loop do fine=MPClanEstate.state['fine'].to_i legal=clan_estate_pick_rows([["Штраф клана: #{fine} золота — оплатить со счёта клана",'fine'],['Внести золото на счёт клана','fund'],['Назад','back']]) if legal=='fine' MPClanEstate.send_action('pay_fine') return elsif legal=='fund' qty=clan_estate_pick_rows([['1 золотая','1'],['2 золотых','2'],['Назад','0']]).to_i if qty>0 MPClanEstate.send_action('fund','amount'=>qty) return end else break end end end end if guild_worker_path begin result=super MPClanEstate.save_guild_progress result ensure MPClanEstate.restore_worker_view(self) end else super end end def clan_estate_passport # Ask the plugin directly. This check is independent from a pending house # request and verifies both ordinary player slavery and clan slavery. status=MPClanEstate.authoritative_document_slave_status if status==true call_msg("\\CBmp[GuildEmpolyee,20]\\c[4]Работник:\\C[0] Я не могу восстановить ваши документы, пока вы находитесь в рабстве у игрока или клана. Сначала получите освобождение.") MPClanEstate.incite_map_npcs_against_player return elsif status.nil? call_msg("\\CBmp[GuildEmpolyee,20]\\c[4]Работник:\\C[0] Не удалось проверить ваш статус на сервере. Попробуйте ещё раз через несколько секунд.") return end due=MPClanEstate.state.fetch('passport_due',-1).to_i clock=MPClanEstate.state['clock'].to_i if due<0 picked=clan_estate_pick_rows([['Подать заявление — выдача через 21 игровой день','request'],['Отмена','cancel']]) MPClanEstate.send_action('passport_request') if picked=='request' elsif clock>=due picked=clan_estate_pick_rows([['Забрать готовый паспорт','collect'],['Отмена','cancel']]) MPClanEstate.send_action('passport_collect') if picked=='collect' else call_msg("\\CBmp[GuildEmpolyee,20]\\c[4]Работник:\\C[0] Паспорт ещё не готов. До выдачи осталось #{((due-clock)/2.0).ceil} игровых дней.") end end def clan_estate_assign rows=(MPClanEstate.state['owned_slaves']||[]).map{|c|[c['nick'].to_s,c['contract'].to_s]} rows << ['Отмена','0'] picked=clan_estate_pick_rows(rows).to_i MPClanEstate.send_action('assign','contract'=>picked) if picked>0 end def clan_estate_menu # Clan actions always target the clan the current player actually belongs # to. Internal estate IDs are never shown as a choice to the player. clan=MPClanEstate.state['clan'].to_i if clan<=0 && !MPClanEstate.clan_slave? MPClanEstate.notify('Вы не состоите в клане.') return end rows=[['Клановый дом','house'],['Двор и огород','yard']] rows << ['Статус раба','status'] if MPClanEstate.clan_slave? rows << ["Репутация клана: #{MPClanEstate.state['reputation'].to_i}",'info'] rows << ['Отмена','cancel'] picked=clan_estate_pick_rows(rows) if picked=='status' MPClanEstate.notify(MPClanEstate.slave_status_text) elsif picked=='info' fine=MPClanEstate.state['fine'].to_i text="Репутация клана: #{MPClanEstate.state['reputation'].to_i}." text += fine>0 ? " Штраф: #{fine} золотых." : ' Штрафов нет.' text += ' Клан заморожен.' if MPClanEstate.state['frozen'] MPClanEstate.notify(text) elsif ['house','yard'].include?(picked) data={'kind'=>picked} data['clan']=clan if clan>0 MPClanEstate.send_action('enter',data) end end def clan_estate_chest MPClanEstate.open_chest_scene end end module GuildMenu def open(interpreter=nil) return super unless interpreter unless defined?(WebSocket) && WebSocket.instance_variable_get(:@connected) WebSocket.clan_notify('Нет соединения с сервером.',true) if defined?(WebSocket) return end MPClanEstate.refresh_state rows=[['Список кланов','list'],['Мой клан','mine'],['Создать клан','create']] if MPClanEstate.state['clan'].to_i>0 rows << ['Выйти из клана','leave'] rows << ['Управление кланом на сайте','site'] rows << ['Клановый дом','home'] rows << ['Передать своего раба клану','assign'] end rows << ['Отмена','cancel'] picked=interpreter.clan_estate_pick_rows(rows) case picked when 'list';WebSocket.clan_request_list when 'mine';WebSocket.clan_request_me when 'create' name=MPClanGuild.default_clan_name WebSocket.clan_notify("Создаю «#{name}». Стоимость: 15 Монет III. Для своего названия: /clan create Название | Тег") WebSocket.clan_create_with_fee(name,MPClanGuild.default_clan_tag(name),'') when 'leave';WebSocket.clan_leave when 'site';WebSocket.clan_notify('Переименование, описание, роли и удаление клана доступны в личном кабинете на сайте.') when 'home';MPClanEstate.with_worker_context{interpreter.clan_estate_enter_own_home} when 'assign';MPClanEstate.with_worker_context{interpreter.clan_estate_assign} end end end module Frame def update(*args) result=super if MPClanEstate.install MPClanEstate.tick MPClanEstate.update_menu end result end end end # Clan chest uses the same two-column storage scene as the normal bank, but every # transfer remains server-authoritative. The right pane is built only from the # filtered `chest` map sent by ClanEstate, so slaves never receive hidden stock. # Unlike a normal storage box, the clan chest title intentionally hides the # stock weight/value/count summary ("w / p / xN") and shows only its name. if defined?(Window_BoxTitle) class Window_ClanEstateBoxTitle < Window_BoxTitle def draw_box_amount(draw_maximum) # Clan chest: keep the header clean. Counts remain visible on item rows. end end end if defined?(Scene_ItemStorage) class Scene_ClanEstateStorage < Scene_ItemStorage def prepare(box_id=MPClanEstate::CLAN_CHEST_BOX_ID, taking=false) super(MPClanEstate::CLAN_CHEST_BOX_ID, taking) end def start MPClanEstate.setup_chest_box MPClanEstate.sync_chest_box(true) @ce_chest_fp=MPClanEstate.chest_fingerprint @ce_last_refresh=Graphics.frame_count super begin # Replace only the right clan-chest title window. Normal bank/storage # windows keep their stock weight/value/count summary unchanged. if defined?(Window_ClanEstateBoxTitle) && @box_title @box_title.dispose rescue nil @box_title = Window_ClanEstateBoxTitle.new( Graphics.width/2, Storage_Boxes_Setting::BOXES[MPClanEstate::CLAN_CHEST_BOX_ID][:name], MPClanEstate::CLAN_CHEST_BOX_ID ) end # The base storage scene labels the left pane with menu:Box/Body ("Лона"). # For multiplayer clan storage it must show the actual logged-in nickname. nick = defined?(WebSocket) && WebSocket.respond_to?(:local_nickname) ? WebSocket.local_nickname.to_s.strip : '' unless nick.empty? || !@bag_title @bag_title.instance_variable_set(:@title,nick) @bag_title.refresh end rescue => e puts "[ClanEstate chest title] #{e.class}: #{e.message}" end end def update fp=MPClanEstate.chest_fingerprint if fp!=@ce_chest_fp @ce_chest_fp=fp if MPClanEstate.sync_chest_box(true) refresh end end frame=Graphics.frame_count if frame-@ce_last_refresh.to_i>=300 @ce_last_refresh=frame MPClanEstate.refresh_state end super end def update_item_selection if MPClanEstate.request_pending? # Do not let the player close the window in the tiny interval between # click and authoritative server ACK. Otherwise the transfer is applied # correctly on Scene_Map and visually looks like it happened only because # the chest was closed. The normal request timeout still releases this. if Input.trigger?(:B) || WolfPad.trigger?(:X_LINK) || (Mouse.enable? && Input.trigger?(:MX_LINK)) SndLib.sys_buzzer end return end super end def ce_server_refresh MPClanEstate.sync_chest_box(true) @ce_chest_fp=MPClanEstate.chest_fingerprint refresh @bag_window.refresh if @bag_window && @bag_window.respond_to?(:refresh) @box_window.refresh if @box_window && @box_window.respond_to?(:refresh) @bag_title.refresh if @bag_title && @bag_title.respond_to?(:refresh) @box_title.refresh if @box_title && @box_title.respond_to?(:refresh) true rescue => e puts "[ClanEstate chest scene refresh] #{e.class}: #{e.message}" false end def move_item(val=nil) if @box_window.active item=@box_window.item return SndLib.sys_buzzer if item.nil? || @box_window.index<0 available=$game_boxes.item_number(item,@box_id).to_i key=MPClanEstate.item_key(item) qty = val=='max' ? available : (val.is_a?(Numeric) ? [available,val.to_i].min : 1) ration=MPClanEstate.slave_withdraw_remaining(key) qty=[qty,ration].min unless ration.nil? if qty<=0 MPClanEstate.notify('Дневной лимит этого типа припасов уже выбран.') if MPClanEstate.clan_slave? return SndLib.sys_buzzer end if MPClanEstate.send_action('withdraw','item'=>key,'amount'=>qty) SndLib.sys_equip(80,140) end elsif @bag_window.active item=@bag_window.item return SndLib.sys_buzzer if item.nil? || @bag_window.index<0 || !@bag_window.enable?(item) if MPClanEstate.child_item?(item) MPClanEstate.notify('Ребёнка нельзя поместить в клановый сундук.') return SndLib.sys_buzzer end key=MPClanEstate.item_key(item) if (MPClanEstate.state['locked']||{})[key].to_i>0 return SndLib.sys_buzzer end available=$game_party.item_number(item).to_i qty = val=='max' ? available : (val.is_a?(Numeric) ? [available,val.to_i].min : 1) return SndLib.sys_buzzer if qty<=0 if MPClanEstate.send_action('deposit','item'=>key,'amount'=>qty) SndLib.sys_equip end else SndLib.sys_buzzer end end end end # The clan house reuses a physical NoerHome map, whose ordinary nap event can # roll hostile bandits. In a valid clan-house session expose no nap event to # the local sleep command, making it take the normal `handleNap` branch. Yard, # ordinary houses and every non-clan map retain their original encounter logic. if defined?(Game_Map) module ClanEstateProtectedNap def napEventId if defined?(MPClanEstate) && MPClanEstate.active? && MPClanEstate.home_kind.to_s == 'house' return nil end super end end Game_Map.prepend(ClanEstateProtectedNap) unless Game_Map.ancestors.include?(ClanEstateProtectedNap) end # Clan garden beds are physically 2x2 tiles. The stock NoerHome renderer # draws one crop sprite at the bed origin; for clan farming that looked like one # lonely plant in a large bed. Keep the server's one-cycle-per-bed rules intact, # but render a full bed: 4 potato/carrot plants or 2 tomato plants. if defined?(Spriteset_Map) module ClanEstateDenseGardenSprites def refresh_noerhome_estate_sprites result=super begin active = defined?(MPClanEstate) && MPClanEstate.active? && defined?(NoerHomeGarden) && NoerHomeGarden.visible_yard? unless active @clan_estate_density_signature=nil return result end sig=@noerhome_estate_signature return result if @clan_estate_density_signature==sig @clan_estate_density_signature=sig state=NoerHomeGarden.decode coords=NoerHomeGarden.plots state.each do |index,data| xy=coords[index.to_i] next unless xy && data crop=data[:crop].to_s offsets = crop=='tomato' ? [[1,0]] : [[1,0],[0,1],[1,1]] stage=NoerHomeGarden.stage_for(data) opacity = stage>=3 ? 255 : (stage==2 ? 210 : 160) offsets.each do |dx,dy| make_noerhome_sprite(NoerHomeGarden.crop_image_path(crop),xy[0]+dx,xy[1]+dy,74,opacity) end end update_noerhome_estate_sprites rescue => e puts "[ClanEstate garden sprites] #{e.class}: #{e.message}" end result end end Spriteset_Map.prepend(ClanEstateDenseGardenSprites) end # Clan-slave display in the character main-stats panel. # 1.3.5: do NOT replace the normal Lona title ("Простолюдинка", etc.). # Clan slaves use the same title rendering as every other player. Their bond # is shown only in the ordinary clan row as "Раб клана: <название>". if defined?(Menu_MainStats) class Menu_MainStats < Menu_ContentBase unless method_defined?(:clan_estate_make_menu_hash_without_slave_clan_row) alias clan_estate_make_menu_hash_without_slave_clan_row make_menu_hash end def make_menu_hash data = clan_estate_make_menu_hash_without_slave_clan_row begin return data unless defined?(MPClanEstate) && MPClanEstate.respond_to?(:clan_slave?) && MPClanEstate.clan_slave? clan_name = MPClanEstate.respond_to?(:local_clan_name) ? MPClanEstate.local_clan_name.to_s.strip : '' if clan_name.empty? && MPClanEstate.respond_to?(:local_clan_id) clan_id = MPClanEstate.local_clan_id.to_i clan_name = "##{clan_id}" if clan_id > 0 end label = 'Раб клана: ' value = clan_name.to_s # Russian-font main stats returns [label_hash, value_hash]. if data.is_a?(Array) && data[0].is_a?(Hash) && data[1].is_a?(Hash) data[0]['clan'] = [157 + 7, 12 * 17, 220, 60, label] data[1]['clan'] = [157 + 7, 12 * 17, 220, 60, (' ' * label.length) + value, 0] elsif data.is_a?(Hash) # Fallback for the stock/non-split stats renderer. text = value.empty? ? 'Раб клана' : "Раб клана: #{value}" data['clan'] = [157 + 8, 60 + 85, 240, 60, text, 0] end rescue => e puts "[ClanEstate] slave clan row failed: #{e.class}: #{e.message}" end data end end end Graphics.singleton_class.prepend(MPClanEstate::Frame) # Live UI для кланового сундука (патч из 29_live_esc_menu — класс уже определён). begin MPLiveEscMenu.install_clan_chest_live! if defined?(MPLiveEscMenu) && MPLiveEscMenu.respond_to?(:install_clan_chest_live!) rescue => e puts "[ClanEstate] live chest install: #{e.class}: #{e.message}" rescue nil end