Not translated yet — showing English.

Collision

Bind a transform to the obstacle map; declare what contact does. Collision runs inside the platform's simulation. You declare bodies, layers and responses, and subscribe to contacts.

When to use it

• Moving entities must resolve contacts server-side (slide, stop, bounce) without a hand-written deflection routine.
• Gameplay reacts to touch: pickups collect on overlap, trigger volumes fire an entity state machine.
• Locomotion and projectiles need swept resolution against the map's obstacle set.
• Placement previews or targeting need "would this fit here?" and volume-overlap queries.
• Skip it when nothing physically meets. Request/response gameplay over records is plain Data.

Who does what

At a glance

Shape, layer and what contact does all sit on the body itself — nothing declares layer pairs from a distance:

[Entity("tank")]
public class Tank
{
    [Sync] public Vector3 Position;

    [Body(Shape.Capsule, Radius = 0.6f, Layer = "vehicles")]
    [CollidesWith("walls", Response.Slide)]
    [CollidesWith("pickups", Response.Pass)]        // reported, motion passes through
    public Body Body;
}

@Entity('tank')
export class Tank {
  @Sync() position!: Vector3;

  @Body({ shape: 'capsule', radius: 0.6, layer: 'vehicles' })
  @CollidesWith('walls', Response.Slide)
  @CollidesWith('pickups', Response.Pass)        // reported, motion passes through
  body: Body;
}

@entity("tank")
class Tank:
    position: Vector3 = sync()

    body = collision.body(shape="capsule", radius=0.6, layer="vehicles",
                           collides_with=[
                               ("walls", Response.SLIDE),
                               ("pickups", Response.PASS),   # reported, motion passes through
                           ])

// the declaration rides inside the engine's own reflection macros, in the specifier position —
// UHT reads it from the header text, and the member is a reflected property at the same time
UCLASS(PSEntity = "tank")
class UTank : public UObject
{
    GENERATED_BODY()

    UPROPERTY(PSSync)
    FVector3f Position;

    // walls slide, pickups report the contact and let motion pass through —
    // multi-entry values are one quoted list (a specifier value is a single token)
    UPROPERTY(PSBody = (Shape = "Capsule", Radius = "0.6", Layer = "vehicles"),
              PSCollidesWith = "walls:Slide, pickups:Pass")
    FPSBody Body;
};
// declarations compile into the same pushed model — playserv push from the UE project or CI

[Entity("tank")]
public class Tank
{
    [Sync] public Vector3 Position;

    [Body(Shape.Capsule, Radius = 0.6f, Layer = "vehicles")]
    [CollidesWith("walls", Response.Slide)]
    [CollidesWith("pickups", Response.Pass)]        // reported, motion passes through
    public Body Body;
}

A contact is an event, and modules subscribe to it. There is no hook on a contact: by the time one exists the step has already resolved it, so there is nothing left to reject. Where a studio needs different rules, it overrides the admissibility and path checks as an implementation — see Extensibility — and the response stays declared.

The model

What a body declares.

The response is declared on a pair — an obstacle's passability kind × a body type — and it comes from a closed set:

The coefficients are declared values rather than computed from masses and materials — there are neither in this contract.

What is true of every check.

Errors

• "Inadmissible" is an answer, not an error, and it names which of three reasons: outside the bounds, occupied by a static obstacle, or occupied by another entity's body. A client reacts to the three differently: turn round, go round, or wait.
• Declaration failures land at deploy, never on the first contact: a body shaped outside the closed set, a body on an aspect with no transform, and a pair with no declared response are all refused at deploy.
• The entity or the location is not found answers not found, and repeating is pointless.
• The check rate exceeded answers in the rate-limit category, with the deadline before which a retry is pointless.

Limits

The numbers arrive with the platform limits chapter; what happens at each ceiling is fixed now.

• Bodies in a room: declaring another is refused as a conflict; existing bodies are never removed to make room.
• Contacts per step: the excess is never discarded silently. Either the step is refused, or the order of cut-off is declared.
• A body's size against the map's grid step: refused at deploy, because a body smaller than the height field's step falls through the terrain.
• Areas one body may be inside: an excess is refused at deploy.
• The check rate per actor: a rate limit with a deadline.
• Bodies in a "who is in this area" answer: truncated by a declared order, and the truncation flag is obligatory.