94da385ff4
Drives the full post-handshake flow on a live ACE server. After the
3-way handshake completes, acdream:
1. Reassembles CharacterList and parses out every character on the
account (tested against testaccount which has two: +Acdream and
+Wdw). Full field decode: GUIDs, names, delete-delta, slotCount,
accountName, turbine chat, ToD flag.
2. Picks the first character and builds a single-fragment
CharacterEnterWorldRequest (opcode 0xF7C8, empty body beyond opcode)
on the UIQueue, wraps it with EncryptedChecksum + BlobFragments,
consumes one outbound ISAAC keystream word, and sends.
3. Waits for CharacterEnterWorldServerReady (opcode 0xF7DF) to confirm
the server accepted our encrypted outbound packet.
4. Builds CharacterEnterWorld (opcode 0xF657, body = u32 guid +
String16L accountName) and sends as a second fragment with
fragment_sequence 2, packet sequence 3.
5. Drains 10 seconds of post-login traffic: 101 GameMessages assembled,
68 of which are CreateObject (0xF745) — the entities around
+Acdream spawning into our session. Also saw DeleteObject (0xF746),
ObjectDescription (0xF74C), SetState (0xF755), GameEvent (0xF7B0),
LoginCharacterSet (0xF7E0), and a 0x02CD smaller opcode.
This is the Phase 4.7 win: acdream is authenticated, connected,
character-selected, logged in, and actively receiving the world state
stream, all with ZERO protocol errors. Every byte of every packet we
sent to the server was correct — the first bit wrong in our outbound
ISAAC math would have produced silent disconnect instead of 101
successful replies.
Added to AcDream.Core.Net:
- Messages/CharacterList.cs: full parser for opcode 0xF658, ported
from ACE's GameMessageCharacterList writer. Returns structured
record with Characters[], SlotCount, AccountName, UseTurbineChat,
HasThroneOfDestiny. Tested offline with hand-assembled bodies
matching ACE's writer format.
- Messages/CharacterEnterWorld.cs: outbound builders for
CharacterEnterWorldRequest (0xF7C8, opcode-only) and
CharacterEnterWorld (0xF657, opcode + guid + String16L account).
- Messages/GameMessageFragment.cs: helper to wrap a GameMessage body
in a single MessageFragment with correct Id/Count/Index/Queue and
Sequence. Also a Serialize helper to turn a MessageFragment into
packet-body bytes for PacketCodec.Encode. Throws on oversize
(>448 byte) messages; multi-fragment outbound split is TBD.
- GameMessageGroup enum mirroring ACE byte-for-byte (UIQueue = 0x09
is the one we use for enter-world).
Fixed: FragmentAssembler was keying on MessageFragmentHeader.Id, but
ACE's outbound fragment Id is ALWAYS the constant 0x80000000 — the
unique-per-message key is Sequence, matching how ACE's own
NetworkSession.HandleFragment keys its partialFragments dict. Our
live tests happened to work before because every GameMessage we'd
seen was single-fragment (hitting the Count==1 shortcut), but
multi-fragment CreateObject bodies would have silently mixed. Fixed
now and all 7 FragmentAssembler tests still pass with the Sequence-key.
Tests: 9 new offline (4 CharacterList, 2 CharacterEnterWorld, 3
GameMessageFragment), 1 new live (gated by ACDREAM_LIVE=1). Total
77 core + 83 net = 160 passing.
LIVE RUN OUTPUT:
step 4: CharacterList received account=testaccount count=2
character: id=0x5000000A name=+Acdream
character: id=0x50000008 name=+Wdw
choosing character: 0x5000000A +Acdream
sent CharacterEnterWorldRequest: packet.seq=2 frag.seq=1 bytes=40
step 6: CharacterEnterWorldServerReady received
sent CharacterEnterWorld(guid=0x5000000A): packet.seq=3 frag.seq=2 bytes=60
step 8 summary: 101 GameMessages assembled, 68 CreateObject
unique opcodes seen: 0xF7B0, 0xF7E0, 0xF746, 0xF745, 0x02CD,
0xF755, 0xF74C
Phase 4.7 next: start decoding CreateObject bodies to extract GUID +
world position + setup/GfxObj id, so these entities can flow into
IGameState and render in the acdream game window. The foundry statue
is waiting in one of those 68 spawns.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
56 lines
2.1 KiB
C#
56 lines
2.1 KiB
C#
using AcDream.Core.Net.Packets;
|
|
|
|
namespace AcDream.Core.Net.Messages;
|
|
|
|
/// <summary>
|
|
/// Outbound GameMessages for the character-select → in-world transition.
|
|
/// The client sends two messages in order after receiving
|
|
/// <see cref="CharacterList"/>:
|
|
///
|
|
/// <list type="number">
|
|
/// <item><c>CharacterEnterWorldRequest</c> (opcode <c>0xF7C8</c>) —
|
|
/// empty body beyond the 4-byte opcode. "Hi server, I'm about
|
|
/// to try to enter the world, anything I should know?"</item>
|
|
/// <item>Server replies with
|
|
/// <c>CharacterEnterWorldServerReady</c> (0xF7DF).</item>
|
|
/// <item><c>CharacterEnterWorld</c> (opcode <c>0xF657</c>) — u32 GUID
|
|
/// of the chosen character + String16L account name. Server
|
|
/// validates ownership and begins spawning the player + world
|
|
/// entities into our session, which is where the CreateObject
|
|
/// flood starts.</item>
|
|
/// </list>
|
|
///
|
|
/// Both messages are tiny enough to fit in one fragment each. They go on
|
|
/// the <see cref="GameMessageGroup.UIQueue"/> queue per ACE's
|
|
/// <c>CharacterHandler</c> annotations.
|
|
/// </summary>
|
|
public static class CharacterEnterWorld
|
|
{
|
|
public const uint EnterWorldRequestOpcode = 0xF7C8u;
|
|
public const uint EnterWorldOpcode = 0xF657u;
|
|
|
|
/// <summary>
|
|
/// Build the body bytes for an outbound <c>CharacterEnterWorldRequest</c>.
|
|
/// Just the 4-byte opcode, nothing else.
|
|
/// </summary>
|
|
public static byte[] BuildEnterWorldRequestBody()
|
|
{
|
|
var w = new PacketWriter(8);
|
|
w.WriteUInt32(EnterWorldRequestOpcode);
|
|
return w.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Build the body bytes for an outbound <c>CharacterEnterWorld</c>.
|
|
/// Layout: opcode(4) + characterGuid(4) + String16L(accountName).
|
|
/// </summary>
|
|
public static byte[] BuildEnterWorldBody(uint characterGuid, string accountName)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(accountName);
|
|
var w = new PacketWriter(32);
|
|
w.WriteUInt32(EnterWorldOpcode);
|
|
w.WriteUInt32(characterGuid);
|
|
w.WriteString16L(accountName);
|
|
return w.ToArray();
|
|
}
|
|
}
|