static int readStream(void *context, char *buffer, int len) {
Common::ReadStream *stream = static_cast<Common::ReadStream *>(context);
if (!stream)
return -1;
return stream->read(buffer, len);
}
Common::String *LureEngine::detectSave(int slotNumber) {
Common::ReadStream *f = this->_saveFileMan->openForLoading(
generateSaveName(slotNumber));
if (f == NULL) return NULL;
Common::String *result = NULL;
// Check for header
char buffer[5];
f->read(&buffer[0], 5);
if (memcmp(&buffer[0], "lure", 5) == 0) {
// Check language version
uint8 language = f->readByte();
uint8 version = f->readByte();
if ((language == getLureLanguage()) && (version >= LURE_MIN_SAVEGAME_MINOR)) {
// Read in the savegame title
char saveName[MAX_DESC_SIZE];
char *p = saveName;
int decCtr = MAX_DESC_SIZE - 1;
while ((decCtr > 0) && ((*p++ = f->readByte()) != 0)) --decCtr;
*p = '\0';
result = new Common::String(saveName);
}
}
delete f;
return result;
}
void Parser::readBG(Common::ReadStream &in, Background &curBG) {
curBG._verbIndex = in.readUint16BE();
curBG._nounIndex = in.readUint16BE();
curBG._commentIndex = in.readSint16BE();
curBG._matchFl = (in.readByte() != 0);
curBG._roomState = in.readByte();
curBG._bonusIndex = in.readByte();
}
void Parser::readBG(Common::ReadStream &in, background_t &curBG) {
curBG.verbIndex = in.readUint16BE();
curBG.nounIndex = in.readUint16BE();
curBG.commentIndex = in.readSint16BE();
curBG.matchFl = (in.readByte() != 0);
curBG.roomState = in.readByte();
curBG.bonusIndex = in.readByte();
}
bool SavePartVars::read(Common::ReadStream &stream) {
if (!_header.verify(stream))
return false;
if (stream.read(_data, _size) != _size)
return false;
return !stream.err();
}
Common::String readLAString(Common::ReadStream &ms) {
int strLength = ms.readUint32LE();
char* readString = new char[strLength];
ms.read(readString, strLength);
Common::String retVal(readString);
delete[] readString;
return retVal;
}
/**
* Extracts a string from a data stream
* @param df data stream
*/
Common::String readString(Common::ReadStream &df) {
Common::String var;
uint8 len = df.readByte();
for (int i = 0; i < len; i++) {
char c;
c = df.readByte();
var += c;
}
return var;
}
/**
* Load a NULL-terminated string from the given stream.
*/
static Common::String loadString(Common::ReadStream &in, uint maxSize = 999) {
Common::String result;
while (!in.eos() && (result.size() < maxSize)) {
char ch = (char)in.readByte();
if (ch == '\0')
break;
result += ch;
}
return result;
}
DataBlockPtr AdlEngine_v2::readDataBlockPtr(Common::ReadStream &f) const {
byte track = f.readByte();
byte sector = f.readByte();
byte offset = f.readByte();
byte size = f.readByte();
if (f.eos() || f.err())
error("Error reading DataBlockPtr");
if (track == 0 && sector == 0 && offset == 0 && size == 0)
return DataBlockPtr();
return _disk->getDataBlock(track, sector, offset, size);
}
Common::String XARCMember::readString(Common::ReadStream &stream) {
Common::String str;
// Read until we find a 0
char c = 1;
while (c != 0) {
c = stream.readByte();
if (stream.eos()) {
c = 0;
} else {
str += c;
}
}
return str;
}
XARCMember::XARCMember(const XARCArchive *xarc, Common::ReadStream &stream, uint32 offset) {
_xarc = xarc;
// Read the information about this archive member
_name = readString(stream);
_offset = offset;
_length = stream.readUint32LE();
debugC(20, kDebugArchive, "Stark::XARC Member: \"%s\" starts at offset=%d and has length=%d", _name.c_str(), _offset, _length);
// Unknown value. English: 0, others: 1
uint32 unknown = stream.readUint32LE();
debugC(kDebugUnknown, "Stark::XARC Member: \"%s\" has unknown=%d", _name.c_str(), unknown);
if (unknown != 0 && unknown != 1) {
warning("Stark::XARC Member: \"%s\" has unknown=%d with unknown meaning", _name.c_str(), unknown);
}
}
void SoundHandler::loadIntroSong(Common::ReadStream &in) {
for (int varnt = 0; varnt < _vm->_numVariant; varnt++) {
uint16 numBuf = in.readUint16BE();
if (varnt == _vm->_gameVariant)
_DOSIntroSong = _vm->_text->getTextData(numBuf);
}
}
static void deDPCM8Stereo(int16 *out, Common::ReadStream &audioStream, uint32 numBytes, uint8 &sampleL, uint8 &sampleR) {
for (uint32 i = 0; i < numBytes; ++i) {
const uint8 delta = audioStream.readByte();
deDPCM8Nibble(out++, sampleL, delta >> 4);
deDPCM8Nibble(out++, sampleR, delta & 0xf);
}
}
static void saveOrLoadCommonArray(Common::ReadStream &stream, A &array) {
uint count = stream.readUint16LE();
if (count == array.size()) {
for (uint i = 0; i < count; ++i) {
saveOrLoad(stream, array[i]);
}
}
}
void Design::drawOval(Graphics::ManagedSurface *surface, Common::ReadStream &in,
Patterns &patterns, byte fillType, byte borderThickness, byte borderFillType) {
int16 y1 = in.readSint16BE();
int16 x1 = in.readSint16BE();
int16 y2 = in.readSint16BE();
int16 x2 = in.readSint16BE();
PlotData pd(surface, &patterns, fillType, 1, this);
if (fillType <= patterns.size())
Graphics::drawEllipse(x1, y1, x2-1, y2-1, kColorBlack, true, drawPixel, &pd);
pd.fillType = borderFillType;
pd.thickness = borderThickness;
if (borderThickness > 0 && borderFillType <= patterns.size())
Graphics::drawEllipse(x1, y1, x2-1, y2-1, kColorBlack, false, drawPixel, &pd);
}
/**
* Load _cmdList from Hugo.dat
*/
void Parser::loadCmdList(Common::ReadStream &in) {
cmd tmpCmd;
memset(&tmpCmd, 0, sizeof(tmpCmd));
for (int varnt = 0; varnt < _vm->_numVariant; varnt++) {
uint16 numElem = in.readUint16BE();
if (varnt == _vm->_gameVariant) {
_cmdListSize = numElem;
_cmdList = (cmd **)malloc(sizeof(cmd *) * _cmdListSize);
}
for (int16 i = 0; i < numElem; i++) {
uint16 numSubElem = in.readUint16BE();
if (varnt == _vm->_gameVariant)
_cmdList[i] = (cmd *)malloc(sizeof(cmd) * numSubElem);
for (int16 j = 0; j < numSubElem; j++)
readCmd(in, (varnt == _vm->_gameVariant) ? _cmdList[i][j] : tmpCmd);
}
}
}
void Voice8Header::load(Common::ReadStream &stream) {
oneShotHiSamples = stream.readUint32BE();
repeatHiSamples = stream.readUint32BE();
samplesPerHiCycle = stream.readUint32BE();
samplesPerSec = stream.readUint16BE();
octaves = stream.readByte();
compression = stream.readByte();
volume = stream.readUint32BE();
}
bool SaveContainer::read(Common::ReadStream &stream) {
// Verify the header and get the container's size
if (!_header.verifyReadSize(stream))
return false;
// The part count has to be correct
if (stream.readUint32LE() != _partCount)
return false;
// Iterate over all parts
for (PartIterator it = _parts.begin(); it != _parts.end(); ++it) {
// Read the size
uint32 size = stream.readUint32LE();
if (stream.err()) {
clear();
return false;
}
Part *&p = *it;
delete p;
// Create a suitable part
p = new Part(size);
}
// Update size
_header.setSize(calcSize());
// Iterate over all parts
for (PartIterator it = _parts.begin(); it != _parts.end(); ++it) {
Part *&p = *it;
// Read the part
if (stream.read(p->data, p->size) != p->size) {
clear();
return false;
}
}
return !stream.err();
}
/**
* Read a cmd structure from Hugo.dat
*/
void Parser::readCmd(Common::ReadStream &in, cmd &curCmd) {
curCmd.verbIndex = in.readUint16BE();
curCmd.reqIndex = in.readUint16BE();
curCmd.textDataNoCarryIndex = in.readUint16BE();
curCmd.reqState = in.readByte();
curCmd.newState = in.readByte();
curCmd.textDataWrongIndex = in.readUint16BE();
curCmd.textDataDoneIndex = in.readUint16BE();
curCmd.actIndex = in.readUint16BE();
}
void HiRes5Engine::loadSong(Common::ReadStream &stream) {
while (true) {
const byte period = stream.readByte();
if (stream.err() || stream.eos())
error("Error loading song");
if (period == 0xff)
return;
byte length = stream.readByte();
if (stream.err() || stream.eos())
error("Error loading song");
const uint kLoopCycles = 20; // Delay loop cycles
double freq = 0.0;
// This computation ignores CPU cycles spent on overflow handling and
// speaker control. As a result, our tone frequencies will be slightly
// higher than those on original hardware.
if (period != 0)
freq = kClock / 2.0 / (period * kLoopCycles);
const double len = (length > 0 ? length - 1 : 255) * 256 * kLoopCycles * 1000 / (double)kClock;
_song.push_back(Tone(freq, len));
}
}
/**
* Read _backgrounObjects from Hugo.dat
*/
void Parser::loadBackgroundObjects(Common::ReadStream &in) {
background_t tmpBG;
memset(&tmpBG, 0, sizeof(tmpBG));
for (int varnt = 0; varnt < _vm->_numVariant; varnt++) {
uint16 numElem = in.readUint16BE();
if (varnt == _vm->_gameVariant) {
_backgroundObjectsSize = numElem;
_backgroundObjects = (background_t **)malloc(sizeof(background_t *) * numElem);
}
for (int i = 0; i < numElem; i++) {
uint16 numSubElem = in.readUint16BE();
if (varnt == _vm->_gameVariant)
_backgroundObjects[i] = (background_t *)malloc(sizeof(background_t) * numSubElem);
for (int j = 0; j < numSubElem; j++)
readBG(in, (varnt == _vm->_gameVariant) ? _backgroundObjects[i][j] : tmpBG);
}
}
}
/**
* Load hotspots data from hugo.dat
*/
void MouseHandler::loadHotspots(Common::ReadStream &in) {
Hotspot *wrkHotspots = 0;
Hotspot tmp;
memset(&tmp, 0, sizeof(tmp));
for (int varnt = 0; varnt < _vm->_numVariant; varnt++) {
int numRows = in.readUint16BE();
if (varnt == _vm->_gameVariant)
_hotspots = wrkHotspots = (Hotspot *)malloc(sizeof(Hotspot) * numRows);
for (int i = 0; i < numRows; i++)
readHotspot(in, (varnt == _vm->_gameVariant) ? wrkHotspots[i] : tmp);
}
}
void Graphics_v1::drawCorners(Common::ReadStream &corners, const Common::Point &pos, byte rotation, byte scaling, byte color) const {
const byte stepping[] = {
0xff, 0xfe, 0xfa, 0xf4, 0xec, 0xe1, 0xd4, 0xc5,
0xb4, 0xa1, 0x8d, 0x78, 0x61, 0x49, 0x31, 0x18,
0xff
};
byte quadrant = rotation >> 4;
rotation &= 0xf;
byte xStep = stepping[rotation];
byte yStep = stepping[(rotation ^ 0xf) + 1] + 1;
Common::Point p(pos);
while (true) {
byte b = corners.readByte();
if (corners.eos() || corners.err())
error("Error reading corners");
if (b == 0)
return;
do {
byte xFrac = 0x80;
byte yFrac = 0x80;
for (uint j = 0; j < scaling; ++j) {
if (xFrac + xStep + 1 > 255)
drawCornerPixel(p, color, b, quadrant);
xFrac += xStep + 1;
if (yFrac + yStep > 255)
drawCornerPixel(p, color, b, quadrant + 1);
yFrac += yStep;
}
b >>= 3;
} while (b != 0);
}
}
bool LureEngine::loadGame(uint8 slotNumber) {
Common::ReadStream *f = this->_saveFileMan->openForLoading(
generateSaveName(slotNumber));
if (f == NULL)
return false;
// Check for header
char buffer[5];
f->read(buffer, 5);
if (memcmp(buffer, "lure", 5) != 0) {
warning(FAILED_MSG, slotNumber);
delete f;
return false;
}
// Check language version
uint8 language = f->readByte();
_saveVersion = f->readByte();
if ((language != getLureLanguage()) || (_saveVersion < LURE_MIN_SAVEGAME_MINOR)) {
warning("loadGame: Failed to load slot %d - incorrect version", slotNumber);
delete f;
return false;
}
// Read in and discard the savegame caption
while (f->readByte() != 0)
;
// Load in the data
Resources::getReference().loadFromStream(f);
Game::getReference().loadFromStream(f);
Sound.loadFromStream(f);
Fights.loadFromStream(f);
Room::getReference().loadFromStream(f);
delete f;
return true;
}
/**
* Read _catchallList from Hugo.dat
*/
void Parser::loadCatchallList(Common::ReadStream &in) {
background_t *wrkCatchallList = 0;
background_t tmpBG;
memset(&tmpBG, 0, sizeof(tmpBG));
for (int varnt = 0; varnt < _vm->_numVariant; varnt++) {
uint16 numElem = in.readUint16BE();
if (varnt == _vm->_gameVariant)
_catchallList = wrkCatchallList = (background_t *)malloc(sizeof(background_t) * numElem);
for (int i = 0; i < numElem; i++)
readBG(in, (varnt == _vm->_gameVariant) ? wrkCatchallList[i] : tmpBG);
}
}
void MouseHandler::readHotspot(Common::ReadStream &in, Hotspot &hotspot) {
hotspot._screenIndex = in.readSint16BE();
hotspot._x1 = in.readSint16BE();
hotspot._y1 = in.readSint16BE();
hotspot._x2 = in.readSint16BE();
hotspot._y2 = in.readSint16BE();
hotspot._actIndex = in.readUint16BE();
hotspot._viewx = in.readSint16BE();
hotspot._viewy = in.readSint16BE();
hotspot._direction = in.readSint16BE();
}
bool SaveHeader::read(Common::ReadStream &stream) {
// Read the header and verify the global IDs
if (stream.readUint32BE() != kID1)
return false;
if (stream.readUint32BE() != kID2)
return false;
_type = stream.readUint32BE();
_version = stream.readUint32LE();
_size = stream.readUint32LE();
return !stream.err();
}
/*-----------------------------------------------------------------------
* BtPage
*-----------------------------------------------------------------------*/
void BtPage::readBTree(Common::ReadStream &s) {
_header._count = s.readUint16LE();
_header._down = s.readUint16LE();
if (_header._down == kBtValNone) {
// Leaf list
for (int i = 0; i < kBtLeafCount; ++i) {
s.read(_leaf[i]._key, kBtKeySize);
_leaf[i]._pos = s.readUint32LE();
_leaf[i]._size = s.readUint16LE();
}
} else {
// Root index
for (int i = 0; i < kBtInnerCount; ++i) {
s.read(_inner[i]._key, kBtKeySize);
_inner[i]._down = s.readUint16LE();
}
}
}
bool SaveHeader::verify(Common::ReadStream &stream) const {
// Compare the header with the stream's content
if (stream.readUint32BE() != kID1)
return false;
if (stream.readUint32BE() != kID2)
return false;
if (stream.readUint32BE() != _type)
return false;
if (stream.readUint32LE() != _version)
return false;
if (stream.readUint32LE() != _size)
return false;
return !stream.err();
}
bool SaveHeader::verifyReadSize(Common::ReadStream &stream) {
// Compare the header with the stream's content, expect for the size
if (stream.readUint32BE() != kID1)
return false;
if (stream.readUint32BE() != kID2)
return false;
if (stream.readUint32BE() != _type)
return false;
if (stream.readUint32LE() != _version)
return false;
// Read the size out of the stream instead
_size = stream.readUint32LE();
return !stream.err();
}