Logo Search packages:      
Sourcecode: scummvm version File versions  Download package

util.cpp

/* ScummVM - Scumm Interpreter
 * Copyright (C) 2002-2005 The ScummVM project
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * $Header: /cvsroot/scummvm/scummvm/scumm/util.cpp,v 2.14.2.1 2005/10/18 02:11:25 sev Exp $
 *
 */

#include "scumm/util.h"
#include "common/util.h"
#include "common/md5.h"

using Common::File;

namespace Scumm {

#pragma mark -
#pragma mark --- ScummFile ---
#pragma mark -

ScummFile::ScummFile() : _encbyte(0), _subFileStart(0), _subFileLen(0) {
}

void ScummFile::setEnc(byte value) {
      _encbyte = value;
}

void ScummFile::setSubfileRange(uint32 start, uint32 len) {
      // TODO: Add sanity checks
      const uint32 fileSize = File::size();
      assert(start <= fileSize);
      assert(start + len <= fileSize);
      _subFileStart = start;
      _subFileLen = len;
      seek(0, SEEK_SET);
}

void ScummFile::resetSubfile() {
      _subFileStart = 0;
      _subFileLen = 0;
      seek(0, SEEK_SET);
}

bool ScummFile::open(const char *filename, AccessMode mode) {
      if (File::open(filename, mode)) {
            resetSubfile();
            return true;
      } else {
            return false;
      }
}

bool ScummFile::openSubFile(const char *filename) {
      assert(isOpen());

      // Disable the XOR encryption and reset any current subfile range
      setEnc(0);
      resetSubfile();

      // Read in the filename table and look for the specified file

      unsigned long file_off, file_len;
      char file_name[0x20+1];
      unsigned long i;

      // Get the length of the data file to use for consistency checks
      const uint32 data_file_len = size();

      // Read offset and length to the file records */
      const uint32 file_record_off = readUint32BE();
      const uint32 file_record_len = readUint32BE();

      // Do a quick check to make sure the offset and length are good
      if (file_record_off + file_record_len > data_file_len) {
            return false;
      }

      // Do a little consistancy check on file_record_length
      if (file_record_len % 0x28) {
            return false;
      }

      // Scan through the files
      for (i = 0; i < file_record_len; i += 0x28) {
            // read a file record
            seek(file_record_off + i, SEEK_SET);
            file_off = readUint32BE();
            file_len = readUint32BE();
            read(file_name, 0x20);
            file_name[0x20] = 0;

            assert(file_name[0]);
            //debug(7, "  extracting \'%s\'", file_name);

            // Consistency check. make sure the file data is in the file
            if (file_off + file_len > data_file_len) {
                  return false;
            }

            if (scumm_stricmp(file_name, filename) == 0) {
                  // We got a match!
                  setSubfileRange(file_off, file_len);
                  return true;
            }
      }

      return false;
}


bool ScummFile::eof() {
      return _subFileLen ? (pos() >= _subFileLen) : File::eof();
}

uint32 ScummFile::pos() {
      return File::pos() - _subFileStart;
}

uint32 ScummFile::size() {
      return _subFileLen ? _subFileLen : File::size();
}

void ScummFile::seek(int32 offs, int whence) {
      if (_subFileLen) {
            // Constrain the seek to the subfile
            switch (whence) {
            case SEEK_END:
                  offs = _subFileStart + _subFileLen - offs;
                  break;
            case SEEK_SET:
                  offs += _subFileStart;
                  break;
            case SEEK_CUR:
                  offs += File::pos();
                  break;
            }
            assert((int32)_subFileStart <= offs && offs <= (int32)(_subFileStart + _subFileLen));
            whence = SEEK_SET;
      }
      File::seek(offs, whence);
}

uint32 ScummFile::read(void *dataPtr, uint32 dataSize) {
      uint32 realLen;

      if (_subFileLen) {
            // Limit the amount we read by the subfile boundaries.
            const uint32 curPos = pos();
            assert(_subFileLen >= curPos);
            uint32 newPos = curPos + dataSize;
            if (newPos > _subFileLen) {
                  dataSize = _subFileLen - curPos;
                  _ioFailed = true;
            }
      }

      realLen = File::read(dataPtr, dataSize);


      // If an encryption byte was specified, XOR the data we just read by it.
      // This simple kind of "encryption" was used by some of the older SCUMM
      // games.
      if (_encbyte) {
            byte *p = (byte *)dataPtr;
            byte *end = p + realLen;
            while (p < end)
                  *p++ ^= _encbyte;
      }

      return realLen;
}

uint32 ScummFile::write(const void *, uint32) {
      error("ScummFile does not support writing!");
      return 0;
}

#pragma mark -
#pragma mark --- Utilities ---
#pragma mark -

void checkRange(int max, int min, int no, const char *str) {
      if (no < min || no > max) {
            char buf[256];
            snprintf(buf, sizeof(buf), str, no);
            error("Value %d is out of bounds (%d,%d) (%s)", no, min, max, buf);
      }
}

/**
 * Convert an old style direction to a new style one (angle),
 */
int newDirToOldDir(int dir) {
      if (dir >= 71 && dir <= 109)
            return 1;
      if (dir >= 109 && dir <= 251)
            return 2;
      if (dir >= 251 && dir <= 289)
            return 0;
      return 3;
}

/**
 * Convert an new style (angle) direction to an old style one.
 */
int oldDirToNewDir(int dir) {
      assert(0 <= dir && dir <= 3);
      const int new_dir_table[4] = { 270, 90, 180, 0 };
      return new_dir_table[dir];
}

/**
 * Convert an angle to a simple direction.
 */
int toSimpleDir(int dirType, int dir) {
      if (dirType) {
            const int16 directions[] = { 22,  72, 107, 157, 202, 252, 287, 337 };
            for (int i = 0; i < 7; i++)
                  if (dir >= directions[i] && dir <= directions[i+1])
                        return i+1;
      } else {
            const int16 directions[] = { 71, 109, 251, 289 };
            for (int i = 0; i < 3; i++)
                  if (dir >= directions[i] && dir <= directions[i+1])
                        return i+1;
      }

      return 0;
}

/**
 * Convert a simple direction to an angle.
 */
int fromSimpleDir(int dirType, int dir) {
      if (dirType)
            return dir * 45;
      else
            return dir * 90;
}

/**
 * Normalize the given angle - that means, ensure it is positive, and
 * change it to the closest multiple of 45 degree by abusing toSimpleDir.
 */
int normalizeAngle(int angle) {
      int temp;

      temp = (angle + 360) % 360;

      return toSimpleDir(1, temp) * 45;
}

const char *tag2str(uint32 tag) {
      static char str[5];
      str[0] = (char)(tag >> 24);
      str[1] = (char)(tag >> 16);
      str[2] = (char)(tag >> 8);
      str[3] = (char)tag;
      str[4] = '\0';
      return str;
}

#pragma mark -
#pragma mark --- ScummNESFile ---
#pragma mark -

enum ResType {
      NES_UNKNOWN,
      NES_GLOBDATA,
      NES_ROOM,
      NES_SCRIPT,
      NES_SOUND,
      NES_COSTUME,
      NES_ROOMGFX,
      NES_COSTUMEGFX,
      NES_SPRPALS,
      NES_SPRDESC,
      NES_SPRLENS,
      NES_SPROFFS,
      NES_SPRDATA,
      NES_CHARSET,
      NES_PREPLIST
};

struct ScummNESFile::Resource {
      uint32 offset[kROMsetNum];
      uint16 length[kROMsetNum];
      ResType type;
};

ScummNESFile::ScummNESFile() : _stream(0), _buf(0), _ROMset(kROMsetNum) {
}

uint32 ScummNESFile::write(const void *, uint32) {
      error("ScummNESFile does not support writing!");
      return 0;
}

void ScummNESFile::setEnc(byte enc) {
      _stream->setEnc(enc);
}

#ifdef PALMOS_68K
static ScummNESFile::Resource *res_roomgfx;
static ScummNESFile::Resource *res_costumegfx;
static ScummNESFile::Resource *res_rooms;
static ScummNESFile::Resource *res_scripts;
static ScummNESFile::Resource *res_sounds;
static ScummNESFile::Resource *res_costumes;
static ScummNESFile::Resource *res_sprpals;
static ScummNESFile::Resource *res_sprdesc;
static ScummNESFile::Resource *res_sprlens;
static ScummNESFile::Resource *res_sproffs;
static ScummNESFile::Resource *res_sprdata;

#else
static ScummNESFile::Resource res_roomgfx[40] = {
      { {0x04001,0x04001,0x04001,0x04001}, {0x03C9,0x03B9,0x03F0,0x0426}, NES_ROOMGFX },
      { {0x043CA,0x043BA,0x043F1,0x04427}, {0x069E,0x069E,0x069E,0x069E}, NES_ROOMGFX },
      { {0x04A68,0x04A58,0x04A8F,0x04AC5}, {0x0327,0x0327,0x0327,0x0327}, NES_ROOMGFX },
      { {0x04D8F,0x04D7F,0x04DB6,0x04DEC}, {0x053B,0x053B,0x053B,0x053B}, NES_ROOMGFX },
      { {0x052CA,0x052BA,0x052F1,0x05327}, {0x06BE,0x06BE,0x06BE,0x06BE}, NES_ROOMGFX },
      { {0x05988,0x05978,0x059AF,0x059E5}, {0x0682,0x0682,0x0682,0x0682}, NES_ROOMGFX },
      { {0x0600A,0x05FFA,0x06031,0x06067}, {0x0778,0x0778,0x0778,0x0778}, NES_ROOMGFX },
      { {0x06782,0x06772,0x067A9,0x067DF}, {0x0517,0x0517,0x0517,0x0517}, NES_ROOMGFX },
      { {0x06C99,0x06C89,0x06CC0,0x06CF6}, {0x07FB,0x07FB,0x07FB,0x07FB}, NES_ROOMGFX },
      { {0x07494,0x07484,0x074BB,0x074F1}, {0x07BE,0x07BE,0x07BE,0x07BE}, NES_ROOMGFX },
      { {0x08001,0x08001,0x08001,0x08001}, {0x07A5,0x07A5,0x07A5,0x07A5}, NES_ROOMGFX },
      { {0x087A6,0x087A6,0x087A6,0x087A6}, {0x06DD,0x06DD,0x06DD,0x06DD}, NES_ROOMGFX },
      { {0x08E83,0x08E83,0x08E83,0x08E83}, {0x04EA,0x04EA,0x04EA,0x04EA}, NES_ROOMGFX },
      { {0x0936D,0x0936D,0x0936D,0x0936D}, {0x0846,0x0846,0x07E2,0x07E2}, NES_ROOMGFX },
      { {0x09BB3,0x09BB3,0x09B4F,0x09B4F}, {0x08C8,0x08C8,0x0791,0x0791}, NES_ROOMGFX },
      { {0x0A47B,0x0A47B,0x0A2E0,0x0A2E0}, {0x0844,0x0844,0x07B5,0x07B5}, NES_ROOMGFX },
      { {0x0ACBF,0x0ACBF,0x0AA95,0x0AA95}, {0x0515,0x0515,0x0515,0x0515}, NES_ROOMGFX },
      { {0x0B1D4,0x0B1D4,0x0AFAA,0x0AFAA}, {0x0799,0x0799,0x0799,0x0799}, NES_ROOMGFX },
      { {0x0B96D,0x0B96D,0x0B743,0x0B743}, {0x04BB,0x04BB,0x04BF,0x04BB}, NES_ROOMGFX },
      { {0x07C52,0x07C42,0x0BC02,0x0BBFE}, {0x0319,0x0319,0x0319,0x0319}, NES_ROOMGFX },
      { {0x0C001,0x0C001,0x0C001,0x0C001}, {0x0464,0x0464,0x0464,0x0464}, NES_ROOMGFX },
      { {0x0C465,0x0C465,0x0C465,0x0C465}, {0x076D,0x076D,0x072C,0x072C}, NES_ROOMGFX },
      { {0x0CBD2,0x0CBD2,0x0CB91,0x0CB91}, {0x0827,0x0827,0x0827,0x0827}, NES_ROOMGFX },
      { {0x0D3F9,0x0D3F9,0x0D3B8,0x0D3B8}, {0x0515,0x0515,0x0515,0x0515}, NES_ROOMGFX },
      { {0x0D90E,0x0D90E,0x0D8CD,0x0D8CD}, {0x064E,0x064E,0x064E,0x064E}, NES_ROOMGFX },
      { {0x0DF5C,0x0DF5C,0x0DF1B,0x0DF1B}, {0x0775,0x0775,0x0775,0x0775}, NES_ROOMGFX },
      { {0x0E6D1,0x0E6D1,0x0E690,0x0E690}, {0x06DD,0x06DD,0x06DD,0x06DD}, NES_ROOMGFX },
      { {0x0EDAE,0x0EDAE,0x0ED6D,0x0ED6D}, {0x0376,0x0376,0x0376,0x0376}, NES_ROOMGFX },
      { {0x0F124,0x0F124,0x0F0E3,0x0F0E3}, {0x05F7,0x05F7,0x05F7,0x05F7}, NES_ROOMGFX },
      { {0x0F71B,0x0F71B,0x0F6DA,0x0F6DA}, {0x0787,0x0787,0x0791,0x0787}, NES_ROOMGFX },
      { {0x10001,0x10001,0x07C79,0x10001}, {0x02D6,0x02D6,0x02D6,0x02D6}, NES_ROOMGFX },
      { {0x102D7,0x102D7,0x10001,0x102D7}, {0x06A3,0x06A3,0x06A3,0x06A3}, NES_ROOMGFX },
      { {0x1097A,0x1097A,0x106A4,0x1097A}, {0x099F,0x099F,0x0921,0x0921}, NES_ROOMGFX },
      { {0x11319,0x11319,0x10FC5,0x1129B}, {0x0361,0x0361,0x0361,0x0361}, NES_ROOMGFX },
      { {0x1167A,0x1167A,0x11326,0x115FC}, {0x0489,0x0489,0x0489,0x0489}, NES_ROOMGFX },
      { {0x11B03,0x11B03,0x117AF,0x11A85}, {0x0437,0x0437,0x0437,0x0437}, NES_ROOMGFX },
      { {0x11F3A,0x11F3A,0x11BE6,0x11EBC}, {0x084D,0x084D,0x084F,0x070D}, NES_ROOMGFX },
      { {0x0BE28,0x12787,0x12435,0x07CAF}, {0x0199,0x0199,0x0199,0x0199}, NES_ROOMGFX },
      { {0x12787,0x12920,0x125CE,0x125C9}, {0x09A7,0x09A7,0x0947,0x0947}, NES_ROOMGFX },
      { {0x1312E,0x132C7,0x12F15,0x12F10}, {0x037A,0x037A,0x037A,0x037A}, NES_ROOMGFX }
};

static ScummNESFile::Resource res_costumegfx[2] = {
      { {0x30001,0x30001,0x2EFE1,0x30001}, {0x0EB8,0x0EB8,0x0EB8,0x0EB8}, NES_COSTUMEGFX },
      { {0x2F9F1,0x2F9F1,0x30001,0x2F608}, {0x0340,0x0340,0x0340,0x0340}, NES_COSTUMEGFX }
};

static ScummNESFile::Resource res_rooms[55] = {
      { {0x00000,0x00000,0x00000,0x00000}, {0x0000,0x0000,0x0000,0x0000}, NES_ROOM },
      { {0x14001,0x14001,0x14001,0x14001}, {0x0D0C,0x0D0C,0x0D12,0x0D76}, NES_ROOM },
      { {0x134A8,0x13641,0x1328F,0x1328A}, {0x04B3,0x04B3,0x04B3,0x04C6}, NES_ROOM },
      { {0x15397,0x15397,0x15367,0x15451}, {0x0849,0x0849,0x0859,0x0885}, NES_ROOM },
      { {0x15C68,0x15C68,0x13742,0x13750}, {0x0685,0x0685,0x0694,0x0693}, NES_ROOM },
      { {0x16381,0x16381,0x15C45,0x15D68}, {0x0715,0x0715,0x0707,0x0709}, NES_ROOM },
      { {0x1395B,0x16CE8,0x1658F,0x166D4}, {0x04E7,0x04E7,0x04E0,0x0528}, NES_ROOM },
      { {0x16CE8,0x18001,0x16A6F,0x16BFC}, {0x0AC0,0x0ABF,0x0AC8,0x0ACC}, NES_ROOM },
      { {0x18001,0x171CF,0x18001,0x18001}, {0x06BA,0x06BA,0x06C7,0x06E2}, NES_ROOM },
      { {0x17AED,0x13AF4,0x1789C,0x17A63}, {0x03CB,0x03D2,0x03EA,0x03E5}, NES_ROOM },
      { {0x18BE7,0x18E1A,0x18C09,0x18C3B}, {0x0663,0x0663,0x0649,0x066A}, NES_ROOM },
      { {0x192A6,0x194D9,0x192AE,0x19301}, {0x0580,0x04A9,0x04AB,0x049E}, NES_ROOM },
      { {0x19A44,0x19BA0,0x19982,0x199C8}, {0x0443,0x0443,0x0447,0x044B}, NES_ROOM },
      { {0x1A106,0x1A262,0x1A04D,0x1A0B1}, {0x0563,0x047C,0x047E,0x0478}, NES_ROOM },
      { {0x1A669,0x1A6DE,0x1A4CB,0x1A529}, {0x0446,0x0446,0x0444,0x043F}, NES_ROOM },
      { {0x1AAAF,0x1AB24,0x1A90F,0x1A968}, {0x03A7,0x03A7,0x03B9,0x03C8}, NES_ROOM },
      { {0x1AE56,0x1AECB,0x1ACC8,0x1AD30}, {0x07E3,0x07E3,0x07E9,0x086F}, NES_ROOM },
      { {0x1B699,0x1B70E,0x1B511,0x1B5FF}, {0x0692,0x0692,0x06A4,0x069B}, NES_ROOM },
      { {0x1C001,0x1C001,0x1C001,0x1C001}, {0x0B49,0x0ACA,0x0B1A,0x0AA9}, NES_ROOM },
      { {0x1CD09,0x1CC8A,0x1CCFD,0x1CC97}, {0x04C6,0x04C6,0x0486,0x049E}, NES_ROOM },
      { {0x1D4C2,0x1D443,0x1D482,0x1D42C}, {0x0568,0x0568,0x0579,0x05A8}, NES_ROOM },
      { {0x1DF6C,0x1DEED,0x1DF61,0x1DF71}, {0x0514,0x0514,0x051E,0x054E}, NES_ROOM },
      { {0x1E8FA,0x1E87B,0x1E8EC,0x1E9D1}, {0x05CC,0x05CC,0x05CF,0x0606}, NES_ROOM },
      { {0x1EF83,0x1EF04,0x1EF73,0x1F0A2}, {0x0389,0x0389,0x0398,0x039A}, NES_ROOM },
      { {0x1F5E4,0x1F565,0x1F5F0,0x1F74E}, {0x0723,0x0723,0x071A,0x071C}, NES_ROOM },
      { {0x20001,0x20001,0x20001,0x20001}, {0x049A,0x049A,0x049C,0x04B5}, NES_ROOM },
      { {0x20511,0x20511,0x2051E,0x2052E}, {0x04F8,0x04F8,0x051E,0x04FF}, NES_ROOM },
      { {0x21666,0x21666,0x21725,0x2172E}, {0x05CB,0x05D5,0x05D5,0x05DB}, NES_ROOM },
      { {0x21DD6,0x21DE0,0x21EA5,0x21EAD}, {0x046B,0x046B,0x047F,0x0489}, NES_ROOM },
      { {0x222F0,0x222FA,0x223D1,0x223E1}, {0x0460,0x0460,0x0460,0x0465}, NES_ROOM },
      { {0x227B6,0x227C0,0x22897,0x228AC}, {0x0909,0x0909,0x090D,0x0957}, NES_ROOM },
      { {0x24001,0x24001,0x24001,0x24001}, {0x0366,0x0366,0x0378,0x037E}, NES_ROOM },
      { {0x23BDF,0x247DB,0x247C9,0x2481A}, {0x03CA,0x03CA,0x03CA,0x03CA}, NES_ROOM },
      { {0x247DB,0x24BA5,0x24B93,0x24BE4}, {0x050D,0x050D,0x050D,0x050D}, NES_ROOM },
      { {0x25ACF,0x23BE9,0x25267,0x252C0}, {0x0346,0x0346,0x0346,0x0346}, NES_ROOM },
      { {0x1BDBD,0x17DB5,0x17CD0,0x1BD30}, {0x01CA,0x01CA,0x01CA,0x01CA}, NES_ROOM },
      { {0x25E15,0x25E99,0x255AD,0x25606}, {0x0457,0x0457,0x0453,0x046D}, NES_ROOM },
      { {0x2626C,0x262F0,0x25A00,0x25A73}, {0x0547,0x0547,0x053E,0x055A}, NES_ROOM },
      { {0x267B3,0x26837,0x25F3E,0x25FCD}, {0x064A,0x064A,0x0647,0x0654}, NES_ROOM },
      { {0x1FD72,0x1FCF3,0x1BC49,0x26C98}, {0x024B,0x024B,0x024B,0x024B}, NES_ROOM },
      { {0x2739A,0x2741E,0x26B58,0x26EE3}, {0x01FA,0x01FA,0x01FA,0x01FA}, NES_ROOM },
      { {0x2766D,0x276F1,0x26E27,0x271DD}, {0x0219,0x0219,0x0217,0x0217}, NES_ROOM },
      { {0x28001,0x28001,0x27345,0x27713}, {0x02F4,0x02F4,0x02F4,0x02F4}, NES_ROOM },
      { {0x284D6,0x284D6,0x27829,0x28001}, {0x045C,0x045C,0x045C,0x045C}, NES_ROOM },
      { {0x289A3,0x289A3,0x28001,0x284CE}, {0x09CF,0x09CF,0x098A,0x0975}, NES_ROOM },
      { {0x293C6,0x293C6,0x289DF,0x28E97}, {0x05A0,0x05A0,0x05A1,0x05E6}, NES_ROOM },
      { {0x27B65,0x27BE9,0x2A442,0x27C3A}, {0x0201,0x0201,0x0201,0x0201}, NES_ROOM },
      { {0x2ADD1,0x2ADE3,0x2A6E9,0x2A9D6}, {0x0325,0x0325,0x0325,0x0325}, NES_ROOM },
      { {0x2B339,0x2B34B,0x1FD75,0x2AF88}, {0x01FC,0x01FC,0x01FC,0x01FC}, NES_ROOM },
      { {0x2B535,0x2B547,0x2AC64,0x2B184}, {0x02A9,0x02A9,0x02A9,0x02A9}, NES_ROOM },
      { {0x2B7DE,0x2B7F0,0x2AF0D,0x2B42D}, {0x02DE,0x02DE,0x02D1,0x02DF}, NES_ROOM },
      { {0x2C001,0x2C001,0x2B2E6,0x2B818}, {0x03CE,0x03CE,0x03CC,0x03EC}, NES_ROOM },
      { {0x2BBC0,0x2BBD2,0x23D61,0x2BD67}, {0x0205,0x0205,0x0205,0x0209}, NES_ROOM },
      { {0x2C53A,0x2C53A,0x2B818,0x2C001}, {0x0170,0x0170,0x0168,0x0168}, NES_ROOM },
      { {0x13E42,0x2BDD7,0x27CF6,0x2C4BF}, {0x0169,0x0169,0x0169,0x0169}, NES_ROOM }
};

static ScummNESFile::Resource res_scripts[179] = {
      { {0x00000,0x00000,0x00000,0x00000}, {0x0000,0x0000,0x0000,0x0000}, NES_SCRIPT }, // 0
      { {0x29966,0x29966,0x28F80,0x2947D}, {0x044D,0x044D,0x043B,0x0480}, NES_SCRIPT },
      { {0x29DB3,0x29DB3,0x293BB,0x298FD}, {0x0207,0x0207,0x0209,0x0226}, NES_SCRIPT },
      { {0x29FBA,0x29FBA,0x295C4,0x29B23}, {0x009F,0x009F,0x00AB,0x0092}, NES_SCRIPT },
      { {0x2A059,0x2A059,0x2966F,0x29BB5}, {0x03F4,0x03F4,0x03FD,0x040C}, NES_SCRIPT },
      { {0x2A44D,0x2A44D,0x29A6C,0x29FC1}, {0x01A1,0x01A1,0x01A1,0x01A1}, NES_SCRIPT },
      { {0x00000,0x00000,0x00000,0x00000}, {0x0000,0x0000,0x0000,0x0000}, NES_SCRIPT },
      { {0x2A5EE,0x2A5EE,0x29C0D,0x2A162}, {0x004A,0x005C,0x005C,0x005C}, NES_SCRIPT },
      { {0x00000,0x00000,0x00000,0x00000}, {0x0000,0x0000,0x0000,0x0000}, NES_SCRIPT },
      { {0x2A638,0x2A64A,0x29C69,0x2A1BE}, {0x0005,0x0005,0x0005,0x0005}, NES_SCRIPT },
      { {0x2C6AA,0x2C6AA,0x2B980,0x2C169}, {0x000D,0x000D,0x000D,0x000D}, NES_SCRIPT }, // 10
      { {0x2C6B7,0x2C6B7,0x2B98D,0x2C176}, {0x000D,0x000D,0x000D,0x000D}, NES_SCRIPT },
      { {0x186BB,0x17889,0x186C8,0x186E3}, {0x0040,0x0040,0x0040,0x0040}, NES_SCRIPT },
      { {0x186FB,0x178C9,0x18708,0x18723}, {0x0016,0x0016,0x0016,0x0016}, NES_SCRIPT },
      { {0x1B639,0x1B6AE,0x1B4B1,0x1B59F}, {0x0046,0x0046,0x0046,0x0046}, NES_SCRIPT },
      { {0x1EEC6,0x1EE47,0x1EEBB,0x1EFD7}, {0x00BD,0x00BD,0x00B8,0x00CB}, NES_SCRIPT },
      { {0x21C31,0x21C3B,0x21CFA,0x21D09}, {0x0055,0x0055,0x005C,0x0054}, NES_SCRIPT },
      { {0x177A8,0x18AC0,0x17537,0x176C8}, {0x0027,0x0027,0x0027,0x0027}, NES_SCRIPT },
      { {0x1FD07,0x1FC88,0x1FD0A,0x1FE6A}, {0x0027,0x0027,0x0027,0x0027}, NES_SCRIPT },
      { {0x1FD2E,0x1FCAF,0x1FD31,0x1FE91}, {0x0027,0x0027,0x0027,0x0027}, NES_SCRIPT },
      { {0x1BD2B,0x1BDA0,0x1BBB5,0x1BC9A}, {0x0022,0x0022,0x0022,0x0022}, NES_SCRIPT }, // 20
      { {0x15BE0,0x15BE0,0x15BC0,0x15CD6}, {0x0088,0x0088,0x0085,0x0092}, NES_SCRIPT },
      { {0x22241,0x2224B,0x22324,0x22336}, {0x0020,0x0020,0x001E,0x001C}, NES_SCRIPT },
      { {0x22261,0x2226B,0x22342,0x22352}, {0x008F,0x008F,0x008F,0x008F}, NES_SCRIPT },
      { {0x1924A,0x1947D,0x19252,0x192A5}, {0x002B,0x002B,0x002B,0x002B}, NES_SCRIPT },
      { {0x1CB4A,0x1CACB,0x1CB1B,0x1CAAA}, {0x0061,0x0061,0x006D,0x0069}, NES_SCRIPT },
      { {0x1CBAB,0x1CB2C,0x1CB88,0x1CB13}, {0x003C,0x003C,0x004C,0x0054}, NES_SCRIPT },
      { {0x1CBE7,0x1CB68,0x1CBD4,0x1CB67}, {0x0042,0x0042,0x0044,0x0048}, NES_SCRIPT },
      { {0x1CC29,0x1CBAA,0x1CC18,0x1CBAF}, {0x004F,0x004F,0x0053,0x0058}, NES_SCRIPT },
      { {0x2049B,0x2049B,0x2049D,0x204B6}, {0x0076,0x0076,0x0081,0x0078}, NES_SCRIPT },
      { {0x16A96,0x16A96,0x1634C,0x16471}, {0x0035,0x0035,0x0035,0x0035}, NES_SCRIPT }, // 30
      { {0x16ACB,0x16ACB,0x16381,0x164A6}, {0x001C,0x001C,0x001C,0x001C}, NES_SCRIPT },
      { {0x16AE7,0x16AE7,0x1639D,0x164C2}, {0x0014,0x0014,0x0014,0x0014}, NES_SCRIPT },
      { {0x16AFB,0x16AFB,0x163B1,0x164D6}, {0x001C,0x001C,0x001C,0x001C}, NES_SCRIPT },
      { {0x16B17,0x16B17,0x163CD,0x164F2}, {0x0027,0x0027,0x0027,0x0027}, NES_SCRIPT },
      { {0x16B3E,0x16B3E,0x163F4,0x16519}, {0x01AA,0x01AA,0x019B,0x01BB}, NES_SCRIPT },
      { {0x1D1CF,0x1D150,0x1D183,0x1D135}, {0x0096,0x0096,0x0094,0x008D}, NES_SCRIPT },
      { {0x1D265,0x1D1E6,0x1D217,0x1D1C2}, {0x010E,0x010E,0x0117,0x0119}, NES_SCRIPT },
      { {0x1D373,0x1D2F4,0x1D32E,0x1D2DB}, {0x001C,0x001C,0x001C,0x001C}, NES_SCRIPT },
      { {0x1D38F,0x1D310,0x1D34A,0x1D2F7}, {0x0056,0x0056,0x0056,0x0056}, NES_SCRIPT },
      { {0x1D3E5,0x1D366,0x1D3A0,0x1D34D}, {0x0072,0x0072,0x0072,0x0072}, NES_SCRIPT }, // 40
      { {0x1E480,0x1E401,0x1E47F,0x1E4BF}, {0x0028,0x0028,0x0028,0x0028}, NES_SCRIPT },
      { {0x1E4A8,0x1E429,0x1E4A7,0x1E4E7}, {0x017D,0x017D,0x0175,0x01E0}, NES_SCRIPT },
      { {0x1E625,0x1E5A6,0x1E61C,0x1E6C7}, {0x0229,0x0229,0x022B,0x0241}, NES_SCRIPT },
      { {0x28932,0x28932,0x27C85,0x2845D}, {0x0071,0x0071,0x0071,0x0071}, NES_SCRIPT },
      { {0x17EB8,0x13EC6,0x17C86,0x17E48}, {0x004D,0x004D,0x004A,0x004C}, NES_SCRIPT },
      { {0x162ED,0x162ED,0x13DD6,0x13DE3}, {0x0039,0x0039,0x0039,0x0039}, NES_SCRIPT },
      { {0x18711,0x178DF,0x1871E,0x18739}, {0x028B,0x028B,0x0270,0x0296}, NES_SCRIPT },
      { {0x1899C,0x17B6A,0x1898E,0x189CF}, {0x00BB,0x00BB,0x00C0,0x00C2}, NES_SCRIPT },
      { {0x18A57,0x17C25,0x18A4E,0x18A91}, {0x018B,0x018B,0x01B6,0x01A5}, NES_SCRIPT },
      { {0x00000,0x00000,0x00000,0x00000}, {0x0000,0x0000,0x0000,0x0000}, NES_SCRIPT }, // 50
      { {0x19E87,0x19FE3,0x19DC9,0x19E13}, {0x00ED,0x00ED,0x00EE,0x00F3}, NES_SCRIPT },
      { {0x21C86,0x21C90,0x21D56,0x21D5D}, {0x00F6,0x00F6,0x00F5,0x00F6}, NES_SCRIPT },
      { {0x1E84E,0x1E7CF,0x1E847,0x1E908}, {0x009B,0x009B,0x0094,0x00B8}, NES_SCRIPT },
      { {0x21D7C,0x21D86,0x21E4B,0x21E53}, {0x0047,0x0047,0x0047,0x0047}, NES_SCRIPT },
      { {0x2C6C4,0x2C6C4,0x2B99A,0x2C183}, {0x004D,0x004D,0x004D,0x004D}, NES_SCRIPT },
      { {0x16326,0x16326,0x13E0F,0x13E1C}, {0x0024,0x0024,0x0024,0x0024}, NES_SCRIPT },
      { {0x14D0D,0x14D0D,0x14D13,0x14D77}, {0x0014,0x0014,0x0014,0x0014}, NES_SCRIPT },
      { {0x177CF,0x18AE7,0x1755E,0x176EF}, {0x0059,0x0059,0x0054,0x0059}, NES_SCRIPT },
      { {0x17828,0x18B40,0x175B2,0x17748}, {0x0109,0x011E,0x011A,0x013F}, NES_SCRIPT },
      { {0x17931,0x18C5E,0x176CC,0x17887}, {0x0009,0x0009,0x0009,0x0009}, NES_SCRIPT }, // 60
      { {0x14D21,0x14D21,0x14D27,0x14D8B}, {0x01B6,0x01B6,0x01B9,0x01D4}, NES_SCRIPT },
      { {0x2B0F6,0x2B108,0x2AA0E,0x2ACFB}, {0x0243,0x0243,0x0256,0x028D}, NES_SCRIPT },
      { {0x230BF,0x230C9,0x231A4,0x23203}, {0x067F,0x067F,0x06D2,0x0779}, NES_SCRIPT },
      { {0x2C711,0x2C711,0x2B9E7,0x2C1D0}, {0x001C,0x001C,0x001D,0x001B}, NES_SCRIPT },
      { {0x2C72D,0x2C72D,0x2BA04,0x2C1EB}, {0x001A,0x001A,0x0016,0x001F}, NES_SCRIPT },
      { {0x2C747,0x2C747,0x2BA1A,0x2C20A}, {0x0021,0x0021,0x002D,0x0024}, NES_SCRIPT },
      { {0x2C768,0x2C768,0x2BA47,0x2C22E}, {0x0024,0x0024,0x0027,0x0019}, NES_SCRIPT },
      { {0x2C78C,0x2C78C,0x2BA6E,0x2C247}, {0x0017,0x0017,0x0016,0x0018}, NES_SCRIPT },
      { {0x2C7A3,0x2C7A3,0x2BA84,0x2C25F}, {0x0017,0x0017,0x0014,0x001D}, NES_SCRIPT },
      { {0x2C7BA,0x2C7BA,0x2BA98,0x2C27C}, {0x0014,0x0014,0x0015,0x0016}, NES_SCRIPT }, // 70
      { {0x2C7CE,0x2C7CE,0x2BAAD,0x2C292}, {0x0024,0x0024,0x0029,0x0027}, NES_SCRIPT },
      { {0x00000,0x00000,0x00000,0x00000}, {0x0000,0x0000,0x0000,0x0000}, NES_SCRIPT },
      { {0x2C7F2,0x2C7F2,0x2BAD6,0x2C2B9}, {0x0011,0x0011,0x0010,0x0011}, NES_SCRIPT },
      { {0x1793A,0x18C67,0x176D5,0x17890}, {0x009D,0x009D,0x00A2,0x00AA}, NES_SCRIPT },
      { {0x22750,0x2275A,0x22831,0x22846}, {0x0066,0x0066,0x0066,0x0066}, NES_SCRIPT },
      { {0x14ED7,0x14ED7,0x14EE0,0x14F5F}, {0x0075,0x0075,0x0077,0x0083}, NES_SCRIPT },
      { {0x1F30C,0x1F28D,0x1F30B,0x1F43C}, {0x0120,0x0120,0x011A,0x013A}, NES_SCRIPT },
      { {0x1FD55,0x1FCD6,0x1FD58,0x1FEB8}, {0x001D,0x001D,0x001D,0x001D}, NES_SCRIPT },
      { {0x1F42C,0x1F3AD,0x1F425,0x1F576}, {0x008F,0x008F,0x0095,0x0098}, NES_SCRIPT },
      { {0x1F4BB,0x1F43C,0x1F4BA,0x1F60E}, {0x0097,0x0097,0x009E,0x009B}, NES_SCRIPT }, // 80
      { {0x179D7,0x18D04,0x17777,0x1793A}, {0x006A,0x006A,0x006F,0x006E}, NES_SCRIPT },
      { {0x17A41,0x18D6E,0x177E6,0x179A8}, {0x0030,0x0030,0x002F,0x0033}, NES_SCRIPT },
      { {0x1F552,0x1F4D3,0x1F558,0x1F6A9}, {0x0092,0x0092,0x0098,0x00A5}, NES_SCRIPT },
      { {0x2C803,0x2C803,0x2BAE6,0x2C2CA}, {0x00CC,0x00CC,0x00C4,0x00BA}, NES_SCRIPT },
      { {0x2C8CF,0x2C8CF,0x2BBAA,0x2C384}, {0x00BA,0x00BA,0x00AE,0x00AC}, NES_SCRIPT },
      { {0x2C989,0x2C989,0x2BC58,0x2C430}, {0x0088,0x0088,0x0088,0x008F}, NES_SCRIPT },
      { {0x20A09,0x20A09,0x20A3C,0x20A2D}, {0x01B0,0x01B0,0x01BB,0x01BE}, NES_SCRIPT },
      { {0x20BB9,0x20BB9,0x20BF7,0x20BEB}, {0x0168,0x0168,0x0197,0x0158}, NES_SCRIPT },
      { {0x20D21,0x20D21,0x20D8E,0x20D43}, {0x006C,0x006C,0x006E,0x0079}, NES_SCRIPT },
      { {0x20D8D,0x20D8D,0x20DFC,0x20DBC}, {0x0037,0x0037,0x0028,0x002B}, NES_SCRIPT }, // 90
      { {0x20DC4,0x20DC4,0x20E24,0x20DE7}, {0x00E4,0x00E4,0x00EA,0x00E8}, NES_SCRIPT },
      { {0x20EA8,0x20EA8,0x20F0E,0x20ECF}, {0x0045,0x0045,0x0049,0x004A}, NES_SCRIPT },
      { {0x20EED,0x20EED,0x20F57,0x20F19}, {0x00E1,0x00E1,0x00E7,0x0110}, NES_SCRIPT },
      { {0x20FCE,0x20FCE,0x2103E,0x21029}, {0x00F6,0x00F6,0x010C,0x0136}, NES_SCRIPT },
      { {0x210C4,0x210C4,0x2114A,0x2115F}, {0x0141,0x0141,0x0151,0x0152}, NES_SCRIPT },
      { {0x21205,0x21205,0x2129B,0x212B1}, {0x0183,0x0183,0x01B0,0x01B3}, NES_SCRIPT },
      { {0x21388,0x21388,0x2144B,0x21464}, {0x0034,0x0034,0x0034,0x0032}, NES_SCRIPT },
      { {0x213BC,0x213BC,0x2147F,0x21496}, {0x00A9,0x00A9,0x00A9,0x00A9}, NES_SCRIPT },
      { {0x24367,0x24367,0x24379,0x2437F}, {0x011B,0x011B,0x010E,0x0133}, NES_SCRIPT },
      { {0x1BD4D,0x1BDC2,0x1BBD7,0x1BCBC}, {0x0070,0x0070,0x0072,0x0074}, NES_SCRIPT }, // 100
      { {0x1CC78,0x1CBF9,0x1CC6B,0x1CC07}, {0x0091,0x0091,0x0092,0x0090}, NES_SCRIPT },
      { {0x29372,0x29372,0x2898B,0x28E43}, {0x0054,0x0054,0x0054,0x0054}, NES_SCRIPT },
      { {0x19F74,0x1A0D0,0x19EB7,0x19F06}, {0x00CE,0x00CE,0x00D3,0x00DB}, NES_SCRIPT },
      { {0x1A042,0x1A19E,0x19F8A,0x19FE1}, {0x0077,0x0077,0x0077,0x0080}, NES_SCRIPT },
      { {0x14F4C,0x14F4C,0x14F57,0x14FE2}, {0x0057,0x0057,0x0057,0x0057}, NES_SCRIPT },
      { {0x27886,0x2790A,0x2703E,0x273F4}, {0x02DF,0x02DF,0x0307,0x031F}, NES_SCRIPT },
      { {0x1DA2A,0x1D9AB,0x1D9FB,0x1D9D4}, {0x0219,0x0219,0x024F,0x0238}, NES_SCRIPT },
      { {0x1DC43,0x1DBC4,0x1DC4A,0x1DC0C}, {0x00F9,0x00F9,0x00E4,0x00FE}, NES_SCRIPT },
      { {0x1DD3C,0x1DCBD,0x1DD2E,0x1DD0A}, {0x0056,0x0056,0x0059,0x005A}, NES_SCRIPT },
      { {0x1DD92,0x1DD13,0x1DD87,0x1DD64}, {0x01C2,0x01C2,0x01C2,0x01F5}, NES_SCRIPT }, // 110
      { {0x14FA3,0x14FA3,0x14FAE,0x15039}, {0x004D,0x004D,0x004D,0x004D}, NES_SCRIPT },
      { {0x27594,0x27618,0x26D52,0x270DD}, {0x00D9,0x00D9,0x00D5,0x0100}, NES_SCRIPT },
      { {0x21DC3,0x21DCD,0x21E92,0x21E9A}, {0x0013,0x0013,0x0013,0x0013}, NES_SCRIPT },
      { {0x2A63D,0x2A64F,0x29C6E,0x2A1C3}, {0x00F0,0x00F0,0x00F0,0x00F0}, NES_SCRIPT },
      { {0x24482,0x24482,0x24487,0x244B2}, {0x00E7,0x00E7,0x00E0,0x00E4}, NES_SCRIPT },
      { {0x21465,0x21465,0x21528,0x2153F}, {0x00F2,0x00F2,0x00F2,0x00EC}, NES_SCRIPT },
      { {0x24569,0x24569,0x24567,0x24596}, {0x002B,0x002B,0x0023,0x0033}, NES_SCRIPT },
      { {0x2C3CF,0x2C3CF,0x2B6B2,0x2BC04}, {0x010F,0x010F,0x010B,0x0108}, NES_SCRIPT },
      { {0x24594,0x24594,0x2458A,0x245C9}, {0x00AA,0x00AA,0x00A1,0x009F}, NES_SCRIPT },
      { {0x24CE8,0x250B2,0x250A0,0x250F1}, {0x0DAB,0x0DAB,0x018B,0x0193}, NES_SCRIPT }, // 120
      { {0x1B67F,0x1B6F4,0x1B4F7,0x1B5E5}, {0x000D,0x000D,0x000D,0x000D}, NES_SCRIPT },
      { {0x1B68C,0x1B701,0x1B504,0x1B5F2}, {0x000D,0x000D,0x000D,0x000D}, NES_SCRIPT },
      { {0x2373E,0x23748,0x23876,0x2397C}, {0x017C,0x017C,0x018E,0x0199}, NES_SCRIPT },
      { {0x282F5,0x282F5,0x27639,0x27A07}, {0x01E1,0x01E1,0x01F0,0x0233}, NES_SCRIPT },
      { {0x238BA,0x238C4,0x23A04,0x23B15}, {0x0153,0x0153,0x017B,0x0171}, NES_SCRIPT },
      { {0x23A0D,0x23A17,0x23B7F,0x23C86}, {0x019C,0x019C,0x01AC,0x01BC}, NES_SCRIPT },
      { {0x23BA9,0x23BB3,0x23D2B,0x23E42}, {0x0016,0x0016,0x0016,0x0016}, NES_SCRIPT },
      { {0x2C4DE,0x2C4DE,0x2B7BD,0x2BD0C}, {0x005C,0x005C,0x005B,0x005B}, NES_SCRIPT },
      { {0x23BBF,0x23BC9,0x23D41,0x23E58}, {0x0020,0x0020,0x0020,0x0020}, NES_SCRIPT },
      { {0x27D66,0x27DEA,0x2A643,0x27E3B}, {0x00A5,0x00A5,0x00A6,0x00B9}, NES_SCRIPT }, // 130
      { {0x2A72D,0x2A73F,0x29D5E,0x2A2B3}, {0x034D,0x034D,0x0399,0x03D3}, NES_SCRIPT },
      { {0x14FF0,0x14FF0,0x14FFB,0x15086}, {0x00E3,0x00E3,0x00D2,0x00E4}, NES_SCRIPT },
      { {0x2BABC,0x2BACE,0x2B1DE,0x2B70C}, {0x005F,0x005F,0x0063,0x0067}, NES_SCRIPT },
      { {0x00000,0x00000,0x00000,0x00000}, {0x0000,0x0000,0x0000,0x0000}, NES_SCRIPT },
      { {0x25A93,0x25E5D,0x2522B,0x25284}, {0x003C,0x003C,0x003C,0x003C}, NES_SCRIPT },
      { {0x1E8E9,0x1E86A,0x1E8DB,0x1E9C0}, {0x0011,0x0011,0x0011,0x0011}, NES_SCRIPT },
      { {0x1634A,0x1634A,0x13E33,0x13E40}, {0x0018,0x0018,0x0018,0x0018}, NES_SCRIPT },
      { {0x26DFD,0x26E81,0x26585,0x26621}, {0x001F,0x001F,0x001F,0x001F}, NES_SCRIPT },
      { {0x26E1C,0x26EA0,0x265A4,0x26640}, {0x0054,0x0054,0x0054,0x0054}, NES_SCRIPT },
      { {0x26E70,0x26EF4,0x265F8,0x26694}, {0x0149,0x0149,0x017D,0x0173}, NES_SCRIPT }, // 140
      { {0x26FB9,0x2703D,0x26775,0x26807}, {0x004B,0x004B,0x004B,0x004B}, NES_SCRIPT },
      { {0x27004,0x27088,0x267C0,0x26852}, {0x017D,0x017D,0x0165,0x0190}, NES_SCRIPT },
      { {0x27181,0x27205,0x26925,0x269E2}, {0x0027,0x0027,0x0027,0x0027}, NES_SCRIPT },
      { {0x271A8,0x2722C,0x2694C,0x26A09}, {0x0041,0x0041,0x0041,0x0041}, NES_SCRIPT },
      { {0x271E9,0x2726D,0x2698D,0x26A4A}, {0x01B1,0x01B1,0x01CB,0x024E}, NES_SCRIPT },
      { {0x16362,0x16362,0x13E4B,0x13E58}, {0x001F,0x001F,0x001F,0x001F}, NES_SCRIPT },
      { {0x2463E,0x2463E,0x2462B,0x24668}, {0x002A,0x002A,0x002A,0x002A}, NES_SCRIPT },
      { {0x150D3,0x150D3,0x150CD,0x1516A}, {0x019E,0x019E,0x0187,0x01C9}, NES_SCRIPT },
      { {0x19275,0x194A8,0x1927D,0x192D0}, {0x0031,0x0031,0x0031,0x0031}, NES_SCRIPT },
      { {0x17A71,0x18D9E,0x17815,0x179DB}, {0x007C,0x007C,0x0087,0x0088}, NES_SCRIPT }, // 150
      { {0x21557,0x21557,0x2161A,0x2162B}, {0x00DC,0x00DC,0x00D8,0x00D0}, NES_SCRIPT },
      { {0x1D457,0x1D3D8,0x1D412,0x1D3BF}, {0x0018,0x0018,0x0018,0x0018}, NES_SCRIPT },
      { {0x1D46F,0x1D3F0,0x1D42A,0x1D3D7}, {0x0053,0x0053,0x0058,0x0055}, NES_SCRIPT },
      { {0x18BE2,0x17DB0,0x18C04,0x18C36}, {0x0005,0x0005,0x0005,0x0005}, NES_SCRIPT },
      { {0x15271,0x15271,0x15254,0x15333}, {0x011B,0x011B,0x0108,0x0113}, NES_SCRIPT },
      { {0x1538C,0x1538C,0x1535C,0x15446}, {0x000B,0x000B,0x000B,0x000B}, NES_SCRIPT },
      { {0x24668,0x24668,0x24655,0x24692}, {0x0138,0x0138,0x0139,0x014D}, NES_SCRIPT },
      { {0x247A0,0x247A0,0x2478E,0x247DF}, {0x0014,0x0014,0x0014,0x0014}, NES_SCRIPT },
      { {0x1DF54,0x1DED5,0x1DF49,0x1DF59}, {0x0018,0x0018,0x0018,0x0018}, NES_SCRIPT },
      { {0x247B4,0x247B4,0x247A2,0x247F3}, {0x0027,0x0027,0x0027,0x0027}, NES_SCRIPT }, // 160
      { {0x1A0B9,0x1A215,0x1A001,0x1A061}, {0x004D,0x004D,0x004C,0x0050}, NES_SCRIPT },
      { {0x00000,0x00000,0x00000,0x00000}, {0x0000,0x0000,0x0000,0x0000}, NES_SCRIPT },
      { {0x2BB1B,0x2BB2D,0x2B241,0x2B773}, {0x00A5,0x00A5,0x00A5,0x00A5}, NES_SCRIPT },
      { {0x2AA7A,0x2AA8C,0x2A0F7,0x2A686}, {0x00C1,0x00C1,0x00B5,0x00BA}, NES_SCRIPT },
      { {0x2AB3B,0x2AB4D,0x2A1AC,0x2A740}, {0x0140,0x0140,0x0140,0x0140}, NES_SCRIPT },
      { {0x19826,0x19982,0x19759,0x1979F}, {0x00BF,0x00BF,0x00CA,0x00CA}, NES_SCRIPT },
      { {0x198E5,0x19A41,0x19823,0x19869}, {0x014D,0x014D,0x014D,0x014D}, NES_SCRIPT },
      { {0x19A32,0x19B8E,0x19970,0x199B6}, {0x0012,0x0012,0x0012,0x0012}, NES_SCRIPT },
      { {0x2AC7B,0x2AC8D,0x2A2EC,0x2A880}, {0x0005,0x0005,0x0005,0x0005}, NES_SCRIPT },
      { {0x2AC80,0x2AC92,0x2A2F1,0x2A885}, {0x0005,0x0005,0x0005,0x0005}, NES_SCRIPT }, // 170
      { {0x2AC85,0x2AC97,0x2A2F6,0x2A88A}, {0x0005,0x0005,0x0005,0x0005}, NES_SCRIPT },
      { {0x2AC8A,0x2AC9C,0x2A2FB,0x2A88F}, {0x0005,0x0005,0x0005,0x0005}, NES_SCRIPT },
      { {0x2AC8F,0x2ACA1,0x2A300,0x2A894}, {0x0005,0x0005,0x0005,0x0005}, NES_SCRIPT },
      { {0x21633,0x21633,0x216F2,0x216FB}, {0x0033,0x0033,0x0033,0x0033}, NES_SCRIPT },
      { {0x2AC94,0x2ACA6,0x2A305,0x2A899}, {0x0005,0x0005,0x0005,0x0005}, NES_SCRIPT },
      { {0x00000,0x00000,0x00000,0x00000}, {0x0000,0x0000,0x0000,0x0000}, NES_SCRIPT },
      { {0x2AC99,0x2ACAB,0x2A30A,0x2A89E}, {0x009C,0x009C,0x009C,0x009C}, NES_SCRIPT },
      { {0x2AD35,0x2AD47,0x2A3A6,0x2A93A}, {0x009C,0x009C,0x009C,0x009C}, NES_SCRIPT }
};

static ScummNESFile::Resource res_sounds[82] = {
      { {0x0FFE8,0x0BF54,0x0BF58,0x07F74}, {0x000A,0x000A,0x000A,0x000A}, NES_SOUND },
      { {0x30ECA,0x30ECA,0x30352,0x30ECA}, {0x0832,0x0832,0x0832,0x0832}, NES_SOUND },
      { {0x30ECA,0x30ECA,0x30352,0x30ECA}, {0x0832,0x0832,0x0832,0x0832}, NES_SOUND },
      { {0x30ECA,0x30ECA,0x30352,0x30ECA}, {0x0832,0x0832,0x0832,0x0832}, NES_SOUND },
      { {0x30ECA,0x30ECA,0x30352,0x30ECA}, {0x0832,0x0832,0x0832,0x0832}, NES_SOUND },
      { {0x30ECA,0x30ECA,0x30352,0x30ECA}, {0x0832,0x0832,0x0832,0x0832}, NES_SOUND },
      { {0x17FCA,0x0BF5E,0x0BF62,0x0BF6C}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x27E0B,0x27ECB,0x27E5F,0x1BEFA}, {0x0073,0x0073,0x0073,0x0073}, NES_SOUND },
      { {0x17FDB,0x0BF6F,0x17F5A,0x17F10}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x17FEC,0x0FF5D,0x17F6B,0x17F21}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x27E7E,0x316FC,0x27ED2,0x1FED5}, {0x0056,0x0056,0x0056,0x0056}, NES_SOUND },
      { {0x27ED4,0x13F4E,0x1BF55,0x17F32}, {0x001F,0x001F,0x001F,0x001F}, NES_SOUND },
      { {0x23FEE,0x0FF6E,0x23F66,0x17F51}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x0FFF2,0x13F6D,0x0BF73,0x0FF76}, {0x000A,0x000A,0x000A,0x000A}, NES_SOUND },
      { {0x27EF3,0x1BF47,0x1BF74,0x17F62}, {0x000A,0x000A,0x000A,0x000A}, NES_SOUND },
      { {0x27EFD,0x1BF51,0x27F28,0x1FF2B}, {0x0019,0x0019,0x0019,0x0019}, NES_SOUND },
      { {0x27F16,0x31752,0x2BF0A,0x23E78}, {0x004B,0x004B,0x004B,0x004B}, NES_SOUND },
      { {0x27F61,0x1BF6A,0x1FF71,0x17F6C}, {0x000A,0x000A,0x000A,0x000A}, NES_SOUND },
      { {0x27F6B,0x27F3E,0x27F41,0x1BF6D}, {0x000F,0x000F,0x000F,0x000F}, NES_SOUND },
      { {0x27F7A,0x27F4D,0x27F50,0x1FF44}, {0x001D,0x001D,0x001D,0x001D}, NES_SOUND },
      { {0x27F97,0x3179D,0x2FEAA,0x23EC3}, {0x0045,0x0045,0x0045,0x0045}, NES_SOUND },
      { {0x27FDC,0x27F6A,0x27F6D,0x1FF61}, {0x000F,0x000F,0x000F,0x000F}, NES_SOUND },
      { {0x2FD42,0x2BF40,0x2BF55,0x23F08}, {0x001B,0x001B,0x001B,0x001B}, NES_SOUND },
      { {0x2FD5D,0x317E2,0x2FEEF,0x23F23}, {0x0033,0x0033,0x0033,0x0033}, NES_SOUND },
      { {0x27FEB,0x2BF5B,0x2FF22,0x23F56}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x2BFEF,0x2BF6C,0x2BF70,0x1FF70}, {0x000F,0x000F,0x000F,0x000F}, NES_SOUND },
      { {0x2FD90,0x31815,0x30B84,0x27EF4}, {0x0075,0x0075,0x0075,0x0075}, NES_SOUND },
      { {0x2FE05,0x2FF6C,0x2FF33,0x23F67}, {0x0014,0x0014,0x0014,0x0014}, NES_SOUND },
      { {0x0FFE8,0x0BF54,0x0BF58,0x07F74}, {0x000A,0x000A,0x000A,0x000A}, NES_SOUND },
      { {0x2FE19,0x3188A,0x30BF9,0x2FB83}, {0x00FF,0x00FF,0x00FF,0x00FF}, NES_SOUND },
      { {0x2FF18,0x31989,0x2FF47,0x27F69}, {0x000F,0x000F,0x000F,0x000F}, NES_SOUND },
      { {0x2FF27,0x31998,0x2FF56,0x2BF70}, {0x000F,0x000F,0x000F,0x000F}, NES_SOUND },
      { {0x2FF36,0x319A7,0x30CF8,0x2FC82}, {0x0092,0x0092,0x0092,0x0092}, NES_SOUND },
      { {0x2FF36,0x319A7,0x30CF8,0x2FC82}, {0x0092,0x0092,0x0092,0x0092}, NES_SOUND },
      { {0x2FFC8,0x31A39,0x30D8A,0x2FD14}, {0x002D,0x002D,0x002D,0x002D}, NES_SOUND },
      { {0x316FC,0x31A66,0x30DB7,0x2FD41}, {0x00F8,0x00F8,0x00F8,0x00F8}, NES_SOUND },
      { {0x317F4,0x31B5E,0x2FF65,0x2FE39}, {0x0016,0x0016,0x0016,0x0016}, NES_SOUND },
      { {0x3180A,0x31B74,0x30EAF,0x2FE4F}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x3181B,0x31B85,0x30EC0,0x2FE60}, {0x004B,0x004B,0x004B,0x004B}, NES_SOUND },
      { {0x31866,0x31BD0,0x30F0B,0x2FEAB}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x31877,0x31BE1,0x30F1C,0x2FEBC}, {0x003B,0x003B,0x003B,0x003B}, NES_SOUND },
      { {0x318B2,0x31C1C,0x30F57,0x316FC}, {0x008A,0x008A,0x008A,0x008A}, NES_SOUND },
      { {0x3193C,0x31CA6,0x30FE1,0x2FEF7}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x3194D,0x31CB7,0x30FF2,0x2FF08}, {0x000F,0x000F,0x000F,0x000F}, NES_SOUND },
      { {0x3195C,0x31CC6,0x31001,0x31786}, {0x00A2,0x00A2,0x00A2,0x00A2}, NES_SOUND },
      { {0x319FE,0x31D68,0x310A3,0x31828}, {0x00D3,0x00D3,0x00D3,0x00D3}, NES_SOUND },
      { {0x31AD1,0x31E3B,0x31176,0x318FB}, {0x0097,0x0097,0x0097,0x0097}, NES_SOUND },
      { {0x2BFEF,0x2BF6C,0x2BF70,0x1FF70}, {0x000F,0x000F,0x000F,0x000F}, NES_SOUND },
      { {0x3195C,0x31CC6,0x31001,0x31786}, {0x00A2,0x00A2,0x00A2,0x00A2}, NES_SOUND },
      { {0x31B68,0x31ED2,0x3120D,0x31992}, {0x05D1,0x05D1,0x05D1,0x05D1}, NES_SOUND },
      { {0x31B68,0x31ED2,0x3120D,0x31992}, {0x05D1,0x05D1,0x05D1,0x05D1}, NES_SOUND },
      { {0x32139,0x324A3,0x317DE,0x2FF17}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x0FFE8,0x0BF54,0x0BF58,0x07F74}, {0x000A,0x000A,0x000A,0x000A}, NES_SOUND },
      { {0x2FD90,0x31815,0x30B84,0x27EF4}, {0x0075,0x0075,0x0075,0x0075}, NES_SOUND },
      { {0x27ED4,0x13F4E,0x1BF55,0x17F32}, {0x001F,0x001F,0x001F,0x001F}, NES_SOUND },
      { {0x3214A,0x324B4,0x317EF,0x31F63}, {0x098E,0x098E,0x098E,0x098E}, NES_SOUND },
      { {0x3181B,0x31B85,0x30EC0,0x2FE60}, {0x004B,0x004B,0x004B,0x004B}, NES_SOUND },
      { {0x32AD8,0x32E42,0x3217D,0x2FF28}, {0x0011,0x0011,0x0011,0x0011}, NES_SOUND },
      { {0x30ECA,0x30ECA,0x30352,0x30ECA}, {0x0832,0x0832,0x0832,0x0832}, NES_SOUND },
      { {0x32AE9,0x32E53,0x3218E,0x2FF39}, {0x000F,0x000F,0x000F,0x000F}, NES_SOUND },
      { {0x32AF8,0x32E62,0x3219D,0x2FF48}, {0x002F,0x002F,0x002F,0x002F}, NES_SOUND },
      { {0x32B27,0x32E91,0x321CC,0x328F1}, {0x001D,0x001D,0x001D,0x001D}, NES_SOUND },
      { {0x32B44,0x32EAE,0x321E9,0x3290E}, {0x0018,0x0018,0x0018,0x0018}, NES_SOUND },
      { {0x32B5C,0x32EC6,0x32201,0x32926}, {0x0016,0x0016,0x0016,0x0016}, NES_SOUND },
      { {0x32B72,0x32EDC,0x32217,0x3293C}, {0x001B,0x001B,0x001B,0x001B}, NES_SOUND },
      { {0x32B8D,0x32EF7,0x32232,0x32957}, {0x0088,0x0088,0x0088,0x0088}, NES_SOUND },
      { {0x32C15,0x32F7F,0x322BA,0x329DF}, {0x0065,0x0065,0x0065,0x0065}, NES_SOUND },
      { {0x32C7A,0x32FE4,0x3231F,0x32A44}, {0x0065,0x0065,0x0065,0x0065}, NES_SOUND },
      { {0x32CDF,0x33049,0x32384,0x32AA9}, {0x0073,0x0073,0x0073,0x0073}, NES_SOUND },
      { {0x32D52,0x330BC,0x323F7,0x32B1C}, {0x00F9,0x00F9,0x00F9,0x00F9}, NES_SOUND },
      { {0x32E4B,0x331B5,0x324F0,0x32C15}, {0x049E,0x049E,0x049E,0x049E}, NES_SOUND },
      { {0x34001,0x34001,0x3298E,0x330B3}, {0x0EA8,0x0EA8,0x0EA8,0x0EA8}, NES_SOUND },
      { {0x332E9,0x34EA9,0x34001,0x34001}, {0x0B18,0x0B18,0x0B18,0x0B18}, NES_SOUND },
      { {0x34EA9,0x359C1,0x34B19,0x34B19}, {0x0B9C,0x0B9C,0x0B9C,0x0B9C}, NES_SOUND },
      { {0x35A45,0x3655D,0x356B5,0x356B5}, {0x0C6B,0x0C6B,0x0C6B,0x0C6B}, NES_SOUND },
      { {0x366B0,0x38001,0x36320,0x36320}, {0x0E56,0x0E56,0x0E56,0x0E56}, NES_SOUND },
      { {0x38001,0x371C8,0x37176,0x37176}, {0x0C70,0x0C70,0x0C70,0x0C70}, NES_SOUND },
      { {0x38C71,0x38E57,0x38001,0x38001}, {0x0DEC,0x0DEC,0x0DEC,0x0DEC}, NES_SOUND },
      { {0x39A5D,0x39C43,0x38DED,0x38DED}, {0x0B77,0x0B77,0x0B77,0x0B77}, NES_SOUND },
      { {0x37506,0x33653,0x33836,0x39964}, {0x042F,0x042F,0x042F,0x042F}, NES_SOUND },
      { {0x3A5D4,0x3A7BA,0x39964,0x39D93}, {0x0AC5,0x0AC5,0x0AC5,0x0AC5}, NES_SOUND },
      { {0x3B099,0x3B27F,0x3A429,0x3A858}, {0x0BE4,0x0BE4,0x0BE4,0x0BE4}, NES_SOUND }
};

static ScummNESFile::Resource res_costumes[25] = {
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x13FAB,0x0FEA2,0x17E9A,0x13E77}, {0x004B,0x004B,0x004B,0x004B}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x17F5A,0x0FEED,0x0FF4A,0x07F3E}, {0x0036,0x0036,0x0036,0x0036}, NES_COSTUME },
      { {0x17F90,0x0FF23,0x17EE5,0x13EC2}, {0x003A,0x003A,0x003A,0x003A}, NES_COSTUME },
      { {0x17F90,0x0FF23,0x17EE5,0x13EC2}, {0x003A,0x003A,0x003A,0x003A}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x1BF87,0x13F13,0x17F1F,0x13EFC}, {0x003B,0x003B,0x003B,0x003B}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x23FA9,0x23F2F,0x1BE94,0x13F37}, {0x0045,0x0045,0x0045,0x0045}, NES_COSTUME },
      { {0x1FFBD,0x1FF3E,0x1BED9,0x17E94}, {0x0040,0x0040,0x0040,0x0040}, NES_COSTUME },
      { {0x1BFC2,0x27E8F,0x1BF19,0x17ED4}, {0x003C,0x003C,0x003C,0x003C}, NES_COSTUME },
      { {0x17F90,0x0FF23,0x17EE5,0x13EC2}, {0x003A,0x003A,0x003A,0x003A}, NES_COSTUME },
      { {0x17F90,0x0FF23,0x17EE5,0x13EC2}, {0x003A,0x003A,0x003A,0x003A}, NES_COSTUME },
      { {0x17F05,0x0BEFF,0x0FEF5,0x0BF17}, {0x0055,0x0055,0x0055,0x0055}, NES_COSTUME },
      { {0x13FAB,0x0FEA2,0x17E9A,0x13E77}, {0x004B,0x004B,0x004B,0x004B}, NES_COSTUME }
};
#endif

static ScummNESFile::Resource res_globdata =
      { {0x2CA11,0x2CA11,0x2C001,0x2C628}, {0x0307,0x0307,0x0307,0x0307}, NES_GLOBDATA };

#ifndef PALMOS_68K
// sprite palette data
static ScummNESFile::Resource res_sprpals[2] = {
      { {0x0BFC1,0x07F61,0x07F55,0x07ED8}, {0x0010,0x0010,0x0010,0x0010}, NES_SPRPALS },
      { {0x0BFD1,0x0BEB2,0x07F65,0x07EE8}, {0x0010,0x0010,0x0010,0x0010}, NES_SPRPALS }
};

// associates costume IDs with sprite sets (indexes into SPRLENS/SPROFFS)
static ScummNESFile::Resource res_sprdesc[2] = {
      { {0x0FFB7,0x0BEC2,0x0BF1B,0x07EF8}, {0x0031,0x0031,0x0031,0x0031}, NES_SPRDESC },
      { {0x0BFE1,0x07F71,0x07F75,0x07F29}, {0x0009,0x0009,0x0009,0x0009}, NES_SPRDESC }
};

// number of sprites in each set (indicates length within SPRDATA)
static ScummNESFile::Resource res_sprlens[2] = {
      { {0x0FEA2,0x1BE32,0x13E6A,0x0FE61}, {0x0115,0x0115,0x0115,0x0115}, NES_SPRLENS },
      { {0x07FF5,0x07F5B,0x07F4F,0x07ED2}, {0x0006,0x0006,0x0006,0x0006}, NES_SPRLENS }
};

// offset of each sprite set (indexes into SPRDATA)
static ScummNESFile::Resource res_sproffs[2] = {
      { {0x2BDC5,0x2FD42,0x2BCE0,0x2F959}, {0x022A,0x022A,0x022A,0x022A}, NES_SPROFFS },
      { {0x0BFEA,0x0BEF3,0x0BF4C,0x07F32}, {0x000C,0x000C,0x000C,0x000C}, NES_SPROFFS }
};

// sprite data sets (packed NES sprite data)
static ScummNESFile::Resource res_sprdata[2] = {
      { {0x2CE11,0x2CE11,0x2C401,0x2CA28}, {0x2BE0,0x2BE0,0x2BE0,0x2BE0}, NES_SPRDATA },
      { {0x07F6B,0x0BE28,0x0FE6B,0x07E48}, {0x008A,0x008A,0x008A,0x008A}, NES_SPRDATA }
};
#endif

static ScummNESFile::Resource res_charset =
      { {0x3F6EE,0x3F724,0x3F739,0x3F739}, {0x0090,0x0090,0x0090,0x0090}, NES_CHARSET };

static ScummNESFile::Resource res_preplist =
      { {0x3FB5A,0x3FB90,0x3FBA9,0x3FBAF}, {0x000E,0x000E,0x000E,0x0010}, NES_PREPLIST };

uint16 write_byte(Common::WriteStream *out, byte val) {
      val ^= 0xFF;
      if (out != 0)
            out->writeByte(val);
      return 1;
}

uint16 write_word(Common::WriteStream *out, uint16 val) {
      val ^= 0xFFFF;
      if (out != 0)
            out->writeUint16LE(val);
      return 2;
}

byte ScummNESFile::fileReadByte() {
      byte b = 0;
      File::read(&b, 1);
      return b;
}

uint16 ScummNESFile::fileReadUint16LE() {
      uint16 a = fileReadByte();
      uint16 b = fileReadByte();
      return a | (b << 8);
}

uint32 ScummNESFile::resOffset(Resource *res) {
      return res->offset[_ROMset];
}

uint16 ScummNESFile::resLength(Resource *res) {
      return res->length[_ROMset];
}

uint16 ScummNESFile::extractResource(Common::WriteStream *output, Resource *res) {
      uint16 len, i, j;
      byte val;
      byte cnt;
      uint16 reslen = 0;

      if (res == NULL)
            error("extract_resource - no resource specified");

      if ((resOffset(res) == 0) && (resLength(res) == 0))
            return 0;   /* there are 8 scripts that are zero bytes long, so we should skip them */

      File::seek(resOffset(res),SEEK_SET);

      switch (res->type) {
      case NES_GLOBDATA:
            len = resLength(res);

            for (i = 0; i < len; i++)
                  reslen += write_byte(output, fileReadByte());

            break;

      case NES_ROOMGFX:
      case NES_COSTUMEGFX:
            reslen += write_word(output, (uint16)(resLength(res) + 2));
            len = fileReadByte();
            reslen += write_byte(output, (byte)len);

            if (!len)
                  len = 256;
            len = len << 4;

            for (i = 0; i < len;) {
                  reslen += write_byte(output, cnt = fileReadByte());
                  for (j = 0; j < (cnt & 0x7F); j++, i++)
                        if ((cnt & 0x80) || (j == 0))
                              reslen += write_byte(output, fileReadByte());
            }

            if (File::pos() - resOffset(res) != resLength(res))
                  error("extract_resource - length mismatch while extracting graphics resource (was %04X, should be %04X)", File::pos() - resOffset(res), resLength(res));

            break;

      case NES_ROOM:
      case NES_SCRIPT:
            len = fileReadUint16LE();

            if (len != resLength(res))
                  error("extract_resource - length mismatch while extracting room/script resource (was %04X, should be %04X)", len, resLength(res));

            File::seek(-2, SEEK_CUR);

            for (i = 0; i < len; i++)
                  reslen += write_byte(output, fileReadByte());

            break;

      case NES_SOUND:
            len = resLength(res) + 2;
            val = fileReadByte();
            cnt = fileReadByte();

            if ((val == 2) && (cnt == 100)) {
                  reslen += write_word(output, len);
                  reslen += write_byte(output, val);
                  reslen += write_byte(output, cnt);

                  cnt = fileReadByte();
                  reslen += write_byte(output, cnt);
                  for (i = 0; i < cnt; i++)
                        reslen += write_byte(output, fileReadByte());
                  for (i = 0; i < cnt; i++)
                        reslen += write_byte(output, fileReadByte());

                  while (1) {
                        reslen += write_byte(output, val = fileReadByte());
                        if (val >= 0xFE)
                              break;
                  }
            } else if (((val == 0) || (val == 1) || (val == 4)) && (cnt == 10)) {
                  reslen += write_word(output, len);
                  reslen += write_byte(output, val);
                  reslen += write_byte(output, cnt);
                  while (1) {
                        reslen += write_byte(output, val = fileReadByte());

                        if (val >= 0xFE)
                              break;

                        if (val >= 0x10)
                              reslen += write_byte(output, fileReadByte());
                        else {
                              reslen += write_byte(output, fileReadByte());
                              reslen += write_byte(output, fileReadByte());
                              reslen += write_byte(output, fileReadByte());
                              reslen += write_byte(output, fileReadByte());
                        }
                  }
            } else
                  error("extract_resource - unknown sound type %d/%d detected",val,cnt);

            if (File::pos() - resOffset(res) != resLength(res))
                  error("extract_resource - length mismatch while extracting sound resource (was %04X, should be %04X)", File::pos() - resOffset(res), resLength(res));

            break;

      case NES_COSTUME:
      case NES_SPRPALS:
      case NES_SPRDESC:
      case NES_SPRLENS:
      case NES_SPROFFS:
      case NES_SPRDATA:
      case NES_CHARSET:
            len = resLength(res);
            reslen += write_word(output, (uint16)(len + 2));

            for (i = 0; i < len; i++)
                  reslen += write_byte(output, fileReadByte());

            break;

      case NES_PREPLIST:
            len = resLength(res);
                reslen += write_word(output, 0x002A);

            reslen += write_byte(output, ' ');
            for (i = 1; i < 8; i++)
                  reslen += write_byte(output, 0);

            for (j = 0; j < 4; j++)
            {
                  reslen += write_byte(output,' ');
                  for (i = 1; (val = fileReadByte()); i++)
                        reslen += write_byte(output, val);
                  for (; i < 8; i++)
                        reslen += write_byte(output, 0);
            }
            break;

      default:
            error("extract_resource - unknown resource type %d specified!", res->type);
      }

      return reslen;
}

// based on structure of Classic PC Maniac Mansion LFL files
// (roomgfx resources are arranged in order, one per file,
// after the room blocks) */
static ScummNESFile::Resource *lfl_01[] = { &res_rooms[1], &res_roomgfx[1], &res_scripts[57], &res_scripts[61], &res_scripts[76], &res_scripts[105], &res_scripts[111], &res_sounds[5], &res_scripts[132], &res_scripts[148], &res_scripts[155], &res_scripts[156], &res_sounds[39], NULL };
static ScummNESFile::Resource *lfl_02[] = { &res_rooms[2], &res_roomgfx[2], NULL };
static ScummNESFile::Resource *lfl_03[] = { &res_rooms[3], &res_roomgfx[3], &res_scripts[21], &res_sounds[26], NULL };
static ScummNESFile::Resource *lfl_04[] = { &res_rooms[4], &res_roomgfx[4], &res_scripts[46], &res_scripts[56], &res_scripts[137], &res_scripts[146], &res_sounds[12], &res_sounds[11], &res_sounds[13], &res_sounds[42], NULL };
static ScummNESFile::Resource *lfl_05[] = { &res_rooms[5], &res_roomgfx[5], &res_scripts[30], &res_scripts[31], &res_scripts[32], &res_scripts[33], &res_scripts[34], &res_scripts[35], &res_sounds[22], &res_sounds[23], &res_sounds[24], &res_sounds[21], &res_sounds[46], NULL };
static ScummNESFile::Resource *lfl_06[] = { &res_rooms[6], &res_roomgfx[6], NULL };
static ScummNESFile::Resource *lfl_07[] = { &res_rooms[7], &res_roomgfx[7], &res_scripts[17], &res_scripts[58], &res_scripts[59], &res_scripts[60], &res_scripts[74], &res_scripts[81], &res_scripts[82], &res_scripts[150], &res_sounds[14], &res_sounds[15], &res_sounds[16], &res_sounds[17], NULL };
static ScummNESFile::Resource *lfl_08[] = { &res_rooms[8], &res_roomgfx[8], &res_scripts[7], &res_scripts[12], &res_scripts[13], &res_scripts[47], &res_scripts[48], &res_scripts[49], &res_scripts[154], &res_sounds[32], &res_sounds[33], &res_sounds[36], NULL };
static ScummNESFile::Resource *lfl_09[] = { &res_rooms[9], &res_roomgfx[9], &res_scripts[10], &res_scripts[11], &res_scripts[45], &res_scripts[55], &res_scripts[84], &res_scripts[85], &res_scripts[86], NULL };
static ScummNESFile::Resource *lfl_10[] = { &res_rooms[10], &res_roomgfx[10], &res_scripts[24], &res_scripts[149], &res_sounds[28], NULL };
static ScummNESFile::Resource *lfl_11[] = { &res_rooms[11], &res_roomgfx[11], &res_scripts[166], &res_scripts[167], &res_scripts[168], NULL };
static ScummNESFile::Resource *lfl_12[] = { &res_rooms[12], &res_roomgfx[12], &res_scripts[51], &res_scripts[103], &res_scripts[104], &res_scripts[161], &res_sounds[63], &res_costumes[14], NULL };
static ScummNESFile::Resource *lfl_13[] = { &res_rooms[13], &res_roomgfx[13], NULL };
static ScummNESFile::Resource *lfl_14[] = { &res_rooms[14], &res_roomgfx[14], NULL };
static ScummNESFile::Resource *lfl_15[] = { &res_rooms[15], &res_roomgfx[15], &res_sounds[27], NULL };
static ScummNESFile::Resource *lfl_16[] = { &res_rooms[16], &res_roomgfx[16], &res_scripts[14], &res_scripts[121], &res_scripts[122], &res_sounds[40], &res_sounds[64], &res_sounds[68], NULL };
static ScummNESFile::Resource *lfl_17[] = { &res_rooms[17], &res_roomgfx[17], &res_scripts[20], &res_scripts[100], &res_sounds[25], &res_sounds[44], &res_sounds[2], &res_sounds[50], &res_sounds[52], NULL };
static ScummNESFile::Resource *lfl_18[] = { &res_rooms[18], &res_roomgfx[18], &res_scripts[25], &res_scripts[26], &res_scripts[27], &res_scripts[28], &res_scripts[64], &res_scripts[65], &res_scripts[66], &res_scripts[67], &res_scripts[68], &res_scripts[69], &res_scripts[70], &res_scripts[71], &res_scripts[73], &res_scripts[101], &res_sounds[35], NULL };
static ScummNESFile::Resource *lfl_19[] = { &res_rooms[19], &res_roomgfx[19], &res_scripts[36], &res_scripts[37], &res_scripts[38], &res_scripts[39], &res_scripts[40], &res_scripts[152], &res_scripts[153], &res_costumes[10], NULL };
static ScummNESFile::Resource *lfl_20[] = { &res_rooms[20], &res_roomgfx[20], &res_scripts[107], &res_scripts[108], &res_scripts[109], &res_scripts[110], &res_scripts[159], NULL };
static ScummNESFile::Resource *lfl_21[] = { &res_rooms[21], &res_roomgfx[21], &res_scripts[41], &res_scripts[42], &res_scripts[43], &res_scripts[53], &res_scripts[136], &res_sounds[29], &res_sounds[20], &res_sounds[37], NULL };
static ScummNESFile::Resource *lfl_22[] = { &res_rooms[22], &res_roomgfx[22], &res_scripts[15], NULL };
static ScummNESFile::Resource *lfl_23[] = { &res_rooms[23], &res_roomgfx[23], &res_scripts[77], &res_scripts[79], &res_scripts[80], &res_scripts[83], &res_sounds[41], NULL };
static ScummNESFile::Resource *lfl_24[] = { &res_rooms[24], &res_roomgfx[24], &res_scripts[18], &res_scripts[19], &res_scripts[78], &res_sounds[7], &res_sounds[3], &res_sounds[18], &res_sounds[34], &res_costumes[12], NULL };
static ScummNESFile::Resource *lfl_25[] = { &res_rooms[25], &res_roomgfx[25], &res_scripts[29], &res_sounds[30], &res_sounds[31], NULL };
static ScummNESFile::Resource *lfl_26[] = { &res_rooms[26], &res_roomgfx[26], &res_scripts[87], &res_scripts[88], &res_scripts[89], &res_scripts[90], &res_scripts[91], &res_scripts[92], &res_scripts[93], &res_scripts[94], &res_scripts[95], &res_scripts[96], &res_scripts[97], &res_scripts[98], &res_scripts[116], &res_scripts[151], &res_scripts[174], &res_costumes[11], NULL };
static ScummNESFile::Resource *lfl_27[] = { &res_rooms[27], &res_roomgfx[27], &res_scripts[16], &res_scripts[52], &res_scripts[54], &res_scripts[113], &res_sounds[45], &res_costumes[19], NULL };
static ScummNESFile::Resource *lfl_28[] = { &res_rooms[28], &res_roomgfx[28], &res_scripts[22], &res_scripts[23], NULL };
static ScummNESFile::Resource *lfl_29[] = { &res_rooms[29], &res_roomgfx[29], &res_scripts[75], &res_sounds[43], NULL };
static ScummNESFile::Resource *lfl_30[] = { &res_rooms[30], &res_roomgfx[30], &res_scripts[63], &res_sounds[0], &res_scripts[123], &res_scripts[125], &res_scripts[126], &res_scripts[127], &res_scripts[129], &res_sounds[55], &res_sounds[59], &res_sounds[60], &res_costumes[8], NULL };
static ScummNESFile::Resource *lfl_31[] = { &res_rooms[31], &res_roomgfx[31], &res_scripts[99], &res_scripts[115], &res_scripts[117], &res_scripts[119], &res_scripts[147], &res_scripts[157], &res_scripts[158], &res_scripts[160], &res_costumes[13], &res_costumes[9], &res_costumes[23], &res_costumes[24], NULL };
static ScummNESFile::Resource *lfl_32[] = { &res_rooms[32], &res_roomgfx[32], &res_costumes[15], NULL };
static ScummNESFile::Resource *lfl_33[] = { &res_rooms[33], &res_roomgfx[33], &res_scripts[120], &res_scripts[135], &res_sounds[56], &res_sounds[57], &res_sounds[58], &res_sounds[1], &res_costumes[22], NULL };
static ScummNESFile::Resource *lfl_34[] = { &res_rooms[34], &res_roomgfx[34], NULL };
static ScummNESFile::Resource *lfl_35[] = { &res_rooms[35], &res_roomgfx[35], NULL };
static ScummNESFile::Resource *lfl_36[] = { &res_rooms[36], &res_roomgfx[36], &res_sounds[10], &res_sounds[4], NULL };
static ScummNESFile::Resource *lfl_37[] = { &res_rooms[37], &res_roomgfx[37], NULL };
static ScummNESFile::Resource *lfl_38[] = { &res_rooms[38], &res_roomgfx[38], &res_scripts[138], &res_scripts[139], &res_scripts[140], &res_scripts[141], &res_scripts[142], &res_scripts[143], &res_scripts[144], &res_scripts[145], NULL };
static ScummNESFile::Resource *lfl_39[] = { &res_rooms[39], &res_roomgfx[39], NULL };
static ScummNESFile::Resource *lfl_40[] = { &res_rooms[40], &res_roomgfx[0], &res_scripts[112], &res_costumes[17], NULL };
static ScummNESFile::Resource *lfl_41[] = { &res_rooms[41], &res_scripts[106], &res_sounds[47], &res_sounds[48], &res_sounds[53], &res_sounds[49], &res_sounds[51], NULL };
static ScummNESFile::Resource *lfl_42[] = { &res_rooms[42], &res_scripts[124], &res_costumes[18],  NULL };
static ScummNESFile::Resource *lfl_43[] = { &res_rooms[43], &res_scripts[44], &res_sounds[19], NULL };
static ScummNESFile::Resource *lfl_44[] = { &res_rooms[44], &res_scripts[102], &res_sounds[6], &res_sounds[38], &res_sounds[8], &res_sounds[9], &res_costumes[1], &res_costumes[2], &res_costumes[5], &res_costumes[6], &res_costumes[3], &res_costumes[4], &res_costumes[7], NULL };
static ScummNESFile::Resource *lfl_45[] = { &res_rooms[45], &res_scripts[1], &res_scripts[2], &res_scripts[3], &res_scripts[4], &res_scripts[5], &res_scripts[9], &res_scripts[114], &res_scripts[131], &res_scripts[164], &res_scripts[165], &res_scripts[169], &res_scripts[170], &res_scripts[171], &res_scripts[172], &res_scripts[173], &res_scripts[175], &res_sounds[54], NULL };
static ScummNESFile::Resource *lfl_46[] = { &res_rooms[46], &res_scripts[130], &res_sounds[65], &res_costumes[0], &res_costumes[21], NULL };
static ScummNESFile::Resource *lfl_47[] = { &res_rooms[47], &res_scripts[62], &res_sounds[69], NULL };
static ScummNESFile::Resource *lfl_48[] = { &res_rooms[48], NULL };
static ScummNESFile::Resource *lfl_49[] = { &res_rooms[49], NULL };
static ScummNESFile::Resource *lfl_50[] = { &res_rooms[50], &res_scripts[133], &res_scripts[163], NULL };
static ScummNESFile::Resource *lfl_51[] = { &res_rooms[51], &res_scripts[118], &res_scripts[128], &res_sounds[61], &res_sounds[62], &res_sounds[67], &res_sounds[66], &res_costumes[16], &res_costumes[20], NULL };
static ScummNESFile::Resource *lfl_52[] = { &res_rooms[52], NULL };
/*    remaining 'standard' resources (not used by any of the original LFL files) */
static ScummNESFile::Resource *lfl_53[] = { &res_rooms[53], &res_scripts[177], &res_scripts[178], &res_sounds[70], &res_sounds[71], &res_sounds[72], &res_sounds[73], &res_sounds[74], &res_sounds[75], &res_sounds[76], &res_sounds[77], &res_sounds[78], &res_sounds[79], &res_sounds[80], &res_sounds[81], NULL };
/*    all 'non-standard' resources (the costume-related stuff) */
static ScummNESFile::Resource *lfl_54[] = { &res_rooms[54], &res_sprdesc[0], &res_sprdesc[1], &res_sprlens[0], &res_sprlens[1], &res_sproffs[0], &res_sproffs[1], &res_sprdata[0], &res_sprdata[1], &res_costumegfx[0], &res_costumegfx[1], &res_sprpals[0], &res_sprpals[1], &res_charset, &res_preplist, NULL };

typedef     struct _lfl {
      int num;
      ScummNESFile::Resource **entries;
} t_lfl, *p_lfl;

t_lfl lfls[] = {
      {  1, lfl_01 },
      {  2, lfl_02 },
      {  3, lfl_03 },
      {  4, lfl_04 },
      {  5, lfl_05 },
      {  6, lfl_06 },
      {  7, lfl_07 },
      {  8, lfl_08 },
      {  9, lfl_09 },
      { 10, lfl_10 },
      { 11, lfl_11 },
      { 12, lfl_12 },
      { 13, lfl_13 },
      { 14, lfl_14 },
      { 15, lfl_15 },
      { 16, lfl_16 },
      { 17, lfl_17 },
      { 18, lfl_18 },
      { 19, lfl_19 },
      { 20, lfl_20 },
      { 21, lfl_21 },
      { 22, lfl_22 },
      { 23, lfl_23 },
      { 24, lfl_24 },
      { 25, lfl_25 },
      { 26, lfl_26 },
      { 27, lfl_27 },
      { 28, lfl_28 },
      { 29, lfl_29 },
      { 30, lfl_30 },
      { 31, lfl_31 },
      { 32, lfl_32 },
      { 33, lfl_33 },
      { 34, lfl_34 },
      { 35, lfl_35 },
      { 36, lfl_36 },
      { 37, lfl_37 },
      { 38, lfl_38 },
      { 39, lfl_39 },
      { 40, lfl_40 },
      { 41, lfl_41 },
      { 42, lfl_42 },
      { 43, lfl_43 },
      { 44, lfl_44 },
      { 45, lfl_45 },
      { 46, lfl_46 },
      { 47, lfl_47 },
      { 48, lfl_48 },
      { 49, lfl_49 },
      { 50, lfl_50 },
      { 51, lfl_51 },
      { 52, lfl_52 },
      { 53, lfl_53 },
      { 54, lfl_54 },
      { -1, NULL }
};

#pragma START_PACK_STRUCTS
struct _lfl_index {
      byte  room_lfl[55];
      uint16      room_addr[55];
      byte  costume_lfl[80];
      uint16      costume_addr[80];
      byte  script_lfl[200];
      uint16      script_addr[200];
      byte  sound_lfl[100];
      uint16      sound_addr[100];
} GCC_PACK lfl_index;
#pragma END_PACK_STRUCTS


bool ScummNESFile::generateResource(int res) {
      p_lfl lfl = &lfls[res - 1];
      int j;
      int bufsize = 2;

      for (j = 0; lfl->entries[j] != NULL; j++)
            bufsize += extractResource(0, lfl->entries[j]);

      free(_buf);
      _buf = (byte *)calloc(1, bufsize);

      Common::MemoryWriteStream out(_buf, bufsize);

      for (j = 0; lfl->entries[j] != NULL; j++) {
            Resource *entry = lfl->entries[j];
            extractResource(&out, entry);
      }
      write_byte(&out, 0xD1);
      write_byte(&out, 0xF5);

      if (_stream)
            delete _stream;

      _stream = new Common::MemoryReadStream(_buf, bufsize);

      return true;
}

bool ScummNESFile::generateIndex() {
      int i, j;

      for (i = 0; lfls[i].num != -1; i++) {
            p_lfl lfl = &lfls[i];
            uint16 respos = 0;

            for (j = 0; lfl->entries[j] != NULL; j++) {
                  Resource *entry = lfl->entries[j];

                  switch (entry->type) {
                  case NES_ROOM:
                        lfl_index.room_lfl[entry - res_rooms] = lfl->num;
                        lfl_index.room_addr[entry - res_rooms] = TO_LE_16(respos);
                        break;
                  case NES_COSTUME:
                        lfl_index.costume_lfl[entry - res_costumes] = lfl->num;
                        lfl_index.costume_addr[entry - res_costumes] = TO_LE_16(respos);
                        break;
                  case NES_SPRDESC:
                        lfl_index.costume_lfl[entry - res_sprdesc + 25] = lfl->num;
                        lfl_index.costume_addr[entry - res_sprdesc + 25] = TO_LE_16(respos);
                        break;
                  case NES_SPRLENS:
                        lfl_index.costume_lfl[entry - res_sprlens + 27] = lfl->num;
                        lfl_index.costume_addr[entry - res_sprlens + 27] = TO_LE_16(respos);
                        break;
                  case NES_SPROFFS:
                        lfl_index.costume_lfl[entry - res_sproffs + 29] = lfl->num;
                        lfl_index.costume_addr[entry - res_sproffs + 29] = TO_LE_16(respos);
                        break;
                  case NES_SPRDATA:
                        lfl_index.costume_lfl[entry - res_sprdata + 31] = lfl->num;
                        lfl_index.costume_addr[entry - res_sprdata + 31] = TO_LE_16(respos);
                        break;
                  case NES_COSTUMEGFX:
                        lfl_index.costume_lfl[entry - res_costumegfx + 33] = lfl->num;
                        lfl_index.costume_addr[entry - res_costumegfx + 33] = TO_LE_16(respos);
                        break;
                  case NES_SPRPALS:
                        lfl_index.costume_lfl[entry - res_sprpals + 35] = lfl->num;
                        lfl_index.costume_addr[entry - res_sprpals + 35] = TO_LE_16(respos);
                        break;
                  case NES_ROOMGFX:
                        lfl_index.costume_lfl[entry - res_roomgfx + 37] = lfl->num;
                        lfl_index.costume_addr[entry - res_roomgfx + 37] = TO_LE_16(respos);
                        break;
                  case NES_SCRIPT:
                        lfl_index.script_lfl[entry - res_scripts] = lfl->num;
                        lfl_index.script_addr[entry - res_scripts] = TO_LE_16(respos);
                        break;
                  case NES_SOUND:
                        lfl_index.sound_lfl[entry - res_sounds] = lfl->num;
                        lfl_index.sound_addr[entry - res_sounds] = TO_LE_16(respos);
                        break;
                  case NES_CHARSET:
                        lfl_index.costume_lfl[77] = lfl->num;
                        lfl_index.costume_addr[77] = TO_LE_16(respos);
                        break;
                  case NES_PREPLIST:
                        lfl_index.costume_lfl[78] = lfl->num;
                        lfl_index.costume_addr[78] = TO_LE_16(respos);
                        break;
                  default:
                        error("Unindexed entry found!");
                        break;
                  }
                  respos += extractResource(0, entry);
            }
      }

      int bufsize = 2;

      bufsize += 775;
      bufsize += sizeof(lfl_index);

      free(_buf);
      _buf = (byte *)calloc(1, bufsize);

      Common::MemoryWriteStream out(_buf, bufsize);

      write_byte(&out, 0x43);
      write_byte(&out, 0x46);

      extractResource(&out, &res_globdata);

      for (i = 0; i < (int)sizeof(lfl_index); i++)
            write_byte(&out, ((byte *)&lfl_index)[i]);

      if (_stream)
            delete _stream;

      _stream = new Common::MemoryReadStream(_buf, bufsize);

      return true;
}

bool ScummNESFile::open(const char *filename, AccessMode mode) {
      uint8 md5sum[16];

      if (_ROMset == kROMsetNum) {
            if (Common::md5_file(filename, md5sum)) {
                  char md5str[32+1];
                  for (int j = 0; j < 16; j++) {
                        sprintf(md5str + j*2, "%02x", (int)md5sum[j]);
                  }

                  if (!strcmp(md5str, "3905799e081b80a61d4460b7b733c206")) {
                        _ROMset = kROMsetUSA;
                        debug(1, "ROM contents verified as Maniac Mansion (USA)");
                  } else if (!strcmp(md5str, "d8d07efcb88f396bee0b402b10c3b1c9")) {
                        _ROMset = kROMsetEurope;
                        debug(1, "ROM contents verified as Maniac Mansion (Europe)");
                  } else if (!strcmp(md5str, "22d07d6c386c9c25aca5dac2a0c0d94b")) {
                        _ROMset = kROMsetSweden;
                        debug(1, "ROM contents verified as Maniac Mansion (Sweden)");
                  } else if (!strcmp(md5str, "81bbfa181184cb494e7a81dcfa94fbd9")) {
                        _ROMset = kROMsetFrance;
                        debug(2, "ROM contents verified as Maniac Mansion (France)");
                  } else {
                        error("Unsupported Maniac Mansion ROM, md5: %s", md5str);
                        return false;
                  }
            } else {
                  return false;
            }
      }

      if (File::open(filename, mode)) {
            if (_stream)
                  delete _stream;
            _stream = 0;

            free(_buf);
            _buf = 0;

            return true;
      } else {
            return false;
      }
}

void ScummNESFile::close() {
      if (_stream)
            delete _stream;
      _stream = 0;

      free(_buf);
      _buf = 0;

      File::close();
}

bool ScummNESFile::openSubFile(const char *filename) {
      assert(isOpen());

      const char *ext = strrchr(filename, '.');
      char resNum[3];
      int res;

      // We always have file name in form of XX.lfl
      resNum[0] = ext[-2];
      resNum[1] = ext[-1];
      resNum[2] = 0;

      res = atoi(resNum);

      if (res == 0) {
            return generateIndex();
      } else {
            return generateResource(res);
      }
}

#pragma mark -
#pragma mark --- ScummC64File ---
#pragma mark -

static const int maniacResourcesPerFile[55] = {
       0, 11,  1,  3,  9, 12,  1, 13, 10,  6,
       4,  1,  7,  1,  1,  2,  7,  8, 19,  9,
       6,  9,  2,  6,  8,  4, 16,  8,  3,  3,
      12, 12,  2,  8,  1,  1,  2,  1,  9,  1,
       3,  7,  3,  3, 13,  5,  4,  3,  1,  1,
       3, 10,  1,  0,  0
};

static const int zakResourcesPerFile[59] = {
       0, 29, 12, 14, 13,  4,  4, 10,  7,  4,
      14, 19,  5,  4,  7,  6, 11,  9,  4,  4,
       1,  3,  3,  5,  1,  9,  4, 10, 13,  6,
       7, 10,  2,  6,  1, 11,  2,  5,  7,  1,
       7,  1,  4,  2,  8,  6,  6,  6,  4, 13,
       3,  1,  2,  1,  2,  1, 10,  1,  1
};


ScummC64File::ScummC64File(char *disk1, char *disk2, bool maniac) : _stream(0), _buf(0), _maniac(maniac) {
      _disk1 = disk1;
      _disk2 = disk2;

      _openedDisk = 0;

      if (maniac) {
            _numGlobalObjects = 256;
            _numRooms = 55;
            _numCostumes = 25;
            _numScripts = 160;
            _numSounds = 70;
            _resourcesPerFile = maniacResourcesPerFile;
      } else {
            _numGlobalObjects = 775;
            _numRooms = 59;
            _numCostumes = 38;
            _numScripts = 155;
            _numSounds = 127;
            _resourcesPerFile = zakResourcesPerFile;
      }
}

uint32 ScummC64File::write(const void *, uint32) {
      error("ScummC64File does not support writing!");
      return 0;
}

void ScummC64File::setEnc(byte enc) {
      _stream->setEnc(enc);
}

byte ScummC64File::fileReadByte() {
      byte b = 0;
      File::read(&b, 1);
      return b;
}

uint16 ScummC64File::fileReadUint16LE() {
      uint16 a = fileReadByte();
      uint16 b = fileReadByte();
      return a | (b << 8);
}

bool ScummC64File::openDisk(char num) {
      if (num == '1')
            num = 1;
      if (num == '2')
            num = 2;

      if (_openedDisk != num || !File::isOpen()) {
            if (File::isOpen())
                  File::close();

            if (num == 1)
                  File::open(_disk1.c_str());
            else if (num == 2)
                  File::open(_disk2.c_str());
            else {
                  error("ScummC64File::open(): wrong disk (%c)", num);
                  return false;
            }

            _openedDisk = num;

            if (!File::isOpen()) {
                  error("ScummC64File::open(): cannot open disk (%d)", num);
                  return false;
            }
      }
      return true;
}

bool ScummC64File::open(const char *filename, AccessMode mode) {
      uint16 signature;

      // check signature
      openDisk(1);
      File::seek(0);

      signature = fileReadUint16LE();
      if (signature != 0x0A31) {
            error("ScummC64File::open(): signature not found in disk 1!");
            return false;
      }

      extractIndex(0); // Fill in resource arrays

      openDisk(2);
      File::seek(0);

      signature = fileReadUint16LE();
      if (signature != 0x0132)
            error("Error: signature not found in disk 2!\n");

      return true;
}


uint16 ScummC64File::extractIndex(Common::WriteStream *out) {
      int i;
      uint16 reslen = 0;

      openDisk(1);
      File::seek(0);

      // skip signature
      fileReadUint16LE();

      // write expected signature
      reslen += write_word(out, 0x0132);

      // copy object flags
      for (i = 0; i < _numGlobalObjects; i++)
            reslen += write_byte(out, fileReadByte());

      // copy room offsets
      for (i = 0; i < _numRooms; i++) {
            _roomDisks[i] = fileReadByte();
            reslen += write_byte(out, _roomDisks[i]);
      }
      for (i = 0; i < _numRooms; i++) {
            _roomSectors[i] = fileReadByte();
            reslen += write_byte(out, _roomSectors[i]);
            _roomTracks[i] = fileReadByte();
            reslen += write_byte(out, _roomTracks[i]);
      }
      for (i = 0; i < _numCostumes; i++)
            reslen += write_byte(out, fileReadByte());
      for (i = 0; i < _numCostumes; i++)
            reslen += write_word(out, fileReadUint16LE());

      for (i = 0; i < _numScripts; i++)
            reslen += write_byte(out, fileReadByte());
      for (i = 0; i < _numScripts; i++)
            reslen += write_word(out, fileReadUint16LE());

      for (i = 0; i < _numSounds; i++)
            reslen += write_byte(out, fileReadByte());
      for (i = 0; i < _numSounds; i++)
            reslen += write_word(out, fileReadUint16LE());

      return reslen;
}

bool ScummC64File::generateIndex() {
      int bufsize;

      bufsize = extractIndex(0);

      free(_buf);
      _buf = (byte *)calloc(1, bufsize);

      Common::MemoryWriteStream out(_buf, bufsize);

      extractIndex(&out);

      if (_stream)
            delete _stream;

      _stream = new Common::MemoryReadStream(_buf, bufsize);

      return true;
}

uint16 ScummC64File::extractResource(Common::WriteStream *out, int res) {
      const int SectorOffset[36] = {
            0,
            0, 21, 42, 63, 84, 105, 126, 147, 168, 189, 210, 231, 252, 273, 294, 315, 336,
            357, 376, 395, 414, 433, 452, 471,
            490, 508, 526, 544, 562, 580,
            598, 615, 632, 649, 666
      };
      int i;
      uint16 reslen = 0;

      openDisk(_roomDisks[res]);

      File::seek((SectorOffset[_roomTracks[res]] + _roomSectors[res]) * 256);

      for (i = 0; i < _resourcesPerFile[res]; i++) {
            uint16 len = fileReadUint16LE();
            reslen += write_word(out, len);

            for (len -= 2; len > 0; len--)
                  reslen += write_byte(out, fileReadByte());
      }

      return reslen;
}

bool ScummC64File::generateResource(int res) {
      int bufsize;

      if (res >= _numRooms)
            return false;

      bufsize = extractResource(0, res);

      free(_buf);
      _buf = (byte *)calloc(1, bufsize);

      Common::MemoryWriteStream out(_buf, bufsize);

      extractResource(&out, res);

      if (_stream)
            delete _stream;

      _stream = new Common::MemoryReadStream(_buf, bufsize);

      return true;
}

void ScummC64File::close() {
      if (_stream)
            delete _stream;
      _stream = 0;

      free(_buf);
      _buf = 0;

      File::close();
}

bool ScummC64File::openSubFile(const char *filename) {
      assert(isOpen());

      const char *ext = strrchr(filename, '.');
      char resNum[3];
      int res;

      // We always have file name in form of XX.lfl
      resNum[0] = ext[-2];
      resNum[1] = ext[-1];
      resNum[2] = 0;

      res = atoi(resNum);

      if (res == 0) {
            return generateIndex();
      } else {
            return generateResource(res);
      }

      return true;
}

} // End of namespace Scumm

Generated by  Doxygen 1.6.0   Back to index