---

0x0n : the next n data stored are not compressed.
02 F0 F4 63 produce F0 F4 63

0x1n : ???????????

0x2n : repeats n data.
22 F0 produce F0 F0 F0

0x3n : repeats 16+n data
32 F0 produce ????????

0x4n : ???????????
0x5n : ???????????

0x6n : 2 bytes, 0x6n data. Data is incremented each time
62 03 produce 03 04 05

0x7n : ???????????

0x8n : 3 bytes 0x8n XX YY => "Block copy" : copy n byte(s) from YYXX location of decompressed track

0x9n : ???????????
0xAn : ???????????
0xBn : ???????????

0xCn : 2 bytes 0xCn XX => "Block copy" : copy n byte(s) from (currentLocation-XX) of decompressed track

0xDn : ???????????

0xE4 : 3 bytes, 0xE4 large repeats data.
E4 02 88 produce 88 88 88

0xFn : ???????????

---

Originally posted by Alice

---

So in other words:
3n: Lay down 17+n tiles of the next texture value.

---

Originally posted by Alice

---

Check you've opened the file in binary mode (fopen(blah, "rb")).

---

Originally posted by Dirtbag

---

Welcome Midwife! Looks like the SMK scene is starting to pick up

---

Originally posted by Dirtbag

---

Stifu: Well done on finding the offsets for the demo macros. When I get some spare time I'm going to relase an update to my Mushroom Cup demo of Super Baldy Kart with the demo edited.

---

Originally posted by HyperHacker

---

Bouche once mentioned the idea of figuring out the maximum possible size a compressed map could be

---

Originally posted by HyperHacker

---

Are you finding this by tracing the code?

---

    unsigned int i = 0, j = 0, count, command; // "count" = "n" in our notes

    unsigned int lPosition = 0; // that's the position in the decompressed track

    int srcPosition; // that's for block copies



while (lPosition<(16384)) {

          value = buffer[i++];

// (...)

          command = value & 0xF0;

          command = command >> 4;

          count = value & 0x0F;



switch (command) {

// (...)

                 case 0x08 :

                      srcPosition = buffer[i]+buffer[i+1]*256;

                      i += 2;

                      for (j=0;j<=count;j++) {

                          track[lPosition+j] = track[srcPosition+j];

                      }

                      lPosition += j;

                      break;

// (...)

} // switch end

// (...)

} // while end

Originally posted by GlitchCog

---

I guess E5 is just an additional 256 blocks. That's what I've got it set up to do for now, anyhow.

---

---

Super Mario Kart - Track RLE format:

Px = Parameter x

Commands:

0x0n: X bytes, 0x0n etc. The next n(+1) bytes are not compressed. 02 F0 F4 63 produce F0 F4 63
0x1n: X bytes, same as 0x0n, but with n+16
0x2n: 2 bytes, 0x2n P1. Repeats P1 n(+1) times. 22 F0 produce F0 F0 F0
0x3n: 2 bytes, same as 0x2n, but with n+16
0x4n: 3 bytes, 0x4n P1 P2. Repeats P1 and P2 alternately until n(+1) bytes are laid. 43 22 23 produce 22 23 22 23
0x5n: 3 bytes, same as 0x4n, but with n+16
0x6n: 2 bytes, 0x6n P1. Lays n(+1) bytes, starting from P1 and incrementing it by 1 each time. 62 03 produce 03 04 05
0x7n: 2 bytes, same as 0x6n, but with n+16
0x8n: 3 bytes, 0x8n P1 P2. "Block copy": copies n(+1) bytes from P2P1 location of decompressed track. 80 50 01 means "copy 81 bytes starting from location 0150 of the decompressed track"
0x9n: 3 bytes, same as 0x8n, but with n+16
???0xAn: 2 bytes, 0xAn P1. "Block copy": repeats previous(?) data ranges until n(+1)+?? (?? = multiple de 16?) bytes are laid
0xBn: 2 bytes, same as 0xAn, but with n+16
0xCn: 2 bytes, 0xCn P1. "Block copy": copies n(+1) bytes from (currentLocation - P1) of decompressed track
0xDn: 2 bytes, same as 0xCn, but with n+16


"Super" versions of the commands from 0x0n to 0x7n:
===================================================
0xE0: X bytes, 0xE0 P1 etc. The following P1(+1) bytes are not compressed. E0 01 44 07 produce 44 07
0xE1: X bytes, same as 0xE0, but with P1+256
0xE2: X bytes, same as 0xE0, but with P1+512
0xE3: X bytes, same as 0xE0, but with P1+768
0xE4: 3 bytes, 0xE4 P1 P2. P2 is repeated P1(+1) times. E4 03 88 produce 88 88 88 88
0xE5: 3 bytes, same as 0xE4, but with P1+256
0xE6: 3 bytes, same as 0xE4, but with P1+512
0xE7: 3 bytes, same as 0xE4, but with P1+768
0xE8: 4 bytes, 0xE8 P1 P2 P3. Repeats P2 and P3 alternately until P1(+1) bytes are laid. E8 04 00 01 produce 00 01 00 01 00
0xE9: 4 bytes, same as 0xE8, but with P1+256
0xEA: 4 bytes, same as 0xE8, but with P1+512
0xEB: 4 bytes, same as 0xE8, but with P1+768
0XEC: 3 bytes, 0xEC P1 P2. Lays P1(+1) bytes, starting from P2 and incrementing it by 1 each time. EC 02 49 produce 49 4A 4B
0xED: 3 bytes, same as 0xEC, but with P1+256
0xEE: 3 bytes, same as 0xEC, but with P1+512
0xEF: 3 bytes, same as 0xEC, but with P1+768


"Super" versions of the commands from 0x8n to 0xDn:
===================================================
0xF0: 4 bytes, 0xF0 P1 P2 P3. "Block copy": copies P1(+1) bytes from P3P2 location of decompressed track
0xF1: 4 bytes, same as 0xF0, but with P1+256
0xF2: 4 bytes, same as 0xF0, but with P1+512
0xF3: 4 bytes, same as 0xF0, but with P1+768
0xF4: without any doubt the "Super" version of 0xAn, with P1 replacing n
0xF5: ??? (same as 0xF4, but with P1+256?)
0xF6: ??? (same as 0xF4, but with P1+512?)
0xF7: ??? (same as 0xF4, but with P1+768?)
0xF8: 3 bytes, 0xF8 P1 P2. "Block copy": copies P1(+1) bytes from (currentLocation - P2) of decompressed track
0xF9: 3 bytes, same as 0xF8, but with P1+256
0xFA: 3 bytes, same as 0xF8, but with P1+512
0xFB: 3 bytes, same as 0xF8, but with P1+768
0xFC: ???
0xFD: ???
0xFE: ???
0xFF: 1 byte, end of track

---