void BIFFile::readVarResTable(Common::SeekableReadStream &bif, uint32 offset) {
bif.seek(offset);
for (IResourceList::iterator res = _iResources.begin(); res != _iResources.end(); ++res) {
bif.skip(4); // ID
if (_version == kVersion11)
bif.skip(4); // Flags
res->offset = bif.readUint32LE();
res->size = bif.readUint32LE();
res->type = (FileType) bif.readUint32LE();
}
}
void TGA::readHeader(Common::SeekableReadStream &tga, ImageType &imageType, byte &pixelDepth, byte &imageDesc) {
tga.seek(0);
// TGAs have an optional "id" string in the header
uint32 idLength = tga.readByte();
// Number of colors in the color map / palette
if (tga.readByte() != 0)
throw Common::Exception("Unsupported feature: Color map");
// Image type. 2 == unmapped RGB, 3 == Grayscale
imageType = (ImageType)tga.readByte();
if (!isSupportedImageType(imageType))
throw Common::Exception("Unsupported image type: %d", imageType);
// Color map specifications + X + Y
tga.skip(5 + 2 + 2);
_mipMaps.push_back(new MipMap);
// Image dimensions
_mipMaps[0]->width = tga.readUint16LE();
_mipMaps[0]->height = tga.readUint16LE();
// Bits per pixel
pixelDepth = tga.readByte();
if (imageType == kImageTypeTrueColor || imageType == kImageTypeRLETrueColor) {
if (pixelDepth == 24) {
_format = kPixelFormatB8G8R8;
} else if (pixelDepth == 16 || pixelDepth == 32) {
_format = kPixelFormatB8G8R8A8;
} else if (pixelDepth == 8) {
imageType = kImageTypeBW;
_format = kPixelFormatB8G8R8A8;
} else
throw Common::Exception("Unsupported pixel depth: %d, %d", imageType, pixelDepth);
} else if (imageType == kImageTypeBW) {
if (pixelDepth != 8)
throw Common::Exception("Unsupported pixel depth: %d, %d", imageType, pixelDepth);
_format = kPixelFormatB8G8R8A8;
}
// Image descriptor
imageDesc = tga.readByte();
// Skip the id string
tga.skip(idLength);
}
void Map_v1::loadItemToObject(Common::SeekableReadStream &data) {
int16 count;
if (data.readUint16LE() == 0)
return;
data.skip(1456);
count = data.readUint16LE();
for (int i = 0; i < count; i++) {
data.skip(20);
_vm->_goblin->_itemToObject[i] = data.readUint16LE();
data.skip(5);
}
}
void NewFeature::resetScript() {
// FIXME: registrations, etc
Common::SeekableReadStream *ourSCRB = _view->getSCRB(_data.scrbIndex, _scrbId);
ourSCRB->seek(16);
Common::Point scriptBase, scriptSize;
scriptBase.x = ourSCRB->readUint16BE();
scriptBase.y = ourSCRB->readUint16BE();
scriptSize.x = ourSCRB->readUint16BE();
scriptSize.y = ourSCRB->readUint16BE();
ourSCRB->seek(26);
Common::Point one, two;
while (true) {
if (ourSCRB->pos() == ourSCRB->size())
error("resetScript (getNewXYAndReg) ran out of script");
byte opcode = ourSCRB->readByte();
byte size = ourSCRB->readByte();
if (opcode != 0x10) {
ourSCRB->skip(size - 2);
} else if (size) {
assert(size >= 1);
ourSCRB->skip(2);
int16 x = ourSCRB->readUint16BE();
int16 y = ourSCRB->readUint16BE();
one.x = -x;
one.y = -y;
two.x = scriptBase.x + x;
two.y = scriptBase.y + y;
break;
}
}
delete ourSCRB;
if ((_needsReset || false /* TODO: param */) && (_unknown168 == 0x7FFFFFFF || false /* TODO: param */)) {
_data.currentPos = two;
_data.nextPos = one;
_unknown168 = 0;
if (_needsReset || false /* TODO: param */) {
_data.bounds = Common::Rect(scriptBase.x, scriptBase.y, scriptSize.x, scriptSize.y);
}
} else {
if (false /* FIXME: 0 shapes? */) {
_data.nextPos.x = one.x + two.x - _data.currentPos.x;
_data.nextPos.y = one.y + two.y - _data.currentPos.y;
} else if (_unknown168 != 0x7FFFFFFF) {
_data.nextPos = one;
}
}
// _needsReset = 0; (handled by caller)
}
void HERFFile::load() {
Common::SeekableReadStream *herf = ResMan.getResource(TypeMan.setFileType(_fileName, kFileTypeNone), kFileTypeHERF);
if (!herf)
throw Common::Exception(Common::kOpenError);
herf->skip(4);
uint32 resCount = herf->readUint32LE();
_resources.resize(resCount);
_iResources.resize(resCount);
try {
readResList(*herf);
if (herf->err())
throw Common::Exception(Common::kReadError);
} catch (Common::Exception &e) {
delete herf;
e.add("Failed reading HERF file");
throw e;
}
delete herf;
}
void RIMFile::load(Common::SeekableReadStream &rim) {
readHeader(rim);
if (_id != kRIMID)
throw Common::Exception("Not a RIM file (%s)", Common::debugTag(_id).c_str());
if (_version != kVersion1)
throw Common::Exception("Unsupported RIM file version %s", Common::debugTag(_version).c_str());
rim.skip(4); // Reserved
uint32 resCount = rim.readUint32LE(); // Number of resources in the RIM
uint32 offResList = rim.readUint32LE(); // Offset to the resource list
_resources.resize(resCount);
_iResources.resize(resCount);
try {
// Read the resource list
readResList(rim, offResList);
} catch (Common::Exception &e) {
e.add("Failed reading RIM file");
throw;
}
}
void XEOSITEX::readHeader(Common::SeekableReadStream &xeositex) {
const uint32 magic1 = xeositex.readUint32BE();
const uint32 magic2 = xeositex.readUint32BE();
if ((magic1 != kXEOSID) || (magic2 != kITEXID))
throw Common::Exception("Not a valid XEOSITEX (%s, %s)",
Common::debugTag(magic1).c_str(), Common::debugTag(magic2).c_str());
const uint32 version = xeositex.readUint32LE();
if (version != 0)
throw Common::Exception("Invalid XEOSITEX version %u", version);
const uint32 pixelFormat = xeositex.readUint32LE();
if ((pixelFormat != 3) && (pixelFormat != 4))
throw Common::Exception("Invalid XEOSITEX pixel format %u", pixelFormat);
if (pixelFormat == 3)
_format = kPixelFormatB8G8R8;
else if (pixelFormat == 4)
_format = kPixelFormatB8G8R8A8;
_wrapX = xeositex.readByte() != 0;
_wrapY = xeositex.readByte() != 0;
_flipX = xeositex.readByte() != 0;
_flipY = xeositex.readByte() != 0;
_coordTransform = xeositex.readByte();
xeositex.skip(1); // Filter
const uint32 mipMaps = xeositex.readUint32LE();
_mipMaps.resize(mipMaps, 0);
}
void ActorType::load(byte *dataStart, Common::SeekableReadStream &stream) {
_actorTypeId = stream.readUint32LE();
_surfInfo.load(stream);
uint32 pointsConfigOffs = stream.readUint32LE();
uint namedPointsCount = stream.readUint16LE();
stream.skip(2); // Skip padding
uint32 namedPointsOffs = stream.readUint32LE();
_color.r = stream.readByte();
_color.g = stream.readByte();
_color.b = stream.readByte();
stream.readByte(); // Skip padding
_scale = stream.readByte();
_priority = stream.readByte();
_value1E = stream.readUint16LE();
_pathWalkPointsIndex = stream.readUint16LE();
_scaleLayerIndex = stream.readUint16LE();
_pathWalkRectIndex = stream.readUint16LE();
_priorityLayerIndex = stream.readUint16LE();
_regionLayerIndex = stream.readUint16LE();
_flags = stream.readUint16LE();
_pointsConfig = dataStart + pointsConfigOffs;
stream.seek(namedPointsOffs);
_namedPoints.load(namedPointsCount, stream);
debug(5, "ActorType::load() _actorTypeId: %08X; _color(%d,%d,%d); _scale: %d; _priority: %d; _value1E: %d",
_actorTypeId, _color.r, _color.g, _color.b, _scale, _priority, _value1E);
debug(5, "ActorType::load() _pathWalkPointsIndex: %d; _scaleLayerIndex: %d; _pathWalkRectIndex: %d",
_pathWalkPointsIndex, _scaleLayerIndex, _pathWalkRectIndex);
debug(5, "ActorType::load() _priorityLayerIndex: %d; _regionLayerIndex: %d; _flags: %04X",
_priorityLayerIndex, _regionLayerIndex,_flags);
}
static Common::UString readStringQuoting(Common::SeekableReadStream &ncs, size_t length) {
Common::UString str;
while (length-- > 0) {
byte c = ncs.readByte();
if (!c)
break;
if (c == '\n')
str += "\\n";
else if (c == '\r')
str += "\\r";
else if (c == '\t')
str += "\\t";
else if (c == '\"')
str += "\\\"";
else if (c == '\\')
str += "\\\\";
else if (c < 32 || c > 126)
str += Common::UString::format("\\x%02X", c);
else
str += (uint32) c;
}
if (length != SIZE_MAX)
ncs.skip(length);
return str;
}
void HERFFile::getDictionary(std::list<uint32> &hashes, std::list<Common::UString> &names) const {
hashes.clear();
names.clear();
if (_dictIndex == 0xFFFFFFFF)
return;
Common::SeekableReadStream *dict = getResource(_dictIndex);
dict->skip(8); // unknown
while (dict->pos() < dict->size()) {
uint32 hash = dict->readUint32LE();
if (hash == 0)
break;
hashes.push_back(hash);
names.push_back("");
names.back().readFixedASCII(*dict, 128);
names.back().tolower();
}
delete dict;
}
void Walkmesh::appendFromStream(Common::SeekableReadStream &stream) {
stream.seek(0);
/** Header format:
*
* uint8[8] - WOK version
* uint32 - walkmesh type
* uint8[48] - reserved
* float[3] - position
*/
if (stream.readUint32BE() != MKTAG('B', 'W', 'M', ' ') ||
stream.readUint32BE() != MKTAG('V', '1', '.', '0'))
throw Common::Exception("Invalid WOK version");
stream.skip(64);
uint32 vertexCount = stream.readUint32LE();
uint32 vertexOffset = stream.readUint32LE();
uint32 faceCount = stream.readUint32LE();
uint32 faceOffset = stream.readUint32LE();
uint32 faceTypeOffset = stream.readUint32LE();
//-
appendFaceTypes(stream, faceCount, faceTypeOffset);
appendIndices(stream, faceCount, faceOffset);
appendVertices(stream, vertexCount, vertexOffset);
}
void ASFStream::parseStreamHeader() {
ASFGUID guid = ASFGUID(*_stream);
if (guid != s_asfAudioStream)
throw Common::Exception("ASFStream::parseStreamHeader(): Found non-audio stream");
_stream->skip(16); // skip a guid
_stream->readUint64LE(); // total size
uint32 typeSpecificSize = _stream->readUint32LE();
_stream->readUint32LE();
_streamID = _stream->readUint16LE();
_stream->readUint32LE();
// Parse the wave header
_compression = _stream->readUint16LE();
_channels = _stream->readUint16LE();
_sampleRate = _stream->readUint32LE();
_bitRate = _stream->readUint32LE() * 8;
_blockAlign = _stream->readUint16LE();
_bitsPerCodedSample = (typeSpecificSize == 14) ? 8 : _stream->readUint16LE();
if (typeSpecificSize >= 18) {
uint32 cbSize = _stream->readUint16LE();
cbSize = MIN<int>(cbSize, typeSpecificSize - 18);
_extraData = _stream->readStream(cbSize);
}
_codec = createCodec();
}
Common::SeekableReadStream *QuickTimeDecoder::VideoTrackHandler::getNextFramePacket(uint32 &descId) {
// First, we have to track down which chunk holds the sample and which sample in the chunk contains the frame we are looking for.
int32 totalSampleCount = 0;
int32 sampleInChunk = 0;
int32 actualChunk = -1;
uint32 sampleToChunkIndex = 0;
for (uint32 i = 0; i < _parent->chunkCount; i++) {
if (sampleToChunkIndex < _parent->sampleToChunkCount && i >= _parent->sampleToChunk[sampleToChunkIndex].first)
sampleToChunkIndex++;
totalSampleCount += _parent->sampleToChunk[sampleToChunkIndex - 1].count;
if (totalSampleCount > _curFrame) {
actualChunk = i;
descId = _parent->sampleToChunk[sampleToChunkIndex - 1].id;
sampleInChunk = _parent->sampleToChunk[sampleToChunkIndex - 1].count - totalSampleCount + _curFrame;
break;
}
}
if (actualChunk < 0) {
warning("Could not find data for frame %d", _curFrame);
return 0;
}
// Next seek to that frame
Common::SeekableReadStream *stream = _decoder->_fd;
stream->seek(_parent->chunkOffsets[actualChunk]);
// Then, if the chunk holds more than one frame, seek to where the frame we want is located
for (int32 i = _curFrame - sampleInChunk; i < _curFrame; i++) {
if (_parent->sampleSize != 0)
stream->skip(_parent->sampleSize);
else
stream->skip(_parent->sampleSizes[i]);
}
// Finally, read in the raw data for the frame
//debug("Frame Data[%d]: Offset = %d, Size = %d", _curFrame, stream->pos(), _parent->sampleSizes[_curFrame]);
if (_parent->sampleSize != 0)
return stream->readStream(_parent->sampleSize);
return stream->readStream(_parent->sampleSizes[_curFrame]);
}
bool Resources::loadArchives(const ADGameDescription *gd) {
Common::File *dat_file = new Common::File();
Common::String filename = "teenagent.dat";
if (!dat_file->open(filename.c_str())) {
delete dat_file;
Common::String errorMessage = Common::String::format(_("Unable to locate the '%s' engine data file."), filename.c_str());
warning("%s", errorMessage.c_str());
GUIErrorMessage(errorMessage);
return false;
}
// teenagent.dat used to be compressed with zlib compression. The usage of
// zlib here is no longer needed, and it's maintained only for backwards
// compatibility.
Common::SeekableReadStream *dat = Common::wrapCompressedReadStream(dat_file);
#if !defined(USE_ZLIB)
uint16 header = dat->readUint16BE();
bool isCompressed = (header == 0x1F8B ||
((header & 0x0F00) == 0x0800 &&
header % 31 == 0));
dat->seek(-2, SEEK_CUR);
if (isCompressed) {
// teenagent.dat is compressed, but zlib hasn't been compiled in
delete dat;
Common::String errorMessage = _("The teenagent.dat file is compressed and zlib hasn't been included in this executable. Please decompress it");
warning("%s", errorMessage.c_str());
GUIErrorMessage(errorMessage);
return false;
}
#endif
dat->skip(CSEG_SIZE);
dseg.read(dat, DSEG_SIZE);
eseg.read(dat, ESEG_SIZE);
delete dat;
precomputeDialogOffsets();
FilePack varia;
varia.open("varia.res");
font7.load(varia, 7, 11, 1);
font8.load(varia, 8, 31, 0);
varia.close();
off.open("off.res");
on.open("on.res");
ons.open("ons.res");
lan000.open("lan_000.res");
lan500.open("lan_500.res");
mmm.open("mmm.res");
sam_mmm.open("sam_mmm.res");
sam_sam.open("sam_sam.res");
voices.open("voices.res");
return true;
}
bool NDSFile::readHeader(Common::SeekableReadStream &nds) {
nds.seek(0x00);
_name.readFixedASCII(nds, 12);
_code.readFixedASCII(nds, 4);
_maker.readFixedASCII(nds, 2);
nds.seek(0x20);
_arm9CodeOffset = nds.readUint32LE();
nds.skip(8);
_arm9CodeSize = nds.readUint32LE();
nds.seek(0x30);
_arm7CodeOffset = nds.readUint32LE();
nds.skip(8);
_arm7CodeSize = nds.readUint32LE();
nds.seek(0x40);
_fileNameTableOffset = nds.readUint32LE();
_fileNameTableLength = nds.readUint32LE();
_fatOffset = nds.readUint32LE();
_fatLength = nds.readUint32LE();
nds.seek(0x80);
_romSize = nds.readUint32LE();
_headerSize = nds.readUint32LE();
const uint32 size = nds.size();
if ((_fileNameTableOffset >= size) || ((_fileNameTableOffset + _fileNameTableLength) > size))
return false;
if ((_fatOffset >= size) || ((_fatOffset + _fatLength) > size))
return false;
if ((_arm9CodeOffset >= size) || ((_arm9CodeOffset + _arm9CodeSize) > size))
return false;
if ((_arm7CodeOffset >= size) || ((_arm7CodeOffset + _arm7CodeSize) > size))
return false;
if (_romSize > size)
return false;
if (_headerSize > size)
return false;
return true;
}
static bool isBigEndian(Common::SeekableReadStream &stream) {
stream.skip(4); // Tag, we don't care about that one here
const uint16 bom = stream.readUint16BE();
if ((bom != 0xFFFE) && (bom != 0xFEFF))
throw Common::Exception("Invalid BOM: 0x%04X", (uint) bom);
return bom == 0xFEFF;
}
bool TotFunctions::loadIDE(Tot &tot) {
// Mapping file of function names -> function numbers/offsets
Common::String ideFile = Util::setExtension(tot.file, ".IDE");
Common::SeekableReadStream *ide = _vm->_dataIO->getFile(ideFile);
if (!ide)
// No mapping file => No named functions
return true;
char buffer[17];
uint32 count = ide->readUint16LE();
for (uint32 i = 0; i < count; i++) {
Function function;
function.type = ide->readByte();
ide->read(buffer, 17);
buffer[16] = '\0';
function.name = buffer;
ide->skip(2); // Unknown;
function.offset = ide->readUint16LE();
ide->skip(2); // Unknown;
if ((function.type != 0x47) && (function.type != 0x67))
continue;
tot.script->seek(function.offset);
if (tot.script->readByte() != 1) {
warning("TotFunctions::loadIDE(): IDE corrupt");
return false;
}
debugC(5, kDebugGameFlow, "Function 0x%02X: \"%s\"", function.type,
function.name.c_str());
tot.functions.push_back(function);
}
tot.script->seek(0);
return true;
}
void Frame::load(byte *dataStart, Common::SeekableReadStream &stream) {
_flags = stream.readUint16LE();
stream.skip(2); // Skip padding
uint32 pointsConfigOffs = stream.readUint32LE();
_surfInfo.load(stream);
uint32 compressedPixelsOffs = stream.readUint32LE();
_compressedPixels = dataStart + compressedPixelsOffs;
_pointsConfig = dataStart + pointsConfigOffs;
debug(5, "Frame::load() compressedPixelsOffs: %08X",
compressedPixelsOffs);
}
void PScr::loadSurface(Common::SeekableReadStream &stream) {
stream.skip(4);
int width = stream.readUint16LE();
int height = stream.readUint16LE();
_surface = new Graphics::Surface();
_surface->create(width, height, Graphics::PixelFormat::createFormatCLUT8());
for (int h = 0; h < _surface->h; h++) {
stream.read(_surface->getBasePtr(0, h), _surface->w);
}
}
void DirectorySubEntry::readFromStream(Common::SeekableReadStream &inStream) {
_offset = inStream.readUint32LE();
_size = inStream.readUint32LE();
_metadataSize = inStream.readUint16LE();
_face = inStream.readByte();
_type = static_cast<ResourceType>(inStream.readByte());
if (_metadataSize == 2 && (_type == kSpotItem || _type == kLocalizedSpotItem)) {
_spotItemData.u = inStream.readUint32LE();
_spotItemData.v = inStream.readUint32LE();
} else if (_metadataSize == 10 && (_type == kMovie || _type == kMultitrackMovie)) {
_videoData.v1.setValue(0, inStream.readSint32LE() * 0.000001f);
_videoData.v1.setValue(1, inStream.readSint32LE() * 0.000001f);
_videoData.v1.setValue(2, inStream.readSint32LE() * 0.000001f);
_videoData.v2.setValue(0, inStream.readSint32LE() * 0.000001f);
_videoData.v2.setValue(1, inStream.readSint32LE() * 0.000001f);
_videoData.v2.setValue(2, inStream.readSint32LE() * 0.000001f);
_videoData.u = inStream.readSint32LE();
_videoData.v = inStream.readSint32LE();
_videoData.width = inStream.readSint32LE();
_videoData.height = inStream.readSint32LE();
} else if (_type == kNumMetadata || _type == kTextMetadata) {
if (_metadataSize > 20) {
warning("Too much metadata, skipping");
inStream.skip(_metadataSize * sizeof(uint32));
return;
}
_miscData[0] = _offset;
_miscData[1] = _size;
for (uint i = 0; i < _metadataSize; i++)
_miscData[i + 2] = inStream.readUint32LE();
} else if (_metadataSize != 0) {
warning("Metadata not read for type %d, size %d", _type, _metadataSize);
inStream.skip(_metadataSize * sizeof(uint32));
}
}
void KEYFile::load(Common::SeekableReadStream &key) {
readHeader(key);
if (_id != kKEYID)
throw Common::Exception("Not a KEY file (%s)", Common::debugTag(_id).c_str());
if ((_version != kVersion1) && (_version != kVersion11))
throw Common::Exception("Unsupported KEY file version %s", Common::debugTag(_version).c_str());
uint32 bifCount = key.readUint32LE();
uint32 resCount = key.readUint32LE();
_bifs.reserve(bifCount);
_resources.reserve(resCount);
// Version 1.1 has some NULL bytes here
if (_version == kVersion11)
key.skip(4);
uint32 offFileTable = key.readUint32LE();
uint32 offResTable = key.readUint32LE();
key.skip( 8); // Build year and day
key.skip(32); // Reserved
try {
_bifs.resize(bifCount);
readBIFList(key, offFileTable);
_resources.resize(resCount);
readResList(key, offResTable);
} catch (Common::Exception &e) {
e.add("Failed reading KEY file");
throw;
}
}
bool Cursor::loadStream(Common::SeekableReadStream &stream) {
stream.skip(4);
uint16 width = stream.readUint16LE();
uint16 height = stream.readUint16LE();
_surface = new Graphics::Surface();
_surface->create(width, height, Graphics::PixelFormat::createFormatCLUT8());
for (int h = 0; h < height; h++) {
stream.read(_surface->getBasePtr(0, h), width);
}
return true;
}
/**
* Read _invent from Hugo.dat
*/
void InventoryHandler::loadInvent(Common::SeekableReadStream &in) {
for (int varnt = 0; varnt < _vm->_numVariant; varnt++) {
int16 numElem = in.readUint16BE();
if (varnt == _vm->_gameVariant) {
_maxInvent = numElem;
_invent = (int16 *)malloc(sizeof(int16) * numElem);
for (int i = 0; i < numElem; i++)
_invent[i] = in.readSint16BE();
} else {
in.skip(numElem * sizeof(int16));
}
}
}
void ERFFile::readERFHeader(Common::SeekableReadStream &erf, ERFHeader &header) {
uint32 resCount = 0;
if (_version == kVersion1) {
header.langCount = erf.readUint32LE(); // Number of languages for the description
erf.skip(4); // Number of bytes in the description
resCount = erf.readUint32LE(); // Number of resources in the ERF
header.offDescription = erf.readUint32LE();
header.offKeyList = erf.readUint32LE();
header.offResList = erf.readUint32LE();
erf.skip(4 + 4); // Build year and day
header.descriptionID = erf.readUint32LE();
erf.skip(116); // Reserved
} else if (_version == kVersion2) {
header.langCount = 0; // No description in ERF V2.0
resCount = erf.readUint32LE(); // Number of resources in the ERF
header.descriptionID = 0; // No description in ERF V2.0
header.offDescription = 0; // No description in ERF V2.0
header.offKeyList = 0; // No separate key list in ERF V2.0
header.offResList = 0x20; // Resource list always starts at 0x20 in ERF V2.0
erf.skip(4 + 4); // Build year and day
erf.skip(4); // Unknown, always 0xFFFFFFFF?
}
if (!_noResources) {
_resources.resize(resCount);
_iResources.resize(resCount);
}
}
bool ADLPlayer::readHeader(Common::SeekableReadStream &adl, int &timbreCount) {
// Sanity check
if (adl.size() < 60) {
warning("ADLPlayer::readHeader(): File too small (%d)", adl.size());
return false;
}
_soundMode = adl.readByte();
timbreCount = adl.readByte() + 1;
adl.skip(1);
return true;
}
void GameModule::loadInventoryItemInfos(Common::SeekableReadStream &s) {
debug(0, "GameModule::loadInventoryItemInfos()");
s.seek(0x190);
uint32 offs = s.readUint32LE();
s.seek(offs);
for (int i = 0; i < kInventoryItemCount; ++i) {
_inventoryItemInfos[i].xOffs = s.readUint16LE();
_inventoryItemInfos[i].yOffs = s.readUint16LE();
_inventoryItemInfos[i].width = s.readUint16LE();
_inventoryItemInfos[i].height = s.readUint16LE();
s.skip(8); // Unused
}
}
void RIMFile::readResList(Common::SeekableReadStream &rim, uint32 offset) {
rim.seek(offset);
uint32 index = 0;
ResourceList::iterator res = _resources.begin();
IResourceList::iterator iRes = _iResources.begin();
for (; (res != _resources.end()) && (iRes != _iResources.end()); ++index, ++res, ++iRes) {
res->name = Common::readStringFixed(rim, Common::kEncodingASCII, 16);
res->type = (FileType) rim.readUint16LE();
res->index = index;
rim.skip(4 + 2); // Resource ID + Reserved
iRes->offset = rim.readUint32LE();
iRes->size = rim.readUint32LE();
}
}
void Sprite::loadPalette(Common::SeekableReadStream &stream, uint32 count) {
if (count == 0)
return;
byte *palette = new byte[count * 3];
for (uint32 i = 0; i < count ; i++) {
palette[i * 3 + 2] = stream.readByte();
palette[i * 3 + 1] = stream.readByte();
palette[i * 3 + 0] = stream.readByte();
stream.skip(1);
}
_palette.copyFrom(palette, count);
delete[] palette;
}
void TwoDAFile::readRows2b(Common::SeekableReadStream &twoda) {
/* And now read the cells. In binary 2DA files, each cell only
* stores a single 16-bit number, the offset into the data segment
* where the data for this cell can be found. Moreover, a single
* data offset can be used by several cells, deduplicating the
* cell data.
*/
size_t columnCount = _headers.size();
size_t rowCount = _rows.size();
size_t cellCount = columnCount * rowCount;
uint32 *offsets = new uint32[cellCount];
Common::StreamTokenizer tokenize(Common::StreamTokenizer::kRuleHeed);
tokenize.addSeparator('\0');
for (size_t i = 0; i < cellCount; i++)
offsets[i] = twoda.readUint16LE();
twoda.skip(2); // Size of the data segment in bytes
size_t dataOffset = twoda.pos();
for (size_t i = 0; i < rowCount; i++) {
_rows[i] = new TwoDARow(*this);
_rows[i]->_data.resize(columnCount);
for (size_t j = 0; j < columnCount; j++) {
size_t offset = dataOffset + offsets[i * columnCount + j];
try {
twoda.seek(offset);
} catch (...) {
delete[] offsets;
throw;
}
_rows[i]->_data[j] = tokenize.getToken(twoda);
if (_rows[i]->_data[j].empty())
_rows[i]->_data[j] = "****";
}
}
delete[] offsets;
}
/**
* Read _introX and _introY from hugo.dat
*/
void IntroHandler::loadIntroData(Common::SeekableReadStream &in) {
for (int varnt = 0; varnt < _vm->_numVariant; varnt++) {
int numRows = in.readUint16BE();
if (varnt == _vm->_gameVariant) {
_introXSize = numRows;
_introX = (byte *)malloc(sizeof(byte) * _introXSize);
_introY = (byte *)malloc(sizeof(byte) * _introXSize);
for (int i = 0; i < _introXSize; i++) {
_introX[i] = in.readByte();
_introY[i] = in.readByte();
}
} else {
in.skip(numRows * 2);
}
}
}