RobustToolbox/Robust.Shared/Physics/Components/PhysicsComponentState.cs

using System;
using System.Collections.Generic;
using System.Numerics;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization;

namespace Robust.Shared.Physics.Components;

[Serializable, NetSerializable]
public sealed class PhysicsComponentDeltaState : IAutoGeneratedComponentDeltaState, IComponentDeltaState<PhysicsComponentState>
{
    public const int CanCollideIndex = 0;
    public const int StatusIndex = 1;
    public const int BodyTypeIndex = 2;
    public const int SleepingAllowedIndex = 3;
    public const int FixedRotationIndex = 4;
    public const int FrictionIndex = 5;
    public const int ForceIndex = 6;
    public const int TorqueIndex = 7;
    public const int LinearDampingIndex = 8;
    public const int AngularDampingIndex = 9;
    public const int AngularVelocityIndex = 10;
    public const int LinearVelocityIndex = 11;

    public ulong ChangedFields { get; set; }

    [NetworkedDeltaField(CanCollideIndex)]
    public bool CanCollide;

    [NetworkedDeltaField(StatusIndex)]
    public BodyStatus Status;

    [NetworkedDeltaField(BodyTypeIndex)]
    public BodyType BodyType;

    [NetworkedDeltaField(SleepingAllowedIndex)]
    public bool SleepingAllowed;

    [NetworkedDeltaField(FixedRotationIndex)]
    public bool FixedRotation;

    [NetworkedDeltaField(FrictionIndex)]
    public float Friction;

    [NetworkedDeltaField(ForceIndex)]
    public Vector2 Force;

    [NetworkedDeltaField(TorqueIndex)]
    public float Torque;

    [NetworkedDeltaField(LinearDampingIndex)]
    public float LinearDamping;

    [NetworkedDeltaField(AngularDampingIndex)]
    public float AngularDamping;

    [NetworkedDeltaField(AngularVelocityIndex)]
    public float AngularVelocity;

    [NetworkedDeltaField(LinearVelocityIndex)]
    public Vector2 LinearVelocity;

    public void ApplyToFullState(PhysicsComponentState fullState)
    {
        if ((ChangedFields & (1UL << CanCollideIndex)) != 0)
            fullState.CanCollide = CanCollide;

        if ((ChangedFields & (1UL << StatusIndex)) != 0)
            fullState.Status = Status;

        if ((ChangedFields & (1UL << BodyTypeIndex)) != 0)
            fullState.BodyType = BodyType;

        if ((ChangedFields & (1UL << SleepingAllowedIndex)) != 0)
            fullState.SleepingAllowed = SleepingAllowed;

        if ((ChangedFields & (1UL << FixedRotationIndex)) != 0)
            fullState.FixedRotation = FixedRotation;

        if ((ChangedFields & (1UL << FrictionIndex)) != 0)
            fullState.Friction = Friction;

        if ((ChangedFields & (1UL << ForceIndex)) != 0)
            fullState.Force = Force;

        if ((ChangedFields & (1UL << TorqueIndex)) != 0)
            fullState.Torque = Torque;

        if ((ChangedFields & (1UL << LinearDampingIndex)) != 0)
            fullState.LinearDamping = LinearDamping;

        if ((ChangedFields & (1UL << AngularDampingIndex)) != 0)
            fullState.AngularDamping = AngularDamping;

        if ((ChangedFields & (1UL << AngularVelocityIndex)) != 0)
            fullState.AngularVelocity = AngularVelocity;

        if ((ChangedFields & (1UL << LinearVelocityIndex)) != 0)
            fullState.LinearVelocity = LinearVelocity;
    }

    public PhysicsComponentState CreateNewFullState(PhysicsComponentState fullState)
    {
        var copy = new PhysicsComponentState(fullState);
        ApplyToFullState(copy);
        return copy;
    }
}

[Serializable, NetSerializable]
public sealed class PhysicsComponentState : IComponentState
{
    public bool CanCollide;
    public bool SleepingAllowed;
    public bool FixedRotation;
    public BodyStatus Status;

    public Vector2 LinearVelocity;
    public float AngularVelocity;
    public BodyType BodyType;

    public float Friction;
    public float LinearDamping;
    public float AngularDamping;

    public Vector2 Force;
    public float Torque;

    public PhysicsComponentState() {}

    public PhysicsComponentState(PhysicsComponentState existing)
    {
        CanCollide = existing.CanCollide;
        SleepingAllowed = existing.SleepingAllowed;
        FixedRotation = existing.FixedRotation;
        Status = existing.Status;

        LinearVelocity = existing.LinearVelocity;
        AngularVelocity = existing.AngularVelocity;
        BodyType = existing.BodyType;

        Friction = existing.Friction;
        LinearDamping = existing.LinearDamping;
        AngularDamping = existing.AngularDamping;

        Force = existing.Force;
        Torque = existing.Torque;
    }
}