Esta página ainda não foi traduzida: mostrando a versão em inglês.

Locomotion

Você declara como algo se move; ninguém escreve um integrador. Um modelo de movimento transforma input sequenciado em movimento autoritativo, integrado às colisões, gravado para a predição e modificado por buffs, debuffs e terreno.

Quando usar

• Entidades se movem pelo input do jogador (tanques, personagens, veículos), e o servidor precisa ter a autoridade sobre o movimento.
• Você prefere declarar limites de velocidade, aceleração e taxa de giro a escrever um integrador.
• O gameplay empurra corpos de um lado para o outro: knockback com Impulse, Teleport e modificadores com duração, como lama.
• O movimento precisa parecer instantâneo: o mesmo modelo declarado roda no servidor e no loop da predição.
• Dispensável quando as posições mudam só em saltos discretos. Um campo sincronizado na entidade já resolve.

Quem faz o quê

Resumo

[Entity("tank")]
public class Tank
{
    [Sync] public Vector3 Position;
    [Motion(Model.Tank, MaxSpeed = 8f, Acceleration = 14f, TurnRateDeg = 120f)]
    public Motion Motion;
}

@Entity('tank')
export class Tank {
  @Sync() position!: Vector3;
  @Motion({ model: 'tank', maxSpeed: 8, acceleration: 14, turnRateDeg: 120 }) motion: Motion;
}

@entity("tank")
class Tank:
    position: Vector3 = sync()
    motion = locomotion.motion(model="tank", max_speed=8.0, acceleration=14.0, turn_rate_deg=120.0)

UCLASS(PSEntity = "tank")
class UTank : public UObject
{
    GENERATED_BODY()

    UPROPERTY(PSSync) FVector3f Position;

    UPROPERTY(PSMotion = (Model = "Tank", MaxSpeed = "8.0", Acceleration = "14.0", TurnRateDeg = 120))
    FPSMotion Motion;
};
// declarations compile into the same pushed model — playserv push from the UE project or CI

[Entity("tank")]
public class Tank
{
    [Sync] public Vector3 Position;
    [Motion(Model.Tank, MaxSpeed = 8f, Acceleration = 14f, TurnRateDeg = 120f)]
    public Motion Motion;
}

O input do cliente é uma intenção sequenciada. Quem calcula o movimento, passo a passo, é a plataforma:

room.My<Tank>().Motion.Drive(throttle: 1f, steer: -0.4f);   // cl — sent at input rate

room.my<Tank>().motion.drive({ throttle: 1, steer: -0.4 });   // cl — sent at input rate

room.my(Tank).motion.drive(throttle=1.0, steer=-0.4)   # cl — a bot brain drives the same way

Room->Entities->Of<UTank>()->Select().GetMine().Then(
    TPSOnResult<UTank*>::CreateWeakLambda(this, [this](const TPSResult<UTank*>& Result)
    {
        if (!Result.HasValue()) { return; }
        // client — sent at input rate, numbered so the platform can acknowledge
        Result.Value()->Motion->SubmitInput(FPSMoveInput{ .Throttle = 1.f, .Steer = -0.4f }, InputSequence);
    }));
// co_await support ships later: a built-in SDK coroutine wrapper that respects Unreal's GC and threading.

room.My<Tank>().Motion.Drive(throttle: 1f, steer: -0.4f);   // cl — sent at input rate

Verbos do lado do servidor:

tank.Motion.Impulse(knockback);
tank.Motion.Modify("mud", speedMultiplier: 0.6f, duration: 3.Seconds());
tank.Motion.Teleport(spawn);

tank.motion.impulse(knockback);
tank.motion.modify('mud', { speedMultiplier: 0.6, duration: seconds(3) });
tank.motion.teleport(spawn);

tank.motion.impulse(knockback)
tank.motion.modify("mud", speed_multiplier=0.6, duration=seconds(3))
tank.motion.teleport(spawn)

// on a dedicated server / master-client host
Tank->Motion->Impulse(EPSImpulseKind::Impulse, KnockbackVelocity);
Tank->Motion->Modify({ .Modifier = TEXT("mud"), .SpeedMultiplier = 0.6f, .For = FPSDuration::Seconds(3.f) });
Tank->Motion->Teleport(SpawnPosition, SpawnFacing);
// co_await support ships later: a built-in SDK coroutine wrapper that respects Unreal's GC and threading.

tank.Motion.Impulse(knockback);
tank.Motion.Modify("mud", speedMultiplier: 0.6f, duration: 3.Seconds());
tank.Motion.Teleport(spawn);

O modelo

O que uma entidade declara para se mover.

O que vale para todo passo.

Erros

• Entidade sem modelo de movimento, preset preenchido pela metade e impulso sem decaimento declarado são todos falhas de validação no deploy, não em runtime.
• Geração esperada não confere é uma falha de pré-condição, e vale repetir depois de ler de novo: um input enviado antes de um respawn não pode ser aplicado depois dele.
• Taxa de input excedida responde na categoria de rate limit, com prazo.
• Entidade não controlável é um conflito, e repetir só faz sentido depois que o estado mudar.
• Três coisas não são recusa em nenhum sentido, e as três são observáveis. Input obsoleto é descartado, uma intenção além de um limite é cortada, e uma pose fora da tolerância é ajustada como pose_clamped. Se qualquer uma delas acontecesse em silêncio, o cliente acharia que foi aplicada e divergiria do servidor de vez.

Limites

Os números chegam com o capítulo de limites da plataforma; o que acontece em cada teto já está definido.

• Velocidade e aceleração máximas: cortadas, nunca recusadas.
• Giro máximo por input: cortado.
• Taxa de input por ator: rate limit com prazo.
• Passos de recuperação: acima do teto, os passos são descartados com uma consequência declarada. O tempo da simulação fica para trás, de forma observável, em vez de se recuperar num salto que parece todo mundo se teleportando ao mesmo tempo.
• Magnitude do impulso: cortada no máximo declarado.
• Impulsos simultâneos por entidade: um novo expulsa o mais antigo, e a remoção é observável; não existe soma ilimitada em silêncio.
• Validade de uma pose informada: uma pose mais antiga que o período declarado não é considerada.