aussie/EscapistsReintroduced
1
0
Fork 0
forked from escapists/EscapistsReintroduced
Code Pull Requests Activity

Capture current mission, AI, map and administration development

Browse Source 
Include the current addon, terrain integrations, tools, regression tests and recorded development evidence.
This commit is contained in:
jakub
2026-10-13 22:52:53 +02:00
parent a951a96edc
commit 6a667d8deb
8104 changed files with 2124945 additions and 2061 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/evidence/observer-pip-2026-10-09/baseline/addons/core/Scripts/Game/ERR/00_Core/ERR_Observer.c
+463
View File
@@ -0,0 +1,463 @@
enum ERR_ObserverReason
{
NONE,
SPENT_LIFE,
LATE_EXTRACTION,
SPAWN_UNAVAILABLE,
UNCONSCIOUS
}
class ERR_ObserverRules
{
static int Cycle(bool enabled, bool left, bool right, bool previousLeft, bool previousRight)
{
if (!enabled || left == right) return 0;
if (left && !previousLeft) return -1;
if (right && !previousRight) return 1;
return 0;
}
static bool Toggle(bool enabled, bool pressed, bool previous)
{
return enabled && pressed && !previous;
}
static bool Casualty(bool active, bool currentBody, bool alive, bool conscious)
{
return active && currentBody && alive && !conscious;
}
static bool View(int reason, bool active, bool alive, bool conscious)
{
if (!active || reason == ERR_ObserverReason.NONE) return false;
if (reason == ERR_ObserverReason.UNCONSCIOUS) return alive && !conscious;
return !alive;
}
}
// Presentation only. Existing server admission and observer selection own state.
class ERR_ObserverGuidance
{
static string Message(int reason, bool survivorAvailable)
{
if (reason == ERR_ObserverReason.NONE) return "";
string message = "You are spectating until the next round.";
if (reason == ERR_ObserverReason.SPENT_LIFE)
message = "Your life for this round has been used. You can play again next round.";
else if (reason == ERR_ObserverReason.LATE_EXTRACTION)
message = "Extraction has started. New prisoners can join next round.";
else if (reason == ERR_ObserverReason.SPAWN_UNAVAILABLE)
message = "Your prisoner could not be spawned. You are spectating until the next round.";
else if (reason == ERR_ObserverReason.UNCONSCIOUS)
{
message = "You are unconscious. Your body remains where you fell and teammates can still treat you. Your view returns automatically when you wake up.";
if (!survivorAvailable) return message + " No conscious teammate is currently available; the camera stays near your body.";
}
if (!survivorAvailable)
return message + " No teammate or body is currently available to follow.";
return message + " Press Left / Right arrow to change teammate or body (or /esc spectate next / /esc spectate previous). Press Enter to switch between third-person and the living teammate's camera. Player view waits in third-person if no live camera stream is available. Use camera look controls to orbit and zoom controls to change distance in third-person.";
}
static bool Refresh(bool shown, int previousReason, int reason, bool previousAvailable, bool survivorAvailable)
{
return reason != ERR_ObserverReason.NONE && (!shown || previousReason != reason || previousAvailable != survivorAvailable);
}
}
class ERR_ObserverCameraClass : SCR_ManualCameraClass {}
// Gate before SCR_ManualCamera activates its context: disabling only the follow
// component is too late, since the camera context can already consume chat keys.
class ERR_ObserverCamera : SCR_ManualCamera
{
override protected bool IsDisabledByMenu()
{
if (super.IsDisabledByMenu()) return true;
if (GetGame().GetInputManager().IsContextActive("ChatContext")) return true;
Widget focused = GetGame().GetWorkspace().GetFocusedWidget();
while (focused)
{
if (EditBoxWidget.Cast(focused)) return true;
focused = focused.GetParent();
}
return false;
}
}
// A local follow camera. It never possesses its target or offers free flight.
[BaseContainerProps(), SCR_BaseManualCameraComponentTitle()]
class ERR_FollowSurvivorCameraComponent : SCR_BaseManualCameraComponent
{
protected IEntity m_Target;
protected IEntity m_Vehicle;
protected float m_Yaw;
protected float m_Pitch = 20;
protected float m_Distance = 5;
protected bool m_LeftDown, m_RightDown, m_EnterDown;
protected int m_InputResumeFrames;
protected bool m_PlayerView;
protected ref ERR_ObserverHeadVisibility m_ViewHead = new ERR_ObserverHeadVisibility();
protected float m_OrbitFov, m_OrbitNear;
protected ref ERR_ObserverScopeDisplay m_ScopeDisplay = new ERR_ObserverScopeDisplay();
protected bool m_InputContextActive;
bool InputContextActive() { return m_InputContextActive; }
bool IsPlayerView() { return m_PlayerView; }
// Process one edge per press; menus still consume the state so holding a key
// while closing a menu cannot unexpectedly change the followed teammate.
void Input(bool enabled, bool left, bool right, bool enter)
{
// An inactive context reports zero even while a physical key is held. Let
// the reactivated context settle, then require release before accepting keys.
if (!enabled) m_InputResumeFrames = 2;
else if (m_InputResumeFrames > 0)
{
enabled = false;
if (m_InputResumeFrames > 1 || (!left && !right && !enter)) m_InputResumeFrames--;
}
SCR_PlayerController controller = SCR_PlayerController.Cast(GetGame().GetPlayerController());
int cycle = ERR_ObserverRules.Cycle(enabled, left, right, m_LeftDown, m_RightDown);
if (controller && cycle != 0) controller.ERR_CycleObserver(cycle);
if (ERR_ObserverRules.Toggle(enabled, enter, m_EnterDown)) m_PlayerView = !m_PlayerView;
m_LeftDown = left; m_RightDown = right; m_EnterDown = enter;
}
override bool EOnCameraInit()
{
m_OrbitFov = GetCameraEntity().GetVerticalFOV();
m_OrbitNear = GetCameraEntity().GetNearPlane();
return true;
}
override void EOnCameraExit() { m_ScopeDisplay.Close(); m_ViewHead.Restore(); }
override void EOnCameraFrame(SCR_ManualCameraParam param)
{
SCR_PlayerController controller = SCR_PlayerController.Cast(GetGame().GetPlayerController());
if (!controller || GetGame().GetCameraManager().CurrentCamera() != GetCameraEntity()) { m_ScopeDisplay.Close(); m_ViewHead.Restore(); return; }
m_InputContextActive = GetInputManager().IsContextActive("ERR_ObserverContext");
Input(param.isManualInputEnabled, GetInputManager().GetActionValue("ERR_ObserverPrevious") > 0.5, GetInputManager().GetActionValue("ERR_ObserverNext") > 0.5, GetInputManager().GetActionValue("ERR_ObserverView") > 0.5);
IEntity target = controller.ERR_ObservedEntity();
float fov, nearPlane;
if (m_PlayerView && controller.ERR_ReadPlayerView(target, param.timeSlice, param.transform, fov, nearPlane))
{
param.fov = fov; GetCameraEntity().SetNearPlane(nearPlane);
m_ViewHead.Update(target, param.transform[3]);
RplId scopeWeapon; vector scopeData;
controller.ERR_ReadScope(scopeWeapon, scopeData);
SCR_2DOpticsComponent optic = ERR_ObserverScope.Resolve(target, scopeWeapon, scopeData);
IEntity weapon;
if (optic)
{
RplComponent weaponRpl = RplComponent.Cast(Replication.FindItem(scopeWeapon));
if (weaponRpl) weapon = weaponRpl.GetEntity();
}
if (!param.isManualInputEnabled || !optic || !weapon || !m_ScopeDisplay.RenderScope(optic, weapon, fov, scopeData)) m_ScopeDisplay.Close();
param.isDirty = true;
return;
}
// No estimated head camera: corpses, streaming gaps and expired samples use
// the stable follow view until an authenticated live camera stream arrives.
m_ScopeDisplay.Close();
m_ViewHead.Restore();
param.fov = m_OrbitFov; GetCameraEntity().SetNearPlane(m_OrbitNear);
vector aim = controller.ERR_ObserverAnchor() + "0 1.5 0";
vector position = aim + "0 4 -6";
IEntity exclude = target;
if (target)
{
IEntity vehicle = CompartmentAccessComponent.GetVehicleIn(target);
vector transform[4];
if (vehicle)
{
vehicle.GetWorldTransform(transform);
vector lower, upper;
vehicle.GetWorldBounds(lower, upper);
aim = (lower + upper) * 0.5;
exclude = vehicle;
}
else
{
target.GetWorldTransform(transform);
aim = transform[3] + "0 1.5 0";
if (!ERR_Actors.Alive(target)) aim = transform[3] + "0 0.4 0";
}
if (target != m_Target || vehicle != m_Vehicle)
{
vector angles = transform[2].VectorToAngles();
m_Yaw = angles[0] + 180; m_Pitch = 20; m_Distance = 5;
if (vehicle) m_Distance = 12;
m_Target = target; m_Vehicle = vehicle;
}
if ((!m_PlayerView || !ERR_Actors.Alive(target)) && param.isManualInputEnabled)
{
m_Yaw += GetInputManager().GetActionValue("ManualCameraRotateYaw") * 90 * param.timeSlice;
m_Pitch = Math.Clamp(m_Pitch - GetInputManager().GetActionValue("ManualCameraRotatePitch") * 90 * param.timeSlice, 5, 75);
float scale = Math.Clamp(1 + GetInputManager().GetActionValue("ManualCameraZoom") * 12 * param.timeSlice, 0.5, 1.5);
float minimum = 2, maximum = 12;
if (vehicle) { minimum = 6; maximum = 25; }
m_Distance = Math.Clamp(m_Distance * scale, minimum, maximum);
}
float yaw = m_Yaw * Math.DEG2RAD, pitch = m_Pitch * Math.DEG2RAD;
vector offset = Vector(Math.Sin(yaw) * Math.Cos(pitch), Math.Sin(pitch), Math.Cos(yaw) * Math.Cos(pitch));
position = aim + offset * m_Distance;
}
TraceParam trace = new TraceParam();
trace.Start = aim;
trace.End = position;
trace.Flags = TraceFlags.WORLD | TraceFlags.ENTS;
trace.LayerMask = TRACE_LAYER_CAMERA;
trace.Exclude = exclude;
float fraction = GetCameraEntity().GetWorld().TraceMove(trace, null);
if (fraction < 1) position = vector.Lerp(aim, position, Math.Max(0.05, fraction - 0.05));
Math3D.DirectionAndUpMatrix(vector.Direction(position, aim), "0 1 0", param.transform);
param.transform[3] = position;
param.isDirty = true;
}
}
modded class SCR_PlayerController
{
[RplProp()]
protected ERR_ObserverReason m_ERRObserverReason;
[RplProp()]
protected RplId m_ERRObservedId = RplId.Invalid();
[RplProp()]
protected vector m_ERRObserverAnchor;
protected IEntity m_ERRServerObserved;
protected IEntity m_ERRServerObservedVehicle;
protected SCR_ManualCamera m_ERRObserverCamera;
protected bool m_ERRObserverMonitor;
protected bool m_ERRObserverReady;
protected ERR_ObserverReason m_ERRShownObserverReason;
protected bool m_ERRShownObserverAvailable;
protected string m_ERRShownRecoveryStatus;
protected float m_ERRLastCycle = -1000;
protected IEntity m_ERRRecoveryBody;
protected float m_ERRRecoveryDeadline = -1;
ERR_ObserverReason ERR_ObserverState() { return m_ERRObserverReason; }
vector ERR_ObserverAnchor() { return m_ERRObserverAnchor; }
IEntity ERR_ObservedEntity()
{
RplComponent component = RplComponent.Cast(Replication.FindItem(m_ERRObservedId));
if (!component) return null;
return component.GetEntity();
}
bool ERR_HasObserverCamera() { return m_ERRObserverCamera != null; }
void ERR_SetObserver(ERR_ObserverReason reason)
{
if (!Replication.IsServer()) return;
if (reason != ERR_ObserverReason.NONE && ERR_Actors.Alive(GetControlledEntity()) && reason != ERR_ObserverReason.UNCONSCIOUS) return;
m_ERRObserverReason = reason;
ERR_GameMode mode = ERR_GameMode.Get();
if (mode && reason != ERR_ObserverReason.NONE) m_ERRObserverAnchor = mode.PrisonPosition();
if (reason == ERR_ObserverReason.NONE) ERR_ReleaseObserved();
Replication.BumpMe();
ERR_UpdateObserverServer();
}
protected void ERR_StreamObserved(IEntity entity, bool normalStreaming)
{
RplIdentity identity = GetRplIdentity();
if (!identity.IsValid() || identity == RplIdentity.Local() || !entity) return;
RplComponent component = RplComponent.Cast(entity.FindComponent(RplComponent));
if (component) component.EnableStreamingConNode(identity, normalStreaming);
}
protected void ERR_ReleaseObserved()
{
ERR_StreamObserved(m_ERRServerObserved, true);
ERR_StreamObserved(m_ERRServerObservedVehicle, true);
m_ERRServerObserved = null;
m_ERRServerObservedVehicle = null;
m_ERRObservedId = RplId.Invalid();
}
void ERR_UpdateObserverServer(int direction = 0)
{
if (!Replication.IsServer()) return;
ERR_GameMode mode = ERR_GameMode.Get();
IEntity body = GetControlledEntity();
bool casualty = mode && ERR_ObserverRules.Casualty(mode.Active(), mode.Players() && mode.Players().CurrentActor(body) != null, ERR_Actors.Alive(body), ERR_Actors.CanFight(body));
if (casualty && m_ERRObserverReason != ERR_ObserverReason.UNCONSCIOUS)
{
m_ERRObserverReason = ERR_ObserverReason.UNCONSCIOUS;
m_ERRObserverAnchor = body.GetOrigin();
}
if (m_ERRObserverReason == ERR_ObserverReason.UNCONSCIOUS && !ERR_Actors.Alive(body)) m_ERRObserverReason = ERR_ObserverReason.SPENT_LIFE;
// Death can leave the controller attached to its corpse, so entity-lost is
// not a reliable trigger (especially with the last/only player).
ERR_PlayerLife life;
if (mode && mode.Players()) life = mode.Players().Get(GetPlayerId());
if (mode && mode.Active() && life && life.UsedLife && life.Actor && !ERR_Actors.Alive(life.Actor) && !ERR_Actors.Alive(body) && m_ERRObserverReason == ERR_ObserverReason.NONE)
{
m_ERRObserverReason = ERR_ObserverReason.SPENT_LIFE;
m_ERRObserverAnchor = life.Actor.GetOrigin();
}
if (m_ERRObserverReason == ERR_ObserverReason.NONE) return;
if (!mode || !mode.Active() || (ERR_Actors.Alive(body) && !casualty) || (m_ERRObserverReason == ERR_ObserverReason.UNCONSCIOUS && !casualty))
{
m_ERRObserverReason = ERR_ObserverReason.NONE;
ERR_ReleaseObserved();
Replication.BumpMe();
return;
}
array<IEntity> survivors = {};
ERR_Actors.Players(survivors);
Faction friendly = mode.PlayerFaction();
for (int i = survivors.Count() - 1; i >= 0; i--)
if (survivors[i] == body || (casualty && !ERR_Actors.CanFight(survivors[i])) || !friendly || !mode.Players() || !mode.Players().CurrentActor(survivors[i]) || SCR_FactionManager.SGetFaction(survivors[i]) != friendly) survivors.RemoveOrdered(i);
// Dead teammates remain selectable alongside survivors, including our own body.
ERR_ObserverTargets.Bodies(mode, survivors);
int index = survivors.Find(m_ERRServerObserved);
if (index < 0)
{
if (life && life.Actor) index = survivors.Find(life.Actor);
if (index < 0) index = 0;
}
else index += direction;
if (index < 0) index = survivors.Count() - 1;
if (index >= survivors.Count()) index = 0;
IEntity target;
if (!survivors.IsEmpty()) target = survivors[index];
if (target != m_ERRServerObserved)
{
ERR_ReleaseObserved();
m_ERRServerObserved = target;
if (target)
{
RplComponent component = RplComponent.Cast(target.FindComponent(RplComponent));
if (component) m_ERRObservedId = component.Id();
ERR_StreamObserved(target, false);
}
}
if (target)
{
m_ERRObserverAnchor = target.GetOrigin();
IEntity vehicle = CompartmentAccessComponent.GetVehicleIn(target);
if (vehicle != m_ERRServerObservedVehicle)
{
ERR_StreamObserved(m_ERRServerObservedVehicle, true);
m_ERRServerObservedVehicle = vehicle;
ERR_StreamObserved(vehicle, false);
}
}
else if (casualty) m_ERRObserverAnchor = body.GetOrigin();
Replication.BumpMe();
}
void ERR_CycleObserver(int direction)
{
if (this == GetGame().GetPlayerController()) Rpc(ERR_RequestObserverCycle, direction);
}
[RplRpc(RplChannel.Reliable, RplRcver.Server)]
protected void ERR_RequestObserverCycle(int direction)
{
if (!Replication.IsServer() || (direction != -1 && direction != 1)) return;
float now = GetGame().GetWorld().GetWorldTime();
if (now - m_ERRLastCycle < 250) return;
m_ERRLastCycle = now;
ERR_UpdateObserverServer(direction);
}
void ERR_StartObserverMonitor()
{
if (this != GetGame().GetPlayerController() || System.IsConsoleApp() || m_ERRObserverMonitor) return;
m_ERRObserverMonitor = true;
ERR_OnObserverMonitorStarted();
GetGame().GetCallqueue().CallLater(ERR_UpdateObserverClient, 250, true);
}
protected void ERR_OnObserverMonitorStarted() {}
protected void ERR_UpdateObserverClient()
{
if (!GetGame()) return;
if (this != GetGame().GetPlayerController())
{
// A replaced controller may retain its timer until native destruction.
// Release only its presentation; never restore its old body camera.
GetGame().GetCallqueue().Remove(ERR_UpdateObserverClient);
m_ERRObserverMonitor = false;
m_ERRRecoveryBody = null; m_ERRRecoveryDeadline = -1;
ERR_CloseObserverCamera();
return;
}
ERR_GameMode mode = ERR_GameMode.Get();
ERR_UpdateRecoveryCamera(mode);
bool observe = mode && ERR_ObserverRules.View(m_ERRObserverReason, mode.Active(), ERR_Actors.Alive(GetControlledEntity()), ERR_Actors.CanFight(GetControlledEntity()));
if (!observe)
{
ERR_CloseObserverCamera();
return;
}
SCR_EditorManagerEntity editor = SCR_EditorManagerEntity.GetInstance();
if (editor && editor.IsOpened()) return;
if (!m_ERRObserverCamera)
{
Resource resource = Resource.Load("{EB1210AAE1BB8F54}Prefabs/ERR/SpectatorCamera.et");
if (!resource || !resource.IsValid()) return;
EntitySpawnParams params = new EntitySpawnParams();
params.TransformMode = ETransformMode.WORLD;
params.Transform[3] = m_ERRObserverAnchor + "0 5 -6";
m_ERRObserverCamera = SCR_ManualCamera.Cast(GetGame().SpawnEntityPrefabLocal(resource, GetGame().GetWorld(), params));
if (!m_ERRObserverCamera) return;
}
CameraManager manager = GetGame().GetCameraManager();
if (!manager) return;
// Native death/respawn camera changes can arrive after our camera is created.
if (manager.CurrentCamera() != m_ERRObserverCamera) manager.SetCamera(m_ERRObserverCamera);
if (manager.CurrentCamera() != m_ERRObserverCamera) return;
SCR_RespawnSystemComponent respawn = SCR_RespawnSystemComponent.GetInstance();
if (respawn) respawn.DestroyLoadingPlaceholder();
// The server-selected replicated ID distinguishes no target from a target
// whose local entity is still streaming. Never imply no survivors from delay.
bool survivorAvailable = m_ERRObservedId != RplId.Invalid();
string recovery = mode.RecoveryStatus();
if (ERR_ObserverGuidance.Refresh(m_ERRObserverReady, m_ERRShownObserverReason, m_ERRObserverReason, m_ERRShownObserverAvailable, survivorAvailable) || m_ERRShownRecoveryStatus != recovery)
{
SCR_HintManagerComponent hints = SCR_HintManagerComponent.GetInstance();
if (!hints) return; // retry on the existing monitor; do not lose the first hint
string message = ERR_ObserverGuidance.Message(m_ERRObserverReason, survivorAvailable);
if (!recovery.IsEmpty()) message += "\n" + recovery;
if (!hints.ShowCustom(message, "Spectating", 12)) return;
m_ERRObserverReady = true;
m_ERRShownObserverReason = m_ERRObserverReason;
m_ERRShownObserverAvailable = survivorAvailable;
m_ERRShownRecoveryStatus = recovery;
}
}
// Track the actual local body even when an editor/other camera owns the view.
// Run once per recovery, with retries for asynchronous editor close/camera setup.
protected void ERR_UpdateRecoveryCamera(ERR_GameMode mode)
{
IEntity body = GetControlledEntity();
if (!mode || !mode.Active() || !ERR_Actors.Alive(body))
{ m_ERRRecoveryBody = null; m_ERRRecoveryDeadline = -1; return; }
if (!ERR_Actors.CanFight(body))
{ m_ERRRecoveryBody = body; m_ERRRecoveryDeadline = -1; return; }
if (!m_ERRRecoveryBody) return;
if (body != m_ERRRecoveryBody)
{ m_ERRRecoveryBody = null; m_ERRRecoveryDeadline = -1; return; }
float now = GetGame().GetWorld().GetWorldTime();
if (m_ERRRecoveryDeadline < 0) m_ERRRecoveryDeadline = now + 10000;
SCR_EditorManagerEntity editor = SCR_EditorManagerEntity.GetInstance();
if (editor && editor.IsOpened()) editor.Close(false);
CameraManager manager = GetGame().GetCameraManager();
CameraBase playerCamera = GetPlayerCamera();
if (manager && playerCamera) manager.SetCamera(playerCamera);
if ((manager && playerCamera && manager.CurrentCamera() == playerCamera && (!editor || !editor.IsOpened())) || now >= m_ERRRecoveryDeadline)
{
if (now >= m_ERRRecoveryDeadline) Print("Reintroduced [spectator]: recovery camera return timed out waiting for editor/camera; player body remains controlled", LogLevel.WARNING);
m_ERRRecoveryBody = null; m_ERRRecoveryDeadline = -1;
}
}
protected void ERR_CloseObserverCamera()
{
m_ERRObserverReady = false;
m_ERRShownRecoveryStatus = "";
if (!m_ERRObserverCamera) return;
if (GetGame().GetPlayerController() == this) m_ERRObserverCamera.TrySwitchToControlledEntityCamera();
m_ERRObserverCamera.Terminate();
delete m_ERRObserverCamera;
m_ERRObserverCamera = null;
}
void ~SCR_PlayerController()
{
if (GetGame())
{
GetGame().GetCallqueue().Remove(ERR_UpdateObserverClient);
ERR_CloseObserverCamera();
if (Replication.IsServer()) ERR_ReleaseObserved();
}
}
}
docs/evidence/observer-pip-2026-10-09/baseline/addons/core/Scripts/Game/ERR/00_Core/ERR_ObserverPlayerView.c
+259
View File
@@ -0,0 +1,259 @@
// Camera poses are cosmetic, owner-sampled and relayed only to authorized
// spectators of that body. No client-supplied position affects gameplay.
class ERR_ObserverViewRules
{
// The body and camera arrive through independently timed replication streams.
// Keep the sampled world axes and world-axis eye offset together. Applying
// the proxy body's rotation to delayed body-local aim adds its yaw error to
// both aim and eye position, even when the owner's camera is steady.
static void Encode(vector body[4], vector view[4], out vector pose[4])
{
for (int axis = 0; axis < 3; axis++) pose[axis] = view[axis];
pose[3] = view[3] - body[3];
}
static void Decode(vector body[4], vector pose[4], out vector view[4])
{
for (int axis = 0; axis < 3; axis++) view[axis] = pose[axis];
view[3] = body[3] + pose[3];
}
static bool Sample(vector position, vector forward, vector up, float fov, float nearPlane)
{
// Negated bounded comparisons also reject NaN/infinity before matrix math.
if (!(position.LengthSq() <= 900) || !(fov >= 1 && fov <= 150) || !(nearPlane >= 0.005 && nearPlane <= 2)) return false;
if (!(forward.LengthSq() >= 0.9 && forward.LengthSq() <= 1.1) || !(up.LengthSq() >= 0.9 && up.LengthSq() <= 1.1)) return false;
return Math.AbsFloat(vector.Dot(forward, up)) <= 0.05;
}
static bool Fresh(float now, float received) { return received >= 0 && now >= received && now - received <= 350; }
}
// Keep actual sampled poses on a short timeline instead of restarting a blend
// on every packet arrival. Only presentation is delayed; possession is unchanged.
class ERR_ObserverViewSample
{
int Stamp;
vector Position, Forward, Up;
float Fov, Near;
}
class ERR_ObserverViewBuffer
{
protected RplId m_Target = RplId.Invalid();
protected int m_Stamp = -1;
protected RplId m_ScopeWeapon = RplId.Invalid();
protected vector m_ScopeData;
protected float m_Received = -1;
protected float m_Playback, m_ReadAt;
protected ref array<ref ERR_ObserverViewSample> m_Samples = {};
void Scope(out RplId weapon, out vector data) { weapon = m_ScopeWeapon; data = m_ScopeData; }
void Clear()
{
m_Target = RplId.Invalid(); m_Stamp = -1; m_Received = -1;
m_ScopeWeapon = RplId.Invalid(); m_ScopeData = vector.Zero;
m_Samples.Clear();
}
void Push(RplId target, int stamp, float now, vector position, vector forward, vector up, float fov, float nearPlane, RplId scopeWeapon, vector scopeData)
{
if (!ERR_ObserverScope.Valid(scopeWeapon, scopeData)) return;
if (!ERR_ObserverViewRules.Sample(position, forward, up, fov, nearPlane)) return;
if (target == m_Target && stamp <= m_Stamp) return;
if (target != m_Target || scopeWeapon != m_ScopeWeapon || scopeData[0] != m_ScopeData[0] || !ERR_ObserverViewRules.Fresh(now, m_Received))
{
m_Samples.Clear();
m_Playback = stamp - 100; m_ReadAt = now;
}
ERR_ObserverViewSample sample = new ERR_ObserverViewSample();
sample.Stamp = stamp; sample.Position = position; sample.Forward = forward; sample.Up = up;
sample.Fov = fov; sample.Near = nearPlane;
m_Samples.Insert(sample);
// Bounded even when first-person view is not being rendered.
while (m_Samples.Count() > 12) m_Samples.Remove(0);
m_ScopeWeapon = scopeWeapon; m_ScopeData = scopeData;
m_Target = target; m_Stamp = stamp; m_Received = now;
}
bool Read(RplId target, float now, float seconds, out vector local[4], out float fov, out float nearPlane)
{
if (target != m_Target || !ERR_ObserverViewRules.Fresh(now, m_Received) || m_Samples.IsEmpty()) return false;
// Use elapsed local time, not the number of reads or a packet's arrival time.
// No clock synchronization between clients is required: stamps are relative.
if (now - m_ReadAt > 250) m_Playback = m_Stamp - 100;
else m_Playback += Math.Max(0, now - m_ReadAt);
m_ReadAt = now;
// A long render stall resumes near live rather than replaying old movement.
if (m_Stamp - m_Playback > 250) m_Playback = m_Stamp - 100;
// Never extrapolate through walls or invent aim during a packet gap.
m_Playback = Math.Min(m_Playback, m_Stamp);
while (m_Samples.Count() > 2 && m_Samples[1].Stamp <= m_Playback) m_Samples.Remove(0);
ERR_ObserverViewSample start = m_Samples[0];
ERR_ObserverViewSample end = start;
if (m_Samples.Count() > 1) end = m_Samples[1];
float blend = 0;
if (end.Stamp > start.Stamp) blend = Math.Clamp((m_Playback - start.Stamp) / (end.Stamp - start.Stamp), 0, 1);
vector forward = vector.Lerp(start.Forward, end.Forward, blend);
vector up = vector.Lerp(start.Up, end.Up, blend);
if (forward.LengthSq() < 0.1 || up.LengthSq() < 0.1) { forward = end.Forward; up = end.Up; }
forward.Normalize(); up.Normalize();
if (Math.AbsFloat(vector.Dot(forward, up)) > 0.95) { forward = end.Forward; up = end.Up; }
Math3D.DirectionAndUpMatrix(forward, up, local);
local[3] = vector.Lerp(start.Position, end.Position, blend);
fov = Math.Lerp(start.Fov, end.Fov, blend); nearPlane = end.Near;
return true;
}
}
modded class SCR_PlayerController
{
protected ref ERR_ObserverViewBuffer m_ERRViewBuffer = new ERR_ObserverViewBuffer();
protected ref array<SCR_PlayerController> m_ERRViewWatchers = {};
protected float m_ERRViewServerRequestAt = -1000;
protected float m_ERRViewRequestAt = -1000, m_ERRViewLeaseUntil = -1;
protected float m_ERRViewPublishUntil = -1, m_ERRViewLeaseSent = -1000;
protected float m_ERRViewSendWait, m_ERRViewLastPacket = -1000;
protected int m_ERRViewSequence, m_ERRViewInputSequence;
protected IEntity m_ERRViewSourceBody;
bool ERR_ViewRecipient(IEntity target, float now)
{
ERR_GameMode mode = ERR_GameMode.Get();
return mode && mode.Active() && now <= m_ERRViewLeaseUntil && target && target == m_ERRServerObserved && ERR_Actors.CanFight(target) && mode.Players().CurrentActor(target) && SCR_FactionManager.SGetFaction(target) == mode.PlayerFaction() && GetGame().GetPlayerManager().GetPlayerController(GetPlayerId()) == this && ERR_ObserverRules.View(m_ERRObserverReason, true, ERR_Actors.Alive(GetControlledEntity()), ERR_Actors.CanFight(GetControlledEntity()));
}
void ERR_ReadScope(out RplId weapon, out vector data) { m_ERRViewBuffer.Scope(weapon, data); }
bool ERR_ReadPlayerView(IEntity target, float seconds, out vector transform[4], out float fov, out float nearPlane)
{
if (this != GetGame().GetPlayerController() || !target || !ERR_Actors.CanFight(target)) return false;
float now = GetGame().GetWorld().GetWorldTime();
if (now - m_ERRViewRequestAt >= 500)
{ m_ERRViewRequestAt = now; Rpc(ERR_RequestPlayerView); }
vector pose[4], world[4];
if (!m_ERRViewBuffer.Read(m_ERRObservedId, now, seconds, pose, fov, nearPlane)) return false;
RplId scopeWeapon; vector scopeData;
m_ERRViewBuffer.Scope(scopeWeapon, scopeData);
if (scopeWeapon != RplId.Invalid() && !ERR_ObserverScope.Resolve(target, scopeWeapon, scopeData)) return false;
target.GetWorldTransform(world);
ERR_ObserverViewRules.Decode(world, pose, transform);
return true;
}
[RplRpc(RplChannel.Reliable, RplRcver.Server)]
protected void ERR_RequestPlayerView()
{
if (!Replication.IsServer()) return;
float now = GetGame().GetWorld().GetWorldTime();
if (now - m_ERRViewServerRequestAt < 250) return;
m_ERRViewServerRequestAt = now;
// A lease grants no observer rights; all existing server selection/roster
// checks still apply, both here and when each sample is forwarded.
m_ERRViewLeaseUntil = now + 1500;
if (!ERR_ViewRecipient(m_ERRServerObserved, now)) return;
ERR_PlayerLife life = ERR_GameMode.Get().Players().CurrentActor(m_ERRServerObserved);
SCR_PlayerController source = SCR_PlayerController.Cast(GetGame().GetPlayerManager().GetPlayerController(life.ConnectionId));
if (source) source.ERR_AddViewWatcher(this, now);
}
void ERR_AddViewWatcher(SCR_PlayerController watcher, float now)
{
if (!Replication.IsServer() || !watcher) return;
for (int i = m_ERRViewWatchers.Count() - 1; i >= 0; i--)
if (!m_ERRViewWatchers[i] || !m_ERRViewWatchers[i].ERR_ViewRecipient(GetControlledEntity(), now)) m_ERRViewWatchers.Remove(i);
if (!m_ERRViewWatchers.Contains(watcher) && m_ERRViewWatchers.Count() < 64) m_ERRViewWatchers.Insert(watcher);
if (now - m_ERRViewLeaseSent < 250) return;
m_ERRViewLeaseSent = now;
Rpc(ERR_EnableViewPublisher);
}
[RplRpc(RplChannel.Reliable, RplRcver.Owner)]
protected void ERR_EnableViewPublisher()
{
if (this == GetGame().GetPlayerController()) m_ERRViewPublishUntil = GetGame().GetWorld().GetWorldTime() + 2000;
}
void ERR_PublishPlayerView(float seconds)
{
if (this != GetGame().GetPlayerController() || System.IsConsoleApp()) return;
float now = GetGame().GetWorld().GetWorldTime();
if (now > m_ERRViewPublishUntil) return;
m_ERRViewSendWait += seconds;
if (m_ERRViewSendWait < 0.05) return;
m_ERRViewSendWait = 0;
ERR_GameMode mode = ERR_GameMode.Get();
IEntity actor = GetControlledEntity();
PlayerCamera camera = GetPlayerCamera();
CameraManager manager = GetGame().GetCameraManager();
if (!mode || !mode.Active() || !ERR_Actors.CanFight(actor) || !camera || !manager || manager.CurrentCamera() != camera) return;
vector world[4], view[4], pose[4];
actor.GetWorldTransform(world);
camera.GetWorldCameraTransform(view);
float fov = camera.GetVerticalFOV(), nearPlane = camera.GetNearPlane();
RplId scopeWeapon; vector scopeData;
ERR_ObserverScope.Sample(actor, view, fov, scopeWeapon, scopeData);
ERR_ObserverViewRules.Encode(world, view, pose);
if (!ERR_ObserverViewRules.Sample(pose[3], pose[2], pose[1], fov, nearPlane)) return;
Rpc(ERR_SubmitPlayerView, ++m_ERRViewSequence, pose[3], pose[2], pose[1], fov, nearPlane, scopeWeapon, scopeData);
}
[RplRpc(RplChannel.Unreliable, RplRcver.Server)]
protected void ERR_SubmitPlayerView(int sequence, vector position, vector forward, vector up, float fov, float nearPlane, RplId scopeWeapon, vector scopeData)
{
if (!Replication.IsServer() || !ERR_ObserverScope.Valid(scopeWeapon, scopeData) || !ERR_ObserverViewRules.Sample(position, forward, up, fov, nearPlane)) return;
ERR_GameMode mode = ERR_GameMode.Get();
IEntity actor = GetControlledEntity();
if (!mode || !mode.Active() || !ERR_Actors.CanFight(actor)) return;
ERR_PlayerLife life = mode.Players().CurrentActor(actor);
if (!life || GetGame().GetPlayerManager().GetPlayerController(life.ConnectionId) != this) return;
float now = GetGame().GetWorld().GetWorldTime();
if (actor != m_ERRViewSourceBody) { m_ERRViewSourceBody = actor; m_ERRViewInputSequence = 0; }
if (sequence <= m_ERRViewInputSequence || now - m_ERRViewLastPacket < 35) return;
m_ERRViewInputSequence = sequence; m_ERRViewLastPacket = now;
RplComponent component = RplComponent.Cast(actor.FindComponent(RplComponent));
if (!component) return;
for (int i = m_ERRViewWatchers.Count() - 1; i >= 0; i--)
{
SCR_PlayerController watcher = m_ERRViewWatchers[i];
if (!watcher || !watcher.ERR_ViewRecipient(actor, now)) { m_ERRViewWatchers.Remove(i); continue; }
watcher.ERR_DeliverPlayerView(component.Id(), now, position, forward, up, fov, nearPlane, scopeWeapon, scopeData);
}
}
void ERR_DeliverPlayerView(RplId target, int stamp, vector position, vector forward, vector up, float fov, float nearPlane, RplId scopeWeapon, vector scopeData)
{
Rpc(ERR_ReceivePlayerViewPacket, target, stamp, position, forward, up, Vector(fov, nearPlane, 0), scopeWeapon, scopeData);
}
[RplRpc(RplChannel.Unreliable, RplRcver.Owner)]
protected void ERR_ReceivePlayerViewPacket(RplId target, int stamp, vector position, vector forward, vector up, vector lens, RplId scopeWeapon, vector scopeData)
{
ERR_ReceivePlayerView(target, stamp, position, forward, up, lens[0], lens[1], scopeWeapon, scopeData);
}
protected void ERR_ReceivePlayerView(RplId target, int stamp, vector position, vector forward, vector up, float fov, float nearPlane, RplId scopeWeapon, vector scopeData)
{
ERR_GameMode mode = ERR_GameMode.Get();
if (this != GetGame().GetPlayerController() || target == RplId.Invalid() || target != m_ERRObservedId || !mode || !ERR_ObserverRules.View(m_ERRObserverReason, mode.Active(), ERR_Actors.Alive(GetControlledEntity()), ERR_Actors.CanFight(GetControlledEntity()))) return;
m_ERRViewBuffer.Push(target, stamp, GetGame().GetWorld().GetWorldTime(), position, forward, up, fov, nearPlane, scopeWeapon, scopeData);
}
}
modded class ArmaReforgerScripted
{
override void OnUpdate(BaseWorld world, float timeslice)
{
super.OnUpdate(world, timeslice);
SCR_PlayerController controller = SCR_PlayerController.Cast(GetPlayerController());
if (controller) controller.ERR_PublishPlayerView(timeslice);
}
}
// Use the game's own head/helmet fade rather than moving the camera ahead of
// the face. Changes are local and reversed when the observer stops using them.
class ERR_ObserverHeadVisibility
{
protected SCR_ChimeraCharacter m_Character;
protected SCR_CharacterCameraHandlerComponent m_Handler;
protected int m_Previous, m_Applied;
void Update(IEntity target, vector cameraPosition)
{
if (target != m_Character)
{
Restore();
m_Character = SCR_ChimeraCharacter.Cast(target);
if (!m_Character || !m_Character.GetCharacterController()) return;
m_Handler = SCR_CharacterCameraHandlerComponent.Cast(m_Character.GetCharacterController().GetCameraHandlerComponent());
m_Previous = m_Character.m_fFaceAlphaTest;
}
if (!m_Handler || !m_Character.GetAnimation()) return;
m_Handler.UpdateHeadVisibility(cameraPosition);
m_Applied = m_Character.m_fFaceAlphaTest;
}
void Restore()
{
if (m_Handler && m_Character && m_Character.m_fFaceAlphaTest == m_Applied) m_Handler.OnAlphatestChange(m_Previous);
m_Character = null; m_Handler = null;
}
void ~ERR_ObserverHeadVisibility() { Restore(); }
}
docs/evidence/observer-pip-2026-10-09/baseline/addons/core/Scripts/Game/ERR/00_Core/ERR_ObserverScope.c
+134
View File
@@ -0,0 +1,134 @@
// Presentation only. Scoped spectators use a private full-screen optic display;
// never activate the remote sight (which registers weapon input and changes HUD).
class ERR_ObserverScope
{
static bool Valid(RplId weapon, vector data)
{
if (weapon == RplId.Invalid()) return data == vector.Zero;
return data[0] >= 1 && data[0] <= 32 && data[0] == Math.Round(data[0]) && data[1] >= -90 && data[1] <= 90 && (data[2] == 0 || data[2] == 1);
}
static void Sample(IEntity actor, out vector view[4], out float fov, out RplId weaponId, out vector data)
{
weaponId = RplId.Invalid(); data = vector.Zero;
ChimeraCharacter character = ChimeraCharacter.Cast(actor);
if (!character) return;
CharacterControllerComponent control = character.GetCharacterController();
if (!control || !control.IsWeaponADS()) return;
BaseWeaponManagerComponent weapons = control.GetWeaponManagerComponent();
if (!weapons || !weapons.GetCurrentWeapon()) return;
SCR_2DOpticsComponent optic = SCR_2DOpticsComponent.Cast(weapons.GetCurrentSights());
if (!optic || !optic.IsSightADSActive()) return;
RplComponent rpl = RplComponent.Cast(weapons.GetCurrentWeapon().GetOwner().FindComponent(RplComponent));
if (!rpl || rpl.Id() == RplId.Invalid()) return;
float scopeFov = optic.GetFOV();
if (!(scopeFov >= 1 && scopeFov <= 150)) return;
vector sample = Vector(weapons.GetCurrentSightsIndex() + 1, optic.GetCurrentReticleOffsetY(), 0);
if (optic.ERR_ObserverIlluminated()) sample[2] = 1;
if (!Valid(rpl.Id(), sample)) return;
// A PiP sight has its own sight-line camera. Use that direction rather than
// magnifying the peripheral eye camera, which need not point down the scope.
SCR_2DPIPSightsComponent pip = SCR_2DPIPSightsComponent.Cast(optic);
if (pip && pip.IsPIPEnabled())
{
if (!pip.GetPIPCamera()) return;
pip.GetPIPCamera().GetWorldCameraTransform(view);
}
weaponId = rpl.Id(); data = sample; fov = scopeFov;
}
static SCR_2DOpticsComponent Resolve(IEntity target, RplId weaponId, vector data)
{
if (weaponId == RplId.Invalid() || !Valid(weaponId, data)) return null;
ChimeraCharacter character = ChimeraCharacter.Cast(target);
if (!character || !character.GetCharacterController()) return null;
BaseWeaponManagerComponent weapons = character.GetCharacterController().GetWeaponManagerComponent();
if (!weapons || !weapons.GetCurrentWeapon() || weapons.GetCurrentSightsIndex() + 1 != data[0]) return null;
RplComponent rpl = RplComponent.Cast(weapons.GetCurrentWeapon().GetOwner().FindComponent(RplComponent));
if (!rpl || rpl.Id() != weaponId) return null;
return SCR_2DOpticsComponent.Cast(weapons.GetCurrentSights());
}
}
modded class SCR_2DOpticsComponent
{
bool ERR_ObserverIlluminated() { return m_bIsIlluminationOn; }
}
// Reuse the native reticle textures, angular sizing and vignette layout, without
// registering with the player's HUD, ADS invokers, weapon input or visibility.
class ERR_ObserverScopeDisplay : SCR_2DOpticsDisplay
{
protected ref Widget m_ERRScopeRoot; // Native HUD normally owns this strong reference.
protected IEntity m_ERRHiddenWeapon, m_ERRHiddenOptic;
protected float m_ERRFov;
bool RenderScope(SCR_2DOpticsComponent optic, IEntity weapon, float fov, vector data)
{
if (!optic || !weapon) { Close(); return false; }
if (!m_wRoot)
{
m_ERRScopeRoot = GetGame().GetWorkspace().CreateWidgets("{4CE66FA8219D33D7}UI/layouts/Sights/Optic_Default.layout");
m_wRoot = m_ERRScopeRoot;
if (!m_wRoot) return false;
FindWidgets();
if (!m_wLayoutRear || !m_wLayoutFront || !m_wImgReticle || !m_wImgCover || !m_wBlur || !m_wRearFillLeft || !m_wRearFillTop || !m_wFrontFillLeft || !m_wFrontFillTop) { Close(); return false; }
m_wRoot.SetFlags(WidgetFlags.IGNORE_CURSOR);
m_wRoot.SetZOrder(1); // Standalone workspace root must be above the game viewport.
}
m_ERRFov = fov;
if (m_Optic != optic)
{
RestoreWeapon();
m_Optic = optic;
GetOpticData();
SetupOpticImage();
// Hide only this locally rendered weapon, never the soldier or inventory.
if ((weapon.GetFlags() & EntityFlags.VISIBLE) != 0)
{ m_ERRHiddenWeapon = weapon; weapon.ClearFlags(EntityFlags.VISIBLE, false); }
IEntity opticOwner = optic.GetOwner();
if (opticOwner != weapon && (opticOwner.GetFlags() & EntityFlags.VISIBLE) != 0)
{ m_ERRHiddenOptic = opticOwner; opticOwner.ClearFlags(EntityFlags.VISIBLE, false); }
}
UpdateCurrentFov();
// Native layout uses fill widgets rather than centered anchors. Recompute
// these for resolution/DPI changes, without adding remote animation sway.
WorkspaceWidget workspace = GetGame().GetWorkspace();
float width, height;
workspace.GetScreenSize(width, height);
width = workspace.DPIUnscale(width); height = workspace.DPIUnscale(height);
UpdateScale(1, 1, 1);
m_wFrontFillLeft.SetWidthOverride(LayerDefaultPosition(width, m_fObjectiveSize));
m_wFrontFillTop.SetHeightOverride(LayerDefaultPosition(height, m_fObjectiveSize));
m_wRearFillLeft.SetWidthOverride(LayerDefaultPosition(width, m_fVignetteSize));
m_wRearFillTop.SetHeightOverride(LayerDefaultPosition(height, m_fVignetteSize));
SCR_2DOpticsComponentClass settings = SCR_2DOpticsComponentClass.Cast(optic.GetComponentData(optic.GetOwner()));
if (settings)
{
if (data[2] == 1 && settings.HasIllumination()) ChangeReticleTint(settings.GetReticleIlluminationColor(), settings.GetReticleIlluminationColor());
else ChangeReticleTint(settings.GetReticleColor(), settings.GetReticleOutlineColor());
}
// The relayed pose is already the aiming camera; don't add another local
// weapon-animation sway (remote proxies can be several frames behind).
SetReticleOffset(optic.GetReticleOffsetX(), data[1]);
m_wImgCover.SetVisible(false); m_wBlur.SetIntensity(0); m_wBlur.SetOpacity(0);
m_wRoot.SetOpacity(1); m_wRoot.SetVisible(true);
return true;
}
override void UpdateCurrentFov(bool forceUpdate = false)
{
if (!forceUpdate && float.AlmostEqual(m_fOpticCurrentFov, m_ERRFov)) return;
m_fOpticCurrentFov = m_ERRFov;
UpdateReticleSize();
}
protected void RestoreWeapon()
{
if (m_ERRHiddenWeapon && !m_ERRHiddenWeapon.IsDeleted()) m_ERRHiddenWeapon.SetFlags(EntityFlags.VISIBLE, false);
if (m_ERRHiddenOptic && !m_ERRHiddenOptic.IsDeleted()) m_ERRHiddenOptic.SetFlags(EntityFlags.VISIBLE, false);
m_ERRHiddenWeapon = null; m_ERRHiddenOptic = null;
}
void Close()
{
RestoreWeapon();
m_Optic = null;
if (m_wRoot) m_wRoot.RemoveFromHierarchy();
m_wRoot = null; m_ERRScopeRoot = null;
}
void ~ERR_ObserverScopeDisplay() { Close(); }
}
docs/evidence/observer-pip-2026-10-09/baseline/tests/test_observer_scope.py
+52
View File
@@ -0,0 +1,52 @@
"""Actual scope sampling/identity selection; native weapon/camera APIs doubled."""
from policy_harness import ROOT, body, run
p=ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_ObserverScope.c'
def adapt(s):
import re
s=s.replace('out vector view[4]', 'vector (&view)[4]').replace('out vector data','vector& data').replace('out float fov','float& fov').replace('out RplId weaponId','RplId& weaponId').replace('null','nullptr')
for cls in ('ChimeraCharacter','CharacterControllerComponent','BaseWeaponManagerComponent','SCR_2DOpticsComponent','SCR_2DPIPSightsComponent','RplComponent'):
s=re.sub(r'\b'+cls+r' (\w+)',cls+r'* \1',s);s=s.replace(cls+'.',cls+'::')
for name in ('character','control','weapons','optic','rpl','pip','actor'):
s=s.replace(name+'.',name+'->')
for name in ('GetCharacterController()','GetCurrentWeapon()','GetOwner()','GetPIPCamera()'):
s=s.replace(name+'.',name+'->')
s=s.replace('FindComponent(RplComponent)','FindComponent()').replace('RplId.','RplId::').replace('Math.','Math::').replace('vector.Zero','vector::Zero')
return s
run(r'''
#include <cassert>
#include <cmath>
#include <limits>
struct vector{float a=0,b=0,c=0;float&operator[](int i){return i==0?a:(i==1?b:c);}bool operator==(vector o){return a==o.a&&b==o.b&&c==o.c;}static vector Zero;};vector vector::Zero;
vector Vector(float a,float b,float c){return {a,b,c};}
struct RplId{int id=-1;RplId(int n=-1):id(n){}static RplId Invalid(){return {};}bool operator==(RplId o){return id==o.id;}bool operator!=(RplId o){return id!=o.id;}};
namespace Math{float Round(float n){return std::round(n);}}
struct RplComponent{RplId id=10;RplId Id(){return id;}static RplComponent*Cast(RplComponent*p){return p;}};
struct Camera{void GetWorldCameraTransform(vector (&v)[4]){v[3]={1,2,3};}};
struct SCR_2DOpticsComponent{bool ads=true,lit=false;float fov=12,offset=.1;virtual ~SCR_2DOpticsComponent(){}static SCR_2DOpticsComponent*Cast(SCR_2DOpticsComponent*p){return p;}bool IsSightADSActive(){return ads;}float GetFOV(){return fov;}float GetCurrentReticleOffsetY(){return offset;}bool ERR_ObserverIlluminated(){return lit;}};
struct SCR_2DPIPSightsComponent:SCR_2DOpticsComponent{bool enabled=true;Camera*camera=nullptr;static SCR_2DPIPSightsComponent*Cast(SCR_2DOpticsComponent*p){return dynamic_cast<SCR_2DPIPSightsComponent*>(p);}bool IsPIPEnabled(){return enabled;}Camera*GetPIPCamera(){return camera;}};
struct Weapon{RplComponent rpl;Weapon*GetOwner(){return this;}RplComponent*FindComponent(){return &rpl;}};
struct BaseWeaponManagerComponent{Weapon*weapon=nullptr;SCR_2DOpticsComponent*optic=nullptr;int index=0;Weapon*GetCurrentWeapon(){return weapon;}SCR_2DOpticsComponent*GetCurrentSights(){return optic;}int GetCurrentSightsIndex(){return index;}};
struct CharacterControllerComponent{bool ads=true;BaseWeaponManagerComponent weapons;bool IsWeaponADS(){return ads;}BaseWeaponManagerComponent*GetWeaponManagerComponent(){return &weapons;}};
struct ChimeraCharacter{CharacterControllerComponent control;CharacterControllerComponent*GetCharacterController(){return &control;}static ChimeraCharacter*Cast(ChimeraCharacter*p){return p;}};using IEntity=ChimeraCharacter*;
struct Scope{
'''+''.join(adapt(body(p,s)) for s in ('static bool Valid(', 'static void Sample(', 'static SCR_2DOpticsComponent Resolve('))+r'''
};
int main(){
ChimeraCharacter actor;Weapon weapon;SCR_2DOpticsComponent optic;actor.control.weapons.weapon=&weapon;actor.control.weapons.optic=&optic;
vector view[4],data;float fov=60;RplId id;
Scope::Sample(&actor,view,fov,id,data);assert(id==RplId(10)&&fov==12&&data[0]==1&&data[1]==.1f);
assert(Scope::Resolve(&actor,id,data)==&optic);
actor.control.weapons.index=1;assert(!Scope::Resolve(&actor,id,data));actor.control.weapons.index=0;
assert(!Scope::Resolve(&actor,11,data));assert(!Scope::Resolve(nullptr,id,data));
actor.control.ads=false;fov=60;Scope::Sample(&actor,view,fov,id,data);assert(id==RplId(-1)&&data==vector::Zero&&fov==60);actor.control.ads=true;
optic.ads=false;Scope::Sample(&actor,view,fov,id,data);assert(id==RplId(-1));optic.ads=true;
optic.fov=std::numeric_limits<float>::quiet_NaN();Scope::Sample(&actor,view,fov,id,data);assert(id==RplId(-1));optic.fov=12;
SCR_2DPIPSightsComponent pip;actor.control.weapons.optic=&pip;
Scope::Sample(&actor,view,fov,id,data);assert(id==RplId(-1)); // no camera yet
Camera camera;pip.camera=&camera;pip.lit=true;Scope::Sample(&actor,view,fov,id,data);
assert(id==RplId(10)&&data[2]==1&&view[3]==Vector(1,2,3)&&fov==12);
pip.enabled=false;view[3]={7,8,9};Scope::Sample(&actor,view,fov,id,data);assert(view[3]==Vector(7,8,9)); // 2D keeps sampled player pose
actor.control.weapons.weapon=nullptr;Scope::Sample(&actor,view,fov,id,data);assert(id==RplId(-1));
}
''')
print('PASS: production scope sampling preserves ordinary views, selects active ADS only, carries zoom/zeroing/illumination and rejects mismatched/unstreamed optics; native APIs doubled')
docs/evidence/observer-pip-2026-10-09/baseline/tests/test_observer_view_buffer.py
+114
View File
@@ -0,0 +1,114 @@
"""Execute actual camera sample validation/interpolation; native math substituted."""
import re
from policy_harness import ROOT,body,run
p=ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_ObserverPlayerView.c'
def adapt(s):
for name in ['ERR_ObserverScope','ERR_ObserverViewRules','Math','Math3D','vector','RplId']:s=s.replace(name+'.',name+'::')
s=s.replace('out vector','vector').replace('out float ','float& ')
s=re.sub(r'ERR_ObserverViewSample (\w+)', r'ERR_ObserverViewSample* \1',s)
s=re.sub(r'(sample|start|end)\.', r'\1->',s)
return re.sub(r'(m_Samples\[\d+\])\.',r'\1->',s)
rules='\n'.join(adapt(body(p,k)) for k in ['static bool Sample(', 'static bool Fresh('])
methods='\n'.join(adapt(body(p,k)) for k in ['void Clear(', 'void Push(', 'bool Read('])
baseline=ROOT/'docs/evidence/observer-smoothing-2026-10-09/baseline/addons/core/Scripts/Game/ERR/00_Core/ERR_ObserverPlayerView.c'
old_methods='\n'.join(adapt(body(baseline,k)) for k in ['void Clear(', 'void Push(', 'bool Read('])
run(r'''
#include <cassert>
#include <cmath>
#include <algorithm>
#include <limits>
#include <vector>
#include <iostream>
struct vector {float operator[](int i){return i==0?x:(i==1?y:z);}bool operator==(vector b){return x==b.x&&y==b.y&&z==b.z;}static vector Zero;float x=0,y=0,z=0;vector operator+(vector v){return{x+v.x,y+v.y,z+v.z};}vector operator-(vector v){return{x-v.x,y-v.y,z-v.z};}vector operator*(float n){return{x*n,y*n,z*n};}
float LengthSq(){return x*x+y*y+z*z;}void Normalize(){float n=sqrt(LengthSq());x/=n;y/=n;z/=n;}
static float Dot(vector a,vector b){return a.x*b.x+a.y*b.y+a.z*b.z;}static vector Lerp(vector a,vector b,float f){return a+(b-a)*f;}
};
vector vector::Zero;
namespace Math {float Round(float f){return std::round(f);}float AbsFloat(float f){return fabs(f);}float Max(float a,float b){return std::max(a,b);}float Min(float a,float b){return std::min(a,b);}float Clamp(float n,float a,float b){return std::clamp(n,a,b);}float Lerp(float a,float b,float f){return a+(b-a)*f;}}
vector cross(vector a,vector b){return{a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x};}
namespace Math3D {void DirectionAndUpMatrix(vector forward,vector up,vector* out){auto right=cross(up,forward);right.Normalize();out[0]=right;out[1]=cross(forward,right);out[2]=forward;}}
struct RplId {int value=-1;RplId(int v=-1):value(v){}static RplId Invalid(){return{};}bool operator==(RplId a){return value==a.value;}bool operator!=(RplId a){return value!=a.value;}};
struct ERR_ObserverViewRules {'''+rules+r'''};
struct ERR_ObserverScope {'''+adapt(body(ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_ObserverScope.c','static bool Valid('))+r'''};
struct ERR_ObserverViewSample {int Stamp;vector Position,Forward,Up;float Fov,Near;};
template<class T>struct Array:std::vector<T>{int Count(){return this->size();}bool IsEmpty(){return this->empty();}void Clear(){this->clear();}void Insert(T v){this->push_back(v);}void Remove(int i){this->erase(this->begin()+i);}};
struct Buffer {RplId m_ScopeWeapon;vector m_ScopeData;RplId m_Target;int m_Stamp=-1;float m_Received=-1,m_Playback=0,m_ReadAt=0;Array<ERR_ObserverViewSample*> m_Samples;
'''+methods+r'''};
struct Baseline {RplId m_ScopeWeapon;vector m_ScopeData;RplId m_Target;int m_Stamp=-1;float m_Received=-1;vector m_Position,m_Forward,m_Up,m_StartPosition,m_StartForward,m_StartUp;float m_Fov=0,m_Near=0,m_StartFov=0,m_Blend=1;
'''+old_methods+r'''};
bool close(float a,float b){return fabs(a-b)<0.0001;}
int main(){
vector pos{.1,1.6,.2},forward{0,0,1},up{0,1,0};
assert(ERR_ObserverViewRules::Sample(pos,forward,up,60,.0125));
assert(!ERR_ObserverViewRules::Sample({31,0,0},forward,up,60,.0125));
assert(!ERR_ObserverViewRules::Sample(pos,{},up,60,.0125));
assert(!ERR_ObserverViewRules::Sample(pos,forward,forward,60,.0125));
float nan=std::numeric_limits<float>::quiet_NaN();
assert(!ERR_ObserverViewRules::Sample({nan,0,0},forward,up,60,.0125));
assert(!ERR_ObserverViewRules::Sample(pos,{nan,0,1},up,60,.0125));
assert(!ERR_ObserverViewRules::Sample(pos,forward,up,nan,.0125));
assert(!ERR_ObserverViewRules::Sample(pos,forward,up,60,nan));
assert(!ERR_ObserverViewRules::Sample(pos,forward,up,0,.0125));
Buffer b;vector matrix[4];float fov,nearPlane;
assert(!b.Read(1,100,1,matrix,fov,nearPlane));
b.Push(1,100,100,pos,forward,up,60,.0125, -1, {});assert(b.Read(1,100,.01,matrix,fov,nearPlane));assert(close(matrix[3].y,1.6)&&close(fov,60));
// Actual lean/roll and zoom, without forcing world-up or a hard-coded camera FOV.
vector leanedUp{.6,.8,0};b.Push(1,150,150,{.3,1.4,.2},forward,leanedUp,30,.02, -1, {});
assert(b.Read(1,225,.025,matrix,fov,nearPlane));assert(close(matrix[3].x,.2)&&close(fov,45)&&matrix[1].x>0);
assert(b.Read(1,250,.025,matrix,fov,nearPlane));assert(close(matrix[3].x,.3)&&close(fov,30)&&close(matrix[1].x,.6)&&close(nearPlane,.02));
b.Push(1,149,270,{9,9,9},forward,up,80,.1, -1, {}); // out-of-order packet cannot rewind the view
assert(b.Read(1,275,.025,matrix,fov,nearPlane)&&close(matrix[3].x,.3));
for(int i=0;i<1000;i++)assert(b.Read(1,300,.016,matrix,fov,nearPlane)&&close(matrix[3].x,.3)); // no integration drift
assert(!b.Read(1,501,.01,matrix,fov,nearPlane)); // gap beyond 350 ms, no stale head approximation
assert(!b.Read(2,250,.01,matrix,fov,nearPlane)); // target switch never inherits previous pose
b.Push(2,200,600,{1,2,3},forward,up,75,.1, -1, {});assert(b.Read(2,600,0,matrix,fov,nearPlane)&&close(matrix[3].x,1));
b.Clear();assert(!b.Read(2,600,0,matrix,fov,nearPlane));
b.Push(1,700,700,pos,forward,up,12,.02,22,{1,0,1});
assert(b.Read(1,700,0,matrix,fov,nearPlane)&&close(fov,12)&&b.m_ScopeWeapon==RplId(22));
b.Push(1,701,710,pos,forward,up,60,.02,22,{nan,0,1});
assert(b.m_Stamp==700&&b.m_ScopeData[0]==1);
b.Push(1,702,720,pos,forward,up,60,.02,-1,{});
assert(b.Read(1,720,0,matrix,fov,nearPlane)&&close(fov,60)&&b.m_ScopeWeapon==RplId(-1));
assert(!ERR_ObserverScope::Valid(-1,{1,0,0}));
assert(!ERR_ObserverScope::Valid(22,{1.5,0,0}));
assert(!ERR_ObserverScope::Valid(22,{1,91,0}));
assert(!ERR_ObserverScope::Valid(22,{1,0,2}));
assert(!ERR_ObserverViewRules::Fresh(100,101));
// Real interpolation bodies, same constant-speed poses, uneven packet arrivals.
// Different client/server clock origins, dropped packets and varied render FPS.
for(float frame:{1000.f/30,1000.f/60,1000.f/144}){
Buffer smooth;Baseline old;int packet=0;float prevNew=0,prevOld=0,lastNewStep=0,lastOldStep=0;
float newVariation=0,oldVariation=0;int delay[]={0,25,5,35,0,15};
for(float t=0;t<2500;t+=frame){
while(packet<=50&&packet*50+delay[packet%6]<=t){
if(packet%13!=12){ // occasional single-packet loss
vector location{packet*.05f,1.6,0};
smooth.Push(1,70000+packet*50,10000+t,location,forward,up,60,.02,-1,{});
old.Push(1,70000+packet*50,10000+t,location,forward,up,60,.02,-1,{});
}
packet++;
}
assert(smooth.Read(1,10000+t,frame/1000,matrix,fov,nearPlane));float nextNew=matrix[3].x;
assert(old.Read(1,10000+t,frame/1000,matrix,fov,nearPlane));float nextOld=matrix[3].x;
float newStep=nextNew-prevNew,oldStep=nextOld-prevOld;
assert(newStep>=-0.0001); // no timeline rewind
if(t>500){newVariation+=fabs(newStep-lastNewStep);oldVariation+=fabs(oldStep-lastOldStep);}
prevNew=nextNew;prevOld=nextOld;lastNewStep=newStep;lastOldStep=oldStep;
assert(smooth.m_Samples.Count()<=12);
}
std::cout<<"frame_ms="<<frame<<" buffered_step_variation="<<newVariation<<" baseline="<<oldVariation<<"\n";
assert(newVariation<oldVariation*.25f);
}
// Holding an unrendered stream stays bounded; opening it resumes near live.
Buffer parked;
for(int i=0;i<1000;i++)parked.Push(1,i*50,i*50,pos,forward,up,60,.02,-1,{});
assert(parked.m_Samples.Count()==12);
assert(parked.Read(1,49950,0,matrix,fov,nearPlane)&&close(matrix[3].x,pos.x));
// Scope changes, reacquisition after expiry and target changes snap to their
// own pose instead of blending through another sight or another player.
parked.Push(1,50000,50400,{2,1,0},forward,up,30,.02,-1,{});
assert(parked.Read(1,50400,0,matrix,fov,nearPlane)&&close(matrix[3].x,2));
parked.Clear();assert(parked.m_Samples.IsEmpty()&&parked.m_ScopeWeapon==RplId(-1));
}
''')
print('PASS: actual view buffer validates samples, follows position/roll/FOV, rejects stale/foreign/reordered data, buffers jitter without drift, bounds memory and expires gaps')
docs/evidence/observer-pip-2026-10-09/baseline/tests/test_observer_view_relay.py
+85
View File
@@ -0,0 +1,85 @@
"""Production relay authority/leases and delivery, with owner RPC/native data doubled."""
import re
from policy_harness import ROOT,body,run
p=ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_ObserverPlayerView.c'
def adapt(s):
s=s.replace('protected ', '').replace('null','nullptr')
for cls in ['ERR_GameMode','ERR_PlayerLife','SCR_PlayerController','RplComponent']:
s=re.sub(r'\b'+cls+r' (\w+)\b',cls+r'* \1',s)
for obj in ['mode','life','watcher','source','component']:s=s.replace(obj+'.',obj+'->')
s=s.replace('m_ERRViewWatchers[i].','m_ERRViewWatchers[i]->')
for cls in ['ERR_ObserverScope','ERR_GameMode','ERR_Actors','ERR_ObserverRules','ERR_ObserverViewRules','Replication','SCR_PlayerController','RplComponent','SCR_FactionManager','RplId','Math','vector']:s=s.replace(cls+'.',cls+'::')
s=s.replace('GetGame().','GetGame()->').replace('GetWorld().','GetWorld()->').replace('GetPlayerManager().','GetPlayerManager()->').replace('Players().','Players()->').replace('Get().','Get()->')
s=s.replace('actor.FindComponent(RplComponent)', 'actor->FindComponent()')
s=s.replace('Rpc(ERR_EnableViewPublisher)', 'SendLease()')
return s
methods='\n'.join(adapt(body(p,k)) for k in ['bool ERR_ViewRecipient(', 'protected void ERR_RequestPlayerView(', 'void ERR_AddViewWatcher(', 'protected void ERR_EnableViewPublisher(', 'protected void ERR_SubmitPlayerView(', 'protected void ERR_ReceivePlayerView('])
run(r'''
#include <cassert>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
struct vector {float operator[](int i){return i==0?x:(i==1?y:z);}bool operator==(vector b){return x==b.x&&y==b.y&&z==b.z;}static vector Zero;float x=0,y=0,z=0;float LengthSq(){return x*x+y*y+z*z;}static float Dot(vector a,vector b){return a.x*b.x+a.y*b.y+a.z*b.z;}};
vector vector::Zero;
namespace Math{float Round(float f){return std::round(f);}float AbsFloat(float a){return fabs(a);}}
struct RplId{int value=-1;RplId(int i=-1):value(i){}static RplId Invalid(){return{-1};}bool operator==(RplId b){return value==b.value;}bool operator!=(RplId b){return value!=b.value;}};
struct RplComponent{RplId id{11};RplId Id(){return id;}static RplComponent* Cast(RplComponent* p){return p;}};
struct Actor {bool alive=true,conscious=true;int faction=1;RplComponent replication;RplComponent* FindComponent(){return &replication;}};using IEntity=Actor*;
struct ERR_PlayerLife {int ConnectionId=1;bool valid=true;};
struct Roster {std::map<IEntity,ERR_PlayerLife*> lives;ERR_PlayerLife* CurrentActor(IEntity a){auto p=lives.find(a);return p!=lives.end()&&p->second->valid?p->second:nullptr;}};
struct ERR_GameMode {bool active=true;Roster roster;static ERR_GameMode* current;static ERR_GameMode* Get(){return current;}bool Active(){return active;}Roster* Players(){return &roster;}int PlayerFaction(){return 1;}};ERR_GameMode* ERR_GameMode::current;
namespace ERR_Actors {bool Alive(IEntity a){return a&&a->alive;}bool CanFight(IEntity a){return Alive(a)&&a->conscious;}}
namespace SCR_FactionManager{int SGetFaction(IEntity a){return a?a->faction:0;}}
namespace ERR_ObserverReason{int NONE=0,UNCONSCIOUS=4;}
struct ERR_ObserverRules {'''+body(ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_Observer.c','static bool View(').replace('ERR_ObserverReason.','ERR_ObserverReason::')+r'''};
struct ERR_ObserverViewRules {'''+adapt(body(p,'static bool Sample('))+r'''};
struct ERR_ObserverScope {'''+adapt(body(ROOT/'addons/core/Scripts/Game/ERR/00_Core/ERR_ObserverScope.c','static bool Valid('))+r'''};
namespace Replication{bool server=true;bool IsServer(){return server;}}
struct SCR_PlayerController;
struct Game {float now=1000;SCR_PlayerController* local=nullptr;std::map<int,SCR_PlayerController*> controllers;
Game* GetWorld(){return this;}Game* GetPlayerManager(){return this;}float GetWorldTime(){return now;}SCR_PlayerController* GetPlayerController(){return local;}SCR_PlayerController* GetPlayerController(int id){return controllers[id];}} game;
Game* GetGame(){return &game;}
template<class T>struct Array:std::vector<T>{int Count(){return this->size();}bool Contains(T v){return std::find(this->begin(),this->end(),v)!=this->end();}void Insert(T v){this->push_back(v);}void Remove(int i){this->erase(this->begin()+i);}};
struct Buffer{int pushes=0;void Push(RplId,int,float,vector,vector,vector,float,float,RplId,vector){pushes++;}};
struct SCR_PlayerController {
int id=0;IEntity controlled=nullptr,m_ERRServerObserved=nullptr,m_ERRViewSourceBody=nullptr;RplId m_ERRObservedId;
int m_ERRObserverReason=1,m_ERRViewInputSequence=0,leases=0,deliveries=0;float m_ERRViewLeaseUntil=-1,m_ERRViewServerRequestAt=-1000,m_ERRViewLeaseSent=-1000,m_ERRViewPublishUntil=-1,m_ERRViewLastPacket=-1000;
Array<SCR_PlayerController*> m_ERRViewWatchers;Buffer m_ERRViewBuffer;
int GetPlayerId(){return id;}IEntity GetControlledEntity(){return controlled;}static SCR_PlayerController* Cast(SCR_PlayerController* p){return p;}
void SendLease(){leases++;}
void ERR_DeliverPlayerView(RplId,int,vector,vector,vector,float,float,RplId,vector){deliveries++;}
'''+methods+r'''
};
int main(){
ERR_GameMode mode;ERR_GameMode::current=&mode;Actor target,dead,revived;dead.alive=false;
ERR_PlayerLife sourceLife;mode.roster.lives[&target]=&sourceLife;
SCR_PlayerController source,watcher,stranger;source.id=1;watcher.id=2;stranger.id=3;
source.controlled=&target;watcher.controlled=&dead;watcher.m_ERRServerObserved=&target;watcher.m_ERRObservedId={11};
game.controllers={{1,&source},{2,&watcher},{3,&stranger}};
assert(!watcher.ERR_ViewRecipient(&target,game.now)); // no lease
watcher.ERR_RequestPlayerView();assert(source.m_ERRViewWatchers.Count()==1&&source.leases==1);
watcher.ERR_RequestPlayerView();assert(source.leases==1); // bounded requests
vector position{0,1.6,0},forward{0,0,1},up{0,1,0};
source.ERR_SubmitPlayerView(1,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==1);
source.ERR_SubmitPlayerView(2,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==1); // packet rate bound
game.now+=50;source.ERR_SubmitPlayerView(1,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==1); // replay
source.ERR_SubmitPlayerView(2,{999,0,0},forward,up,60,.0125, -1, {});assert(watcher.deliveries==1);
source.ERR_SubmitPlayerView(2,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==2);
game.now+=50;source.ERR_SubmitPlayerView(3,position,forward,up,12,.0125,22,{99,0,0});assert(watcher.deliveries==2&&source.m_ERRViewInputSequence==2); // malformed scope cannot advance sequence or deliver
game.now+=50;watcher.controlled=&revived;source.ERR_SubmitPlayerView(3,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==2&&source.m_ERRViewWatchers.Count()==0); // no stream to recovered players
watcher.controlled=&dead;game.now+=500;watcher.ERR_RequestPlayerView();assert(source.m_ERRViewWatchers.Count()==1);
target.faction=2;game.now+=50;source.ERR_SubmitPlayerView(4,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==2);target.faction=1;
game.now+=500;watcher.ERR_RequestPlayerView();game.now+=1600;source.ERR_SubmitPlayerView(5,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==2&&source.m_ERRViewWatchers.Count()==0); // lease expired
watcher.ERR_RequestPlayerView();watcher.m_ERRServerObserved=nullptr;game.now+=50;source.ERR_SubmitPlayerView(6,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==2); // target switch
watcher.m_ERRServerObserved=&target;game.now+=500;watcher.ERR_RequestPlayerView();game.controllers[1]=&stranger;source.ERR_SubmitPlayerView(7,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==2);game.controllers[1]=&source;
sourceLife.valid=false;game.now+=50;source.ERR_SubmitPlayerView(7,position,forward,up,60,.0125, -1, {});assert(watcher.deliveries==2);sourceLife.valid=true;
game.local=&watcher;watcher.ERR_ReceivePlayerView({11},1,position,forward,up,60,.0125, -1, {});assert(watcher.m_ERRViewBuffer.pushes==1);
watcher.ERR_ReceivePlayerView({22},2,position,forward,up,60,.0125, -1, {});assert(watcher.m_ERRViewBuffer.pushes==1);
game.local=&stranger;watcher.ERR_ReceivePlayerView({11},3,position,forward,up,60,.0125, -1, {});assert(watcher.m_ERRViewBuffer.pushes==1);
game.local=&watcher;mode.active=false;watcher.ERR_ReceivePlayerView({11},4,position,forward,up,60,.0125, -1, {});assert(watcher.m_ERRViewBuffer.pushes==1);
mode.active=true;game.local=&source;source.ERR_EnableViewPublisher();assert(source.m_ERRViewPublishUntil==game.now+2000);
}
''')
print('PASS: actual relay rejects noncanonical sources, live/foreign/stale viewers, invalid/replayed/fast packets; bounds leases and owner-only target delivery')