add tool for sprite conversion

Author: codengine

.idea/.idea.DarkSeedTools/.idea/vcs.xml

@@ -2,6 +2,8 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TosText", "TosText\TosText.csproj", "{13F1F8FB-B359-4963-9C04-54BB3C4D68B4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TosSprites", "TosSprites\TosSprites.csproj", "{2BB8F15A-8041-496E-AD3C-9E681B99CF30}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -12,5 +14,9 @@ Global
 		{13F1F8FB-B359-4963-9C04-54BB3C4D68B4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{13F1F8FB-B359-4963-9C04-54BB3C4D68B4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{13F1F8FB-B359-4963-9C04-54BB3C4D68B4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2BB8F15A-8041-496E-AD3C-9E681B99CF30}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2BB8F15A-8041-496E-AD3C-9E681B99CF30}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2BB8F15A-8041-496E-AD3C-9E681B99CF30}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2BB8F15A-8041-496E-AD3C-9E681B99CF30}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

DarkSeedTools.sln

@@ -9,7 +9,7 @@ Reads and writes TOSTEXT.BIN.
 #### Extract texts
 
 Usage:
-`TosText.exe extract`
+`TosText.exe extract -i "C:\DARKSEED\TOSTEXT.BIN" -o "C:\DARKSEED\TOSTEXT.TXT"`
 
 ```
 
@@ -27,10 +27,9 @@ Usage:
 #### Rebuild TOSTEXT.BIN
 
 Usage:
-`TosText.exe rebuild`
+`TosText.exe rebuild -i "C:\DARKSEED\TOSTEXT.TXT" -o "C:\DARKSEED\TOSTEXT.BIN"`
 
 ```
-
   -i, --in     Required. Path to input (txt) file
 
   -o, --out    Required. Path to output (bin) file
@@ -40,4 +39,39 @@ Usage:
   --help       Display this help screen.
 
   --version    Display version information.
+```
+
+
+## TosSprite
+
+Reads and writes sprites from and to .NSP files.
+
+#### Extract sprites
+
+Usage:
+`TosSprites.exe extract -i "C:\DARKSEED\CPLAYER.NSP" -o "C:\DARKSEED\out"`
+
+```
+  -i, --in     Required. Path to the input file
+
+  -o, --out    Required. Path where the gif files are stored
+
+  --help       Display this help screen.
+
+  --version    Display version information.
+```
+
+#### Rebuild TOSTEXT.BIN
+
+If the sprites are stored at CPLAYER_0.gif, CPLAYER_1.gif and so on, the prefix would be "CPLAYER".
+
+Usage:
+`TosSprites.exe rebuild -i "C:\DARKSEED\out" -o "C:\DARKSEED\CPLAYER.NSP" -o "CPLAYER"`
+
+```
+  -i, --in        Required. Path to input files
+
+  -p, --prefix    Required. Input filename prefix
+
+  -o, --out       Required. Path to output file
 ```

DarkSeedTools.sln.DotSettings.user

@@ -0,0 +1,138 @@
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Formats.Gif;
+using SixLabors.ImageSharp.Processing.Processors.Quantization;
+
+namespace TosSprites;
+
+public static class Converter
+{
+    private static readonly GifEncoder Encoder;
+    
+    private static readonly Dictionary<(byte R, byte G, byte B), byte> ColorToIndexMap = new();
+    private static readonly Rgba32[] PaletteColors = new Rgba32[16];
+    
+    static Converter()
+    {
+        for (byte i = 0; i < 15; i++)
+        {
+            var gray = (byte)(i * 255 / 14);
+            PaletteColors[i] = new Rgba32(gray, gray, gray, 255);
+            ColorToIndexMap[(gray, gray, gray)] = i;
+        }
+        
+        // Transparent (0xFF in original file)
+        PaletteColors[15] = new Rgba32(0, 0, 0, 0);
+        
+        var colors = new Color[16];
+        for (byte i = 0; i < 16; i++)
+        {
+            colors[i] = new Color(PaletteColors[i]);
+        }
+        
+        Encoder = new GifEncoder
+        {
+            ColorTableMode = GifColorTableMode.Local,
+            Quantizer = new PaletteQuantizer(
+                new ReadOnlyMemory<Color>(colors), 
+                new QuantizerOptions { Dither = null })
+        };
+    }
+
+    public static void ToGif(string outputPath, Sprite sprite)
+    {
+        // Special case for empty sprites
+        if (sprite.IsEmptySprite)
+        {
+            SaveEmptySprite(outputPath);
+            return;
+        }
+        
+        // We only care for visible pixels
+        using var image = new Image<Rgba32>(sprite.Width, sprite.Height);
+        
+        for (var y = 0; y < sprite.Height; y++)
+        {
+            for (var x = 0; x < sprite.Width; x++)
+            {
+                var pixelValue = sprite.GetPixel(x, y);
+                
+                if (pixelValue == Sprite.TransparentPixel)
+                {
+                    image[x, y] = new Rgba32(0, 0, 0, 0);
+                }
+                else if (pixelValue < PaletteColors.Length)
+                {
+                    image[x, y] = PaletteColors[pixelValue];
+                }
+                else
+                {
+                    image[x, y] = new Rgba32(0, 0, 0, 255);
+                }
+            }
+        }
+        
+        image.Save(outputPath, Encoder);
+    }
+
+    private static void SaveEmptySprite(string outputPath)
+    {
+        using var emptyImage = new Image<Rgba32>(1, 1);
+        emptyImage[0, 0] = new Rgba32(0, 0, 0, 0); // Transparent
+        emptyImage.Save(outputPath);
+    }
+
+    public static Sprite FromGif(string inputPath)
+    {
+        using var image = Image.Load<Rgba32>(inputPath);
+        
+        if (image is { Width: 1, Height: 1 } && image[0, 0].A == 0)
+        {
+            return Sprite.CreateEmpty();
+        }
+        
+        var width = (ushort)image.Width;
+        var height = (ushort)image.Height;
+        var pitch = (ushort)(width + (width & 1));
+
+        var sprite = new Sprite(width, height, pitch);
+        
+        for (var y = 0; y < height; y++)
+        {
+            for (var x = 0; x < width; x++)
+            {
+                var color = image[x, y];
+                
+                if (color.A == 0)
+                {
+                    sprite.SetPixel(x, y, Sprite.TransparentPixel);
+                }
+                else
+                {
+                    var colorIndex = GetExactColorIndex(color, inputPath, x, y);
+                    sprite.SetPixel(x, y, colorIndex);
+                }
+            }
+            
+            if (width != pitch)
+            {
+                // For odd widths, explicitly set the padding pixel to transparent
+                sprite.SetPixel(width, y, Sprite.TransparentPixel);
+            }
+        }
+        
+        return sprite;
+    }
+    
+    private static byte GetExactColorIndex(Rgba32 color, string filePath, int x, int y)
+    {
+        if (color.A == 0) return Sprite.TransparentPixel;
+        
+        if (ColorToIndexMap.TryGetValue((color.R, color.G, color.B), out var index))
+        {
+            return index;
+        }
+        
+        throw new Exception($"No exact color match found for RGB({color.R},{color.G},{color.B}) at position ({x},{y}) in file {Path.GetFileName(filePath)}");
+    }
+}

README.md

@@ -0,0 +1,144 @@
+using CommandLine;
+using NaturalSort.Extension;
+
+namespace TosSprites;
+
+internal abstract class Program
+{
+    // Extract operation class
+    [Verb("convert", HelpText = "Convert a .NSP file to .gif files")]
+    public class ConvertOptions
+    {
+        [Option('i', "in", Required = true, HelpText = "Path to the input file")]
+        public string InputPath { get; set; }
+        
+        [Option('o', "out", Required = true, HelpText = "Path where the gif files are stored")]
+        public string OutputPath { get; set; }
+    }
+
+    // Rebuild operation class
+    [Verb("rebuild", HelpText = "Rebuild .gif files to an .NSP file")]
+    public class RebuildOptions
+    {
+        [Option('i', "in", Required = true, HelpText = "Path to input files")]
+        public string InputPath { get; set; }
+        
+        [Option('p', "prefix", Required = true, HelpText = "Input filename prefix")]
+        public string InputFilePrefix { get; set; }
+        
+        [Option('o', "out", Required = true, HelpText = "Path to output file")]
+        public string OutputFile { get; set; }
+    }
+    
+    private static int Main(string[] args)
+    {
+        return Parser.Default.ParseArguments<ConvertOptions, RebuildOptions>(args)
+            .MapResult(
+                (ConvertOptions opts) => RunExtract(opts),
+                (RebuildOptions opts) => RunRebuild(opts),
+                _ => 1);
+    }
+
+    private static int RunExtract(ConvertOptions opts)
+    {
+        if (!File.Exists(opts.InputPath))
+        {
+            Console.Error.WriteLine($"Input file not found: {opts.InputPath}");
+            return -1;
+        }
+
+        if (!Directory.Exists(opts.OutputPath))
+        {
+            Directory.CreateDirectory(opts.OutputPath);            
+        }
+        
+        // Create the base filename for sprites (e.g., CPLAYER_NSP)
+        var baseFileName = Path.GetFileNameWithoutExtension(opts.InputPath);
+        
+        Console.WriteLine($"Processing {opts.InputPath}...");
+        
+        try
+        {
+            using var file = File.OpenRead(opts.InputPath);
+            using var reader = new BinaryReader(file);
+            
+            var spriteCount = file.Length > 0 ? 0xC0 / 2 : 0;
+            var sprites = new Sprite[spriteCount];
+            
+            for (var i = 0; i < sprites.Length; i++)
+            {
+                int width = reader.ReadByte();
+                int height = reader.ReadByte();
+                var pitch = width + (width & 1); // Add padding if width is odd
+                sprites[i] = new Sprite((ushort)width, (ushort)height, (ushort)pitch);
+            }
+            
+            for (var i = 0; i < sprites.Length; i++)
+            {
+                sprites[i].Load(reader);
+                var gifPath = Path.Combine(opts.OutputPath, $"{baseFileName}_{i}.gif");
+                Converter.ToGif(gifPath, sprites[i]);
+            }
+            
+            Console.WriteLine($"Converted {sprites.Length} sprites to GIF in {opts.OutputPath}");
+            return 1;
+        }
+        catch (Exception ex)
+        {
+            Console.Error.WriteLine($"Error: {ex.Message}");
+            Console.Error.WriteLine(ex.StackTrace);
+            return -1;
+        }
+    }
+    
+    private static int RunRebuild(RebuildOptions opts)
+    {
+        if (!Directory.Exists(opts.InputPath))
+        {
+            Console.Error.WriteLine($"Input directory not found: {opts.InputPath}");
+            return -1;
+        }
+
+        var sprites = Directory
+            .EnumerateFiles(opts.InputPath, $"{opts.InputFilePrefix}_*.gif", SearchOption.TopDirectoryOnly)
+            .OrderBy(x => x, StringComparison.OrdinalIgnoreCase.WithNaturalSort())
+            .ToDictionary(file => file, Converter.FromGif);
+            
+        if (sprites.Count == 0)
+        {
+            Console.Error.WriteLine($"No input files found at {opts.InputPath}");
+            return -1;
+        }
+
+        if (File.Exists(opts.OutputFile))
+        {
+            File.Delete(opts.OutputFile);
+        }
+        
+        // Step 3: Create a new file by loading the GIFs back
+        using var outFile = File.Create(opts.OutputFile);
+        using var writer = new BinaryWriter(outFile);
+        
+        foreach (var sprite in sprites.Select(kvp => kvp.Value))
+        {
+            writer.Write((byte)sprite.Width);
+            writer.Write((byte)sprite.Height);
+        }
+        
+        foreach (var kvp in sprites)
+        {
+            try
+            {
+                kvp.Value.Save(writer);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error processing sprite {kvp.Key}: {ex.Message}");
+                throw;
+            }
+        }
+            
+        Console.WriteLine($"Successfully created {opts.OutputFile}");
+        return 1;
+    }
+}