ModdingWiki - User contributions [en-gb]

Rob Northern Compression

2026-05-16T23:46:49Z

Aybe: Add RNC ProPack link @ GitHub

{{Compression Infobox
| Games =
{{Game|Magic Pockets}}
{{Game|Bubble Bobble featuring Rainbow Islands}}
}}

'''Rob Northern Compression''' is a form of lossless compression designed by Rob Northern. The format utilizes [[Huffman Compression]]. This form of compression was used by several Bullfrog games including Magic Carpet, Theme Hospital, and Dungeon Keeper.

Technical specs can be found at [https://github.com/CorsixTH/CorsixTH/wiki/RNC github.com/CorsixTH/CorsixTH/wiki/RNC].

The actual C++ decompression code can be found at [https://github.com/CorsixTH/CorsixTH/tree/master/common github.com/CorsixTH/CorsixTH/tree/master/common].

== Reverse-engineered RNC ProPack compression tool ==

https://github.com/lab313ru/rnc_propack_source

== C++ decompressor port to C# ==

<source lang="csharp">
using System;
using System.IO;

namespace BubbleBobble
{
public static class Rnc // by aybe, Nov. 2019
{
private static readonly ushort[] CrcTable =
{
0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
};

public static RncStatus ReadRnc(Stream input, Stream output)
{
unsafe
{
if (input == null)
throw new ArgumentNullException(nameof(input));

if (output == null)
throw new ArgumentNullException(nameof(output));

var iBytes = new byte[input.Length];

input.Read(iBytes, 0, iBytes.Length);

uint oLen, iLen, oSum, iSum;

fixed (byte* b = &iBytes[0])
{
var sig = ReadU32BE(b);
if (sig != 0x524E4301)
return RncStatus.FileIsNotRnc;

oLen = ReadU32BE(b + 4);
iLen = ReadU32BE(b + 8);
oSum = ReadU16BE(b + 12);
iSum = ReadU16BE(b + 14);
}

var oBytes = new byte[oLen];

fixed (byte* iBuf = &iBytes[0])
fixed (byte* oBuf = &oBytes[0])
{
return Unpack(iBuf, iLen, iSum, oBuf, oLen, oSum);
}
}
}

private static unsafe RncStatus Unpack(byte* iBuf, uint iLen, uint iSum, byte* oBuf, uint oLen, uint oSum)
{
var raw = new HuffmanTable();
var dst = new HuffmanTable();
var len = new HuffmanTable();

var oEnd = oBuf + oLen;
var iEnd = iBuf + 18 + iLen;

iBuf += 18;

if (ComputeChecksum(iBuf, (int) (iEnd - iBuf)) != iSum)
return RncStatus.PackedCrcError;

var stream = new BitStream();
BitStreamInit(&stream, iBuf, iEnd);
BitStreamAdvance(&stream, 2);

while (oBuf < oEnd)
{
ReadHuffmanTable(raw, &stream);
ReadHuffmanTable(dst, &stream);
ReadHuffmanTable(len, &stream);

var chunks = BitStreamRead(&stream, 0xFFFF, 16);

while (true)
{
var length = ReadHuffman(raw, &stream);
if (length == -1)
return RncStatus.HufDecodeError;

if (length != 0)
{
while (length-- != 0)
*oBuf++ = *stream.DataPos++;

BitStreamFix(&stream);
}

if (--chunks <= 0)
break;

var pos = ReadHuffman(dst, &stream);
if (pos == -1)
return RncStatus.HufDecodeError;

pos += 1;

length = ReadHuffman(len, &stream);

if (length == -1)
return RncStatus.HufDecodeError;

length += 2;

for (; length > 0; length--, oBuf++)
*oBuf = oBuf[-pos];
}
}

if (oEnd != oBuf)
return RncStatus.FileSizeMismatch;

return ComputeChecksum(oEnd - oLen, (int) oLen) != oSum
? RncStatus.UnpackedCrcError
: RncStatus.Ok;
}

private static unsafe void BitStreamInit(BitStream* stream, byte* dataPos, byte* dataEnd)
{
stream->BitBuffer = ReadU16LE(dataPos);
stream->BitCount = 16;
stream->DataPos = dataPos;
stream->DataEnd = dataEnd;
}

private static unsafe void BitStreamFix(BitStream* stream)
{
stream->BitCount -= 16;
stream->BitBuffer &= (uint) ((1 << stream->BitCount) - 1);

if (stream->DataPos < stream->DataEnd)
{
stream->BitBuffer |= ReadU16LE(stream->DataPos) << stream->BitCount;
stream->BitCount += 16;
}
else if (stream->DataPos == stream->DataEnd)
{
stream->BitBuffer |= (uint) (*stream->DataPos << stream->BitCount);
stream->BitCount += 8;
}
}

private static unsafe uint BitStreamPeek(BitStream* stream, uint mask)
{
var peek = stream->BitBuffer & mask;

return peek;
}

private static unsafe void BitStreamAdvance(BitStream* stream, int bits)
{
stream->BitBuffer >>= bits;
stream->BitCount -= bits;

if (stream->BitCount >= 16)
return;

stream->DataPos += 2;

if (stream->DataPos < stream->DataEnd)
{
stream->BitBuffer |= ReadU16LE(stream->DataPos) << stream->BitCount;
stream->BitCount += 16;
}
else if (stream->DataPos == stream->DataEnd)
{
stream->BitBuffer |= (uint) (*stream->DataPos << stream->BitCount);
stream->BitCount += 8;
}
}

private static unsafe uint BitStreamRead(BitStream* stream, uint mask, int bits)
{
var peek = BitStreamPeek(stream, mask);

BitStreamAdvance(stream, bits);

return peek;
}

private static unsafe ushort ComputeChecksum(byte* data, int length)
{
var val = default(ushort);

while (length-- != 0)
{
val = (ushort) (val ^ *data++);
val = (ushort) ((val >> 8) ^ CrcTable[val & 0xFF]);
}

return val;
}

private static uint MirrorBits(uint value, int bits)
{
var top = (uint) (1 << (bits - 1));
var bot = 1u;

while (top > bot)
{
var mask = top | bot;

var masked = value & mask;
if (masked != 0 && masked != mask)
value ^= mask;

top >>= 1;
bot <<= 1;
}

return value;
}

private static unsafe long ReadHuffman(HuffmanTable table, BitStream* stream)
{
int i;

for (i = 0; i < table.Count; i++)
{
var mask = (uint) ((1 << table.Leaves[i].CodeLength) - 1);

if (BitStreamPeek(stream, mask) == table.Leaves[i].Code)
break;
}

if (i == table.Count)
return -1;

BitStreamAdvance(stream, table.Leaves[i].CodeLength);

var val = (uint) table.Leaves[i].Value;

if (val < 2)
return val;

val = (uint) (1 << (int) (val - 1));

val |= BitStreamRead(stream, val - 1, table.Leaves[i].Value - 1);

return val;
}

private static unsafe void ReadHuffmanTable(HuffmanTable table, BitStream* stream)
{
int i;

var num = (int) BitStreamRead(stream, 0x1F, 5);
if (num == 0)
return;

var leafLen = new int[32];
var leafMax = 1;

for (i = 0; i < num; i++)
{
leafLen[i] = (int) BitStreamRead(stream, 0x0F, 4);

if (leafMax < leafLen[i])
leafMax = leafLen[i];
}

var count = 0;
var value = 0u; // code as BE

for (i = 1; i <= leafMax; i++)
{
for (var j = 0; j < num; j++)
{
if (leafLen[j] != i)
continue;

table.Leaves[count].Code = MirrorBits(value, i);
table.Leaves[count].CodeLength = i;
table.Leaves[count].Value = j;
value++;
count++;
}

value <<= 1;
}

table.Count = count;
}

private static unsafe uint ReadU16LE(byte* p)
{
uint n = p[1];
n = (n << 8) + p[0];
return n;
}

private static unsafe uint ReadU16BE(byte* p)
{
uint n = p[0];
n = (n << 8) + p[1];
return n;
}

private static unsafe uint ReadU32BE(byte* p)
{
uint n = p[0];
n = (n << 8) + p[1];
n = (n << 8) + p[2];
n = (n << 8) + p[3];
return n;
}

private unsafe struct BitStream
{
public uint BitBuffer;
public int BitCount;
public byte* DataEnd;
public byte* DataPos;
}

private sealed class HuffmanTable
{
public readonly HuffmanLeaf[] Leaves = new HuffmanLeaf[32];
public int Count;
}

private struct HuffmanLeaf
{
public uint Code;
public int CodeLength;
public int Value;
}
}

public enum RncStatus
{
Ok,
UnpackedCrcError,
FileSizeMismatch,
HufDecodeError,
PackedCrcError,
FileIsNotRnc
}
}
</source>

Super Street Fighter II TURBO

2026-05-16T23:35:23Z

Aybe: SSF2T .FMV format link

{{NeedMoreInfo}}
{{Game Infobox
| Levels = No
| Tiles = No
| Sprites = No
| Fullscreen = No
| Sound = No
| Music = No
| Text = No
| Story = No
| Interface = No
}}

'''Super Street Fighter II Turbo''' is a fighting game released for the arcades by Capcom in Japan on February 23, 1994, in North America on February 23 and March 26, 1994 (beta) and in Europe in March 1994 (beta). It is the fifth installment in the Street Fighter II sub-series of Street Fighter games, following Super Street Fighter II: The New Challengers. (from [https://en.wikipedia.org/wiki/Super_Street_Fighter_II_Turbo Wikipedia])

{{BeginGameFileList}}
{{GameFile
| Name = *.fmv
| Format = [[Super Street Fighter II TURBO Movie Format]]
| KnownFormat = Partial
| Desc = Full Motion Video
}}
{{GameFile
| Name = *.spr
| Format = [[Super Street Fighter II TURBO Sprite Format]]
| KnownFormat = Partial
| Desc = Sprite graphics
}}
{{EndGameFileList}}

[[Category:Fighting]]

Super Street Fighter II TURBO Movie Format

2026-05-16T23:33:31Z

Aybe: SSF2T .FMV format

{{Image Infobox
| Hardware1 = VGA
| Depth = 8-bit (VGA)
| MinSize = 320x200
| MaxSize = 320x200
| Palette = Internal
| NumPlanes = 1
| HasTransparency = No
| HasHitmap = No
| Games = {{Game|Super Street Fighter II TURBO}}
}}

This format is used by [[Super Street Fighter II TURBO]] to store intro movies.

== General ==

Each .FMV file is compressed with [[Rob Northern Compression]], then with [[RLE Compression]] of delta frames.

== Algorithm ==

<syntaxhighlight lang="csharp">
using System.Drawing;

namespace SuperStreetFighter2Turbo;

public sealed class Fmv
{
public Fmv(Stream stream)
{
Reader = new BinaryReader(stream);

if (Reader.ReadInt32() != 0x564D4641)
{
throw new InvalidDataException();
}

FrameCount = Reader.ReadUInt16();

Frame.AsSpan().Fill(Reader.ReadByte());

for (var i = 0; i < Palette.Length; i++)
{
var r = Expand(Reader.ReadByte());
var g = Expand(Reader.ReadByte());
var b = Expand(Reader.ReadByte());

Palette[i] = Color.FromArgb(r, g, b);
}

Reader.ReadByte();

return;

static byte Expand(byte b)
{
return (byte)((b * 255 + 31) / 63);
}
}

public byte[] Frame { get; } = new byte[320 * 200];

private int FrameCount { get; }

private int FrameIndex { get; set; }

public Color[] Palette { get; } = new Color[256];

private BinaryReader Reader { get; }

public bool Read()
{
if (FrameIndex >= FrameCount)
{
return false;
}

FrameIndex++;

var index = 0;

while (true)
{
var flags = Reader.ReadByte();

if ((flags & 0xC0) == 0xC0)
{
return true;
}

var count = 4 * (flags & 0x3F);

var chunk = Frame.AsSpan(index, count);

switch (flags & 0xC0)
{
case 0x40:
{
chunk.Fill(Reader.ReadByte());
break;
}
case 0x80:
{
Reader.ReadExactly(chunk);
break;
}
}

index += count;
}
}
}</syntaxhighlight>

== Credits ==

[[User:aybe|aybe]] on the 17th of May 2026

File:Super Street Fighter II TURBO Movie Format.png

2026-05-16T23:09:11Z

Aybe:

Dynablaster

2022-08-01T05:36:11Z

Aybe: Add Dynablaster sprite sheets

{{Game Infobox
| Levels = No
| Tiles = No
| Sprites = No
| Fullscreen = No
| Sound = No
| Music = No
| Text = No
| Story = No
| Interface = No
}}
{{NoModdingInfo}}

== File formats ==

The IMG files in the GFX directory are sprite sheets in [[LBM Format]] with most having a corrupt header.

The following C# program will create corrected copies of them as .LBM files:

<source>

using System.Buffers.Binary;
using System.Text;

var paths = Directory.GetFiles(Environment.CurrentDirectory, "*.img");

foreach (var path in paths)
{
using var src = File.OpenRead(path);
using var tgt = File.Create(Path.ChangeExtension(path, ".lbm"));

src.CopyTo(tgt);

tgt.Position = default;

using var writer = new BinaryWriter(tgt, Encoding.Default, true);

var length = (int)src.Length - 8;

if (BitConverter.IsLittleEndian)
{
length = BinaryPrimitives.ReverseEndianness(length);
}

writer.Write(Encoding.ASCII.GetBytes("FORM"));
writer.Write(length);
writer.Write(Encoding.ASCII.GetBytes("ILBM"));
writer.Write(Encoding.ASCII.GetBytes("BMHD"));
}
</source>

File:Dynablaster.png

2022-08-01T05:35:28Z

Aybe:

Quarantine

2021-11-26T22:47:01Z

Aybe: Levels (preliminary)

{{Game Infobox
| Levels = No
| Tiles = No
| Sprites = No
| Fullscreen = No
| Sound = No
| Music = No
| Text = No
| Story = No
| Interface = No
| Demo = No
}}

'''Quarantine''' is a vehicular first person shooter set in a dystopian city. It was developed by [[:Category:Imagexcel|Imagexcel]] and published by [[:Category:GameTek|GameTek]] in 1994.

The game's executable is a 32-bit [[Linear Executable (LX/LE) Format|Linear Executable]] loaded by the DOS4GW 16-bit extender. It was built with the Watcom C/C++ tool suite.

{{BeginGameFileList}}
{{GameFile
| Name = *.FLI
| Format = [[FLIC Format]]
| KnownFormat = Yes
| Desc = Animations
}}
{{GameFile
| Name = *.IMG
| Format = [[Graphics Interchange Format|GIF]] with modified signature ("<tt>IMAGEX</tt>" instead of standard "<tt>GIF87a</tt>")
| KnownFormat = Yes
| Desc = Fullscreen/backdrop graphics
}}
{{GameFile
| Name = *.SPR
| Format = Simple package of [[Raw VGA Image]]s
| KnownFormat = Yes
| Desc = Sprites
}}
{{EndGameFileList}}

[[Category:GameTek]]
[[Category:Imagexcel]]
[[Category:3D]]
[[Category:First-Person Shooter]]

=== FARE[?].ENC ===

Transcode the file, XOR-ing every byte read with 0x55, the file now looks like a structured text file:

# the person talking, matched with regex <code>^\s*/\s*(\P{C}+)$</code>
# the person quotes, matched with regex <code>^\s*("\P{C}+",?)\s*$</code>
# goto step 1, repeat until EOF

Example:

<source>
/ PROFESSIONAL
"SO, UH. DO YOU THINK YOU COULD GIVE ME A RIDE LITTLE BUDDY? I'M IN A BIT OF A RUSH.",
</source>

== Levels (preliminary) ==

Each level is constituted of three files, e.g. CITY.BLK, CITY.BSP, CITY.MAP.

=== *.MAP ===

# read an [[UINT16LE]], this is the map width
# read an [[UINT16LE]], this is the map height
# follows <code>width * height</code> tiles as [[UINT16LE]]

== Credits ==

[[User:aybe|aybe]] for the ENC format.

Quarantine

2021-11-26T22:15:11Z

Aybe: Reversed ENC format :)

File format data types

2021-09-26T14:49:54Z

Aybe: Add BitConverter.IsLittleEndian

This is a list of all the data types used in the file format descriptions on the wiki. They are loosely based on common C/C++ data types, and should be used throughout the wiki for consistency.

== Type list ==

==== Numeric values ====

{|class="wikitable"
!Data type!!Description
|-
|UINT8||Unsigned 8-bit integer
|-
|UINT16LE||Unsigned 16-bit integer in little-endian format
|-
|UINT16BE||Unsigned 16-bit integer in big-endian format
|-
|UINT32LE||Unsigned 32-bit integer in little-endian format
|-
|UINT32BE||Unsigned 32-bit integer in big-endian format
|}

Signed equivalents are the same without the leading U, i.e. <tt>INT8</tt>, <tt>INT16LE</tt>, etc. Unless otherwise stated, the format is in [[wikipedia:Two's complement|two's complement]] (where a UINT8 value of 255 is -1 as an INT8, for example.)

==== Floating point values ====

{|class="wikitable"
!Data type!!Description
|-
|Single||32-bit float (IEEE-754)
|-
|[[Turbo Pascal Real|Real]]||48-bit float (Pascal specific)
|-
|Double||64-bit float (IEEE-754)
|}

All floating point values are signed. They usually contain a sign bit, exponent, and mantissa.

==== Character strings ====

Characters and strings are all [[wp:Code page 437|CP437]] unless otherwise stated. On modern platforms, this means the bytes will need to be converted to the local character set (such as UTF-8) in order for the glyphs to match what was originally intended.

{|class="wikitable"
!Data type!!Description
|-
|char[x]||String ''x'' bytes/characters long, may or may not be null terminated (each use should indicate which)
|-
|char||Single 8-bit character
|-
|ASCIIZ||A C-style string (variable-length, terminated with a single NULL/0x00 value)
|}

==== Misc data types ====
{|class="wikitable"
!Data type!!Description
|-
|BYTE||Same as UINT8 but conceptually for generic data rather than numeric values (e.g. UINT8 would be used for a number, while a BYTE would be used for a bitfield)
|-
|BYTE[x]||Block of data ''x'' bytes long
|}

== Big endian vs little endian ==

For numeric values larger than a single byte, the endianness specifies how the values are split over multiple bytes. For example a hex value of 0x1234AABB when written to a file will take up two bytes, as follows:

{|class="wikitable"
!Endian!!Bytes in file
|-
|Big||<code>12 34 AA BB</code>
|-
|Little||<code>BB AA 34 12</code>
|}

For those languages that allow direct memory access such as C/C++, converting an integer value to a byte array will reveal the value stored in-memory in the same order as the table above.

Normally when reading or writing a variable to a file a programmer will simply pass the memory address of the variable, resulting in the file mirroring the byte order in memory. This is no problem when reading the variable back in on the same system, as the byte order will match. However when reading data from a different system (for example using an Intel PC to read files from a PowerPC Mac) the byte order will be opposite to what the system expects and the programmer must convert the values manually.

=== Conversion examples ===

If a value is being read on the same system (little to little or big to big) then no action is required. If the systems are different, then the values must be swapped. The following sections list examples for different programming languages.

==== C/C++ ====

<syntaxhighlight lang="c">
// 16-bit
int in = 0x1234;
int out = ((in & 0xFF) << 8) | (in >> 8);
// out should now be 0x3412

// 32-bit
int in = 0x1234AABB;
int out =
((in & 0xFF) << 24) |
((in & 0xFF00) << 8) |
((in & 0xFF0000) >> 8) |
(in >> 24);
// out should now be 0xBBAA3412
</syntaxhighlight>

==== C# .NET ====

<syntaxhighlight lang="csharp">
Int16 ByteSwap16(Int16 inValue)
{
return (Int16)(
((inValue & 0xFF) << 8) |
((inValue >> 8) & 0xFF)
);
}

Int32 ByteSwap32(Int32 inValue)
{
return (Int32)(
((inValue & 0xFF) << 24) |
((inValue & 0xFF00) << 8) |
((inValue & 0xFF0000) >> 8) |
((inValue >> 24) & 0xFF)
);
}
</syntaxhighlight>

==== Visual Basic .NET ====

<syntaxhighlight lang="vbnet">
Function ByteSwap16(ByVal InValue as Int16) as Int16
Return ((InValue And &HFF) << 8) Or ((InValue >> 8) And &HFF)
End Function

Function ByteSwap32(ByVal InValue as Int32) as Int32
Return ((InValue And &HFF) << 24) Or _
((InValue And &HFF00) << 8) Or _
((InValue And &HFF0000) >> 8) Or _
((InValue >> 24) And &HFF)
End Function
</syntaxhighlight>

Note: endianness of the platform in .NET can be known using the value of ''System.BitConverter.IsLittleEndian''.

[[Category:File Formats]]

Category:Fighting

2021-08-09T06:34:02Z

Aybe: Editing Category:Fighting

This category contains all fighting games in the wiki.

[[Category:Game Genres]]

Category:Fighting

2021-08-09T05:23:49Z

Aybe: Creating Category:Fighting

This category contains all fighting games in the wiki.

Super Street Fighter II TURBO

2021-08-09T05:22:33Z

Aybe: Category:Fighting

{{NeedMoreInfo}}
{{Game Infobox
| Levels = No
| Tiles = No
| Sprites = No
| Fullscreen = No
| Sound = No
| Music = No
| Text = No
| Story = No
| Interface = No
}}

Super Street Fighter II Turbo is a fighting game released for the arcades by Capcom in Japan on February 23, 1994, in North America on February 23 and March 26, 1994 (beta) and in Europe in March 1994 (beta). It is the fifth installment in the Street Fighter II sub-series of Street Fighter games, following Super Street Fighter II: The New Challengers. (from [https://en.wikipedia.org/wiki/Super_Street_Fighter_II_Turbo Wikipedia])

{{BeginGameFileList}}
{{GameFile
| Name = *.spr
| Format = [[Super Street Fighter II TURBO Sprite Format]]
| KnownFormat = Partial
| Desc = Sprite graphics
}}
{{EndGameFileList}}

[[Category:Fighting]]

File:Super Street Fighter II TURBO.png

2021-08-09T05:15:23Z

Aybe: Aybe uploaded a new version of File:Mod-Super Street Fighter II TURBO.png

Super Street Fighter II TURBO Sprite Format

2021-08-09T05:05:06Z

Aybe: Editing Super Street Fighter II TURBO Sprite Format (section)

{{Image Infobox
| Hardware1 = VGA
| Depth = 8-bit (VGA)
| MinSize = Unknown
| MaxSize = Unknown
| Palette = External
| NumPlanes = 1
| HasTransparency = Yes
| HasHitmap = Yes
| Games = {{Game|Super Street Fighter II TURBO}}
}}

This format is used by [[Super Street Fighter II TURBO]] to store sprite graphics.

== General ==

Most of the files are RNC-compressed and therefore should be decompressed beforehand.

Some files may store multiple frames each one after the other, this, without any indication.

The associated external [[VGA Palette]] may have the same file name, or not if it's a generic one.

Sprites used during ''Continue'' presumably are XOR-ed as some regions have diverging indices.

== Algorithm ==

{{TODO|Figure out why it does work for all files but LEVELS\DHALSIM\ANIMS.SPR.}}

The format is a simple form of [[RLE Compression]].

<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Text;

namespace SSF2T
{
public class Sprite
{
public Sprite(Stream stream)
{
if (stream == null)
throw new ArgumentNullException(nameof(stream));

using var reader = new BinaryReader(stream, Encoding.Default, true);

Width = reader.ReadUInt16();
Height = reader.ReadUInt16();

var pixels = new byte[Width * Height];

var index = 0;

for (var i = 0; i < Height; i++)
{
while (true)
{
var b = reader.ReadByte();

if (b == 0)
{
break;
}

if (b < 128)
{
index += b;
continue;
}

for (var j = 0; j (pixels);
}

public ushort Width { get; }

public ushort Height { get; }

public IReadOnlyList<byte> Pixels { get; }

}
}</source>

== Credits ==

Reverse-engineered by aybe on 9th of August 2021.

File:Super Street Fighter II TURBO Sprite Format.png

2021-08-09T05:01:38Z

Aybe:

Super Street Fighter II TURBO Sprite Format

2021-08-09T05:01:21Z

Aybe: Creating Super Street Fighter II TURBO Sprite Format

{{Image Infobox
| Hardware1 = VGA
| Depth = 8-bit (VGA)
| MinSize = Unknown
| MaxSize = Unknown
| Palette = External
| NumPlanes = 1
| HasTransparency = Yes
| HasHitmap = Yes
| Games = {{Game|Super Street Fighter II TURBO}}
}}

This format is used by [[Super Street Fighter II TURBO]] to store sprite graphics.

== General ==

Most of the files are RNC-compressed and therefore should be decompressed beforehand.

Some files may store multiple frames each one after the other, this, without any indication.

The associated external [[VGA Palette]] may have the same file name, or not if it's a generic one.

== Algorithm ==

{{TODO|Figure out why it does work for all files but LEVELS\DHALSIM\ANIMS.SPR.}}

The format is a simple form of [[RLE Compression]].

<source lang="csharp">
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Text;

namespace SSF2T
{
public class Sprite
{
public Sprite(Stream stream)
{
if (stream == null)
throw new ArgumentNullException(nameof(stream));

using var reader = new BinaryReader(stream, Encoding.Default, true);

Width = reader.ReadUInt16();
Height = reader.ReadUInt16();

var pixels = new byte[Width * Height];

var index = 0;

for (var i = 0; i < Height; i++)
{
while (true)
{
var b = reader.ReadByte();

if (b == 0)
{
break;
}

if (b < 128)
{
index += b;
continue;
}

for (var j = 0; j (pixels);
}

public ushort Width { get; }

public ushort Height { get; }

public IReadOnlyList<byte> Pixels { get; }

}
}</source>

== Credits ==

Reverse-engineered by aybe on 9th of August 2021.

Super Street Fighter II TURBO

2021-08-09T04:43:08Z

Aybe: Editing Super Street Fighter II TURBO - SPR Format

File:Super Street Fighter II TURBO.png

2021-08-09T04:39:59Z

Aybe:

2019-11-19T09:37:21Z

Aybe: {{NeedMoreInfo}}

{{Game Infobox
| Levels = No
| Tiles = No
| Sprites = No
| Fullscreen = No
| Sound = No
| Music = No
| Text = No
| Story = No
| Interface = No
}}
{{NeedMoreInfo}}

== Versions ==

=== Windows (published by Xplosiv) ===

Runs an emulator (Z80.DLL), SecuROM protected.

=== DOS (version this page is about) ===

Seems to be a direct port of the PSX version, which does not emulate a Z80.

== SPR files ==

Some but not all files are compressed using [[Rob Northern Compression]]. When decompressed, they will be either of [[PCX Format]] or [[LBM Format]], for the latter appearing to be taken from the PSX version with chunks such as '''PSX''', '''CL00''' (CLUT, 16-bit colors), '''TP00''' (texture page, raw image), '''BX00''' (unknown).

Bubble Bobble featuring Rainbow Islands

2019-11-19T09:34:16Z

Aybe: /* SPR files */

{{Game Infobox
| Levels = No
| Tiles = No
| Sprites = No
| Fullscreen = No
| Sound = No
| Music = No
| Text = No
| Story = No
| Interface = No
}}
{{NoModdingInfo}}

== Versions ==

=== Windows (published by Xplosiv) ===

Runs an emulator (Z80.DLL), SecuROM protected.

=== DOS (version this page is about) ===

Seems to be a direct port of the PSX version, which does not emulate a Z80.

== SPR files ==

Some but not all files are compressed using [[Rob Northern Compression]]. When decompressed, they will be either of [[PCX Format]] or [[LBM Format]], for the latter appearing to be taken from the PSX version with chunks such as '''PSX''', '''CL00''' (CLUT, 16-bit colors), '''TP00''' (texture page, raw image), '''BX00''' (unknown).