### Implement TClient for Terraria Client in C#

Source: https://context7.com/chi-rei-den/trprotocol/llms.txt

Shows how to set up a TClient instance, register event handlers for chat and system messages, and custom packet types like WorldData, SyncNPC, and LoadPlayer. Includes examples of sending chat messages, requesting tile sections, spawning players, and initiating game loops with direct or proxy connections.

```csharp
using TrClient;
using TrProtocol.Models;
using TrProtocol.Packets;
using TrProtocol.Packets.Modules;
using System.Net;

var client = new TClient();
client.Username = "MyPlayer";
client.CurRelease = "Terraria279";

// Register chat event handlers
client.OnChat += (sender, text, color) =>
    Console.WriteLine($"[Chat] {text}");

client.OnMessage += (sender, message) =>
    Console.WriteLine($"[System] {message}");

// Register custom packet handlers
client.On<WorldData>(worldData => {
    Console.WriteLine($"Connected to world: {worldData.WorldName}");
    Console.WriteLine($"World size: {worldData.MaxTileX}x{worldData.MaxTileY}");
    Console.WriteLine($"Spawn point: ({worldData.SpawnX}, {worldData.SpawnY})");
});

client.On<SyncNPC>(npc => {
    Console.WriteLine($"NPC {npc.NPCType} at position {npc.Offset}");
});

client.On<LoadPlayer>(loadPlayer => {
    // Send client UUID after receiving player slot
    client.Send(new ClientUUID { UUID = Guid.NewGuid().ToString() });
});

// Send a chat message
client.ChatText("Hello, world!");

// Request tile section at coordinates
client.TileGetSection(100, 100);

// Spawn player at position
client.Spawn(100, 100);

// Start the game loop with password-protected server
client.GameLoop("127.0.0.1", 7777, "serverpassword");

// Or connect via proxy
var endpoint = new IPEndPoint(IPAddress.Parse("192.168.1.100"), 7777);
var proxy = new IPEndPoint(IPAddress.Parse("10.0.0.1"), 8080);
client.GameLoop(endpoint, "password", proxy);
```

--------------------------------

### Initialize Common Data Models

Source: https://context7.com/chi-rei-den/trprotocol/llms.txt

Demonstrates instantiation of coordinate structures, color objects, and network text types used within the protocol.

```csharp
using TrProtocol.Models;

// Vector2 - Float coordinates for precise positioning
var position = new Vector2(1234.5f, 678.9f);
Console.WriteLine(position.ToString());  // Output: [1234.5, 678.9]

// Position - Integer tile coordinates
var tilePos = new Position(100, 200);
Console.WriteLine(tilePos.ToString());  // Output: [100, 200]

// ShortPosition - Short integer coordinates
var shortPos = new ShortPosition { X = 2100, Y = 300 };

// UShortPosition - Unsigned short coordinates
var ushortPos = new UShortPosition { X = 4200, Y = 1200 };

// Color - RGB color values
var white = Color.White;
var customColor = new Color(255, 128, 64);
Console.WriteLine($"R:{customColor.R} G:{customColor.G} B:{customColor.B}");

// BitsByte - Bit flags container
var flags = new BitsByte();
// Access individual bits (implementation depends on usage)

// NetworkText modes
var literal = NetworkText.FromLiteral("Plain text");
var formatted = NetworkText.FromFormattable("Hello {0}!", "World");
var localized = NetworkText.FromKey("ItemName.GoldBar");

// ItemData for inventory operations
// PlayerDeathReason for death messages
// SectionData for world chunk transfers
```

--------------------------------

### Define and Initialize Packet Classes

Source: https://context7.com/chi-rei-den/trprotocol/llms.txt

Use packet classes inheriting from Packet to map binary protocol fields. Ensure all required properties like PlayerSlot or Position are set before serialization.

```csharp
using TrProtocol;
using TrProtocol.Models;
using TrProtocol.Packets;

// SyncPlayer - Player appearance and info
var playerSync = new SyncPlayer
{
    PlayerSlot = 0,
    Name = "PlayerName",
    SkinVariant = 1,
    Hair = 5,
    HairColor = new Color(255, 128, 0),
    SkinColor = new Color(255, 200, 150),
    EyeColor = new Color(0, 100, 200),
    ShirtColor = new Color(100, 100, 255),
    UnderShirtColor = new Color(80, 80, 200),
    PantsColor = new Color(50, 50, 150),
    ShoeColor = new Color(30, 30, 100)
};

// SyncItem - Item in world
var itemSync = new SyncItem
{
    ItemSlot = 100,
    Position = new Vector2(1000.5f, 500.25f),
    Velocity = new Vector2(0f, 2.5f),
    Stack = 99,
    Prefix = 0,
    Owner = 255,
    ItemType = 29  // Gold Bar
};

// SyncNPC - NPC state with conditional fields
var npcSync = new SyncNPC
{
    NPCSlot = 50,
    Offset = new Vector2(5000f, 2000f),
    Velocity = new Vector2(1.5f, 0f),
    Target = 0,
    NPCType = 1,  // Blue Slime
    HP = 100
};

// PlayerHealth - Health synchronization
var healthPacket = new PlayerHealth
{
    PlayerSlot = 0,
    StatLife = 400,
    StatLifeMax = 500
};

// SpawnPlayer - Player spawn request
var spawnPacket = new SpawnPlayer
{
    PlayerSlot = 0,
    Position = new ShortPosition { X = 2100, Y = 300 },
    Context = PlayerSpawnContext.SpawningIntoWorld
};
```

--------------------------------

### Initialize and Use PacketSerializer in C#

Source: https://context7.com/chi-rei-den/trprotocol/llms.txt

Demonstrates creating client and server PacketSerializer instances for a specific Terraria protocol version, serializing a packet to bytes, and deserializing packets from a BinaryReader. Includes setting up custom error logging.

```csharp
using TrProtocol;
using TrProtocol.Packets;

// Create a client-side serializer for Terraria version 2.79
var clientSerializer = new PacketSerializer(client: true, version: "Terraria279");

// Create a server-side serializer
var serverSerializer = new PacketSerializer(client: false, version: "Terraria279");

// Serialize a packet to bytes
var helloPacket = new ClientHello { Version = "Terraria279" };
byte[] data = clientSerializer.Serialize(helloPacket);
// Result: byte array with length prefix and packet data

// Deserialize packets from a BinaryReader
using var ms = new MemoryStream(data);
using var br = new BinaryReader(ms);
Packet packet = serverSerializer.Deserialize(br);
// Returns: ClientHello packet with Version property set

// Custom error logging
clientSerializer.ErrorLogger = Console.Out;
// Logs warnings for unknown packet types or incomplete reads
```

--------------------------------

### Implement Dimensions Proxy Server and Packet Handlers

Source: https://context7.com/chi-rei-den/trprotocol/llms.txt

Configures a proxy listener and defines custom packet handlers to intercept and modify client-server traffic.

```csharp
using Dimensions;
using Dimensions.Core;
using Dimensions.Models;
using System.Net;
using TrProtocol.Packets;
using TrProtocol.Packets.Modules;

// Configuration (config.json)
/*
{
  "listenPort": 7778,
  "protocolVersion": "Terraria279",
  "servers": [
    {
      "name": "main",
      "serverIP": "192.168.1.100",
      "serverPort": 7777
    },
    {
      "name": "secondary",
      "serverIP": "192.168.1.101",
      "serverPort": 7777
    }
  ]
}
*/

// Start the proxy listener
var listener = new Listener(new IPEndPoint(IPAddress.Any, 7778));
listener.OnError += ex => Console.WriteLine($"Error: {ex.Message}");
listener.ListenThread();  // Blocks and listens for connections

// Custom packet handler implementation
public class MyCustomHandler : ClientHandler
{
    public override void OnC2SPacket(PacketReceiveArgs args)
    {
        // Intercept client-to-server packets
        if (args.Packet is NetTextModuleC2S text)
        {
            Console.WriteLine($"Player said: {text.Text}");

            // Handle custom commands
            if (text.Text.StartsWith("/home"))
            {
                Parent.SendChatMessage("Teleporting home...");
                args.Handled = true;  // Prevent forwarding to server
            }
        }
    }

    public override void OnS2CPacket(PacketReceiveArgs args)
    {
        // Intercept server-to-client packets
        if (args.Packet is WorldData world)
        {
            Console.WriteLine($"World: {world.WorldName}");
        }
    }

    public override void OnCleaning()
    {
        // Called when switching servers, clean up state
        Console.WriteLine("Cleaning up before server switch");
    }
}

// Client class usage for sending messages
public void ExampleClientUsage(Client client)
{
    // Send chat message to connected client
    client.SendChatMessage("Welcome to the proxy!");

    // Send packet to the upstream server
    client.SendServer(new RequestWorldInfo());

    // Send packet directly to the client
    client.SendClient(new NetTextModuleS2C
    {
        PlayerSlot = 255,
        Text = NetworkText.FromLiteral("Server message"),
        Color = Color.White
    });

    // Disconnect client with reason
    client.Disconnect("Kicked for inactivity");

    // Switch to different server
    var config = Program.config;
    var targetServer = config.GetServer("secondary");
    client.ChangeServer(targetServer);
}
```

--------------------------------

### Define Packet Serialization Attributes

Source: https://context7.com/chi-rei-den/trprotocol/llms.txt

Demonstrates how to use attributes to manage conditional serialization, versioning, array sizes, and directional filtering for packets.

```csharp
using TrProtocol;
using TrProtocol.Models;

// Example packet with various serialization attributes
public class ExamplePacket : Packet, IPlayerSlot
{
    public override MessageID Type => MessageID.SyncNPC;

    // IPlayerSlot interface - automatically set by TClient
    public byte PlayerSlot { get; set; }

    // Basic fields serialized in order
    public Vector2 Position { get; set; }
    public BitsByte Flags { get; set; }

    // Conditional field - only serialized if Flags[0] is true
    [Condition(nameof(Flags), 0)]
    public float OptionalValue { get; set; }

    // Conditional with prediction - serialized if Flags[1] is false
    [Condition(nameof(Flags), 1, pred: false)]
    public int AnotherValue { get; set; }

    // Version-specific field - only for Terraria248
    [ProtocolVersion("Terraria248")]
    public short LegacyField { get; set; }

    // Fixed-size array
    [ArraySize(22)]
    public Buff[] Buffs { get; set; }

    // Bounds checking for numeric fields
    [Bounds("Terraria279", upperBound: 255, lowerBound: 0)]
    public byte PlayerIndex { get; set; }

    // Field ignored during serialization
    [Ignore]
    public object LocalData { get; set; }

    // Force serialize private/protected property
    [ForceSerialize]
    protected int InternalValue { get; set; }
}

// S2C only packet - only server can send
[S2COnly]
public class ServerOnlyPacket : Packet
{
    public override MessageID Type => MessageID.WorldData;
    public string WorldName { get; set; }

    // S2C only property within a bidirectional packet
    [S2COnly]
    public int ServerOnlyField { get; set; }
}

// C2S only packet - only client can send
[C2SOnly]
public class ClientOnlyPacket : Packet
{
    public override MessageID Type => MessageID.ClientHello;
    public string Version { get; set; }
}
```

--------------------------------

### Handle NetModules and NetworkText

Source: https://context7.com/chi-rei-den/trprotocol/llms.txt

Use NetTextModuleC2S and NetTextModuleS2C for chat messages. NetworkText supports literal, formattable, and localized text types with binary serialization methods.

```csharp
using TrProtocol.Models;
using TrProtocol.Packets.Modules;

// Client sending a chat message (C2S)
var chatMessage = new NetTextModuleC2S
{
    Command = "Say",
    Text = "Hello everyone!"
};

// Server sending a chat message (S2C)
var serverMessage = new NetTextModuleS2C
{
    PlayerSlot = 255,  // 255 for server messages
    Text = NetworkText.FromLiteral("Welcome to the server!"),
    Color = new Color(255, 255, 0)  // Yellow text
};

// Create formatted text with substitutions
var formattedText = NetworkText.FromFormattable(
    "Player {0} has joined the game!",
    "NewPlayer"
);

// Create localization key reference
var localizedText = NetworkText.FromKey(
    "Game.JoinMessage",
    "PlayerName"
);

// Serialize NetworkText
using var ms = new MemoryStream();
using var bw = new BinaryWriter(ms);
serverMessage.Text.Serialize(bw);

// Deserialize NetworkText
ms.Position = 0;
using var br = new BinaryReader(ms);
var deserializedText = NetworkText.Deserialize(br);
Console.WriteLine(deserializedText.ToString());
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.