8 files changed, 122 insertions(+), 27 deletions(-)

M src/Anonymizer/Movers/Basic/CInfoPacketMover.cs
M src/Anonymizer/Movers/Basic/InPacketMover.cs
M src/Anonymizer/Movers/RegisteredMovers.cs
M src/Anonymizer/PacketProcessor.cs
M src/Anonymizer/Sinks/FileSink.cs
M src/Anonymizer/Sinks/FileSinkOptions.cs
M src/Anonymizer/Sinks/IPacketDestination.cs
M src/Anonymizer/Sinks/IPacketSource.cs

@@ 16,7 16,8 @@ public class CInfoPacketMover : AbstractMover<CInfoPacket>
         => packet with
         {
             CharacterId = anonymizer.AnonymizeId(packet.CharacterId),
-            FamilyId = packet.FamilyId is null ? null : anonymizer.AnonymizeId(long.Parse(packet.FamilyId)).ToString(),
+            Name = anonymizer.AnonymizeName(packet.Name),
+            FamilyId = packet.FamilyId is null ? null : anonymizer.AnonymizeName(packet.FamilyId),
             FamilyName = packet.FamilyName is null ? null : anonymizer.AnonymizeName(packet.FamilyName),
             GroupId = packet.GroupId is null ? null : anonymizer.AnonymizeId(packet.GroupId.Value)
         };

@@ 17,7 17,7 @@ public class InPacketMover : AbstractMover<InPacket>
     {
         return packet with
         {
-            EntityId = packet.EntityId,
+            EntityId = anonymizer.AnonymizeId(packet.EntityId),
             Name = packet.Name is null ? null : (NameString)anonymizer.AnonymizeName(packet.Name),
             PlayerSubPacket = packet.PlayerSubPacket is null
                 ? null


@@ 39,6 39,23 @@ public class InPacketMover : AbstractMover<InPacket>
                                     (packet.PlayerSubPacket.FamilySubPacket.Value.FamilyId)
                             }
                     }
+                },
+            NonPlayerSubPacket = packet.NonPlayerSubPacket is null
+                ? null
+                : packet.NonPlayerSubPacket with
+                {
+                    OwnerId = packet.NonPlayerSubPacket.OwnerId is null
+                        ? null
+                        : anonymizer.AnonymizeId(packet.NonPlayerSubPacket.OwnerId.Value),
+                    Name = packet.NonPlayerSubPacket.Name is null
+                        ? null
+                        : (NameString)anonymizer.AnonymizeName(packet.NonPlayerSubPacket.Name)
+                },
+            ItemSubPacket = packet.ItemSubPacket is null
+                ? null
+                : packet.ItemSubPacket with
+                {
+                    OwnerId = anonymizer.AnonymizeId(packet.ItemSubPacket.OwnerId)
                 }
         };
     }

@@ 36,11 36,14 @@ public class RegisteredMovers
     public void AddMover<TPacket>()
         where TPacket : IPacket
     {
-        var header = typeof(TPacket).GetCustomAttribute<PacketHeaderAttribute>();
+        var headers = typeof(TPacket).GetCustomAttributes<PacketHeaderAttribute>();
 
-        if (header?.Identifier is not null)
+        foreach (var header in headers)
         {
-            _packetHeaders.Add(header.Identifier);
+            if (header.Identifier is not null)
+            {
+                _packetHeaders.Add(header.Identifier);
+            }
         }
     }
 

@@ 103,22 103,38 @@ public class PacketProcessor
     /// <param name="destination">The destination to put processed packets into.</param>
     /// <param name="ct">The cancellation token for cancelling the operation.</param>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-    public async Task<Result> ProcessSourceDestination(IPacketSource source, IPacketDestination destination, CancellationToken ct = default)
+    public async Task<Result> ProcessSourceDestination
+        (IPacketSource source, IPacketDestination destination, CancellationToken ct = default)
     {
-        while (await source.TryGetNextPacketAsync(out var packet, ct))
+        var errors = new List<IResult>();
+        PacketInfo? packetInfo;
+        while ((packetInfo = await source.TryGetNextPacketAsync(ct)) != null)
         {
-            var processedPacketResult = ProcessPacket(packet!);
+            var processedPacketResult = ProcessPacket(packetInfo);
             if (!processedPacketResult.IsDefined(out var processedPacket))
             {
-                return Result.FromError(processedPacketResult);
+                errors.Add(Result.FromError(processedPacketResult));
+                continue;
             }
 
             if (processedPacket.Keep)
             {
-                await destination.WritePacketAsync(processedPacket.NewPacketString);
+                await destination.WritePacketAsync
+                (
+                    packetInfo with
+                    {
+                        Packet = processedPacket.NewPacketString
+                    },
+                    ct
+                );
             }
         }
 
-        return Result.FromSuccess();
+        return errors.Count switch
+        {
+            0 => Result.FromSuccess(),
+            1 => (Result)errors[0],
+            _ => new AggregateError(errors)
+        };
     }
 }=
\ No newline at end of file

@@ 14,9 14,10 @@ namespace Anonymizer.Sinks;
 /// </summary>
 public class FileSink : IDisposable, IPacketSource, IPacketDestination
 {
+    private readonly Regex _regex;
     private readonly FileSinkOptions _options;
-    private readonly FileStream _sourceStream;
-    private readonly FileStream _destinationStream;
+    private readonly StreamReader _reader;
+    private readonly StreamWriter _writer;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="FileSink"/> class.


@@ 26,30 27,61 @@ public class FileSink : IDisposable, IPacketSource, IPacketDestination
     /// <param name="options">The options.</param>
     public FileSink(string sourceFile, string destinationFile, FileSinkOptions options)
     {
+        _regex = new Regex(options.LineRegex);
         _options = options;
-        _sourceStream = File.OpenRead(sourceFile);
-        _destinationStream = File.OpenWrite(destinationFile);
+
+        _reader = new StreamReader(File.OpenRead(sourceFile));
+        _writer = new StreamWriter(File.OpenWrite(destinationFile));
     }
 
     /// <inheritdoc />
     public long Cursor { get; private set; }
 
     /// <inheritdoc />
-    public Task<bool> TryGetNextPacketAsync(out PacketInfo packetInfo, CancellationToken ct = default)
+    public async Task<PacketInfo?> TryGetNextPacketAsync(CancellationToken ct = default)
     {
-        throw new NotImplementedException();
+        if (_reader.EndOfStream)
+        {
+            return null;
+        }
+
+        var line = await _reader.ReadLineAsync(ct);
+        if (string.IsNullOrEmpty(line))
+        {
+            return null;
+        }
+
+        Cursor++;
+
+        var match = _regex.Match(line);
+        if (!match.Success)
+        {
+            Console.Error.WriteLine($"Could not find match on line {line}");
+            return new PacketInfo(PacketSource.Client, string.Empty);
+        }
+
+        var type = match.Groups[1].Value;
+        var packetStr = match.Groups[2].Value;
+        var source = type == _options.RecvString ? PacketSource.Server : PacketSource.Client;
+
+        return new PacketInfo(source, packetStr);
     }
 
     /// <inheritdoc />
-    public Task WritePacketAsync(string packetString)
+    public async Task WritePacketAsync(PacketInfo packet, CancellationToken ct = default)
     {
-        throw new NotImplementedException();
+        var output = _options.OutputFormat
+            .Replace("%TYPE%", packet.Source == PacketSource.Client ? _options.SendString : _options.RecvString)
+            .Replace("%PACKET%", packet.Packet);
+
+        await _writer.WriteLineAsync(new ReadOnlyMemory<char>(output.ToCharArray()), ct);
+        await _writer.FlushAsync();
     }
 
     /// <inheritdoc />
     public void Dispose()
     {
-        _sourceStream.Dispose();
-        _destinationStream.Dispose();
+        _writer.Dispose();
+        _reader.Dispose();
     }
 }=
\ No newline at end of file

@@ 8,4 8,28 @@ using System.Text.RegularExpressions;
 
 namespace Anonymizer.Sinks;
 
-public record FileSinkOptions(Regex lineRegex, string recvString, string sendString);>
\ No newline at end of file
+/// <summary>
+/// Options for <see cref="FileSink"/>.
+/// </summary>
+public class FileSinkOptions
+{
+    /// <summary>
+    /// Gets or sets the line format to output.
+    /// </summary>
+    public string OutputFormat { get; set; } = "[%TYPE%]\t%PACKET%";
+
+    /// <summary>
+    /// Gets or sets the regex match of the line.
+    /// </summary>
+    public string LineRegex { get; set; } = ".*\\[(Recv|Send)\\]\t(.*)";
+
+    /// <summary>
+    /// Gets or sets the receive string from the packet line.
+    /// </summary>
+    public string RecvString { get; set; } = "Recv";
+
+    /// <summary>
+    /// Gets or sets the send string from the packet line.
+    /// </summary>
+    public string SendString { get; set; } = "Send";
+}<
\ No newline at end of file

@@ 4,6 4,8 @@
 //  Copyright (c) František Boháček. All rights reserved.
 //  Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using NosSmooth.Packets.Server.Skills;
+
 namespace Anonymizer.Sinks;
 
 /// <summary>


@@ 14,7 16,8 @@ public interface IPacketDestination
     /// <summary>
     /// Write the given packet string into the destination.
     /// </summary>
-    /// <param name="packetString">The packet string to write.</param>
+    /// <param name="packetInfo">The packet info to write.</param>
+    /// <param name="ct">The cancellation token used for cancelling the operation.</param>
     /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-    public Task WritePacketAsync(string packetString);
+    public Task WritePacketAsync(PacketInfo packetInfo, CancellationToken ct = default);
 }=
\ No newline at end of file

@@ 24,8 24,7 @@ public interface IPacketSource
     /// <remarks>
     /// Moves the cursor.
     /// </remarks>
-    /// <param name="packetInfo">The information about next packet.</param>
     /// <param name="ct">The cancellation token used for cancelling the operation.</param>
-    /// <returns>Whether next packet was loaded and cursor moved. If false, there are no more packets.</returns>
-    public Task<bool> TryGetNextPacketAsync([NotNullWhen(true)] out PacketInfo? packetInfo, CancellationToken ct = default);
+    /// <returns>Null if no more packets are present.</returns>
+    public Task<PacketInfo?> TryGetNextPacketAsync(CancellationToken ct = default);
 }=
\ No newline at end of file