Overlay de fronteira (cliente): paredes do grid + labels Cell X,Y

- AZeusFrontierOverlayActor: paredes (ProceduralMesh, material de portal) em
  todas as fronteiras do grid; label DrawDebugString no centro de cada cell com
  notacao de quadtree ("Cell 0" / "Cell 0,2" pos-split) + nome do servidor.
- UZeusAOIComponent: liga via toggle "Fronteiras (Mesh)" / CVar zeus.debug.frontier,
  spawna/atualiza o ator, re-pede o 6163 a cada 2s (reflete split/merge).
- ZMMO.Build.cs: + ProceduralMeshComponent.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Config/DefaultGame.ini

@@ -71,6 +71,13 @@ ScreenSetAsset=/Game/ZMMO/UI/InGame/DA_InGameScreenSet.DA_InGameScreenSet
 ; (UWorldSubsystem) subscribe nos delegates do UZeusNetworkSubsystem.
 +ComponentClasses=/Script/ZeusGAS.ZeusGASComponent
 
+; === GAS Cue paths (Batch 2.5 — S_ABILITY_CUE multicast cosmetico) ===
+; UGameplayCueManager scaneia esses paths no boot pra mapear FGameplayTag
+; -> AGameplayCueNotify_Actor BP. UZeusGASComponent::DispatchAbilityCue chama
+; ASC->ExecuteGameplayCueLocal(CueTag, params) -> manager resolve pelo path.
+[/Script/GameplayAbilities.AbilitySystemGlobals]
++GameplayCueNotifyPaths="/Game/ZMMO/GAS/Cues"
+
 [/Script/Engine.AssetManagerSettings]
 -PrimaryAssetTypesToScan=(PrimaryAssetType="Map",AssetBaseClass=/Script/Engine.World,bHasBlueprintClasses=False,bIsEditorOnly=True,Directories=((Path="/Game/Maps")),SpecificAssets=,Rules=(Priority=-1,ChunkId=-1,bApplyRecursively=True,CookRule=Unknown))
 -PrimaryAssetTypesToScan=(PrimaryAssetType="PrimaryAssetLabel",AssetBaseClass=/Script/Engine.PrimaryAssetLabel,bHasBlueprintClasses=False,bIsEditorOnly=True,Directories=((Path="/Game")),SpecificAssets=,Rules=(Priority=-1,ChunkId=-1,bApplyRecursively=True,CookRule=Unknown))

Config/DefaultZeusV1.ini

@@ -0,0 +1,19 @@
+; DefaultZeusV1.ini
+; Config inicial pra UZeusNetworkingClientSubsystem (P9-6/P9-7 plugin).
+; Editar via UE Project Settings -> Plugins -> Zeus V1 OU editar este arquivo
+; e relancar o editor.
+;
+; PORT 7777: ZeusGateway. NodeService popula routes via charId lookup quando
+; cliente conecta (validado: handshake routed charId=7 -> SP_01 cell 0). Fluxo
+; padrao de producao -- UE conecta no Gateway, Gateway resolve cell ownership
+; via lease em Valkey + encaminha pro ZS correto.
+;
+; ALTERNATIVO (debug only -- bug aberto pendente investigacao):
+; ServerPort=9001 conecta DIRETO em SP_01 mas hoje pacote UE nao chega no
+; server (FUdpSocketBuilder + Windows multi-NIC loopback issue). Use 7777.
+
+[/Script/ZeusNetwork.ZeusNetworkingClientSubsystem]
+ServerHost=127.0.0.1
+ServerPort=7777
+bUseZeusNetworkingV1=True
+bAutoConnectOnStart=True

Config/Tags/ZeusServerTags.ini

@@ -0,0 +1,83 @@
+; Gerado por ZeusTool tags sync -- tags do ZeusServer p/ o cliente UE.
+; NAO editar a mao: regenere com `ZeusTool tags sync <json> <ini>`.
+[/Script/GameplayTags.GameplayTagsList]
+GameplayTagList=(Tag="Zeus",DevComment="")
+GameplayTagList=(Tag="Zeus.Ability",DevComment="")
+GameplayTagList=(Tag="Zeus.Ability.Casting",DevComment="")
+GameplayTagList=(Tag="Zeus.Ability.Channeling",DevComment="")
+GameplayTagList=(Tag="Zeus.Ability.Movement",DevComment="")
+GameplayTagList=(Tag="Zeus.Ability.Movement.Dash",DevComment="")
+GameplayTagList=(Tag="Zeus.Ability.Recovery",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Agi",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Aspd",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Atk",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.BaseExp",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.BaseLevel",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Crit",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Def",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Dex",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Flee",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Hit",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Hp",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Int",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.JobExp",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.JobLevel",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Luk",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Matk",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.MatkMax",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.MatkMin",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.MaxHp",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.MaxSp",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Mdef",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.SkillPoint",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Sp",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.StatusPoint",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Str",DevComment="")
+GameplayTagList=(Tag="Zeus.Attribute.Vit",DevComment="")
+GameplayTagList=(Tag="Zeus.Combat",DevComment="")
+GameplayTagList=(Tag="Zeus.Combat.Blocking",DevComment="")
+GameplayTagList=(Tag="Zeus.Combat.Dodging",DevComment="")
+GameplayTagList=(Tag="Zeus.Combat.InCombat",DevComment="")
+GameplayTagList=(Tag="Zeus.Combat.LockOn",DevComment="")
+GameplayTagList=(Tag="Zeus.Combo",DevComment="")
+GameplayTagList=(Tag="Zeus.Combo.Slot1",DevComment="")
+GameplayTagList=(Tag="Zeus.Combo.Slot2",DevComment="")
+GameplayTagList=(Tag="Zeus.Combo.Slot3",DevComment="")
+GameplayTagList=(Tag="Zeus.Combo.Window",DevComment="")
+GameplayTagList=(Tag="Zeus.Cooldown",DevComment="")
+GameplayTagList=(Tag="Zeus.Cue",DevComment="")
+GameplayTagList=(Tag="Zeus.Cue.Movement",DevComment="")
+GameplayTagList=(Tag="Zeus.Cue.Movement.Dash",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage.Earth",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage.Fire",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage.Holy",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage.Magical",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage.Physical",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage.Poison",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage.Shadow",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage.Water",DevComment="")
+GameplayTagList=(Tag="Zeus.Damage.Wind",DevComment="")
+GameplayTagList=(Tag="Zeus.Effect",DevComment="")
+GameplayTagList=(Tag="Zeus.Effect.Cooldown",DevComment="")
+GameplayTagList=(Tag="Zeus.Effect.Cooldown.Dash",DevComment="")
+GameplayTagList=(Tag="Zeus.Effect.Cost",DevComment="")
+GameplayTagList=(Tag="Zeus.Effect.Cost.Sp_10",DevComment="")
+GameplayTagList=(Tag="Zeus.Status",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.Buff",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.CC",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.CC.Disarmed",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.CC.Feared",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.CC.Frozen",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.CC.KnockedDown",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.CC.Rooted",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.CC.Silenced",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.CC.Stunned",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.Dead",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.Debuff",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.Invulnerable",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.Regen",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.Regen.Blocked",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.Regen.Boosted",DevComment="")
+GameplayTagList=(Tag="Zeus.Status.Regen.Poisoned",DevComment="")

Source/ZMMO/Game/Entity/ZeusCharacter.cpp

@@ -17,10 +17,16 @@
 #include "Subsystems/WorldSubsystem.h"
 #include "UObject/ConstructorHelpers.h"
 #include "ZMMO.h"
+#include "GameplayTagContainer.h"
+#include "GameplayTagsManager.h"
 #include "ZeusGASComponent.h"
+#include "ZeusAOIComponent.h"
 #include "ZeusPlayerState.h"
+#include "Blueprint/UserWidget.h"
+#include "GameFramework/PlayerController.h"
 #include "ZeusWorldSubsystem.h"
 #include "ZeusNetworkSubsystem.h"
+#include "ZeusNetworkingClientSubsystem.h"
 #include "UI/FrontEnd/UIFrontEndFlowSubsystem.h"
 
 DEFINE_LOG_CATEGORY(LogZeusPlayer);
@@ -55,6 +61,14 @@ AZeusCharacter::AZeusCharacter()
 	FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName);
 	FollowCamera->bUsePawnControlRotation = false;
 
+	// AOI do cliente (+ overlays de debug). Implementa IZeusAOIDebugTarget; o
+	// Zeus Admin Tools acha este componente no pawn e dirige os overlays.
+	AOIComponent = CreateDefaultSubobject<UZeusAOIComponent>(TEXT("ZeusAOIComponent"));
+
+	// AdminPanelClass NAO e' resolvido aqui via FClassFinder: na criacao do CDO
+	// (load do modulo) o asset registry pode nao estar pronto e o static cacheia
+	// null pra sempre. Resolvido lazy em ToggleAdminPanel (LoadClass em runtime).
+
 	// AttributeComponent migrou pro PlayerState (AZeusPlayerState + Component
 	// Registry config-driven). Pawn fica leve — so' movement/input/camera.
 
@@ -101,11 +115,14 @@ AZeusCharacter::AZeusCharacter()
 		TEXT("/Game/Input/Actions/IA_MouseLook.IA_MouseLook"));
 	static ConstructorHelpers::FObjectFinder<UInputAction> JumpActionAsset(
 		TEXT("/Game/Input/Actions/IA_Jump.IA_Jump"));
+	static ConstructorHelpers::FObjectFinder<UInputAction> DashActionAsset(
+		TEXT("/Game/Input/Actions/IA_Dash.IA_Dash"));
 
 	if (MoveActionAsset.Succeeded()) { MoveAction = MoveActionAsset.Object; }
 	if (LookActionAsset.Succeeded()) { LookAction = LookActionAsset.Object; }
 	if (MouseLookActionAsset.Succeeded()) { MouseLookAction = MouseLookActionAsset.Object; }
 	if (JumpActionAsset.Succeeded()) { JumpAction = JumpActionAsset.Object; }
+	if (DashActionAsset.Succeeded()) { DashAction = DashActionAsset.Object; }
 }
 
 void AZeusCharacter::BeginPlay()
@@ -166,11 +183,71 @@ void AZeusCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputCompo
 
 		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &AZeusCharacter::Look);
 		EnhancedInputComponent->BindAction(MouseLookAction, ETriggerEvent::Triggered, this, &AZeusCharacter::Look);
+
+		if (DashAction)
+		{
+			EnhancedInputComponent->BindAction(DashAction, ETriggerEvent::Triggered, this, &AZeusCharacter::OnDashTriggered);
+		}
 	}
 	else
 	{
 		UE_LOG(LogZeusPlayer, Error, TEXT("'%s' Failed to find an Enhanced Input component."), *GetNameSafe(this));
 	}
+
+	// Debug: F8 abre/fecha o Zeus Admin Tools (AIO Debug). Legacy BindKey
+	// convive com Enhanced Input. Trocar a tecla aqui se conflitar.
+	PlayerInputComponent->BindKey(EKeys::F8, IE_Pressed, this, &AZeusCharacter::ToggleAdminPanel);
+}
+
+void AZeusCharacter::ToggleAdminPanel()
+{
+	APlayerController* PC = Cast<APlayerController>(GetController());
+	if (!PC)
+	{
+		return;
+	}
+
+	// Aberto -> fecha + devolve input pro jogo.
+	if (AdminPanelInstance && AdminPanelInstance->IsInViewport())
+	{
+		AdminPanelInstance->RemoveFromParent();
+		PC->SetInputMode(FInputModeGameOnly());
+		PC->bShowMouseCursor = false;
+		return;
+	}
+
+	// Lazy load (runtime): no F8 o asset ja' esta carregavel; evita o pitfall do
+	// FClassFinder na criacao do CDO. Path do generated class (_C).
+	// A UI vive no CONTENT DO PLUGIN (mount /ZeusAdminTools/), nao no /Game do projeto:
+	// o plugin ZeusAdminTools e' autocontido (C++ + UI no repo Server).
+	if (!AdminPanelClass)
+	{
+		AdminPanelClass = LoadClass<UUserWidget>(nullptr,
+			TEXT("/ZeusAdminTools/UI/WBP_AdminToolsAIO.WBP_AdminToolsAIO_C"));
+	}
+	if (!AdminPanelClass)
+	{
+		UE_LOG(LogZeusPlayer, Warning, TEXT("[AdminPanel] AdminPanelClass nao resolvido (WBP_AdminToolsAIO ausente?)."));
+		return;
+	}
+
+	if (!AdminPanelInstance)
+	{
+		AdminPanelInstance = CreateWidget<UUserWidget>(PC, AdminPanelClass);
+	}
+	if (AdminPanelInstance)
+	{
+		AdminPanelInstance->AddToViewport(1000);
+
+		// UIOnly: trava a acao do jogo enquanto o menu esta aberto e garante que
+		// os cliques vao 100% pra UI (no GameAndUI o viewport rouba o clique).
+		// O mundo continua renderizando + os overlays de debug seguem desenhando.
+		FInputModeUIOnly Mode;
+		Mode.SetWidgetToFocus(AdminPanelInstance->TakeWidget());
+		Mode.SetLockMouseToViewportBehavior(EMouseLockMode::DoNotLock);
+		PC->SetInputMode(Mode);
+		PC->bShowMouseCursor = true;
+	}
 }
 
 void AZeusCharacter::Move(const FInputActionValue& Value)
@@ -203,6 +280,40 @@ void AZeusCharacter::OnJumpReleased()
 	DoJumpEnd();
 }
 
+void AZeusCharacter::OnDashTriggered()
+{
+	// Resolve UZeusGASComponent do PlayerState. Component vive la' via
+	// AZeusPlayerState Component Registry (config-driven). Sem el, ASC ausente
+	// e RequestActivateAbilityByTag falha — log warning.
+	const APlayerState* PS = GetPlayerState();
+	if (!PS)
+	{
+		UE_LOG(LogZeusPlayer, Warning, TEXT("OnDashTriggered: PlayerState nullptr — ignorado"));
+		return;
+	}
+	UZeusGASComponent* Comp = PS->FindComponentByClass<UZeusGASComponent>();
+	if (!Comp)
+	{
+		UE_LOG(LogZeusPlayer, Warning, TEXT("OnDashTriggered: UZeusGASComponent nao achado"));
+		return;
+	}
+
+	// Tag canonica casa com row do DT + JSON do server. Hash FNV calculado
+	// dentro do componente (RequestActivateAbilityByTag).
+	const FGameplayTag DashTag = UGameplayTagsManager::Get().RequestGameplayTag(
+		FName(TEXT("Zeus.Ability.Movement.Dash")));
+	if (!DashTag.IsValid())
+	{
+		UE_LOG(LogZeusPlayer, Warning,
+			TEXT("OnDashTriggered: tag Zeus.Ability.Movement.Dash nao registrada no cliente"));
+		return;
+	}
+
+	const bool bSent = Comp->RequestActivateAbilityByTag(DashTag);
+	UE_LOG(LogZeusPlayer, Log, TEXT("OnDashTriggered -> RequestActivateAbilityByTag = %s"),
+		bSent ? TEXT("OK (C_ABILITY_TRY_ACTIVATE enviado)") : TEXT("FALHOU"));
+}
+
 void AZeusCharacter::DoMove(const float Right, const float Forward)
 {
 	PendingMoveRight = FMath::Clamp(Right, -1.0f, 1.0f);
@@ -252,7 +363,7 @@ void AZeusCharacter::SetEntityRelevant(bool /*bRelevant*/)
 
 void AZeusCharacter::ResolveZeusNetworkSubsystem()
 {
-	if (ZeusNetwork)
+	if (ZeusNetwork && NetClient)
 	{
 		return;
 	}
@@ -263,7 +374,14 @@ void AZeusCharacter::ResolveZeusNetworkSubsystem()
 		return;
 	}
 
+	if (!ZeusNetwork)
+	{
 		ZeusNetwork = GI->GetSubsystem<UZeusNetworkSubsystem>();
+	}
+	if (!NetClient)
+	{
+		NetClient = GI->GetSubsystem<UZeusNetworkingClientSubsystem>();
+	}
 }
 
 void AZeusCharacter::BindZeusSpawnDelegate()
@@ -272,49 +390,71 @@ void AZeusCharacter::BindZeusSpawnDelegate()
 	{
 		return;
 	}
-	if (!ZeusNetwork)
+	if (!NetClient && !ZeusNetwork)
 	{
 		return;
 	}
 
-	ZeusNetwork->OnPlayerSpawned.AddDynamic(this, &AZeusCharacter::HandleZeusPlayerSpawned);
+	// Self-entity (entityId do proprio char) vem do sistema de rede novo.
+	if (NetClient)
+	{
+		NetClient->OnSelfEntityAssigned.AddDynamic(this, &AZeusCharacter::HandleSelfEntityAssigned);
+	}
+	// CHAR_INFO (nome/guild) ainda nao tem equivalente no sistema novo -> legacy.
+	if (ZeusNetwork)
+	{
 		ZeusNetwork->OnCharInfoReceived.AddDynamic(this, &AZeusCharacter::HandleZeusCharInfo);
+	}
 	bSpawnDelegateBound = true;
 }
 
 void AZeusCharacter::UnbindZeusSpawnDelegate()
 {
-	if (!bSpawnDelegateBound || !ZeusNetwork)
+	if (!bSpawnDelegateBound)
 	{
-		bSpawnDelegateBound = false;
 		return;
 	}
-	ZeusNetwork->OnPlayerSpawned.RemoveDynamic(this, &AZeusCharacter::HandleZeusPlayerSpawned);
+	if (NetClient)
+	{
+		NetClient->OnSelfEntityAssigned.RemoveDynamic(this, &AZeusCharacter::HandleSelfEntityAssigned);
+	}
+	if (ZeusNetwork)
+	{
 		ZeusNetwork->OnCharInfoReceived.RemoveDynamic(this, &AZeusCharacter::HandleZeusCharInfo);
+	}
 	bSpawnDelegateBound = false;
 }
 
 void AZeusCharacter::TryRegisterLocalEntityFromCachedSpawn()
 {
-	if (!ZeusNetwork)
+	// Self-entity vem do sistema de rede novo (ENT_SELF). O subsystem e'
+	// per-GameInstance e sobrevive ao OpenLevel, entao o entityId pode ja' ter
+	// chegado antes deste pawn existir -- puxa o cache agora. Caso ainda nao
+	// tenha chegado, o bind em OnSelfEntityAssigned cobre quando chegar.
+	// A pos/yaw vem do proprio pawn (ja posicionado via PendingSpawnPose do DB);
+	// o sistema novo so' carrega o entityId.
+	if (NetClient)
 	{
-		return;
+		const int64 SelfId = NetClient->GetLocalEntityId();
+		if (SelfId != 0)
+		{
+			HandleLocalSpawnReady(SelfId, GetActorLocation(), GetActorRotation().Yaw, 0);
+		}
 	}
 
-	int64 CachedEntityId = 0;
-	FVector CachedPosCm = FVector::ZeroVector;
-	float CachedYawDeg = 0.0f;
-	int64 CachedServerTimeMs = 0;
-	if (ZeusNetwork->TryGetLastLocalSpawn(CachedEntityId, CachedPosCm, CachedYawDeg, CachedServerTimeMs))
-	{
-		HandleLocalSpawnReady(CachedEntityId, CachedPosCm, CachedYawDeg, CachedServerTimeMs);
-	}
-
-	// Race fix: o S_CHAR_INFO chega ANTES de S_SPAWN_PLAYER mas o pawn pode
-	// nao existir ainda (OpenLevel em andamento). Aplica o ultimo cacheado.
+	// Race fix CHAR_INFO (ainda legacy): o S_CHAR_INFO pode ter chegado antes do
+	// pawn existir; aplica o ultimo nome/guild cacheado.
 	TryApplyCachedCharInfo();
 }
 
+void AZeusCharacter::HandleSelfEntityAssigned(const int64 InEntityId)
+{
+	// Sistema novo informou o entityId do proprio char (ENT_SELF). Reusa o mesmo
+	// caminho do spawn local legacy (seta ZeusEntityId + RegisterLocalEntity).
+	// pos/yaw vem do pawn (ja posicionado); o sistema novo so' traz o entityId.
+	HandleLocalSpawnReady(InEntityId, GetActorLocation(), GetActorRotation().Yaw, 0);
+}
+
 void AZeusCharacter::HandleZeusPlayerSpawned(const int64 InEntityId, const bool bIsLocal,
 	const FVector PosCm, const float YawDeg, const int64 ServerTimeMs)
 {
@@ -388,6 +528,17 @@ void AZeusCharacter::HandleZeusCharInfo(const int64 InEntityId, const FString& C
 		TEXT("AZeusCharacter: S_CHAR_INFO recebido EntityId=%lld name=%s guild=%s"),
 		InEntityId, *CharName, *GuildName);
 
+	// 2026-06-03 fix: server envia S_CHAR_INFO de TODOS os players (proprio +
+	// catch-up de proxies pre-existentes). Sem este filtro, o nome do ultimo
+	// proxy recebido sobrescrevia o do pawn local (ex: player Mateuus loga e
+	// ve "Olatudook" em si mesmo porque o catch-up do Olatudook chegou depois
+	// do S_CHAR_INFO proprio). Proxies remotos sao roteados pelo registry no
+	// UZeusWorldSubsystem (futuro nameplate por EntityId).
+	if (ZeusEntityId != 0 && InEntityId != ZeusEntityId)
+	{
+		return;
+	}
+
 	APlayerState* PS = GetPlayerState();
 	if (!PS)
 	{
@@ -427,7 +578,10 @@ void AZeusCharacter::TryApplyCachedCharInfo()
 void AZeusCharacter::FlushInputAxisToServer(const float DeltaSeconds)
 {
 	ResolveZeusNetworkSubsystem();
-	if (!ZeusNetwork || !ZeusNetwork->IsConnected())
+	// Sistema de rede novo (canonico) tem prioridade; legacy e' fallback.
+	const bool bV1 = (NetClient
+		&& NetClient->GetConnectionState() == EZeusV1ConnectionState::Accepted);
+	if (!bV1 && (!ZeusNetwork || !ZeusNetwork->IsConnected()))
 	{
 		return;
 	}
@@ -436,7 +590,19 @@ void AZeusCharacter::FlushInputAxisToServer(const float DeltaSeconds)
 	SendAccumulatorSec += DeltaSeconds;
 	TimeSinceLastSendSec += DeltaSeconds;
 
-	const bool bMovingInput = !FMath::IsNearlyZero(PendingMoveForward) || !FMath::IsNearlyZero(PendingMoveRight);
+	// Movimento p/ efeitos de rate NAO e' so' o input (W/A/S/D): o CMC do dono
+	// continua desacelerando (braking) por ~0.3s depois de soltar a tecla. Se
+	// pararmos de enviar no rate rapido assim que o input zera, o servidor fica
+	// congelado na ultima `simpleVelCmS` alta e o proxy remoto extrapola ~1m alem
+	// (NewPos = Last.Pos + Last.Vel*ExtrapSec) ate o heartbeat corrigir -> overshoot
+	// + snap-back ("velocidade grande que demora a zerar" + jitter). Tratar a
+	// velocidade residual como movimento mantem o envio a InputSendRateHz ate o
+	// dono realmente parar, alimentando o proxy com a curva de desaceleracao.
+	const bool bHasInputAxis = !FMath::IsNearlyZero(PendingMoveForward) || !FMath::IsNearlyZero(PendingMoveRight);
+	const FVector OwnerVelNow = GetVelocity();
+	constexpr float kResidualSpeedSqCmS = 25.0f * 25.0f; // abaixo de 25 cm/s tratamos como parado
+	const bool bHasResidualVel = OwnerVelNow.SizeSquared() > kResidualSpeedSqCmS;
+	const bool bMovingInput = bHasInputAxis || bHasResidualVel;
 	const bool bJumpEvent = bPendingJumpPressed || bPendingJumpReleased;
 	const bool bRateReached = SendAccumulatorSec >= SendInterval;
 	const bool bHeartbeatReached = TimeSinceLastSendSec >= HeartbeatIntervalSec;
@@ -450,6 +616,23 @@ void AZeusCharacter::FlushInputAxisToServer(const float DeltaSeconds)
 	const bool bFallingChanged = (bIsFalling != bPreviousFalling);
 
 	const bool bShouldSend = bJumpEvent || bFallingChanged || (bMovingInput && bRateReached) || (!bMovingInput && bHeartbeatReached);
+	// DEBUG-INPUT (2026-06-12): log ~1x/s COM o PIE. Remover apos achar o gap.
+	{
+		static float DbgInputAcc = 0.0f;
+		DbgInputAcc += DeltaSeconds;
+		if (DbgInputAcc >= 1.0f)
+		{
+			DbgInputAcc = 0.0f;
+			const int32 PieId = (GetWorld() && GetWorld()->GetOutermost())
+				? GetWorld()->GetOutermost()->GetPIEInstanceID() : -1;
+			UE_LOG(LogZeusPlayer, Warning,
+				TEXT("[PIE%d][InputDbg] bV1=%d state=%d moving=%d rate=%d should=%d hbReached=%d fwd=%.2f right=%.2f"),
+				PieId, bV1 ? 1 : 0,
+				NetClient ? static_cast<int32>(NetClient->GetConnectionState()) : -99,
+				bMovingInput ? 1 : 0, bRateReached ? 1 : 0, bShouldSend ? 1 : 0,
+				bHeartbeatReached ? 1 : 0, PendingMoveForward, PendingMoveRight);
+		}
+	}
 	if (!bShouldSend)
 	{
 		return;
@@ -457,18 +640,55 @@ void AZeusCharacter::FlushInputAxisToServer(const float DeltaSeconds)
 
 	++InputSequence;
 	const int32 ClientTimeMs = static_cast<int32>(FPlatformTime::Seconds() * 1000.0);
-	// ADR 0040: yaw da camara/controller para que o servidor consiga rotar o
-	// input (referencial-camara) para velocidade mundial. Fallback para o yaw
-	// do actor se nao houver controller (e.g. tela de loading).
-	const float ViewYawDeg = (GetController()
-		? static_cast<float>(GetController()->GetControlRotation().Yaw)
-		: static_cast<float>(GetActorRotation().Yaw));
+	// YAW DO CORPO (nao da mira): GetActorRotation().Yaw reflete o orient-to-movement
+	// do CMC (bOrientRotationToMovement=true, RotationRate=(0,500,0)) -> o corpo vira
+	// pra direcao do MOVIMENTO (WASD), suave a 500 deg/s, e o MOUSE nao gira o corpo
+	// (bUseControllerRotationYaw=false). O servidor usa este yaw direto e o proxy nos
+	// outros clientes o replica -> o proxy vira IDENTICO ao corpo do dono.
+	//
+	// (Historico bug 2026-06-13: antes mandava GetControlRotation().Yaw -- a MIRA --
+	// e o servidor fazia atan2(vel) INSTANTANEO quando movia (proxy "virava demais"
+	// 45 graus) e usava a mira quando parado (proxy seguia o mouse). ADR 0040: o
+	// servidor NAO rotaciona mais o input por este yaw (ADR 0041 manda pos+vel
+	// mundiais), entao trocar a mira pelo corpo e' seguro. Quando precisar da MIRA
+	// real (aim/combate), adicionar um campo aimYawDeg dedicado -- nao reusar este.)
+	const float BodyYawDeg = static_cast<float>(GetActorRotation().Yaw);
 	// ADR 0041: cliente autoritativo da posicao XYZ + velocidade XY. O CMC ja
 	// integrou o input local antes deste flush, portanto `GetActorLocation` e
 	// `GetVelocity` reflectem o estado real que o servidor deve replicar para
 	// os outros clientes (sujeito ao clamp anti-cheat).
 	const FVector PosCm = GetActorLocation();
 	const FVector Vel = GetVelocity();
+	if (bV1)
+	{
+		// Sistema novo: INPUT 6077 com a pose absoluta (ADR 0040/0041).
+		const bool bSent = NetClient->EmitInput(
+			PendingMoveForward,
+			PendingMoveRight,
+			bPendingJumpPressed,
+			bPendingJumpReleased,
+			InputSequence,
+			ClientTimeMs,
+			BodyYawDeg,
+			PosCm,
+			FVector2D(Vel.X, Vel.Y),
+			bIsFalling,
+			static_cast<float>(Vel.Z));
+		// DEBUG-INPUT (2026-06-12): confirma chamada + retorno do SendPacket.
+		static float DbgEmitAcc = 0.0f;
+		DbgEmitAcc += DeltaSeconds;
+		if (DbgEmitAcc >= 1.0f)
+		{
+			DbgEmitAcc = 0.0f;
+			const int32 PieId = (GetWorld() && GetWorld()->GetOutermost())
+				? GetWorld()->GetOutermost()->GetPIEInstanceID() : -1;
+			UE_LOG(LogZeusPlayer, Warning,
+				TEXT("[PIE%d][InputDbg] EmitInput seq=%d sent=%d pos=%s"),
+				PieId, InputSequence, bSent ? 1 : 0, *PosCm.ToString());
+		}
+	}
+	else if (ZeusNetwork)
+	{
 		ZeusNetwork->SendInputAxis(
 			PendingMoveForward,
 			PendingMoveRight,
@@ -476,11 +696,12 @@ void AZeusCharacter::FlushInputAxisToServer(const float DeltaSeconds)
 			bPendingJumpReleased,
 			InputSequence,
 			ClientTimeMs,
-		ViewYawDeg,
+			BodyYawDeg,
 			PosCm,
 			FVector2D(Vel.X, Vel.Y),
 			bIsFalling,
 			static_cast<float>(Vel.Z));
+	}
 
 	SendAccumulatorSec = 0.0f;
 	TimeSinceLastSendSec = 0.0f;

Source/ZMMO/Game/Entity/ZeusCharacter.h

@@ -11,6 +11,9 @@ class USpringArmComponent;
 class UCameraComponent;
 class UInputAction;
 class UZeusNetworkSubsystem;
+class UZeusNetworkingClientSubsystem;
+class UZeusAOIComponent;
+class UUserWidget;
 struct FInputActionValue;
 
 DECLARE_LOG_CATEGORY_EXTERN(LogZeusPlayer, Log, All);
@@ -46,6 +49,10 @@ class ZMMO_API AZeusCharacter : public ACharacter, public IZeusEntityInterface
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess = "true"))
 	UCameraComponent* FollowCamera;
 
+	/** AOI do cliente (+ overlays de debug dirigidos pelo Zeus Admin Tools). */
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Zeus|AOI", meta = (AllowPrivateAccess = "true"))
+	TObjectPtr<UZeusAOIComponent> AOIComponent;
+
 	// GAS Component vive no PlayerState (AZeusPlayerState + Component Registry).
 	// Acesso: GetPlayerState<AZeusPlayerState>()->GetZeusComponent<UZeusGASComponent>().
 
@@ -62,6 +69,16 @@ protected:
 	UPROPERTY(EditAnywhere, Category = "Input")
 	UInputAction* MouseLookAction;
 
+	/// IA_Dash — dispara C_ABILITY_TRY_ACTIVATE pra Zeus.Ability.Movement.Dash
+	/// via UZeusGASComponent. Bind padrao no IMC_Default: LeftShift -> Pressed.
+	UPROPERTY(EditAnywhere, Category = "Input")
+	UInputAction* DashAction;
+
+	/** Painel Zeus Admin Tools (AIO Debug), aberto/fechado por F8. Default =
+	 *  WBP_AdminToolsAIO (resolvido no construtor). */
+	UPROPERTY(EditAnywhere, Category = "Zeus|Admin")
+	TSubclassOf<UUserWidget> AdminPanelClass;
+
 	/** Cadencia de envio dos pacotes `C_INPUT_AXIS` (Hz). */
 	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Zeus|Networking", meta = (ClampMin = "1", ClampMax = "120"))
 	int32 InputSendRateHz = 30;
@@ -104,6 +121,14 @@ protected:
 	void OnJumpPressed();
 	void OnJumpReleased();
 
+	/// IA_Dash Triggered -> resolve UZeusGASComponent do PlayerState e chama
+	/// RequestActivateAbilityByTag("Zeus.Ability.Movement.Dash"). Server valida
+	/// + responde S_ABILITY_ACTIVATED (HP/SP atualizado, montage roda local).
+	void OnDashTriggered();
+
+	/** F8: cria/mostra ou esconde o painel Zeus Admin Tools (input mode UI + cursor). */
+	void ToggleAdminPanel();
+
 public:
 	/** Wrappers expostos a Blueprint (UI / mobile / automation). */
 	UFUNCTION(BlueprintCallable, Category = "Input")
@@ -140,6 +165,11 @@ private:
 	UFUNCTION()
 	void HandleZeusPlayerSpawned(int64 InEntityId, bool bIsLocal, FVector PosCm, float YawDeg, int64 ServerTimeMs);
 
+	// Self-entity do sistema de rede novo (ENT_SELF): o cliente aprende o
+	// proprio entityId. Substitui o caminho legacy OnPlayerSpawned(bIsLocal=true).
+	UFUNCTION()
+	void HandleSelfEntityAssigned(int64 InEntityId);
+
 	UFUNCTION()
 	void HandleZeusCharInfo(int64 InEntityId, const FString& CharName, const FString& GuildName);
 
@@ -148,6 +178,14 @@ private:
 	UPROPERTY()
 	TObjectPtr<UZeusNetworkSubsystem> ZeusNetwork;
 
+	// Sistema de rede novo (canonico): fonte do self-entity (ENT_SELF).
+	UPROPERTY()
+	TObjectPtr<UZeusNetworkingClientSubsystem> NetClient;
+
+	/** Instancia viva do painel admin (criada lazy no primeiro F8). */
+	UPROPERTY(Transient)
+	TObjectPtr<UUserWidget> AdminPanelInstance;
+
 	bool bSpawnDelegateBound = false;
 
 	/** Identidade autoritativa atribuida quando o servidor envia S_SPAWN_PLAYER local. */

Source/ZMMO/Game/Entity/ZeusPlayerProxy.cpp

@@ -132,11 +132,18 @@ void AZeusPlayerProxy::Tick(const float DeltaSeconds)
 		// conhecida, clampada por `MaxExtrapolationSeconds` para nao deixar
 		// o proxy fugir se a rede ficar muda.
 		const FZeusProxySnapshot& Last = SnapshotBuffer.Last();
-		const float ExtrapSec = FMath::Clamp(
-			static_cast<float>(RenderMs - Last.ServerTimeMs) / 1000.0f,
-			0.0f, MaxExtrapolationSeconds);
+		const float RawExtrapSec =
+			static_cast<float>(RenderMs - Last.ServerTimeMs) / 1000.0f;
+		const float ExtrapSec = FMath::Clamp(RawExtrapSec, 0.0f, MaxExtrapolationSeconds);
 		NewPos = Last.PosCm + Last.VelCmS * ExtrapSec;
-		NewVel = Last.VelCmS;
+		// STARVATION (buffer=1 por muito tempo -- ex: 1o login sem DELTA_BATCH por
+		// segundos): a extrapolacao satura no clamp e a POSE congela, mas manter a
+		// velocidade faz o AnimBP rodar locomocao PARADO ("andar no lugar"/moonwalk
+		// = o "jitter" reportado). Se ja passamos bem do clamp, zera a vel visual
+		// pra o proxy ir pra Idle ate' os deltas voltarem (em vez de animar
+		// andando travado). Quando os deltas chegam, o ramo de interpolacao retoma.
+		const bool bStarved = RawExtrapSec > (MaxExtrapolationSeconds + 0.15f);
+		NewVel = bStarved ? FVector::ZeroVector : Last.VelCmS;
 		bExtrapolating = ExtrapSec > KINDA_SMALL_NUMBER;
 	}
 	else
@@ -150,12 +157,32 @@ void AZeusPlayerProxy::Tick(const float DeltaSeconds)
 		NewVel = FMath::Lerp(A.VelCmS, B.VelCmS, InterpAlpha);
 	}
 
-	// Yaw deriva da velocidade interpolada: locomotion mantem face na direcao
-	// do movimento; em idle preserva o yaw atual para nao "snappar".
+	// ORIENTACAO DO CORPO = REPLICA do yaw autoritativo do servidor (Snapshot.YawDeg),
+	// interpolado shortest-path entre os MESMOS A/B da posicao. Esse yaw agora carrega
+	// o yaw do CORPO do dono (orient-to-movement do CMC: vira pra direcao do MOVIMENTO
+	// /WASD, suave a 500 deg/s; parado mantem; o MOUSE nao gira o corpo) -- o cliente
+	// dono manda GetActorRotation().Yaw e o servidor repassa direto. Por isso o proxy
+	// so' REPLICA: vira identico ao corpo do dono, sem re-derivar nada.
+	//
+	// NAO derivamos de Atan2(velocidade): isso era a fonte do bug 2026-06-13 ("virava
+	// demais 45 graus") -- a direcao da velocidade salta, o yaw do corpo nao. A
+	// suavizacao correta ja' aconteceu no CMC do dono; aqui so' interpolamos amostras.
+	//
+	// FUTURO -- Motion Matching/aim: quando "a mira dita a locomocao" (strafe/aim
+	// offset), o servidor passara a mandar um aimYawDeg separado e o AnimBP usara a
+	// velocidade relativa a este yaw pra escolher fwd/back/left/right. Por ORA, 1 yaw.
 	FRotator NewRot = GetActorRotation();
-	if (FVector(NewVel.X, NewVel.Y, 0.0f).SizeSquared() > 1.0f)
+	if (IdxB == INDEX_NONE)
 	{
-		NewRot.Yaw = FMath::RadiansToDegrees(FMath::Atan2(NewVel.Y, NewVel.X));
+		NewRot.Yaw = SnapshotBuffer.Last().YawDeg; // extrapolando: segura o ultimo yaw
+	}
+	else
+	{
+		const float YawA = SnapshotBuffer[IdxB - 1].YawDeg;
+		const float YawB = SnapshotBuffer[IdxB].YawDeg;
+		// FindDeltaAngleDegrees -> menor arco (-180..180); evita girar "o lado longo".
+		const float DeltaYaw = FMath::FindDeltaAngleDegrees(YawA, YawB);
+		NewRot.Yaw = YawA + DeltaYaw * InterpAlpha;
 	}
 	NewRot.Pitch = 0.0f;
 	NewRot.Roll  = 0.0f;
@@ -207,10 +234,26 @@ void AZeusPlayerProxy::Tick(const float DeltaSeconds)
 		LastDiagLogSec = NowSec;
 		const int64 NewestMs = SnapshotBuffer.Last().ServerTimeMs;
 		const int64 RenderLagMs = ServerNowMs - NewestMs;
-		UE_LOG(LogZMMO, Verbose,
-			TEXT("ZeusPlayerProxy[%lld] buffer=%d renderLagMs=%lld interpAlpha=%.2f extrap=%d delayMs=%.0f"),
-			EntityId, SnapshotBuffer.Num(), RenderLagMs, InterpAlpha,
-			bExtrapolating ? 1 : 0, InterpolationDelayMs);
+		// === DIAG PERMANENTE -- jitter por FOME DE DELTAS ========================
+		// Bug investigado/resolvido 2026-06-13 (ver memoria
+		// project_proxy_delta_starvation_jitter). Este Warning FICA DE PROPOSITO
+		// (decisao do dono: NAO rebaixar p/ Verbose nem remover) -- e' a sonda pra
+		// cacar regressao do jitter de proxy. Como ler:
+		//   secsSinceSnap = ha quanto tempo o proxy NAO recebe snapshot. Sobe = FOME
+		//     (player remoto parado -> ComputeDelta suprime no server -> sem DELTA_BATCH).
+		//   newestMs = serverTimeMs do ultimo snapshot; CONGELA na fome (deveria avancar).
+		//   renderLagMs = ServerNowMs - newestMs; cresce 1:1 com o wall-clock na fome.
+		//   speed=0 na fome = a mitigacao (zera a vel visual -> Idle, sem "moonwalk") agindo.
+		//   Ao o player voltar a se mover sai "buffer STALE ... reset+reseed" (anti-stale)
+		//   e renderLagMs/secsSinceSnap voltam a ~0 (snap limpo, sem salto/jitter).
+		// =========================================================================
+		const double SecsSinceSnap =
+			(LastSnapshotRecvSec > 0.0) ? (NowSec - LastSnapshotRecvSec) : -1.0;
+		UE_LOG(LogZMMO, Warning,
+			TEXT("ZeusPlayerProxy[%lld] buffer=%d renderLagMs=%lld newestMs=%lld secsSinceSnap=%.1f interpAlpha=%.2f extrap=%d speed=%.0f"),
+			EntityId, SnapshotBuffer.Num(), RenderLagMs, NewestMs, SecsSinceSnap, InterpAlpha,
+			bExtrapolating ? 1 : 0,
+			FVector(VisualVelocity.X, VisualVelocity.Y, 0.0f).Size());
 	}
 }
 
@@ -222,18 +265,65 @@ void AZeusPlayerProxy::SetZeusIdentity(const int64 InEntityId, const EZeusEntity
 
 void AZeusPlayerProxy::ApplyEntitySnapshot(const FZeusEntitySnapshot& Snapshot)
 {
-	// Estabiliza o offset de relogio na primeira amostra. Subsequente nao
-	// re-sincroniza para evitar saltos visuais; um esquema mais sofisticado
-	// (ema do offset) cabe quando tivermos ping/RTT estabilizado por sessao.
+	LastSnapshotRecvSec = FPlatformTime::Seconds(); // DIAG: marca chegada (mede a fome no Tick)
+
+	// 2026-06-06 H3 fix — disciplina o ServerClockOffsetMs via EMA com clamp.
+	// Antes: offset congelado na 1a amostra. Em cross-server handoff a fonte
+	// do ServerTimeMs muda (publisher antigo -> novo) e o offset fica
+	// permanentemente skewed, alimentando tremor pos-handoff e drift cumulativo
+	// de clock cliente vs server. Agora cada amostra recalcula candidato e
+	// suaviza (alpha=0.02, ~50 amostras pra convergir) com clamp max 2ms/snapshot
+	// pra evitar salto visual durante transicao.
+	const int64 LocalNowMs = static_cast<int64>(FPlatformTime::Seconds() * 1000.0);
+	const int64 OffsetCandidate = LocalNowMs - Snapshot.ServerTimeMs;
+
+	// Anti-stale (2026-06-13): se este snapshot esta MUITO a frente do mais novo
+	// do buffer, o proxy ficou "mudo" por segundos -- player remoto parado ->
+	// ComputeDelta suprime -> sem DELTA_BATCH novo -> renderLagMs disparou pra
+	// dezenas de segundos. Manter os snapshots velhos faz a interpolacao usar um
+	// span gigante (pose de ~100s atras -> agora) quando o player volta a se mover,
+	// causando rasteio/salto (o jitter reportado). Descarta o buffer obsoleto +
+	// re-bootstrapa o relogio pra a interpolacao recomecar limpa neste keyframe.
+	if (SnapshotBuffer.Num() > 0
+		&& (Snapshot.ServerTimeMs - SnapshotBuffer.Last().ServerTimeMs) > 1000)
+	{
+		UE_LOG(LogZMMO, Warning,
+			TEXT("ZeusPlayerProxy[%lld] buffer STALE gap=%lldms -> reset+reseed"),
+			EntityId, Snapshot.ServerTimeMs - SnapshotBuffer.Last().ServerTimeMs);
+		SnapshotBuffer.Reset();
+		ServerClockOffsetMs = OffsetCandidate;
+	}
+
 	if (SnapshotBuffer.Num() == 0)
 	{
-		const int64 LocalNowMs = static_cast<int64>(FPlatformTime::Seconds() * 1000.0);
-		ServerClockOffsetMs = LocalNowMs - Snapshot.ServerTimeMs;
+		// Primeira amostra: bootstrap direto (nao tem baseline pra suavizar).
+		ServerClockOffsetMs = OffsetCandidate;
+		// DIAG (jitter 1o login): confirma o seed do relogio. serverTimeMs deve ser
+		// != 0 e o offset razoavel; se vier 0 aqui, o keyframe/catch-up corrompeu o
+		// bootstrap (hipotese descartada, mas o log fecha a questao em campo).
+		UE_LOG(LogZMMO, Warning,
+			TEXT("ZeusPlayerProxy[%lld] SEED clock serverTimeMs=%lld localNowMs=%lld offset=%lld"),
+			EntityId, Snapshot.ServerTimeMs, LocalNowMs, ServerClockOffsetMs);
+	}
+	else
+	{
+		const double Alpha = 0.02;
+		const int64 RawTarget = static_cast<int64>(
+			static_cast<double>(ServerClockOffsetMs) * (1.0 - Alpha)
+			+ static_cast<double>(OffsetCandidate) * Alpha);
+		// Clamp max 2ms por amostra — em 30Hz isso converge a 60ms/s, mais que
+		// o suficiente pra absorver drift normal sem causar tremor visual.
+		const int64 Delta = RawTarget - ServerClockOffsetMs;
+		const int64 ClampedDelta = (Delta > 2)  ? 2
+		                          : (Delta < -2) ? -2
+		                          : Delta;
+		ServerClockOffsetMs += ClampedDelta;
 	}
 
 	FZeusProxySnapshot S;
 	S.PosCm = Snapshot.PositionCm;
 	S.VelCmS = Snapshot.VelocityCmS;
+	S.YawDeg = Snapshot.YawDeg; // yaw do CORPO do dono (orient-to-movement; mouse nao gira)
 	S.bGrounded = Snapshot.bGrounded;
 	S.ServerTimeMs = Snapshot.ServerTimeMs;
 

Source/ZMMO/Game/Entity/ZeusPlayerProxy.h

@@ -42,6 +42,15 @@ struct FZeusProxySnapshot
 	UPROPERTY()
 	FVector VelCmS = FVector::ZeroVector;
 
+	/** Yaw autoritativo do servidor (graus) = o MESMO yaw que o player LOCAL aplicou
+	 *  ao virar. O proxy replica EXATAMENTE a viradinha do local (apertou D = mesma
+	 *  virada nos dois). Sem armazenar isto, o proxy derivava o yaw da velocidade
+	 *  (Atan2) e "virava totalmente pra direcao do movimento" (bug 2026-06-13).
+	 *  NAO confundir com "mira dita a locomocao" (strafe / Motion Matching) -- isso
+	 *  esta' DESABILITADO por ora (ver AVISO em ZeusPlayerProxy.cpp::Tick). */
+	UPROPERTY()
+	float YawDeg = 0.0f;
+
 	UPROPERTY()
 	bool bGrounded = true;
 
@@ -140,6 +149,12 @@ protected:
 	 */
 	int64 ServerClockOffsetMs = 0;
 
+	/** DIAG (2026-06-13): instante (s, monotonic) do ultimo snapshot recebido em
+	 *  ApplyEntitySnapshot. Usado no log do Tick pra medir "secsSinceSnap" = quanto
+	 *  tempo o proxy ficou MUDO (sem delta). secsSinceSnap grande == fome (player
+	 *  remoto parado -> ComputeDelta suprime). 0 = nenhum snapshot ainda. */
+	double LastSnapshotRecvSec = 0.0;
+
 	/** Aceleracao derivada (com smoothing) escrita no CMC custom para alimentar
 	 *  o AnimBP (`ShouldMove`/`Jump_Start` exigem Acceleration!=0). */
 	FVector LastDerivedAccelerationCmS2 = FVector::ZeroVector;

Source/ZMMO/Game/Modes/ZeusPlayerState.cpp

@@ -1,9 +1,13 @@
 #include "ZeusPlayerState.h"
 
+#include "AbilitySystemComponent.h"
 #include "Components/ActorComponent.h"
 #include "Misc/ConfigCacheIni.h"
 #include "Net/UnrealNetwork.h"
 #include "ZMMO.h"
+#include "ZeusAbilitySystemComponent.h"
+#include "ZeusAttributeSet.h"
+#include "ZeusGASComponent.h"
 
 AZeusPlayerState::AZeusPlayerState()
 {
@@ -98,3 +102,32 @@ void AZeusPlayerState::SetCharInfo(const FString& InCharName, const FString& InG
 	CharName = InCharName;
 	GuildName = InGuildName;
 }
+
+UAbilitySystemComponent* AZeusPlayerState::GetAbilitySystemComponent() const
+{
+	// ASC vive como subobject do UZeusGASComponent (que esta no Component
+	// Registry). UE5 GAS nodes BP ("Get Ability System Component", "Apply
+	// Gameplay Effect To Target", etc.) chamam isto via IAbilitySystemInterface.
+	// O retorno e o ponteiro upcastado pra UAbilitySystemComponent (base) —
+	// mas em runtime e' UZeusAbilitySystemComponent (cast tipado via
+	// GetZeusAbilitySystemComponent abaixo).
+	return GetZeusAbilitySystemComponent();
+}
+
+UZeusAbilitySystemComponent* AZeusPlayerState::GetZeusAbilitySystemComponent() const
+{
+	if (UZeusGASComponent* GAS = GetZeusComponent<UZeusGASComponent>())
+	{
+		return GAS->AbilitySystemComponent.Get();
+	}
+	return nullptr;
+}
+
+UZeusAttributeSet* AZeusPlayerState::GetZeusAttributeSet() const
+{
+	if (UZeusGASComponent* GAS = GetZeusComponent<UZeusGASComponent>())
+	{
+		return GAS->AttributeSet.Get();
+	}
+	return nullptr;
+}

Source/ZMMO/Game/Modes/ZeusPlayerState.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "AbilitySystemInterface.h"
 #include "CoreMinimal.h"
 #include "GameFramework/PlayerState.h"
 #include "Templates/SubclassOf.h"
@@ -7,6 +8,8 @@
 
 class FLifetimeProperty;
 class UActorComponent;
+class UZeusAbilitySystemComponent;
+class UZeusAttributeSet;
 
 /**
  *  PlayerState do MMO. Pattern UE5 idiomatico: o GameMode atribui
@@ -45,13 +48,36 @@ class UActorComponent;
  *  ou o helper `GetZeusComponent<T>()`.
  */
 UCLASS(Config = Game, BlueprintType)
-class ZMMO_API AZeusPlayerState : public APlayerState
+class ZMMO_API AZeusPlayerState : public APlayerState, public IAbilitySystemInterface
 {
 	GENERATED_BODY()
 
 public:
 	AZeusPlayerState();
 
+	// === IAbilitySystemInterface (UE5 GAS) ===
+	//
+	// Padrao Lyra: PlayerState implementa a interface; o ASC vive como
+	// subobject do UZeusGASComponent (Component Registry). Isso permite que
+	// qualquer Actor que receba este PlayerState resolva o ASC via cast
+	// pra IAbilitySystemInterface OU via node BP "Get Ability System
+	// Component" (que faz o mesmo internamente).
+	//
+	// Acesso BP: "Get Ability System Component" + pin do PlayerState.
+	// Acesso C++: `Cast<IAbilitySystemInterface>(PlayerState)->GetAbilitySystemComponent()`.
+	virtual UAbilitySystemComponent* GetAbilitySystemComponent() const override;
+
+	/// Versao tipada do ASC custom — retorna direto UZeusAbilitySystemComponent
+	/// (os 12 overrides que falam com o servidor custom via opcodes ZeusNetwork).
+	/// Prefira este sobre o getter da interface no BP — evita cast + expoe a API
+	/// do ASC custom (RequestActivateAbility, etc.).
+	UFUNCTION(BlueprintPure, Category = "Zeus|GAS")
+	UZeusAbilitySystemComponent* GetZeusAbilitySystemComponent() const;
+
+	/// Helper BP-friendly pro AttributeSet tipado (template C++ nao expoe pra BP).
+	UFUNCTION(BlueprintPure, Category = "Zeus|GAS")
+	UZeusAttributeSet* GetZeusAttributeSet() const;
+
 	// === Identidade publica ===
 	//
 	// Todos os campos publicos sao Replicated — hoje o cliente UE5 roda em

Source/ZMMO/Game/Network/ZeusAOIComponent.cpp

@@ -0,0 +1,346 @@
+// Copyright Zeus Server Engine. All rights reserved.
+
+#include "ZeusAOIComponent.h"
+
+#include "ZeusNetworkingClientSubsystem.h" // V1 canonico: OnDebugAoiInfo (6161) + EmitDebugAoiRequest (6160)
+#include "ZeusFrontierOverlayActor.h"      // ator que desenha as paredes de fronteira
+#include "ZMMONetLog.h"           // Batch 2.5: LogZeusAOI (categoria do modulo ZMMO)
+
+#include "DrawDebugHelpers.h"
+#include "Engine/GameInstance.h"
+#include "Engine/World.h"
+#include "GameFramework/Actor.h"
+
+// Console vars — espelham as flags do painel (overlay liga se flag OU CVar).
+static TAutoConsoleVariable<int32> CVarShowAOI(
+	TEXT("zeus.debug.aoi"), 0, TEXT("Desenha a Zona de Interesse (esfera do raio AOI)."), ECVF_Default);
+static TAutoConsoleVariable<int32> CVarShowDespawn(
+	TEXT("zeus.debug.despawn"), 0, TEXT("Desenha a Zona de Despawn (esfera externa do AOI)."), ECVF_Default);
+static TAutoConsoleVariable<int32> CVarShowCell(
+	TEXT("zeus.debug.cell"), 0, TEXT("Desenha os bounds da celula (placeholder)."), ECVF_Default);
+static TAutoConsoleVariable<int32> CVarShowProxy(
+	TEXT("zeus.debug.proxy"), 0, TEXT("Desenha labels de proxy (TODO)."), ECVF_Default);
+static TAutoConsoleVariable<int32> CVarShowHandoff(
+	TEXT("zeus.debug.handoff"), 0, TEXT("Desenha a linha de handoff (placeholder)."), ECVF_Default);
+static TAutoConsoleVariable<int32> CVarShowDrift(
+	TEXT("zeus.debug.drift"), 0, TEXT("Desenha o drift autoritativo (TODO)."), ECVF_Default);
+static TAutoConsoleVariable<int32> CVarShowFrontier(
+	TEXT("zeus.debug.frontier"), 0, TEXT("Desenha as paredes das fronteiras do mesh (own<->neighbor)."), ECVF_Default);
+
+namespace
+{
+	const FColor kColorInterest(93, 213, 255);  // cyan — Zona de Interesse
+	const FColor kColorDespawn(255, 140, 90);   // laranja — Zona de Despawn (externa)
+	const FColor kColorCell(232, 192, 96);
+	const FColor kColorHandoff(255, 155, 190);
+
+	// Resolucao das esferas de overlay. 32 segments deixavam a "bolha" facetada
+	// (poucas linhas) num raio de 60-80m; 48 deixa o circulo bem mais denso/legivel.
+	constexpr int32 kSphereSegments = 48;
+	// Clamp visual defensivo: se o raio vier absurdo (config corrompida), nao desenha
+	// uma esfera gigante que engole o mapa. 500m cobre qualquer AOI real (max=800m,
+	// mas overlay > 500m ja' nao ajuda a leitura). So' afeta o desenho, nao o gameplay.
+	constexpr float kMaxOverlayRadiusCm = 50000.0f;
+}
+
+UZeusAOIComponent::UZeusAOIComponent()
+{
+	PrimaryComponentTick.bCanEverTick = true;
+	PrimaryComponentTick.bStartWithTickEnabled = true;
+	SetIsReplicatedByDefault(false); // debug/cliente; gameplay AOI real entra depois
+}
+
+void UZeusAOIComponent::BeginPlay()
+{
+	Super::BeginPlay();
+
+	// Bind do feed de config de AOI (servidor -> cliente) pelo transporte V1
+	// canonico. O legacy (UZeusNetworkSubsystem) esta desativado no V1 -> usava
+	// SendDebugAoiRequest que logava "ignorado: nao conectado" e o overlay nunca
+	// recebia a config. Agora via UZeusNetworkingClientSubsystem (OnDebugAoiInfo 6161).
+	if (UWorld* World = GetWorld())
+	{
+		if (UGameInstance* GI = World->GetGameInstance())
+		{
+			if (UZeusNetworkingClientSubsystem* NetC = GI->GetSubsystem<UZeusNetworkingClientSubsystem>())
+			{
+				AoiConfigHandle_ = NetC->OnDebugAoiInfo.AddUObject(this, &UZeusAOIComponent::HandleAoiConfig);
+					FrontierConfigHandle_ = NetC->OnDebugFrontierInfo.AddUObject(this, &UZeusAOIComponent::HandleFrontierConfig);
+			}
+		}
+	}
+
+	// Best-effort: ja' pede a config (no-op se ainda nao conectado — o request
+	// e' re-disparado ao ligar um overlay em SetOverlayEnabled).
+	RequestAoiConfig();
+}
+
+void UZeusAOIComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+	if (AoiConfigHandle_.IsValid() || FrontierConfigHandle_.IsValid())
+	{
+		if (UWorld* World = GetWorld())
+		{
+			if (UGameInstance* GI = World->GetGameInstance())
+			{
+				if (UZeusNetworkingClientSubsystem* NetC = GI->GetSubsystem<UZeusNetworkingClientSubsystem>())
+				{
+					if (AoiConfigHandle_.IsValid())      { NetC->OnDebugAoiInfo.Remove(AoiConfigHandle_); }
+					if (FrontierConfigHandle_.IsValid()) { NetC->OnDebugFrontierInfo.Remove(FrontierConfigHandle_); }
+				}
+			}
+		}
+		AoiConfigHandle_.Reset();
+		FrontierConfigHandle_.Reset();
+	}
+	if (FrontierActor_)
+	{
+		FrontierActor_->Destroy();
+		FrontierActor_ = nullptr;
+	}
+	Super::EndPlay(EndPlayReason);
+}
+
+void UZeusAOIComponent::TickComponent(float DeltaTime, ELevelTick TickType,
+                                      FActorComponentTickFunction* ThisTickFunction)
+{
+	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
+
+	// Frontier: sincroniza o overlay com o estado atual. Pega o liga/desliga via
+	// CVar zeus.debug.frontier (que nao passa por SetOverlayEnabled) e garante que
+	// ao desligar as paredes sejam REMOVIDAS (UpdateFrontierOverlay -> ClearOverlay).
+	if (ResolveOverlay(EZeusAOIOverlay::FrontierCells) != bFrontierApplied_)
+	{
+		UpdateFrontierOverlay();
+	}
+
+	// Re-pede o frontier periodicamente enquanto ligado -> o overlay reflete
+	// split/merge da topologia dinamica (debug client-side, baixa freq, so' ON).
+	if (ResolveOverlay(EZeusAOIOverlay::FrontierCells))
+	{
+		FrontierRepollAccumSec_ += DeltaTime;
+		if (FrontierRepollAccumSec_ >= FrontierRepollIntervalSec)
+		{
+			FrontierRepollAccumSec_ = 0.0f;
+			RequestFrontierConfig();
+		}
+	}
+
+	if (AnyOverlayActive())
+	{
+		DrawOverlays();
+	}
+}
+
+void UZeusAOIComponent::RequestAoiConfig()
+{
+	if (UWorld* World = GetWorld())
+	{
+		if (UGameInstance* GI = World->GetGameInstance())
+		{
+			if (UZeusNetworkingClientSubsystem* NetC = GI->GetSubsystem<UZeusNetworkingClientSubsystem>())
+			{
+				NetC->EmitDebugAoiRequest(); // V1: no-op se ainda nao Accepted
+			}
+		}
+	}
+}
+
+void UZeusAOIComponent::HandleAoiConfig(float InterestCm, float DespawnCm)
+{
+	InterestRadiusCm = InterestCm;
+	DespawnRadiusCm  = DespawnCm;
+	// K4: log AOI cfg recebido do server (paridade com Net.AOI server-side
+	// "config_applied ZI=... ZD=..."). Cold path (1 por sessao).
+	UE_LOG(LogZeusAOI, Display,
+		TEXT("AOI cfg recv interestCm=%.0f (%.0fm) despawnCm=%.0f (%.0fm)"),
+		InterestCm, InterestCm / 100.0f,
+		DespawnCm, DespawnCm / 100.0f);
+}
+
+void UZeusAOIComponent::RequestFrontierConfig()
+{
+	if (UWorld* World = GetWorld())
+	{
+		if (UGameInstance* GI = World->GetGameInstance())
+		{
+			if (UZeusNetworkingClientSubsystem* NetC = GI->GetSubsystem<UZeusNetworkingClientSubsystem>())
+			{
+				NetC->EmitDebugFrontierRequest(); // V1: no-op se ainda nao Accepted
+			}
+		}
+	}
+}
+
+void UZeusAOIComponent::HandleFrontierConfig(const ZeusV1::FDebugFrontierInfo& Info)
+{
+	FrontierInfo_ = Info;
+	bFrontierReceived_ = true;
+	UE_LOG(LogZeusAOI, Display,
+		TEXT("Frontier cfg recv own=%d neighbors=%d"),
+		Info.OwnedCells.Num(), Info.NeighborCells.Num());
+	UpdateFrontierOverlay();
+}
+
+AZeusFrontierOverlayActor* UZeusAOIComponent::EnsureFrontierActor()
+{
+	if (FrontierActor_) { return FrontierActor_; }
+	UWorld* World = GetWorld();
+	if (!World) { return nullptr; }
+	FActorSpawnParameters Params;
+	Params.Owner = GetOwner();
+	Params.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
+	FrontierActor_ = World->SpawnActor<AZeusFrontierOverlayActor>(
+		AZeusFrontierOverlayActor::StaticClass(), FVector::ZeroVector, FRotator::ZeroRotator, Params);
+	return FrontierActor_;
+}
+
+void UZeusAOIComponent::UpdateFrontierOverlay()
+{
+	const bool bOn = ResolveOverlay(EZeusAOIOverlay::FrontierCells);
+	bFrontierApplied_ = bOn;
+	if (!bOn)
+	{
+		if (FrontierActor_) { FrontierActor_->ClearOverlay(); }
+		return;
+	}
+	if (!bFrontierReceived_)
+	{
+		// Ainda nao temos as cells; pede e espera o 6163 (HandleFrontierConfig re-chama).
+		RequestFrontierConfig();
+		return;
+	}
+	AZeusFrontierOverlayActor* Actor = EnsureFrontierActor();
+	if (!Actor) { return; }
+	const float AnchorZ = GetOwner() ? GetOwner()->GetActorLocation().Z : 0.0f;
+	Actor->RebuildFromFrontier(FrontierInfo_, AnchorZ);
+}
+
+bool UZeusAOIComponent::ResolveOverlay(EZeusAOIOverlay Overlay) const
+{
+	switch (Overlay)
+	{
+	case EZeusAOIOverlay::AOIRadius:   return bShowAOIRadius    || CVarShowAOI.GetValueOnGameThread()     > 0;
+	case EZeusAOIOverlay::DespawnZone: return bShowDespawnZone  || CVarShowDespawn.GetValueOnGameThread() > 0;
+	case EZeusAOIOverlay::CellBounds:  return bShowCellBounds   || CVarShowCell.GetValueOnGameThread()    > 0;
+	case EZeusAOIOverlay::ProxyLabels: return bShowProxyLabels  || CVarShowProxy.GetValueOnGameThread()   > 0;
+	case EZeusAOIOverlay::HandoffLine: return bShowHandoffLine  || CVarShowHandoff.GetValueOnGameThread() > 0;
+	case EZeusAOIOverlay::AuthDrift:   return bShowAuthDrift    || CVarShowDrift.GetValueOnGameThread()   > 0;
+	case EZeusAOIOverlay::FrontierCells: return bShowFrontier  || CVarShowFrontier.GetValueOnGameThread() > 0;
+	default: return false;
+	}
+}
+
+bool UZeusAOIComponent::AnyOverlayActive() const
+{
+	return ResolveOverlay(EZeusAOIOverlay::AOIRadius)
+		|| ResolveOverlay(EZeusAOIOverlay::DespawnZone)
+		|| ResolveOverlay(EZeusAOIOverlay::CellBounds)
+		|| ResolveOverlay(EZeusAOIOverlay::ProxyLabels)
+		|| ResolveOverlay(EZeusAOIOverlay::HandoffLine)
+		|| ResolveOverlay(EZeusAOIOverlay::AuthDrift)
+		|| ResolveOverlay(EZeusAOIOverlay::FrontierCells);
+}
+
+void UZeusAOIComponent::DrawOverlays()
+{
+	const AActor* Owner = GetOwner();
+	UWorld* World = GetWorld();
+	if (!Owner || !World) { return; }
+
+	const FVector Loc = Owner->GetActorLocation();
+
+	// Zona de Interesse (interna) — raio real do servidor. Sem o raio (==0),
+	// ainda nao chegou a config: nao desenha (loading).
+	if (ResolveOverlay(EZeusAOIOverlay::AOIRadius) && InterestRadiusCm > 0.0f)
+	{
+		const float R = FMath::Min(InterestRadiusCm, kMaxOverlayRadiusCm);
+		DrawDebugSphere(World, Loc, R, kSphereSegments, kColorInterest, false, -1.0f, 0, LineThickness);
+	}
+	// Zona de Despawn (externa, > interesse = histerese) — raio real do servidor.
+	if (ResolveOverlay(EZeusAOIOverlay::DespawnZone) && DespawnRadiusCm > 0.0f)
+	{
+		const float R = FMath::Min(DespawnRadiusCm, kMaxOverlayRadiusCm);
+		DrawDebugSphere(World, Loc, R, kSphereSegments, kColorDespawn, false, -1.0f, 0, LineThickness);
+	}
+	if (ResolveOverlay(EZeusAOIOverlay::CellBounds))
+	{
+		// PLACEHOLDER: box grande centrada no player. TODO bounds reais da cell.
+		DrawDebugBox(World, Loc, FVector(CellBoundsExtentCm, CellBoundsExtentCm, 2000.0f),
+			kColorCell, false, -1.0f, 0, LineThickness);
+	}
+	if (ResolveOverlay(EZeusAOIOverlay::HandoffLine))
+	{
+		// PLACEHOLDER: vetor pra frente. TODO apontar pro centro da cell vizinha.
+		const float Len = InterestRadiusCm > 0.0f ? InterestRadiusCm : 3000.0f;
+		const FVector End = Loc + Owner->GetActorForwardVector() * Len;
+		DrawDebugDirectionalArrow(World, Loc, End, 200.0f, kColorHandoff, false, -1.0f, 0, LineThickness);
+	}
+	// ProxyLabels / AuthDrift: TODO (precisam do registry de proxies/snapshots).
+}
+
+void UZeusAOIComponent::SetOverlayEnabled_Implementation(EZeusAOIOverlay Overlay, bool bEnabled)
+{
+	switch (Overlay)
+	{
+	case EZeusAOIOverlay::AOIRadius:   bShowAOIRadius   = bEnabled; break;
+	case EZeusAOIOverlay::DespawnZone: bShowDespawnZone = bEnabled; break;
+	case EZeusAOIOverlay::CellBounds:  bShowCellBounds  = bEnabled; break;
+	case EZeusAOIOverlay::ProxyLabels: bShowProxyLabels = bEnabled; break;
+	case EZeusAOIOverlay::HandoffLine: bShowHandoffLine = bEnabled; break;
+	case EZeusAOIOverlay::AuthDrift:   bShowAuthDrift   = bEnabled; break;
+	case EZeusAOIOverlay::FrontierCells: bShowFrontier  = bEnabled; break;
+	default: break;
+	}
+
+	// Ao ligar uma zona de AOI sem ter os raios ainda, pede a config (loading).
+	const bool bAoiZone = (Overlay == EZeusAOIOverlay::AOIRadius || Overlay == EZeusAOIOverlay::DespawnZone);
+	if (bEnabled && bAoiZone && InterestRadiusCm <= 0.0f)
+	{
+		RequestAoiConfig();
+	}
+
+	// Frontier: ao ligar pede as cells (6162) e reconstroi; ao desligar limpa as paredes.
+	if (Overlay == EZeusAOIOverlay::FrontierCells)
+	{
+		if (bEnabled) { RequestFrontierConfig(); }
+		UpdateFrontierOverlay();
+	}
+}
+
+void UZeusAOIComponent::SetAllOverlays_Implementation(bool bEnabled)
+{
+	bShowAOIRadius = bShowDespawnZone = bShowCellBounds = bEnabled;
+	bShowProxyLabels = bShowHandoffLine = bShowAuthDrift = bEnabled;
+	bShowFrontier = bEnabled;
+
+	if (bEnabled && InterestRadiusCm <= 0.0f)
+	{
+		RequestAoiConfig();
+	}
+	if (bEnabled) { RequestFrontierConfig(); }
+	UpdateFrontierOverlay();
+}
+
+bool UZeusAOIComponent::IsOverlayEnabled_Implementation(EZeusAOIOverlay Overlay) const
+{
+	// Reflete o estado real (flag OU CVar) p/ a UI mostrar o que esta' desenhando.
+	return ResolveOverlay(Overlay);
+}
+
+float UZeusAOIComponent::GetInterestRadiusCm_Implementation() const
+{
+	return InterestRadiusCm; // 0 = config do servidor ainda nao chegou (loading)
+}
+
+float UZeusAOIComponent::GetDespawnRadiusCm_Implementation() const
+{
+	return DespawnRadiusCm;
+}
+
+int32 UZeusAOIComponent::GetEnabledOverlayCount() const
+{
+	return (bShowAOIRadius ? 1 : 0) + (bShowDespawnZone ? 1 : 0) + (bShowCellBounds ? 1 : 0)
+		+ (bShowProxyLabels ? 1 : 0) + (bShowHandoffLine ? 1 : 0) + (bShowAuthDrift ? 1 : 0)
+		+ (bShowFrontier ? 1 : 0);
+}

Source/ZMMO/Game/Network/ZeusAOIComponent.h

@@ -0,0 +1,111 @@
+// Copyright Zeus Server Engine. All rights reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Components/ActorComponent.h"
+#include "ZeusAOIDebugTarget.h" // plugin ZeusAdminToolsRuntime: interface + EZeusAOIOverlay
+#include "ZeusV1Protocol.h"     // ZeusV1::FDebugFrontierInfo (overlay de fronteira)
+#include "ZeusAOIComponent.generated.h"
+
+class AZeusFrontierOverlayActor;
+
+/**
+ *  UZeusAOIComponent (cliente / jogo)
+ *
+ *  Componente de gameplay do player local. Dominio principal: Area of Interest
+ *  do cliente (proxies, despawn coordenado, interpolacao — ver
+ *  [[project_aoi_client_component]]). AQUI, alem disso, expoe um "plus" de
+ *  DEBUG: overlays via DrawDebug* dirigidos pelo painel admin (plugin) atraves
+ *  de IZeusAOIDebugTarget, e/ou por console vars (zeus.debug.aoi etc.).
+ *
+ *  As DUAS zonas do AOI (Interesse interna + Despawn externa = histerese) vem do
+ *  SERVIDOR: ao ligar um overlay (ou no BeginPlay) o componente pede a config via
+ *  C_DEBUG_AOI_REQUEST e recebe S_DEBUG_AOI_INFO (delegate OnDebugAoiInfo do
+ *  UZeusNetworkSubsystem) com interestRadiusCm + despawnRadiusCm. Enquanto nao
+ *  chega (raio == 0), nao desenha (loading).
+ *
+ *  Vive na src do ZMMO (nao no plugin): e' um componente do JOGO. O plugin
+ *  ZeusAdminTools apenas COMUNICA com ele via a interface — direcao da
+ *  dependencia: ZMMO -> plugin (implementa a interface).
+ */
+UCLASS(ClassGroup = (Zeus), meta = (BlueprintSpawnableComponent), DisplayName = "Zeus AOI Component")
+class ZMMO_API UZeusAOIComponent : public UActorComponent, public IZeusAOIDebugTarget
+{
+	GENERATED_BODY()
+
+public:
+	UZeusAOIComponent();
+
+	virtual void BeginPlay() override;
+	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+	virtual void TickComponent(float DeltaTime, ELevelTick TickType,
+	                           FActorComponentTickFunction* ThisTickFunction) override;
+
+	// === IZeusAOIDebugTarget (dirigido pelo painel admin) ===
+	virtual void SetOverlayEnabled_Implementation(EZeusAOIOverlay Overlay, bool bEnabled) override;
+	virtual void SetAllOverlays_Implementation(bool bEnabled) override;
+	virtual bool IsOverlayEnabled_Implementation(EZeusAOIOverlay Overlay) const override;
+	virtual float GetInterestRadiusCm_Implementation() const override;
+	virtual float GetDespawnRadiusCm_Implementation() const override;
+
+	// === Flags de debug por overlay ===
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Zeus|AOI Debug|Overlays") bool bShowAOIRadius = false;    // Zona de Interesse
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Zeus|AOI Debug|Overlays") bool bShowDespawnZone = false;  // Zona de Despawn
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Zeus|AOI Debug|Overlays") bool bShowCellBounds = false;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Zeus|AOI Debug|Overlays") bool bShowProxyLabels = false;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Zeus|AOI Debug|Overlays") bool bShowHandoffLine = false;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Zeus|AOI Debug|Overlays") bool bShowAuthDrift = false;
+	// Fronteiras do mesh: paredes own<->neighbor com label "Cell <id>", renderizadas
+	// por AZeusFrontierOverlayActor a partir do DEBUG_FRONTIER_INFO (6163).
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Zeus|AOI Debug|Overlays") bool bShowFrontier = false;
+
+	// === Parametros ===
+	// Raios reais vem do servidor (S_DEBUG_AOI_INFO). 0 = ainda nao recebido (loading).
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Zeus|AOI Debug|Params") float InterestRadiusCm = 0.0f;
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Zeus|AOI Debug|Params") float DespawnRadiusCm = 0.0f;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Zeus|AOI Debug|Params") float CellBoundsExtentCm = 50000.0f;
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Zeus|AOI Debug|Params") float LineThickness = 2.0f;
+
+	UFUNCTION(BlueprintPure, Category = "Zeus|AOI Debug")
+	int32 GetEnabledOverlayCount() const;
+
+private:
+	void DrawOverlays();
+	bool ResolveOverlay(EZeusAOIOverlay Overlay) const;
+	bool AnyOverlayActive() const;
+
+	/** Pede a config de AOI ao servidor (C_DEBUG_AOI_REQUEST). No-op se ja' temos
+	 *  os raios ou se nao houver UZeusNetworkSubsystem conectado. */
+	void RequestAoiConfig();
+
+	/** Bind de UZeusNetworkSubsystem::OnDebugAoiInfo: armazena os raios reais. */
+	void HandleAoiConfig(float InterestCm, float DespawnCm);
+
+	/** Pede o frontier do mesh ao servidor (DEBUG_FRONTIER_REQUEST 6162). */
+	void RequestFrontierConfig();
+	/** Bind de OnDebugFrontierInfo: guarda as cells e (se overlay on) reconstroi as paredes. */
+	void HandleFrontierConfig(const ZeusV1::FDebugFrontierInfo& Info);
+	/** Spawna (lazy) o ator que desenha as paredes + labels. */
+	AZeusFrontierOverlayActor* EnsureFrontierActor();
+	/** Liga / reconstroi / limpa o overlay de fronteira conforme bShowFrontier + dados. */
+	void UpdateFrontierOverlay();
+
+	/** Handle do bind do OnDebugAoiInfo (pra remover no EndPlay). */
+	FDelegateHandle AoiConfigHandle_;
+
+	/** Handle do bind do OnDebugFrontierInfo (frontier overlay). */
+	FDelegateHandle FrontierConfigHandle_;
+	/** Ultimo frontier recebido do server (own cells + neighbors). */
+	ZeusV1::FDebugFrontierInfo FrontierInfo_;
+	bool bFrontierReceived_ = false;
+	/** Estado do overlay JA aplicado (paredes desenhadas). O TickComponent compara
+	 *  com ResolveOverlay p/ pegar liga/desliga via CVar tambem (nao so' o toggle). */
+	bool bFrontierApplied_ = false;
+	/** Re-poll periodico do frontier enquanto ligado -> overlay reflete split/merge
+	 *  da topologia dinamica (o 6163 traz o estado atual do topology:current). */
+	float FrontierRepollIntervalSec = 2.0f;
+	float FrontierRepollAccumSec_ = 0.0f;
+	/** Ator que desenha as paredes + labels (spawn lazy ao ligar o overlay). */
+	UPROPERTY() TObjectPtr<AZeusFrontierOverlayActor> FrontierActor_ = nullptr;
+};

Source/ZMMO/Game/Network/ZeusFrontierOverlayActor.cpp

@@ -0,0 +1,205 @@
+// Copyright Zeus Server Engine. All rights reserved.
+
+#include "ZeusFrontierOverlayActor.h"
+
+#include "ZMMONetLog.h" // LogZeusAOI (categoria do modulo ZMMO)
+
+#include "ProceduralMeshComponent.h"
+#include "Materials/MaterialInterface.h"
+#include "Engine/World.h"
+#include "DrawDebugHelpers.h"
+#include "UObject/ConstructorHelpers.h"
+
+namespace
+{
+	const TCHAR* kWallMaterialPath =
+		TEXT("/Game/ZMMO/Materials/VFX/Portal/GridBoundary/Instancia/MI_VFX_Portal_GridBoundary_01.MI_VFX_Portal_GridBoundary_01");
+
+	const FColor kLabelAlive(93, 213, 255); // ciano  -- server online
+	const FColor kLabelDead(255, 90, 90);   // vermelho -- server offline / cell vazia
+
+	// Offset do cellId de filha de split (espelha CHILD_CELLID_OFFSET do server).
+	constexpr uint32 kChildCellIdOffset = 1000000u;
+
+	// Decodifica o cellId int na notacao de quadtree: raiz -> "0".."3"; filha ->
+	// "<pai>,<quadrante>" (ex "0,2"); neto -> "0,2,1" (recursivo). Espelha
+	// childCellId = offset + pai*4 + quadrante do SplitCoordinator.
+	FString DecodeCellPath(uint32 CellId)
+	{
+		if (CellId < kChildCellIdOffset)
+		{
+			return FString::Printf(TEXT("%u"), CellId);
+		}
+		const uint32 Rel = CellId - kChildCellIdOffset;
+		return DecodeCellPath(Rel / 4u) + FString::Printf(TEXT(",%u"), Rel % 4u);
+	}
+
+	// Aresta compartilhada entre dois retangulos axis-aligned (no plano XY).
+	bool SharedEdge(float aMinX, float aMinY, float aMaxX, float aMaxY,
+	                float bMinX, float bMinY, float bMaxX, float bMaxY,
+	                float Eps, FVector2D& OutA, FVector2D& OutB)
+	{
+		const float yLo = FMath::Max(aMinY, bMinY), yHi = FMath::Min(aMaxY, bMaxY);
+		const float xLo = FMath::Max(aMinX, bMinX), xHi = FMath::Min(aMaxX, bMaxX);
+
+		if (FMath::Abs(aMaxX - bMinX) <= Eps && yHi > yLo) { OutA = {aMaxX, yLo}; OutB = {aMaxX, yHi}; return true; }
+		if (FMath::Abs(aMinX - bMaxX) <= Eps && yHi > yLo) { OutA = {aMinX, yLo}; OutB = {aMinX, yHi}; return true; }
+		if (FMath::Abs(aMaxY - bMinY) <= Eps && xHi > xLo) { OutA = {xLo, aMaxY}; OutB = {xHi, aMaxY}; return true; }
+		if (FMath::Abs(aMinY - bMaxY) <= Eps && xHi > xLo) { OutA = {xLo, aMinY}; OutB = {xHi, aMinY}; return true; }
+		return false;
+	}
+}
+
+AZeusFrontierOverlayActor::AZeusFrontierOverlayActor()
+{
+	PrimaryActorTick.bCanEverTick = true;
+	PrimaryActorTick.bStartWithTickEnabled = true;
+
+	WallMesh = CreateDefaultSubobject<UProceduralMeshComponent>(TEXT("WallMesh"));
+	SetRootComponent(WallMesh);
+	WallMesh->bUseAsyncCooking = false;
+	WallMesh->SetCollisionEnabled(ECollisionEnabled::NoCollision);
+	WallMesh->SetCastShadow(false);
+
+	static ConstructorHelpers::FObjectFinder<UMaterialInterface> MatFinder(kWallMaterialPath);
+	if (MatFinder.Succeeded())
+	{
+		WallMaterial = MatFinder.Object;
+	}
+}
+
+void AZeusFrontierOverlayActor::RebuildFromFrontier(const ZeusV1::FDebugFrontierInfo& Info, float AnchorZCm)
+{
+	if (!WallMesh) { return; }
+	AnchorZ_ = AnchorZCm;
+
+	// 1) Junta own + neighbors numa lista unica de cells (grid inteiro). Dedup por cellId.
+	Cells_.Reset();
+	auto AddCell = [this](uint32 CellId, int32 MinX, int32 MinY, int32 MaxX, int32 MaxY,
+	                      const FString& InOwner, bool bIsDead)
+	{
+		for (const FCellView& Ex : Cells_) { if (Ex.CellId == CellId) { return; } }
+		FCellView V;
+		V.CellId = CellId;
+		V.MinX = static_cast<float>(MinX); V.MinY = static_cast<float>(MinY);
+		V.MaxX = static_cast<float>(MaxX); V.MaxY = static_cast<float>(MaxY);
+		V.Owner = InOwner; V.bDead = bIsDead;
+		Cells_.Add(MoveTemp(V));
+	};
+	for (const ZeusV1::FFrontierOwnCell& C : Info.OwnedCells)
+	{
+		AddCell(C.CellId, C.MinXCm, C.MinYCm, C.MaxXCm, C.MaxYCm, C.OwnerName, false);
+	}
+	for (const ZeusV1::FFrontierNeighborCell& Nb : Info.NeighborCells)
+	{
+		AddCell(Nb.CellId, Nb.MinXCm, Nb.MinYCm, Nb.MaxXCm, Nb.MaxYCm, Nb.OwnerName, Nb.bDead);
+	}
+
+	// 2) Paredes: 1 quad por aresta compartilhada entre QUALQUER par (i<j -> dedup).
+	const float BaseZ = AnchorZCm - WallHeightCm * 0.5f;
+	const float TopZ  = AnchorZCm + WallHeightCm * 0.5f;
+
+	TArray<FVector> Verts;
+	TArray<int32> Tris;
+	TArray<FVector> Normals;
+	TArray<FVector2D> UVs;
+	TArray<FProcMeshTangent> Tangents;
+	TArray<FLinearColor> Colors;
+
+	for (int32 i = 0; i < Cells_.Num(); ++i)
+	{
+		for (int32 j = i + 1; j < Cells_.Num(); ++j)
+		{
+			const FCellView& A = Cells_[i];
+			const FCellView& B = Cells_[j];
+			FVector2D P0, P1;
+			if (!SharedEdge(A.MinX, A.MinY, A.MaxX, A.MaxY,
+			                B.MinX, B.MinY, B.MaxX, B.MaxY, EdgeEpsilonCm, P0, P1))
+			{
+				continue;
+			}
+
+			const int32 Base = Verts.Num();
+			Verts.Add(FVector(P0.X, P0.Y, BaseZ));
+			Verts.Add(FVector(P1.X, P1.Y, BaseZ));
+			Verts.Add(FVector(P1.X, P1.Y, TopZ));
+			Verts.Add(FVector(P0.X, P0.Y, TopZ));
+
+			const FVector2D Dir2D = (P1 - P0).GetSafeNormal();
+			const FVector N(-Dir2D.Y, Dir2D.X, 0.f);
+			Normals.Add(N); Normals.Add(N); Normals.Add(N); Normals.Add(N);
+
+			UVs.Add(FVector2D(0.f, 1.f));
+			UVs.Add(FVector2D(1.f, 1.f));
+			UVs.Add(FVector2D(1.f, 0.f));
+			UVs.Add(FVector2D(0.f, 0.f));
+
+			const FProcMeshTangent Tan(FVector(Dir2D.X, Dir2D.Y, 0.f), false);
+			Tangents.Add(Tan); Tangents.Add(Tan); Tangents.Add(Tan); Tangents.Add(Tan);
+
+			const FLinearColor C = (A.bDead || B.bDead) ? FLinearColor(kLabelDead) : FLinearColor(kLabelAlive);
+			Colors.Add(C); Colors.Add(C); Colors.Add(C); Colors.Add(C);
+
+			Tris.Add(Base + 0); Tris.Add(Base + 1); Tris.Add(Base + 2);
+			Tris.Add(Base + 0); Tris.Add(Base + 2); Tris.Add(Base + 3);
+			Tris.Add(Base + 0); Tris.Add(Base + 2); Tris.Add(Base + 1);
+			Tris.Add(Base + 0); Tris.Add(Base + 3); Tris.Add(Base + 2);
+		}
+	}
+
+	WallMesh->ClearAllMeshSections();
+	WallMesh->SetVisibility(true);
+	if (Verts.Num() > 0)
+	{
+		WallMesh->CreateMeshSection_LinearColor(
+			/*SectionIndex=*/0, Verts, Tris, Normals, UVs, Colors, Tangents, /*bCreateCollision=*/false);
+		if (WallMaterial) { WallMesh->SetMaterial(0, WallMaterial); }
+	}
+	bHasOverlay_ = (Cells_.Num() > 0);
+
+	UE_LOG(LogZeusAOI, Display,
+		TEXT("Frontier overlay rebuilt: cells=%d walls=%d anchorZ=%.0f%s"),
+		Cells_.Num(), Verts.Num() / 4, AnchorZCm,
+		WallMaterial ? TEXT("") : TEXT(" [WARN: material nula]"));
+}
+
+void AZeusFrontierOverlayActor::ClearOverlay()
+{
+	if (WallMesh)
+	{
+		WallMesh->ClearAllMeshSections();
+		WallMesh->SetVisibility(false);
+	}
+	Cells_.Reset();
+	bHasOverlay_ = false;
+}
+
+void AZeusFrontierOverlayActor::DrawCellLabels()
+{
+	if (!bHasOverlay_ || Cells_.Num() == 0) { return; }
+	UWorld* World = GetWorld();
+	if (!World) { return; }
+
+	for (const FCellView& C : Cells_)
+	{
+		const float Cx = (C.MinX + C.MaxX) * 0.5f;
+		const float Cy = (C.MinY + C.MaxY) * 0.5f;
+		const FVector Pos(Cx, Cy, AnchorZ_ + LabelHeightCm);
+
+		// "Cell 0" / "Cell 0,2" (notacao da quadtree) + nome do server dono.
+		FString Txt = FString::Printf(TEXT("Cell %s"), *DecodeCellPath(C.CellId));
+		if (!C.Owner.IsEmpty()) { Txt += TEXT("\n") + C.Owner; }
+		const FColor Col = C.bDead ? kLabelDead : kLabelAlive;
+
+		// DrawDebugString: billboard de tela (visivel de qualquer lado, nao gira,
+		// tamanho de tela constante). Re-desenhado a cada frame (Duration 0).
+		DrawDebugString(World, Pos, Txt, /*TestBaseActor=*/nullptr, Col,
+		                /*Duration=*/0.0f, /*bDrawShadow=*/true, LabelFontScale);
+	}
+}
+
+void AZeusFrontierOverlayActor::Tick(float DeltaSeconds)
+{
+	Super::Tick(DeltaSeconds);
+	DrawCellLabels();
+}

Source/ZMMO/Game/Network/ZeusFrontierOverlayActor.h

@@ -0,0 +1,70 @@
+// Copyright Zeus Server Engine. All rights reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "ZeusV1Protocol.h" // ZeusV1::FDebugFrontierInfo (plugin ZeusNetwork)
+#include "ZeusFrontierOverlayActor.generated.h"
+
+class UProceduralMeshComponent;
+class UMaterialInterface;
+
+/**
+ *  AZeusFrontierOverlayActor (cliente / debug)
+ *
+ *  Desenha no MUNDO as "paredes" de TODAS as fronteiras do grid de server-meshing
+ *  (todas as arestas compartilhadas entre quaisquer duas cells, com dedup), usando
+ *  a material de portal MI_VFX_Portal_GridBoundary_01. As cells vem do
+ *  DEBUG_FRONTIER_INFO (6163), que reflete a topologia DINAMICA (split/merge).
+ *
+ *  Label: no CENTRO de cada cell, um texto via DrawDebugString (billboard de tela,
+ *  visivel de qualquer lado, nao gira). Mostra a notacao da cell:
+ *    raiz   -> "Cell 0", "Cell 1", ...
+ *    split  -> "Cell 0,0", "Cell 0,1", ... (pai,quadrante) -- reflete a quadtree.
+ *  + o nome do servidor dono. NAO e' replicado: visual no cliente local.
+ */
+UCLASS()
+class ZMMO_API AZeusFrontierOverlayActor : public AActor
+{
+	GENERATED_BODY()
+
+public:
+	AZeusFrontierOverlayActor();
+
+	virtual void Tick(float DeltaSeconds) override;
+
+	/** (Re)constroi as paredes do grid + guarda as cells pros labels.
+	 *  AnchorZCm ancora a altura das paredes/labels (tipicamente o Z do player). */
+	void RebuildFromFrontier(const ZeusV1::FDebugFrontierInfo& Info, float AnchorZCm);
+
+	/** Limpa a geometria (overlay desligado). */
+	void ClearOverlay();
+
+	// === Parametros das paredes ===
+	UPROPERTY(EditAnywhere, Category = "Zeus|Frontier") float WallHeightCm  = 12000.0f; // 120m
+	UPROPERTY(EditAnywhere, Category = "Zeus|Frontier") float EdgeEpsilonCm = 4.0f;     // tolerancia "compartilha aresta"
+
+	// === Label "Cell X,Y" no centro de cada cell (DrawDebugString) ===
+	UPROPERTY(EditAnywhere, Category = "Zeus|Frontier|Label") float LabelFontScale = 1.4f; // tamanho na tela (screen-space)
+	UPROPERTY(EditAnywhere, Category = "Zeus|Frontier|Label") float LabelHeightCm  = 250.0f; // altura do label acima do anchor
+
+private:
+	UPROPERTY() UProceduralMeshComponent* WallMesh = nullptr;
+	UPROPERTY() UMaterialInterface* WallMaterial = nullptr;
+
+	/// Snapshot leve das cells (own + neighbors) pros labels.
+	struct FCellView
+	{
+		uint32  CellId = 0;
+		float   MinX = 0.f, MinY = 0.f, MaxX = 0.f, MaxY = 0.f;
+		FString Owner;          // "Server1" (ou vazio)
+		bool    bDead = false;
+	};
+	TArray<FCellView> Cells_;
+	float AnchorZ_ = 0.0f;
+	bool  bHasOverlay_ = false;
+
+	/// Desenha "Cell X,Y\n<server>" no centro de cada cell (chamado no Tick).
+	void DrawCellLabels();
+};

Source/ZMMO/Game/Network/ZeusWorldSubsystem.cpp

@@ -2,11 +2,15 @@
 
 #include "Engine/GameInstance.h"
 #include "Engine/World.h"
+#include "GameFramework/GameStateBase.h"
 #include "ZMMO.h"
 #include "ZeusEntity.h"
 #include "ZeusEntityInterface.h"
+#include "ZeusGASComponent.h"
 #include "ZeusPlayerProxy.h"
+#include "ZeusPlayerState.h"
 #include "ZeusNetworkSubsystem.h"
+#include "ZeusNetworkingClientSubsystem.h"
 
 void UZeusWorldSubsystem::Initialize(FSubsystemCollectionBase& Collection)
 {
@@ -29,45 +33,59 @@ void UZeusWorldSubsystem::OnWorldBeginPlay(UWorld& InWorld)
 {
 	Super::OnWorldBeginPlay(InWorld);
 
-	if (UZeusNetworkSubsystem* ZeusNet = ResolveZeusNetworkSubsystem())
+	// Sistema de rede novo (canonico) -- substitui o ZeusNetworkSubsystem legacy
+	// para spawn/despawn/movimento de proxies. O legacy fica so' com o que ainda
+	// nao tem equivalente (CHAR_INFO/nome, tratado em AZeusCharacter).
+	if (UZeusNetworkingClientSubsystem* Net = ResolveNetClientSubsystem())
 	{
-		ZeusNet->OnPlayerSpawned.AddDynamic(this, &UZeusWorldSubsystem::HandlePlayerSpawned);
-		ZeusNet->OnPlayerDespawned.AddDynamic(this, &UZeusWorldSubsystem::HandlePlayerDespawned);
-		ZeusNet->OnPlayerStateUpdate.AddDynamic(this, &UZeusWorldSubsystem::HandlePlayerStateUpdate);
-		UE_LOG(LogZMMO, Log, TEXT("ZeusWorldSubsystem bound to ZeusNetworkSubsystem delegates."));
+		Net->OnEntitySpawned.AddDynamic(this, &UZeusWorldSubsystem::OnNetEntitySpawned);
+		Net->OnEntityDespawned.AddDynamic(this, &UZeusWorldSubsystem::OnNetEntityDespawned);
+		Net->OnEntityDeltaApplied.AddDynamic(this, &UZeusWorldSubsystem::OnNetEntityDelta);
+		Net->OnSelfEntityAssigned.AddDynamic(this, &UZeusWorldSubsystem::OnNetSelfEntityAssigned);
+		Net->OnCharInfo.AddDynamic(this, &UZeusWorldSubsystem::OnNetCharInfo);
+		UE_LOG(LogZMMO, Log, TEXT("ZeusWorldSubsystem bound to network client subsystem delegates."));
 
-		// Catch-up race fix (Fase 3): broadcasts de proxies remotos chegam
-		// enquanto o cliente novo ainda esta em OpenLevel. UZeusNetworkSubsystem
-		// cacheia em PendingRemoteSpawnsByEntity. Aplicamos aqui — mundo ja
-		// esta pronto (GameMode ativo, WorldPartition cells inicializadas).
-		int32 ReplayCount = 0;
-		ZeusNet->ForEachPendingRemoteSpawn(
-			[this, &ReplayCount](const int64 EntityId, const FVector PosCm, const float YawDeg, const int64 ServerTimeMs)
+		// O subsystem de rede e' per-GameInstance e sobrevive ao OpenLevel, entao
+		// o self-entity e os ENT_SPAWN podem ter chegado ANTES deste bind. Puxa o
+		// self cacheado + faz replay dos proxies ja conhecidos (anti-race).
+		if (const int64 CachedSelf = Net->GetLocalEntityId())
 		{
-				HandlePlayerSpawned(EntityId, /*bIsLocal=*/false, PosCm, YawDeg, ServerTimeMs);
+			OnNetSelfEntityAssigned(CachedSelf);
+		}
+		int32 ReplayCount = 0;
+		Net->ForEachRemoteEntity(
+			[this, &ReplayCount](int64 EntityId, FVector PosCm, float YawDeg)
+			{
+				// Catch-up local: ForEachRemoteEntity nao expoe vel/serverTimeMs ->
+				// ZeroVector + grounded + ts=0 (seed nao roda; o 1o delta ancora o relogio).
+				OnNetEntitySpawned(EntityId, /*Kind=*/1 /*Player*/, PosCm, YawDeg,
+					FVector::ZeroVector, /*bGrounded=*/true, /*ServerTimeMs=*/0);
 				++ReplayCount;
 			});
 		if (ReplayCount > 0)
 		{
-			UE_LOG(LogZMMO, Log, TEXT("ZeusWorldSubsystem: replay de %d proxy(ies) cacheados."), ReplayCount);
+			UE_LOG(LogZMMO, Log, TEXT("ZeusWorldSubsystem: replay de %d proxy(ies) ja conhecidos."), ReplayCount);
 		}
 	}
 	else
 	{
-		UE_LOG(LogZMMO, Warning, TEXT("ZeusWorldSubsystem: ZeusNetworkSubsystem not found at OnWorldBeginPlay."));
+		UE_LOG(LogZMMO, Warning, TEXT("ZeusWorldSubsystem: network client subsystem not found at OnWorldBeginPlay."));
 	}
 }
 
 void UZeusWorldSubsystem::Deinitialize()
 {
-	if (UZeusNetworkSubsystem* ZeusNet = ResolveZeusNetworkSubsystem())
+	if (UZeusNetworkingClientSubsystem* Net = ResolveNetClientSubsystem())
 	{
-		ZeusNet->OnPlayerSpawned.RemoveDynamic(this, &UZeusWorldSubsystem::HandlePlayerSpawned);
-		ZeusNet->OnPlayerDespawned.RemoveDynamic(this, &UZeusWorldSubsystem::HandlePlayerDespawned);
-		ZeusNet->OnPlayerStateUpdate.RemoveDynamic(this, &UZeusWorldSubsystem::HandlePlayerStateUpdate);
+		Net->OnEntitySpawned.RemoveDynamic(this, &UZeusWorldSubsystem::OnNetEntitySpawned);
+		Net->OnEntityDespawned.RemoveDynamic(this, &UZeusWorldSubsystem::OnNetEntityDespawned);
+		Net->OnEntityDeltaApplied.RemoveDynamic(this, &UZeusWorldSubsystem::OnNetEntityDelta);
+		Net->OnSelfEntityAssigned.RemoveDynamic(this, &UZeusWorldSubsystem::OnNetSelfEntityAssigned);
+		Net->OnCharInfo.RemoveDynamic(this, &UZeusWorldSubsystem::OnNetCharInfo);
 	}
 
 	RemoteEntities.Reset();
+	PendingCharInfo.Reset();
 	LocalEntityId = 0;
 	Super::Deinitialize();
 }
@@ -80,7 +98,29 @@ void UZeusWorldSubsystem::RegisterLocalEntity(const int64 EntityId, AActor* Loca
 	}
 
 	LocalEntityId = EntityId;
+
+	// Caso de borda: se o ENT_SPAWN do proprio chegou antes do self-entity, ja
+	// existe um proxy-fantasma com esta chave. Destroi antes de registrar o pawn
+	// real, senao o RemoteEntities.Add sobrescreve a entry e o fantasma fica
+	// orfao no mundo (sem ninguem pra despawna-lo).
+	if (TWeakObjectPtr<AActor>* Existing = RemoteEntities.Find(EntityId))
+	{
+		if (AActor* Ghost = Existing->Get())
+		{
+			if (Ghost != LocalActor && Ghost->IsA(AZeusPlayerProxy::StaticClass()))
+			{
+				HandlePlayerDespawned(EntityId);
+				UE_LOG(LogZMMO, Log,
+					TEXT("ZeusWorldSubsystem: ghost proxy do proprio limpo no RegisterLocalEntity EntityId=%lld"),
+					EntityId);
+			}
+		}
+	}
+
 	RemoteEntities.Add(EntityId, TWeakObjectPtr<AActor>(LocalActor));
+	// V1-CHARINFO: o nome do proprio char pode ter chegado antes do pawn local
+	// existir (CHAR_INFO vem logo apos ENT_SELF); aplica agora.
+	FlushPendingCharInfo(EntityId);
 	UE_LOG(LogZMMO, Log, TEXT("ZeusWorldSubsystem: local entity registered EntityId=%lld actor=%s"),
 		EntityId, *GetNameSafe(LocalActor));
 }
@@ -93,6 +133,21 @@ void UZeusWorldSubsystem::HandlePlayerSpawned(const int64 EntityId, const bool b
 		return;
 	}
 
+	// P10-FIX-LEGACY (workflow wcyeqgrad finding): server pode reenviar
+	// S_SPAWN_PLAYER com bIsLocal=false do PROPRIO entityId via AOI re-emit
+	// (catch-up cross-server, SetOnEnter callback recomputando InterestSet,
+	// handoff em flight). Sem guard, o segundo spawn cria proxy fantasma do
+	// proprio player; GAS/HUD passa a rotear via proxy fantasma e o pawn real
+	// perde vinculo. Sintoma observado: player ve 2 pawns sobrepostos, ou
+	// outros players nao veem o autoritativo.
+	if (LocalEntityId != 0 && EntityId == LocalEntityId)
+	{
+		UE_LOG(LogZMMO, Verbose,
+			TEXT("ZeusWorldSubsystem: ignoring S_SPAWN_PLAYER for own LocalEntityId=%lld (bIsLocal=%d)"),
+			LocalEntityId, bIsLocal ? 1 : 0);
+		return;
+	}
+
 	if (bIsLocal)
 	{
 		// O proprio AZeusCharacter cuida da sua identidade quando recebe o
@@ -160,11 +215,112 @@ void UZeusWorldSubsystem::HandlePlayerSpawned(const int64 EntityId, const bool b
 		AsEntity->SetEntityRelevant(true);
 	}
 
+	// === PlayerState pra proxies (Batch 2.5+) ===
+	//
+	// Sem PlayerState, o proxy fica fora do GameState->PlayerArray. Daqui pra
+	// cima, qualquer sistema que itera PlayerArray (UZeusGASNetworkHandler::
+	// FindGASComponentForEntity, HUD, chat, friend list) NAO consegue achar o
+	// proxy -> fallback ao local player -> efeito apareceria no char errado
+	// (bug do cue do Dash). Criar PS replicado-fake permite que o pipeline GAS
+	// trate proxies igual a local players.
+	//
+	// PlayerState tem o UZeusGASComponent via DefaultGame.ini Component Registry,
+	// entao GASComp e' auto-instanciado. So' precisamos seed o EntityId.
+	if (APawn* ProxyPawn = Cast<APawn>(SpawnedActor))
+	{
+		FActorSpawnParameters PSParams;
+		PSParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
+		PSParams.Owner = ProxyPawn;
+		AZeusPlayerState* ProxyPS = World->SpawnActor<AZeusPlayerState>(
+			AZeusPlayerState::StaticClass(), FVector::ZeroVector, FRotator::ZeroRotator, PSParams);
+		if (ProxyPS)
+		{
+			ProxyPawn->SetPlayerState(ProxyPS);  // tambem chama ProxyPS->SetPawn(ProxyPawn)
+
+			// Add ao PlayerArray do GameState (replicacao UE faria isso automatico,
+			// mas no nosso pipeline custom o PS local-fake precisa ser inserido).
+			if (AGameStateBase* GS = World->GetGameState())
+			{
+				GS->AddPlayerState(ProxyPS);
+			}
+
+			// Seed EntityId no GASComp do PS (criado via Component Registry).
+			// FindGASComponentForEntity vai resolver via PS->FindComponentByClass.
+			if (UZeusGASComponent* GASComp = ProxyPS->FindComponentByClass<UZeusGASComponent>())
+			{
+				GASComp->SeedEntityId(EntityId);
+			}
+
+			UE_LOG(LogZMMO, Log,
+				TEXT("ZeusWorldSubsystem: PlayerState criado p/ proxy EntityId=%lld PS=%s"),
+				EntityId, *ProxyPS->GetName());
+		}
+		else
+		{
+			UE_LOG(LogZMMO, Warning,
+				TEXT("ZeusWorldSubsystem: SpawnActor<AZeusPlayerState> falhou pra proxy EntityId=%lld"),
+				EntityId);
+		}
+	}
+
 	RemoteEntities.Add(EntityId, TWeakObjectPtr<AActor>(SpawnedActor));
+	// V1-CHARINFO: o nome chega ANTES do ator (server emite ENT_CHAR_INFO antes
+	// do ENT_SPAWN); aplica agora que o proxy + PlayerState ja existem.
+	FlushPendingCharInfo(EntityId);
 	UE_LOG(LogZMMO, Log, TEXT("ZeusWorldSubsystem: spawned remote EntityId=%d at (%s) yaw=%.1f t=%lld"),
 		EntityId, *PosCm.ToString(), YawDeg, ServerTimeMs);
 }
 
+void UZeusWorldSubsystem::OnNetCharInfo(const int64 EntityId, const FString& CharName, const FString& GuildName)
+{
+	if (EntityId == 0)
+	{
+		return;
+	}
+	// Aplica direto se o ator/PlayerState ja existe; senao guarda pra aplicar no spawn.
+	if (!ApplyCharInfoToEntity(EntityId, CharName, GuildName))
+	{
+		PendingCharInfo.Add(EntityId, FZeusPendingCharInfo{ CharName, GuildName });
+	}
+}
+
+bool UZeusWorldSubsystem::ApplyCharInfoToEntity(const int64 EntityId, const FString& CharName, const FString& GuildName)
+{
+	const TWeakObjectPtr<AActor>* Found = RemoteEntities.Find(EntityId);
+	if (!Found || !Found->IsValid())
+	{
+		return false;
+	}
+	APawn* Pawn = Cast<APawn>(Found->Get());
+	if (!Pawn)
+	{
+		return false;
+	}
+	AZeusPlayerState* PS = Pawn->GetPlayerState<AZeusPlayerState>();
+	if (!PS)
+	{
+		return false;
+	}
+	PS->SetCharInfo(CharName, GuildName);
+	UE_LOG(LogZMMO, Log,
+		TEXT("ZeusWorldSubsystem: CHAR_INFO aplicado EntityId=%lld name='%s' guild='%s'"),
+		EntityId, *CharName, *GuildName);
+	return true;
+}
+
+void UZeusWorldSubsystem::FlushPendingCharInfo(const int64 EntityId)
+{
+	const FZeusPendingCharInfo* Pending = PendingCharInfo.Find(EntityId);
+	if (!Pending)
+	{
+		return;
+	}
+	if (ApplyCharInfoToEntity(EntityId, Pending->CharName, Pending->GuildName))
+	{
+		PendingCharInfo.Remove(EntityId);
+	}
+}
+
 void UZeusWorldSubsystem::HandlePlayerDespawned(const int64 EntityId)
 {
 	const TWeakObjectPtr<AActor>* Entry = RemoteEntities.Find(EntityId);
@@ -185,6 +341,22 @@ void UZeusWorldSubsystem::HandlePlayerDespawned(const int64 EntityId)
 		{
 			AsEntity->SetEntityRelevant(false);
 		}
+		// Destrui PS proxy linkado (Batch 2.5+). Sem isso o GameState->PlayerArray
+		// fica com PS orfa apos o proxy ser destruido.
+		if (APawn* Pawn = Cast<APawn>(Actor))
+		{
+			if (APlayerState* PS = Pawn->GetPlayerState())
+			{
+				if (UWorld* World = GetWorld())
+				{
+					if (AGameStateBase* GS = World->GetGameState())
+					{
+						GS->RemovePlayerState(PS);
+					}
+				}
+				PS->Destroy();
+			}
+		}
 		Actor->Destroy();
 	}
 	RemoteEntities.Remove(EntityId);
@@ -281,6 +453,108 @@ void UZeusWorldSubsystem::HandlePlayerStateUpdate(const int64 EntityId, const in
 	AsEntity->ApplyEntitySnapshot(Snapshot);
 }
 
+void UZeusWorldSubsystem::OnNetEntitySpawned(int64 EntityId, int32 /*Kind*/, FVector PosCm, float YawDeg,
+	FVector VelCmS, bool bGrounded, int64 ServerTimeMs)
+{
+	// O sistema novo nao manda bIsLocal: derivamos do LocalEntityId (setado por
+	// ENT_SELF). Se ainda for 0 e este ENT_SPAWN for do proprio char, o
+	// OnNetSelfEntityAssigned destruira o fantasma quando o ENT_SELF chegar.
+	const bool bIsLocal = (LocalEntityId != 0 && EntityId == LocalEntityId);
+	HandlePlayerSpawned(EntityId, bIsLocal, PosCm, YawDeg, ServerTimeMs);
+
+	// V1-SPAWN-KEYFRAME(-TS): o ENT_SPAWN carrega vel + grounded + serverTimeMs. Aplica
+	// esse keyframe INICIAL no proxy recem-criado pelo mesmo caminho do delta (semeia o
+	// SnapshotBuffer + ANCORA o ServerClockOffsetMs com o tempo CERTO). Antes o seed usava
+	// ServerTimeMs=0 -> bootstrap do relogio de interpolacao errado -> proxy preso/flutuando
+	// ate' o EMA convergir. Agora com o serverTimeMs real o proxy interpola desde o frame 1.
+	if (!bIsLocal && ServerTimeMs > 0)
+	{
+		HandlePlayerStateUpdate(EntityId, /*InputSeq=*/0, PosCm, VelCmS, bGrounded, ServerTimeMs);
+	}
+}
+
+void UZeusWorldSubsystem::OnNetEntityDespawned(int64 EntityId, int32 /*Reason*/)
+{
+	// NUNCA despawnar o proprio char local via rede (ex: ENT_DESPAWN do proprio
+	// disparado por timeout do server). Destruir o pawn local quebraria o jogo
+	// do dono. O proprio so' sai quando o cliente realmente desconecta.
+	if (LocalEntityId != 0 && EntityId == LocalEntityId)
+	{
+		return;
+	}
+	HandlePlayerDespawned(EntityId);
+}
+
+void UZeusWorldSubsystem::OnNetEntityDelta(int64 EntityId, FVector PosCm, FVector VelCmS,
+	float YawDeg, bool bGrounded, int64 ServerTimeMs)
+{
+	if (EntityId == 0)
+	{
+		return;
+	}
+	if (LocalEntityId != 0 && EntityId == LocalEntityId)
+	{
+		return; // movimento do proprio char e' local; ignora snapshot autoritativo
+	}
+
+	const TWeakObjectPtr<AActor>* Entry = RemoteEntities.Find(EntityId);
+	if (!Entry)
+	{
+		return; // spawn chega em breve via ENT_SPAWN
+	}
+	AActor* Actor = Entry->Get();
+	if (!Actor)
+	{
+		RemoteEntities.Remove(EntityId);
+		return;
+	}
+	IZeusEntityInterface* AsEntity = Cast<IZeusEntityInterface>(Actor);
+	if (!AsEntity)
+	{
+		return;
+	}
+
+	FZeusEntitySnapshot Snapshot;
+	Snapshot.EntityId     = EntityId;
+	Snapshot.EntityType   = AsEntity->GetZeusEntityType();
+	Snapshot.PositionCm   = PosCm;
+	Snapshot.YawDeg       = YawDeg;
+	// V1-REPL-FULL (2026-06-12): velocidade + grounded + serverTimeMs -> o proxy
+	// anima (AnimBP ShouldMove via Acceleration!=0 derivada da vel), cola no chao
+	// (MOVE_Walking quando grounded) e interpola com a timeline autoritativa.
+	Snapshot.VelocityCmS  = VelCmS;
+	Snapshot.bGrounded    = bGrounded;
+	Snapshot.ServerTimeMs = ServerTimeMs;
+	AsEntity->ApplyEntitySnapshot(Snapshot);
+}
+
+void UZeusWorldSubsystem::OnNetSelfEntityAssigned(int64 EntityId)
+{
+	if (EntityId == 0 || LocalEntityId == EntityId)
+	{
+		return;
+	}
+	LocalEntityId = EntityId;
+	UE_LOG(LogZMMO, Log, TEXT("ZeusWorldSubsystem: self entity assigned EntityId=%lld"), EntityId);
+
+	// Re-filtragem tardia: se o ENT_SPAWN do proprio chegou ANTES do ENT_SELF,
+	// ja existe um proxy-fantasma do proprio char. Destroi agora -- mas NUNCA o
+	// pawn local real (o RegisterLocalEntity do AZeusCharacter registra o pawn
+	// com a mesma chave; so destruimos se a entry for um AZeusPlayerProxy).
+	if (TWeakObjectPtr<AActor>* Entry = RemoteEntities.Find(EntityId))
+	{
+		if (AActor* Ghost = Entry->Get())
+		{
+			if (Ghost->IsA(AZeusPlayerProxy::StaticClass()))
+			{
+				HandlePlayerDespawned(EntityId);
+				UE_LOG(LogZMMO, Log,
+					TEXT("ZeusWorldSubsystem: ghost proxy do proprio destruido EntityId=%lld"), EntityId);
+			}
+		}
+	}
+}
+
 UClass* UZeusWorldSubsystem::ResolveActorClass(const EZeusEntityType EntityType) const
 {
 	if (const TSubclassOf<AActor>* Found = RemoteEntityClasses.Find(EntityType))
@@ -307,3 +581,18 @@ UZeusNetworkSubsystem* UZeusWorldSubsystem::ResolveZeusNetworkSubsystem() const
 	}
 	return GI->GetSubsystem<UZeusNetworkSubsystem>();
 }
+
+UZeusNetworkingClientSubsystem* UZeusWorldSubsystem::ResolveNetClientSubsystem() const
+{
+	const UWorld* World = GetWorld();
+	if (!World)
+	{
+		return nullptr;
+	}
+	UGameInstance* GI = World->GetGameInstance();
+	if (!GI)
+	{
+		return nullptr;
+	}
+	return GI->GetSubsystem<UZeusNetworkingClientSubsystem>();
+}

Source/ZMMO/Game/Network/ZeusWorldSubsystem.h

@@ -9,6 +9,7 @@ class AActor;
 class AZeusCharacter;
 class AZeusPlayerProxy;
 class UZeusNetworkSubsystem;
+class UZeusNetworkingClientSubsystem;
 
 /**
  *  UZeusWorldSubsystem
@@ -80,8 +81,39 @@ private:
 	UFUNCTION()
 	void HandlePlayerStateUpdate(int64 EntityId, int32 InputSeq, FVector PosCm, FVector VelCmS, bool bGrounded, int64 ServerTimeMs);
 
+	// Sistema de rede novo (canonico) -- recebe spawn/despawn/delta + self-entity.
+	// Adaptam a assinatura nova para os handlers de spawn/despawn/delta acima.
+	UFUNCTION()
+	void OnNetEntitySpawned(int64 EntityId, int32 Kind, FVector PosCm, float YawDeg,
+		FVector VelCmS, bool bGrounded, int64 ServerTimeMs);
+
+	UFUNCTION()
+	void OnNetEntityDespawned(int64 EntityId, int32 Reason);
+
+	UFUNCTION()
+	void OnNetEntityDelta(int64 EntityId, FVector PosCm, FVector VelCmS, float YawDeg,
+		bool bGrounded, int64 ServerTimeMs);
+
+	UFUNCTION()
+	void OnNetSelfEntityAssigned(int64 EntityId);
+
+	// V1-CHARINFO: nome/guild do char (opcode ENT_CHAR_INFO 6045). Chega ANTES
+	// do ENT_SPAWN do proxy / do RegisterLocalEntity do self, entao se o ator
+	// ainda nao existe o dado fica em PendingCharInfo e e' aplicado no spawn.
+	UFUNCTION()
+	void OnNetCharInfo(int64 EntityId, const FString& CharName, const FString& GuildName);
+
 	UClass* ResolveActorClass(EZeusEntityType EntityType) const;
 	UZeusNetworkSubsystem* ResolveZeusNetworkSubsystem() const;
+	UZeusNetworkingClientSubsystem* ResolveNetClientSubsystem() const;
+
+	// Aplica nome/guild no AZeusPlayerState do EntityId (self ou proxy). Retorna
+	// false se o ator/PlayerState ainda nao existe (caller deve cachear).
+	bool ApplyCharInfoToEntity(int64 EntityId, const FString& CharName, const FString& GuildName);
+
+	// Aplica (e consome) o char info pendente de EntityId, se houver. Chamado
+	// quando o ator passa a existir (spawn de proxy / RegisterLocalEntity).
+	void FlushPendingCharInfo(int64 EntityId);
 
 	/**
 	 *  Registry de proxies remotos. Chave = `EntityId` autoritativo do servidor.
@@ -93,4 +125,12 @@ private:
 
 	/** Cached id do jogador local, para ignorar snapshots dele (cliente solto). */
 	int64 LocalEntityId = 0;
+
+	/** V1-CHARINFO: nome/guild recebido antes do ator existir. Chave = EntityId. */
+	struct FZeusPendingCharInfo
+	{
+		FString CharName;
+		FString GuildName;
+	};
+	TMap<int64, FZeusPendingCharInfo> PendingCharInfo;
 };

Source/ZMMO/Game/UI/FrontEnd/UIFrontEndFlowSubsystem.cpp

@@ -11,6 +11,7 @@
 #include "ZeusGameInstance.h"
 #include "ZeusThemeSubsystem.h"
 #include "ZeusNetworkSubsystem.h"
+#include "ZeusNetworkingClientSubsystem.h" // V1 canonico (sinal de spawn local)
 #include "ZeusCharServerSubsystem.h"
 #include "CommonActivatableWidget.h"
 #include "Engine/DataTable.h"
@@ -265,6 +266,12 @@ UZeusNetworkSubsystem* UUIFrontEndFlowSubsystem::GetZeusNetwork() const
 	return GI ? GI->GetSubsystem<UZeusNetworkSubsystem>() : nullptr;
 }
 
+UZeusNetworkingClientSubsystem* UUIFrontEndFlowSubsystem::GetNetClient() const
+{
+	const UGameInstance* GI = GetGameInstance();
+	return GI ? GI->GetSubsystem<UZeusNetworkingClientSubsystem>() : nullptr;
+}
+
 UZeusCharServerSubsystem* UUIFrontEndFlowSubsystem::GetCharServer() const
 {
 	const UGameInstance* GI = GetGameInstance();
@@ -314,11 +321,20 @@ void UUIFrontEndFlowSubsystem::BindNetwork()
 		Char->OnConnectionFailed.AddDynamic(this, &UUIFrontEndFlowSubsystem::HandleConnectionFailed);
 		Char->OnDisconnected.AddDynamic(this, &UUIFrontEndFlowSubsystem::HandleCharDisconnected);
 	}
-	// UDP (world server) só interessa para o handoff de travel.
+	// UDP (world server): o travel (TRAVEL_TO_MAP) ainda passa pelo objeto legacy
+	// como PONTE (HandleTravelToMap V1 reusa OnServerTravelRequested) -- isso some
+	// na Fase D quando o travel ganhar delegate proprio no V1.
 	if (UZeusNetworkSubsystem* Zeus = GetZeusNetwork())
 	{
 		Zeus->OnServerTravelRequested.AddDynamic(this, &UUIFrontEndFlowSubsystem::HandleServerTravelRequested);
-		Zeus->OnPlayerSpawned.AddDynamic(this, &UUIFrontEndFlowSubsystem::HandlePlayerSpawned);
+	}
+	// V1 CANONICO: o spawn do player local chega via ENT_SELF (o cliente aprende
+	// o proprio entityId) -> OnSelfEntityAssigned. O legacy OnPlayerSpawned NAO
+	// dispara mais com V1, entao a etapa "Spawn" do loading ficava eterna
+	// (loading travado). Liga a etapa ao sinal V1.
+	if (UZeusNetworkingClientSubsystem* Net = GetNetClient())
+	{
+		Net->OnSelfEntityAssigned.AddDynamic(this, &UUIFrontEndFlowSubsystem::HandleV1LocalSpawned);
 	}
 	bNetBound = true;
 }
@@ -338,7 +354,10 @@ void UUIFrontEndFlowSubsystem::UnbindNetwork()
 	if (UZeusNetworkSubsystem* Zeus = GetZeusNetwork())
 	{
 		Zeus->OnServerTravelRequested.RemoveDynamic(this, &UUIFrontEndFlowSubsystem::HandleServerTravelRequested);
-		Zeus->OnPlayerSpawned.RemoveDynamic(this, &UUIFrontEndFlowSubsystem::HandlePlayerSpawned);
+	}
+	if (UZeusNetworkingClientSubsystem* Net = GetNetClient())
+	{
+		Net->OnSelfEntityAssigned.RemoveDynamic(this, &UUIFrontEndFlowSubsystem::HandleV1LocalSpawned);
 	}
 	bNetBound = false;
 }
@@ -505,6 +524,13 @@ void UUIFrontEndFlowSubsystem::HandlePlayerSpawned(int64 /*EntityId*/, bool bIsL
 	}
 }
 
+void UUIFrontEndFlowSubsystem::HandleV1LocalSpawned(int64 EntityId)
+{
+	// ENT_SELF e' SEMPRE o proprio char (o cliente aprendendo seu entityId), entao
+	// bIsLocal=true. Reusa a logica de marcar a etapa "Spawn" + memoizacao anti-race.
+	HandlePlayerSpawned(EntityId, /*bIsLocal=*/true, FVector::ZeroVector, 0.0f, 0);
+}
+
 void UUIFrontEndFlowSubsystem::HandleLoadingComplete()
 {
 	if (UUILoadingScreen_Base* Loading = ActiveLoadingScreen.Get())

Source/ZMMO/Game/UI/FrontEnd/UIFrontEndFlowSubsystem.h

@@ -11,6 +11,7 @@ class UUIManagerSubsystem;
 class UUILoadingScreen_Base;
 class UZeusLoadingProfilesDataAsset;
 class UZeusNetworkSubsystem;
+class UZeusNetworkingClientSubsystem;
 class UZeusCharServerSubsystem;
 struct FZeusMapDef;
 
@@ -171,6 +172,7 @@ private:
 	void BindNetwork();
 	void UnbindNetwork();
 	UZeusNetworkSubsystem* GetZeusNetwork() const;
+	UZeusNetworkingClientSubsystem* GetNetClient() const; // V1 canonico
 	UZeusCharServerSubsystem* GetCharServer() const;
 	UUIManagerSubsystem* GetUIManager() const;
 	UUIFrontEndScreenSet* GetScreenSet();
@@ -198,6 +200,15 @@ private:
 	void HandlePlayerSpawned(int64 EntityId, bool bIsLocal, FVector PosCm,
 	                          float YawDeg, int64 ServerTimeMs);
 
+	/**
+	 *  V1 canonico: o spawn do player local chega via ENT_SELF (o cliente
+	 *  aprende o proprio entityId) -> OnSelfEntityAssigned. Marca a etapa
+	 *  "Spawn" do loading no fluxo V1 (o legacy OnPlayerSpawned nao dispara
+	 *  mais). Adapta a assinatura OneParam pra logica de HandlePlayerSpawned.
+	 */
+	UFUNCTION()
+	void HandleV1LocalSpawned(int64 EntityId);
+
 	/** Disparado pela tela de loading quando todas as etapas viram Done. */
 	UFUNCTION()
 	void HandleLoadingComplete();

Source/ZMMO/Game/UI/FrontEnd/UIUserLobbyScreen_Base.cpp

@@ -8,6 +8,7 @@
 #include "WireHelpers.h"
 #include "ZeusCharServerSubsystem.h"
 #include "ZeusNetworkSubsystem.h"
+#include "ZeusNetworkingClientSubsystem.h" // B4: V1 ConnectWithTicket
 #include "CommonTextBlock.h"
 #include "Components/PanelWidget.h"
 #include "Components/WidgetSwitcher.h"
@@ -384,13 +385,29 @@ void UUIUserLobbyScreen_Base::HandleCharSelectOk(const TArray<uint8>& Payload)
 	// `S_CONNECT_OK` (sucesso) ou `S_CONNECT_REJECT` (ticket invalido/expirado).
 	// Disparamos PRIMEIRO o connect (nao-bloqueante), depois o OpenLevel —
 	// ZeusNetworkSubsystem e per-GameInstance e persiste cross-travel.
-	if (UZeusNetworkSubsystem* ZeusNet = GI->GetSubsystem<UZeusNetworkSubsystem>())
+	// B4 (2026-06-11): se V1 canonico, roteia ConnectWithTicket pro V1 subsystem.
+	// V1 envia CONN_HELLO_CLIENT (6000) com handoffTicket embutido — server
+	// valida via Valkey GETDEL antes do CHALLENGE (HandshakeProcessor::OnHelloClient).
+	const UZeusNetworkingClientSubsystem* V1Cdo = GetDefault<UZeusNetworkingClientSubsystem>();
+	const bool bUseV1 = V1Cdo && V1Cdo->bUseZeusNetworkingV1;
+	if (bUseV1)
+	{
+		if (UZeusNetworkingClientSubsystem* V1 = GI->GetSubsystem<UZeusNetworkingClientSubsystem>())
+		{
+			V1->ConnectWithTicket(GwHost, GwPort, HandoffToken);
+		}
+		else
+		{
+			UE_LOG(LogZMMO, Error, TEXT("Lobby: V1 subsystem ausente — handoff abortado"));
+		}
+	}
+	else if (UZeusNetworkSubsystem* ZeusNet = GI->GetSubsystem<UZeusNetworkSubsystem>())
 	{
 		ZeusNet->ConnectToZeusServerWithTicket(GwHost, GwPort, HandoffToken);
 	}
 	else
 	{
-		UE_LOG(LogZMMO, Error, TEXT("Lobby: ZeusNetworkSubsystem ausente — handoff abortado"));
+		UE_LOG(LogZMMO, Error, TEXT("Lobby: nenhum ZeusNetworkSubsystem disponivel — handoff abortado"));
 	}
 
 	// Fase 4: lookup mapId no DT_Maps e dispara OpenLevel pro level certo.

Source/ZMMO/Game/UI/Widgets/UIProgressBar_Base.cpp

@@ -47,7 +47,7 @@ namespace
 	static const FName P_EdgeGlowWidth("EdgeGlowWidth");
 	static const FName P_EdgeGlowIntensity("EdgeGlowIntensity");
 
-	FORCEINLINE float EaseOutCubic(float Alpha)
+	FORCEINLINE float EaseOutCubicPB(float Alpha)
 	{
 		return 1.f - FMath::Pow(1.f - Alpha, 3.f);
 	}
@@ -195,7 +195,7 @@ void UUIProgressBar_Base::NativeTick(const FGeometry& MyGeometry, float InDeltaT
 		PrimaryElapsed += InDeltaTime;
 		const float Duration = FMath::Max(PrimaryAnimationSeconds, MinAnimSeconds);
 		const float Alpha = FMath::Clamp(PrimaryElapsed / Duration, 0.f, 1.f);
-		CurrentPrimaryLevel = FMath::Lerp(PrimaryStart, TargetPrimaryLevel, EaseOutCubic(Alpha));
+		CurrentPrimaryLevel = FMath::Lerp(PrimaryStart, TargetPrimaryLevel, EaseOutCubicPB(Alpha));
 		ApplyPrimaryToMID(CurrentPrimaryLevel);
 		if (Alpha >= 1.f)
 		{
@@ -210,7 +210,7 @@ void UUIProgressBar_Base::NativeTick(const FGeometry& MyGeometry, float InDeltaT
 		SecondaryElapsed += InDeltaTime;
 		const float Duration = FMath::Max(SecondaryAnimationSeconds, MinAnimSeconds);
 		const float Alpha = FMath::Clamp(SecondaryElapsed / Duration, 0.f, 1.f);
-		CurrentSecondaryLevel = FMath::Lerp(SecondaryStart, TargetSecondaryLevel, EaseOutCubic(Alpha));
+		CurrentSecondaryLevel = FMath::Lerp(SecondaryStart, TargetSecondaryLevel, EaseOutCubicPB(Alpha));
 		ApplySecondaryToMID(CurrentSecondaryLevel);
 		if (Alpha >= 1.f)
 		{

Source/ZMMO/ZMMO.Build.cs

@@ -19,9 +19,11 @@ public class ZMMO : ModuleRules
 			"CommonInput",
 			"GameplayTags",
 			"GameplayAbilities",  // GAS: UAttributeSet, FGameplayAttributeData
+			"ProceduralMeshComponent", // paredes do overlay de fronteira (AZeusFrontierOverlayActor)
 			"ZeusNetwork",
 			"ZeusGAS",            // UZeusGASComponent, UZeusAttributeSet, FZeusAttributesSnapshot
-			"ZeusJobs"
+			"ZeusJobs",
+			"ZeusAdminToolsRuntime" // IZeusAOIDebugTarget + EZeusAOIOverlay (admin panel dirige o componente)
 		});
 
 		PrivateDependencyModuleNames.AddRange(new string[] {

Source/ZMMO/ZMMO.cpp

@@ -1,8 +1,16 @@
 // Copyright Epic Games, Inc. All Rights Reserved.
 
 #include "ZMMO.h"
+#include "ZMMONetLog.h"
 #include "Modules/ModuleManager.h"
 
 IMPLEMENT_PRIMARY_GAME_MODULE( FDefaultGameModuleImpl, ZMMO, "ZMMO" );
 
 DEFINE_LOG_CATEGORY(LogZMMO)
+
+// Batch 2.5 — categorias vivem no modulo ZMMO (nao no plugin) por causa
+// do adaptive non-unity build do UBT (ver ZMMONetLog.h).
+DEFINE_LOG_CATEGORY(LogZeusHandoff)
+DEFINE_LOG_CATEGORY(LogZeusAOI)
+DEFINE_LOG_CATEGORY(LogZeusProxy)
+DEFINE_LOG_CATEGORY(LogZeusHaloTransition)

Source/ZMMO/ZMMONetLog.h

@@ -0,0 +1,24 @@
+// =============================================================================
+// ZMMONetLog.h — categorias UE_LOG do CLIENTE ZMMO (modulo Game), nao do plugin.
+//
+// Por que aqui e nao no plugin ZeusNetwork?
+//   UBT usa `git status` em Clients/ZMMO/ pra adaptive non-unity build. O plugin
+//   ZeusNetwork mora em Server/Plugins/Unreal/ZeusNetwork/ (OUTRO repo git),
+//   entao UBT nao enxerga mudancas la e pula o rebuild do plugin. Resultado:
+//   adicionar DECLARE_LOG_CATEGORY_EXTERN no header do plugin nao funciona
+//   sem rebuild manual do plugin (Build.bat). Solucao: categorias que vivem
+//   no proprio CLIENTE moram aqui — UBT enxerga e linka direto.
+//
+// Setup -logcmds="LogZeusHandoff Verbose, LogZeusAOI Verbose, LogZeusProxy Verbose"
+// pra filtrar Output Log seletivamente.
+//
+// DEFINE_LOG_CATEGORY correspondente em ZMMO.cpp.
+// =============================================================================
+#pragma once
+
+#include "CoreMinimal.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(LogZeusHandoff,         Log,     All);
+DECLARE_LOG_CATEGORY_EXTERN(LogZeusAOI,             Log,     All);
+DECLARE_LOG_CATEGORY_EXTERN(LogZeusProxy,           Verbose, All);
+DECLARE_LOG_CATEGORY_EXTERN(LogZeusHaloTransition,  Log,     All);

ZMMO.uproject

@@ -76,10 +76,6 @@
 		{
 			"Name": "CommonUI",
 			"Enabled": true
-		},
-		{
-			"Name": "NwiroIntegrationKit",
-			"Enabled": false
 		}
 	],
 	"AdditionalPluginDirectories": [