Red Alert File Formats Guide

THE RED ALERT FILE FORMATS GUIDE Release v1.4 Last Updated: 18th April 1997 (c) 1997 Gavin Pugh (email - rascenedit@geocities.com) (WWW - http://www.geocities.com/TimesSquare/Arcade/5553) The purpose of this guide is to detail the structure of files used in the Game Red Alert, for use to create utilities or editors. Command & Conquer : Red Alert is a trademark and copyright of Westwood Studios, and is so acknowledged. Any trademarks not mentioned here are still acknowledged. If you intend to use quite a bit of this guide in your FAQ or similar text then I would quite like to hear from you, as I can create a reference to it in my guide. Also I want be credited if you use parts of this guide in your own. Any use of information in this guide should credit the relevant author, (me in most cases), in such programs as utilities and editors. If you have a contribution then please email it to the above address, it'll be more than welcome, and of course, you'll be credited for it, any help is appreciated. Web Site Authors : You are welcome (and encouraged) to have my guide on your page(s), as long as you do not modify the HTML file in any way whatsoever, and also I request that you include a link on your site to my site at the address at the bottom of this document. Enough of the legal crap, enjoy.... MIX Files All MIX files I have seen can be used with the old C&C utilites, with the MIX headers following this format, In Red Alert only the more minor MIX files hidden in the CD directories follow the normal MIX format, the others are RMIX files. +++--+ +++--+ struct MIXheader { WORD  NumFiles;  //Number Of Files In the MIX LONG  DataSize;  //Size Of The Body }; The Array of offsets has one entry for each file: struct MIXrec { LONG  FileID;  //The ID Of The File, derived from the name of the file LONG  Offset;  //Offset Of The FIle From The Start Of The Body LONG  Size;    //Size Of The File }; If you know how the ID is calculated, I'd like to hear it, just for completeness. RMIX Files However, the two which don't though are : MAIN.MIX and REDALERT.MIX. These both contain other MIX files which also can't be read by Mixman. I'll refer to these 'special' MIX files as RMIX from now on, as a few others working on MIX files have done. Here is a list of all the RMIX files I have found: MAIN.MIX         ;Contains most other MIX files REDALERT.MIX MOVIES1.MIX MOVIES2.MIX GENERAL.MIX SCORES.MIX CONQUER.MIX SPEECH.MIX SOUNDS.MIX RUSSIAN.MIX ALLIES.MIX LOCAL.MIX LORES.MIX HIRES.MIX NCHIRES.MIX EDITOR.MIX EDHI.MIX EDLO.MIX TRANSIT.MIX and SC*.MIX and SS*.MIX, probably used on Counterstrike Well, so far I can amount the structure of an RMIX to: ++--+ ++--+ The header is an encoded representation of where and how long each file is in the body section. The body where all the contained files are, stored one after the other, with nothing inbetween. RMIX Header I can almost definately say that the headers include at least: Looking at MAIN.MIX, it is structured like this: ++-+--+--- ...        | HEADER | CONQUER.MIX | EDHI.MIX | EDLO.MIX .....         ++-+--+--- ... OFFSETS: 0       EC         213903      220D42     222D68 LENGTHS:    EC        213817       D43F       2026 Here is the header in HEX View: 00 00 02 00 6E 3A 77 4B 7A BB E8 57 DB 10 8B 77 EC 67 5C 0C D9 8A 6B 50 47 AC 8D A4 31 FD 0A A1 EB CF F1 5F 93 19 4D FD C6 49 3F 10 67 A5 7B E2 5D 11 98 3C B4 D8 35 40 3B 36 E6 B3 13 37 70 9C 3F 3C E0 70 97 47 1F BC CE 1B B0 D1 68 D4 F3 B7 E2 F6 8A 32 C2 4B 7D BF 43 87 0B 40 63 27 77 9E 9E 94 40 86 9A B6 59 09 15 52 D2 8E FB E6 BA B8 6A 15 FC 31 5A 1C 4A 9E 54 B3 F6 98 66 24 DB 5E 33 14 82 3D 6E 6B 7C 37 EF 3D 58 83 A5 08 D8 2F 9C A0 D0 86 6F C7 65 5F 56 EF E8 7E 13 5F 08 5A 1E E3 E1 E7 47 0E 72 34 4C 65 BD DD 71 AC 83 FD 4C 4C D2 A3 85 E5 06 C3 55 18 BE FA 70 01 81 F1 40 31 5E 71 64 BB 54 04 95 1E 51 10 B6 DF 96 6F 71 C4 6A 19 CE 19 DC 3E 85 1C 4B B1 B3 DC 21 79 D7 B1 65 C1 B8 73 C9 77 A5 14 7B 0C (still in progess, I'm uploading my site now, so I'll be stopping here for the mo) RMT Files (TMP files in Red Alert) Thanks To Moritz Mertinkat, (and Andrew Griffin for the Xdim/Ydim Info) My Note: These RTM files are used in Red Alert for the map tiles, the 3 theater RMIX files contain many of these tiles to put over your maps. These tiles are those you can place using the RA Terrain Editor, but using this method you could also extract the graphics for the INDOOR theater. The header (in pascal): TRMTHeader = record Width   : Word;    {Width of images, always 24 (18h)} Height  : Word;    {Heigth of images, always 24 (18h)} NumTil  : Word;    {Number of Tiles} Unknown1 : Word; XDim    : Word; YDim    : Word; Size    : LongInt; {Size of file} ImgStart : LongInt; {Start of image-data} Unknown3 : LongInt; Unknown4 : LongInt; Index2  : LongInt; Unknown5 : LongInt; Index1  : LongInt; {Offset of "Index"} end; You can use XDim and YDim to determine how the tiles should be used to construct the uber-tile. For example, say XDim = 3 and YDim = 2, then the uber-tile would be a 3x2 tile. This is probably only of use when placing the uber-tile in the first place, as the individual sub-tiles would be placed when the map is being drawn. XDim and YDim give you the dimensions of the uber-tile. If XDim and YDim are both equal to 1, then there is no uber-tile. If this RMT file holds more than 1 tile, then they are all individual tiles and have no special relationship to each other in regards to being parts of a larger tile. Index2-Index1 should be the number of tiles! Index1 is an offset for an array of bytes: Index: ARRAY[1..NumTil] of Byte; Every entry in this array which points to a specified tile. If the entry is 255 (FFh) then the tile is empty! An example: If you want to display tile 8 of a RMT-file you have to do   the following: - open the file - read the header - seek to pos. INDEX1 - read the index - read the 9th byte of it (for tile 8, because the index                                starts with 0!}      - seek to: SizeOf(Header) + Index[9] * (24*24)      - read 576 byte (24*24) and display them!      - close the file  All the graphics-data is uncompressed! PCX-files (Documentation by Moritz Mertinkat) My Note: These PCX files are used for 640x400 images in the Windows 95' version of Red Alert, where CPS files are used for the 320x200 ones in DOS. PCX-Header (in pascal): ---  TPCXHeader = RECORD    Signature : Byte;    Version   : Byte;    Encoding  : Byte;    BitsPixel : Byte;    XMin      : Word;    YMin      : Word;    XMax      : Word;    YMax      : Word;    HRes      : Word;    VRes      : Word;    Palette16 : ARRAY[1..48] of Byte;    Reserved  : Byte;    NumPlanes : Byte;    BytesLine : Word;    PalType   : Word;    Dummy     : ARRAY[1..58] of Byte;  end; Description:
 * HEADER | ARRAY OF OFFSETS/SIZES | BODY |
 * HEADER | BODY |
 * The offsets of the files, from the start of the body.
 * The lengths of the files
 * And some sort of ID, similar to the C&C one.

Signature: 10 = ZSoft PCX-files Version: 0 = PC Paintbrush v2.5 2 = Version 2.8 with palette information 3 = Version 2.8 without palette information 4 = PC Paintbrush for Windows (Plus for Windows uses Ver 5) 5 = Version 3.0: Used by Paintbrush in Win3.x and Win95, Can be used for 24-bit images!! >>>> NOTE: Version 5 is standard!! PalType: 1 = Color/BW  (use this one for 256-color images!) 2 = Grayscale XMin, XMax, YMin and YMax are the image dimensions. HRes and VRes are the horizantal and vertical Resultion of the image in DPI. If you create your own PCX-files, set HRes and VRes to 300. The image data is encoded with RLE (Run Length Encoding) and follows directly after the header. Decoding the PCX-data: -- First you have to calculate the X- and Y-dimension of the image. X-dimension: Width:= BytesLine*NumPlanes (But I've seen, that there's another way doing this:  Width:= XMax-XMin+1) Y-dimension: Height:= YMax-YMin+1 Now, read a single byte (B1) from the PCX-file. If the top two bits of this byte (B1) are set, then the remaining six bits show how many times you have to duplicate the next byte (after B1) in the file. [That means: If the byte (B1) is > 192, then it is a "Repeat-byte" and you have to duplicate the next byte (after B1) RepeatByte-192 times] If the top two bits are not set, the byte (B1) itself is the data with a count of one. [That means: If the byte B1 < 192 then this byte represents a pixel itself] Simply do this with all bytes (and don't forget the linebreaks after Width decoded bytes). If FileSize(PCXFile)-(768+1) = 12 [the byte before the pal-array], then the following 768 bytes contain the palette information - otherwise there's no palette. (If you have any questions, comments, ect. please email me: Moritz Mertinkat) Some sample-code (in pascal) at: http://home.t-online.de/home/moehrchen (TP Programmers Page) (Download-area, "PCX-viewer 4.0b for 256-color-bitmaps") SHP Files The SHP files are stored in the MIX files. They are used for the units, icons in the sidebar, structures and other graphics. A 6 image SHP would look like: [Header][ImgInfo1][ImgInfo2]....[ImgInfo5][ImgInfo6][ImgInfo7][ImgInfo8][THE SHP DATA] Note that the two extra Imginfo parts are special, the last one is all nulls, where the offset in the penultimate one points to the end of the file. The header for these SHP files is as follows: struct SHPheader { WORD  NumImages;  //Number Of Images In SHP file WORD  A;          //Unknown (please email me if you know what they are) WORD  B;          //Unknown WORD  Width;      //Width Of The Images, in pixels WORD  Height;     //Height Of The Images, in pixels LONG  C;          //Unknown }; Each Image (and those 2 special bits), are represented by a info part here. struct ImgInfo { 3 BYTES  Offset;     //Offset of image in file CHAR  Format;     //Format Of Image (&h80 is Format80, &h40 is Format40, etc..) WORD  RefOff;     //Offset of reference image for Format20/40 WORD  RefForm;    //Format of reference image }; Note that the Offset field is different from C&C, with it being 3 bytes, the RefOff field may also be 3 bytes now as well, but the Refform can be a word, so it is most likely not 3 bytes. Packed Sections First, in relation to C&C1 where each cell is represented by 2 bytes, as the total map size in RA seems to be 128x128 then the binary file for the map which could then be fiddled with and read by third-party editors would be a 128x128x3 byte binary file (=48k). Note that 3 bytes per cell in a map section are used in RA. (This would definately be needed if an editor was created allowing the creation of INDOOR maps) To think about.....Maybe putting a 48k SCG01EA.BIN file along with the INI (a'la C&C1), this would be a solution, but unfortunately the RA terrain editor only handles packed maps :( (note that NewINIFormat=1 would be needed for this way to work, and the OVERLAY section used instead of the OverlayPack) This would be a 2-part process: [MapPack] 1=983704304RREREW84790....... 2=8743907547054.........        >    Compressed Binary          >    48k Map Binary 3=.....                               6 8K Chunks In Format80         3 bytes per cell .....        And So On ..  <      70 chars a line    > Aha! Looked in GAME.DAT for the full alphabet and saw:                       ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ (This most probably is the same as Base64, but for completeness, I've decoded it myself) Theory: --- The GAME.DAT sequence shows that A would be 0, B=1, C=2..... +=62 and /=63 Each character represents 6 bits, arranged as follows 6 bits [000000][111111][000000][111111] So in the compressed Binary form: 8 bits [00000011][11110000][00111111] The '=' character means take off 2 bits from the byte sequence, this means that the whole sequence is MOD 8, so doesn't leave any stray bits behind. Now all the data can be handled in normal hex byte form. This Process In Reverse --- If you want to get from the byte sequence to the ASCII string again (maybe for a map tile placing utility), use this: Convert the hex bytes into a long string of bits: (example only here.) 09 00 00 20 00001001 00000000 00000000 00100000 00001001000000000000000000100000 Then start pulling out 6 bits at a time and compare with the ASCII table I made earlier until you've got less than 6 bits left. ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ (Where A=0, B=1, C=2,..... +=62, /=63) 000010 010000 000000 000000 001000 00 >>>>>>>> C Q A A I ..... So after making 5 characters, there are 2 bits left, Red Alert needs this to be 6 bits, so you would need another 4 bits. As you know, each character means 6 bits, and the '=' character means take the last 2 bits off. So you would use this idea to pad 4 bits onto the end using 'A=' which means 0000 The final string therefore would be: CQAAIA= And remember that 2 bits could also be left behind, you would use 'A==' in this case. How To Decode The OverlayPack in HEX Form Well, it will produce a 16k binary, with 1 byte representing each cell Here is the format of the packed section [aa bb cc] 20 [.....] Where ccbbaa is the length of the [...] section The &h20 may have a special meaning, but I've no idea yet. There are two of these in each [OverlayPack], with each representing 8k. After a VERY VERY VERY long time, I was able to work out how the [....] part was coded, just by luck really. Use Format80 to decode this, using an 8K destination buffer in each case, then join both these together to get a 16k file. Look at Appendix A (the Format80 images) for more information on this algorithm. This 16k file produced by the algorithm then reads from left to right like this: +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-+ +FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+ ...... +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-+ +FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+FF+ ... +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ ........ The top left cell would be offset 0, the one below 128, and the one below that 256, (the same as the cell number). Here is a table of what each Hex represents in the OverlayPacks: FF - Blank 00 - Sandbags (SBAG) 01 - Chain-link Fence (CYCL) 02 - Concrete Wall (BRIK) 03 - C&C Barbed Wire (FENC) 04 - Wooden Fence (WOOD) 05 - Ore (GOLD01) Most Dense 06 - Ore (GOLD02)                       The Ore/Gem tiles do not SEEM to be 07 - Ore (GOLD03)                        any different, but they must be, both 08 - Ore (GOLD04) Least Dense           RA and the editor seem to make single 09 - Gems (GEM01) Most Dense            cell gem/ore tiles look the same, and 0A - Gems (GEM02)                       they only look different in clumps. 0B - Gems (GEM03) 0C - Gems (GEM04) Least Dense 0D - Haystacks (V12) 0E - Haystack (V13) 0F - Wheat Field (V14) 10 - Fallow Field (V15) 11 - Corn Field (V16) 12 - Celery Field (V17) 13 - Potato Field (V18) 14 - Circular Thing (FPLS) 15 - Wood Crate (WCRATE) 16 - Silver Crate (SCRATE) 17 - RA Barbed Wire (BARB) 18 - RA Sandbags (exactly same as C&C ones) (SBAG) 19 .. - I've only tested 19h and 1Ah, but I assume the rest also crash RA FE I've noticed that the Water Crate (WWCRATE) is missing, I've tried 19h and 1Ah onto Water tiles, but it still crashes. Also the concrete floor tile (CONC) is not there either, although if you look at my scenario creation guide, you can put both these on using the [OVERLAY] section. Recompressing Overlay Data To An Overlaypack How To Get The 'Compressed' Binary To A Map File It is nearly exactly the same as the overlaypacks, with 6 [....] parts though instead of the two mentioned above. The map should be 48k when expanded (i.e 3 bytes per cell, 128x128x3) Using Format80 again for each [...] section, an 8k destination buffer, and again, splice all these 6 together to make 48k. Here is a simple BASIC-like representation of how it is done: DIM MAP(0 to 127,0 to 127,1 to 3) as byte FOR Y=0 to 127 FOR X=0 to 127 GET 1 BYTE, PUT IT INTO MAP(X,Y,1) GET 1 BYTE, PUT IT INTO MAP(X,Y,2) NEXT NEXT FOR Y=0 to 127 FOR X=0 to 127 GET 1 BYTE, PUT IT INTO MAP(X,Y,3) NEXT NEXT It is quite strange, but It's Westwood's solution to use more than 256 tiles, which was the limit in C&C. Well the hex from the new 48k file is 3 bytes per cell, with them meaning the following : [ xx xx ] [ xx ] Tile I.D. Part Of That Tile To Show In That Cell Here are some of them, I'll probably get round to doing a full list sometime, but I havent checked the old C&C resources for this *yet*. Remember the Tile ID is a word, so I've switched it round (as you should), just in case you think it looks wrong :) TILE ID NO. OF PARTS ---  FFFF 		? 	- Blank Tile 0001 		? 	- Water Recompressing Map Data back into a MapPack Appendix A : Format80/40/20 Images (thanks to Vladan Bato) I will call the three image formats Format80, Format40 and Format20. The Format80 images are compressed with a compression method I'll explain later. The Format40 images must be xor-ed with a Format80 image. That's what the RefOffs and RefForm fields are used for. They tell which Format80 image they are based upon. The Format40 will be explained in detail later. The Format20 images use the same format as the Format40, the difference is that they are xor-ed with the image that precedes them in the file. That can be either in Format20 or in Format40. The RefOffs field contains the number of the first Format40 image in the chain, and the RefForm field is always 4800h. Here's an example : 0) Off0 8000h 0000h 0000h 1) Off1 8000h 0000h 0000h 2) Off2 4000h Off1 8000h 3) Off3 8000h 0000h 0000h 4) Off4 4000h Off1 8000h 5) Off5 2000h 0400h 4800h 6) Off6 2000h 0400h 4800h 7) Off7 4000h Off3 8000h For example to draw image 7, you have to draw the image 3 first (whose offset and format are given) and then xor image 7 over it. To draw image 6, you have to xor it over the previous image, i.e. 5, which is format20 again, that means that it has to be xor-ed over image 4, which is in format40, i.e. it must be xor-ed over the image in format80 it has a reference to. In this case it's image 1. Thus the chain is 1,4,5,6. This is one way to see it, the other could be : Image 6 is in Format20, the RefOffs field contains the number of the first Format40 image in the chain, in this case image 4. To draw Image 4, the Image 1 has to be drawn first, next is image 4, and then all the images from the 4th to the 6th have to be xor-ed over the previous. I made some experiments and found out that you don't have to use the Format40 and Format20 images. I tried converting all of them into Format80 and it worked. Also, when changing graphics, note that all the unit and structure graphics should be drawn using the GDI colors, which will be automatically converted for the other sides. The palette you should use is one of those found in DESERT.MIX, WINTER.MIX and TEMPERAT.MIX. The GDI colors are colors 0B0h-0BFh. The other colors won't be converted and will remain the same for all the sides (be sure to use only the colors that are the same all three palettes). The above applies only to the graphics that appear in all three theaters (the .SHP file found in CONQUER.MIX). The graphics for the structures and overlays that appear in a single theater (found inside the theater specific MIX) can use the palette entries that are unique for that theater (and will be shown with garbled colors in the others). Also a special color is used for shadows. It's color 04h. In the palettes it's bright green, but C&C puts a shadow instead of it. I don't know how the shadows are calculated however. You should've noticed that the array has NumImages+2 elements when only NumImages elements are needed. The last one contains zeros, and the one before that points to the end of the file. These two can be used to identify the file as a .SHP. Here's the description of the compression formats : Format80 and Format40. -- Format80 -- There are several different commands, with different sizes : form 1 to 5 bytes. The positions mentioned below always refer to the destination buffer (i.e. the uncompressed image). The relative positions are relative to the current position in the destination buffer, which is one byte beyond the last written byte. I will give some sample code at the end. (1) 1 byte +---+---+---+---+---+---+---+---+     | 1 | 0 |   |   |   |   |   |   |      +---+---+---+---+---+---+---+---+              \_______________________/                         |                       Count This one means : copy next Count bytes as is from Source to Dest. (2) 2 bytes +---+---+---+---+---+---+---+---+  +---+---+---+---+---+---+---+---+  | 0 |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |  +---+---+---+---+---+---+---+---+   +---+---+---+---+---+---+---+---+      \___________/\__________________________________________________/            |                             |         Count-3                    Relative Pos. This means copy Count bytes from Dest at Current Pos.-Rel. Pos. to Current position. Note that you have to add 3 to the number you find in the bits 4-6 of the first byte to obtain the Count. Note that if the Rel. Pos. is 1, that means repeat Count times the previous byte. (3) 3 bytes +---+---+---+---+---+---+---+---+  +---+---+  | 1 | 1 |   |   |   |   |   |   |   |               |               |  +---+---+---+---+---+---+---+---+   +---+---+          \_______________________/                  Pos |                Count-3 Copy Count bytes from Pos, where Pos is absolute from the start of the destination buffer. (Pos is a word, that means that the images can't be larger than 64K) (4) 4 bytes +---+---+---+---+---+---+---+---+  +---+---+  +---+  | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 |   |       |       |  |       |  +---+---+---+---+---+---+---+---+   +---+---+  +---+                                            Count          Color Write Color Count times. (Count is a word, color is a byte) (5) 5 bytes +---+---+---+---+---+---+---+---+  +---+---+  +---+---+  | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |   |       |       |  |       |       |  +---+---+---+---+---+---+---+---+   +---+---+  +---+---+                                            Count               Pos Copy Count bytes from Dest. starting at Pos. Pos is absolute from the start of the Destination buffer. Both Count and Pos are words. These are all the commands I found out. Maybe there are other ones, but I haven't seen them yet. All the images end with a 80h command. To make things more clearer here's a piece of code that will uncompress the image. DP = destination pointer SP = source pointer Source and Dest are the two buffers SP:=0; DP:=0; repeat Com:=Source[SP]; inc(SP); b7:=Com shr 7; {b7 is bit 7 of Com} case b7 of     0 : begin  {copy command (2)} {Count is bits 4-6 + 3} Count:=(Com and $7F) shr 4 + 3; {Position is bits 0-3, with bits 0-7 of next byte} Posit:=(Com and $0F) shl 8+Source[SP]; Inc(SP); {Starting pos=Cur pos. - calculated value} Posit:=DP-Posit; for i:=Posit to Posit+Count-1 do           begin Dest[DP]:=Dest[i]; Inc(DP); end; end; 1 : begin {Check bit 6 of Com} b6:=(Com and $40) shr 6; case b6 of             0 : begin  {Copy as is command (1)} Count:=Com and $3F; {mask 2 topmost bits} if Count=0 then break; {EOF marker} for i:=1 to Count do                   begin Dest[DP]:=Source[SP]; Inc(DP); Inc(SP); end; end; 1 : begin {large copy, very large copy and fill commands} {Count = (bits 0-5 of Com) +3} {if Com=FEh then fill, if Com=FFh then very large copy} Count:=Com and $3F; if Count<$3E then {large copy (3)} begin Inc(Count,3); {Next word = pos. from start of image} Posit:=Word(Source[SP]); Inc(SP,2); for i:=Posit to Posit+Count-1 do                     begin Dest[DP]:=Dest[i]; Inc(DP); end; end else if Count=$3F then  {very large copy (5)} begin {next 2 words are Count and Pos} Count:=Word(Source[SP]); Posit:=Word(Source[SP+2]); Inc(SP,4); for i:=Posit to Posit+Count-1 do                     begin Dest[DP]:=Dest[i]; Inc(DP); end; end else begin  {Count=$3E, fill (4)} {Next word is count, the byte after is color} Count:=Word(Source[SP]); Inc(SP,2); b:=Source[SP]; Inc(SP); for i:=0 to Count-1 do                     begin Dest[DP]:=b; inc(DP); end; end; end; end; end; end; until false; Note that you won't be able to compile this code, because the typecasting won't work. (But I'm sure you'll be able to fix it). -- Format40 -- As I said before the images in Format40 must be xor-ed over a previous image, or against a black screen (as in the .WSA format). It is used when there are only minor changes between an image and a following one. Here I'll assume that the old image is in Dest, and that the Dest pointer is set to the beginning of that buffer. As for the Format80, there are many commands : (1) 1 byte byte +---+---+---+---+---+---+---+---+ | 1 |   |   |   |   |   |   |   |  +---+---+---+---+---+---+---+---+      \___________________________/                   |                 Count Skip count bytes in Dest (move the pointer forward). (2) 3 bytes byte                          word +---+---+---+---+---+---+---+---+ +---+-+---+  | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |  | 0 | ... |       |  +---+---+---+---+---+---+---+---+  +---+-+---+                                         \_____________/                                                |                                              Count Skip count bytes. (3) 3 bytes byte                             word +---+---+---+---+---+---+---+---+ +---+---+-+---+  | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |  | 1 | 0 | ... |       |  +---+---+---+---+---+---+---+---+  +---+---+-+---+                                             \_____________/                                                   |                                                 Count Xor next count bytes. That means xor count bytes from Source with bytes in Dest. (4) 4 bytes byte                              word           byte +---+---+---+---+---+---+---+---+ +---+---+-+---+  +---+  | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |  | 1 | 1 | ... |       |  |       |  +---+---+---+---+---+---+---+---+  +---+---+-+---+  +---+                                             \_____________/    value |                                                Count Xor next count bytes in Dest with value. 5) 1 byte              byte  +---+---+---+---+---+---+---+---+  | 0 |   |   |   |   |   |   |   |  +---+---+---+---+---+---+---+---+      \___________________________/                   |                 Count  Xor next count bytes from source with dest. 6) 3 bytes byte                    byte       byte +---+---+---+---+---+---+---+---+ +---+  +---+  | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |  |       |  |       |  +---+---+---+---+---+---+---+---+  +---+  +---+                                       Count      Value Xor next count bytes with value. All images end with a 80h 00h 00h command. I think these are all the commands, but there might be some other. If you find anything new, please e-mail me. As before here's some code : DP = destination pointer SP = source pointer Source is buffer containing the Format40 data Dest  is the buffer containing the image over which the second has to be xor-ed SP:=0; DP:=0; repeat Com:=Source[SP]; Inc(SP); if (Com and $80)<>0 then {if bit 7 set} begin if Com<>$80 then {small skip command (1)} begin Count:=Com and $7F; Inc(DP,Count); end else {Big commands} begin Count:=Word(Source[SP]); if Count=0 then break; Inc(SP,2); Tc:=(Count and $C000) shr 14; {Tc=two topmost bits of count} case Tc of         0,1 : begin  {Big skip (2)} Inc(DP,Count); end; 2 : begin {big xor (3)} Count:=Count and $3FFF; for i:=1 to Count do               begin Dest[DP]:=Dest[DP] xor Source[SP]; Inc(DP); Inc(SP); end; end; 3 : begin {big repeated xor (4)} Count:=Count and $3FFF; b:=Source[SP]; Inc(SP); for i:=1 to Count do               begin Dest[DP]:=Dest[DP] xor b;                 Inc(DP); end; end; end; end; end else {xor command} begin Count:=Com; if Count=0 then begin {repeated xor (6)} Count:=Source[SP]; Inc(SP); b:=Source[SP]; Inc(SP); for i:=1 to Count do       begin Dest[DP]:=Dest[DP] xor b;         Inc(DP); end; end else {copy xor (5)} for i:=1 to Count do       begin Dest[DP]:=Dest[DP] xor Source[SP]; Inc(DP); Inc(SP); end; end; until false; Appendix B : CPS Files The .CPS files contain 320x200x256 images. The images are compressed with the Format80 compression method. They may or may not contain a palette. The header has the following structure : Header : record Size   : word;  {File size - 2} Unknown : word; {Always 0004h} ImSize : word;  {Size of uncompressed image (always 0FA00h)} Palette : longint; {Is there a palette ?} end; If Palette is 03000000h then there's a palette after the header, otherwise the image follows. CPS file without palette can be found in the SETUP.MIX file, and they all use the Palette that can be found inside the same .MIX. The image that follows the palette (or the Header) is in Format80 which is explained above. My Note : The CPS files contain all the full screen Red Alert Images, where PCX files are used for the 640x400 images used in the Windows '95 version. Thanks to: Westwood for making the great game Everyone who contributed to the "Scenario Creation Guide" Mike Cocca for help on the MapPacks. Moritz Mertinkat for writing RA-MiXer 3.0, I found this very handy when looking for the offsets, as I myself only could find the SHP files reliably :), and for the RMT/PCX info! Vladan Bato for the C&C Format80/40/20 images and for the great work on the old C&C MIX files. Andrew Griffin for the correction of the RMT files. Anyone who thinks they deserve it. Also, email me if you see anything that is wrong, or missing, or should be included, I'll give you credit for that particular part of course :) You'll find the latest version of this text here: http://www.geocities.com/TimesSquare/Arcade/5553 (c)Gavin Pugh 1997 rascenedit@geocities.com