acdream/tests/AcDream.Core.Net.Tests/Messages/CreateObjectTests.cs

using System.Buffers.Binary;
using System.Text;
using AcDream.Core.Items;
using AcDream.Core.Net.Messages;

namespace AcDream.Core.Net.Tests.Messages;

public sealed class CreateObjectTests
{
    [Fact]
    public void TryParse_WeenieHeaderPrefix_ReturnsNameAndItemType()
    {
        byte[] body = BuildMinimalCreateObjectWithWeenieHeader(
            guid: 0x50000002u,
            name: "Drudge",
            itemType: (uint)ItemType.Creature);

        var parsed = CreateObject.TryParse(body);

        Assert.NotNull(parsed);
        Assert.Equal(0x50000002u, parsed.Value.Guid);
        Assert.Equal("Drudge", parsed.Value.Name);
        Assert.Equal((uint)ItemType.Creature, parsed.Value.ItemType);
    }

    // -----------------------------------------------------------------------
    // Commit A of 2026-04-29 live-entity collision port:
    // PhysicsState (post-flags u32) + ObjectDescriptionFlags (PWD bitfield)
    // must be surfaced for downstream collision registration.
    // -----------------------------------------------------------------------

    [Fact]
    public void TryParse_PhysicsState_Parsed()
    {
        // ETHEREAL_PS = 0x4 + IGNORE_COLLISIONS_PS = 0x10 → 0x14
        byte[] body = BuildMinimalCreateObjectWithWeenieHeader(
            guid: 0x50000003u, name: "GhostNpc",
            itemType: (uint)ItemType.Creature,
            physicsState: 0x14u);

        var parsed = CreateObject.TryParse(body);

        Assert.NotNull(parsed);
        Assert.Equal(0x14u, parsed!.Value.PhysicsState);
    }

    [Fact]
    public void TryParse_ObjectDescriptionFlags_PlayerKillerBitsSurface()
    {
        // BF_PLAYER (0x8) | BF_PLAYER_KILLER (0x20) → a PK player.
        byte[] body = BuildMinimalCreateObjectWithWeenieHeader(
            guid: 0x50000004u, name: "+PkPlayer",
            itemType: (uint)ItemType.Creature,
            objectDescriptionFlags: 0x8u | 0x20u);

        var parsed = CreateObject.TryParse(body);

        Assert.NotNull(parsed);
        Assert.Equal(0x28u, parsed!.Value.ObjectDescriptionFlags);
    }

    [Fact]
    public void TryParse_ObjectDescriptionFlags_PkLiteBit()
    {
        // BF_PLAYER (0x8) | BF_PKLITE_PKSTATUS (0x2000000) → a PK-lite player.
        byte[] body = BuildMinimalCreateObjectWithWeenieHeader(
            guid: 0x50000005u, name: "+PklPlayer",
            itemType: (uint)ItemType.Creature,
            objectDescriptionFlags: 0x8u | 0x2000000u);

        var parsed = CreateObject.TryParse(body);

        Assert.NotNull(parsed);
        Assert.Equal(0x2000008u, parsed!.Value.ObjectDescriptionFlags);
    }

    private static byte[] BuildMinimalCreateObjectWithWeenieHeader(
        uint guid,
        string name,
        uint itemType,
        uint physicsState = 0,
        uint objectDescriptionFlags = 0)
    {
        var bytes = new List<byte>();
        WriteU32(bytes, CreateObject.Opcode);
        WriteU32(bytes, guid);

        // ModelData header: marker, subpalette count, texture count, animpart count.
        bytes.Add(0x11);
        bytes.Add(0);
        bytes.Add(0);
        bytes.Add(0);

        // PhysicsData: physics flags = 0, then PhysicsState u32, then 9 seq stamps.
        WriteU32(bytes, 0);
        WriteU32(bytes, physicsState);
        for (int i = 0; i < 9; i++)
            WriteU16(bytes, 0);
        Align4(bytes);

        // Fixed WeenieHeader prefix per ACE SerializeCreateObject.
        WriteU32(bytes, 0);              // weenieFlags
        WriteString16L(bytes, name);
        WritePackedDword(bytes, 0x1234); // WeenieClassId
        WritePackedDword(bytes, 0);      // IconId via known-type writer
        WriteU32(bytes, itemType);
        WriteU32(bytes, objectDescriptionFlags);
        Align4(bytes);

        return bytes.ToArray();
    }

    private static void WriteU32(List<byte> bytes, uint value)
    {
        Span<byte> tmp = stackalloc byte[4];
        BinaryPrimitives.WriteUInt32LittleEndian(tmp, value);
        bytes.AddRange(tmp.ToArray());
    }

    private static void WriteU16(List<byte> bytes, ushort value)
    {
        Span<byte> tmp = stackalloc byte[2];
        BinaryPrimitives.WriteUInt16LittleEndian(tmp, value);
        bytes.AddRange(tmp.ToArray());
    }

    private static void WritePackedDword(List<byte> bytes, uint value)
    {
        if (value <= 0x7FFF)
        {
            WriteU16(bytes, (ushort)value);
            return;
        }

        WriteU16(bytes, (ushort)(((value >> 16) & 0x7FFF) | 0x8000));
        WriteU16(bytes, (ushort)(value & 0xFFFF));
    }

    private static void WriteString16L(List<byte> bytes, string value)
    {
        byte[] encoded = Encoding.GetEncoding(1252).GetBytes(value);
        WriteU16(bytes, checked((ushort)encoded.Length));
        bytes.AddRange(encoded);
        Align4(bytes);
    }

    private static void Align4(List<byte> bytes)
    {
        while ((bytes.Count & 3) != 0)
            bytes.Add(0);
    }
}