void ScummEngine_v0::drawSentenceLine() {
_redrawSentenceLine = false;
if (!(_userState & USERSTATE_IFACE_SENTENCE))
return;
clearSentenceLine();
if (_activeVerb == kVerbNewKid) {
_sentenceBuf = "";
for (int i = 0; i < 3; ++i) {
const char *actorName;
int actorId = VAR(97 + i);
if (actorId == 0) {
// after usage of the radiation suit, kid vars are set to 0
actorName = " ";
} else {
Actor *a = derefActor(actorId, "drawSentenceLine");
actorName = (const char *)a->getActorName();
}
_sentenceBuf += Common::String::format("%-13s", actorName);
}
flushSentenceLine();
return;
}
// Current Verb
if (_activeVerb == kVerbNone)
_activeVerb = kVerbWalkTo;
char *verbName = (char *)getResourceAddress(rtVerb, _activeVerb);
assert(verbName);
_sentenceBuf = verbName;
if (_activeObject) {
// Draw the 1st active object
drawSentenceObject(_activeObject);
// Append verb preposition
int sentencePrep = activeVerbPrep();
if (sentencePrep) {
drawPreposition(sentencePrep);
// Draw the 2nd active object
if (_activeObject2)
drawSentenceObject(_activeObject2);
}
}
flushSentenceLine();
}
int ScummEngine_v71he::getStringCharWidth(byte chr) {
int charset = _string[0]._default.charset;
byte *ptr = getResourceAddress(rtCharset, charset);
assert(ptr);
ptr += 29;
int spacing = 0;
int offs = READ_LE_UINT32(ptr + chr * 4 + 4);
if (offs) {
spacing = ptr[offs] + (signed char)ptr[offs + 2];
}
return spacing;
}
int ScummEngine_v72he::getSoundResourceSize(ResId id) {
const byte *ptr;
int offs, size;
if (id > _numSounds) {
if (!((SoundHE *)_sound)->getHEMusicDetails(id, offs, size)) {
debug(0, "getSoundResourceSize: musicID %d not found", id);
return 0;
}
} else {
ptr = getResourceAddress(rtSound, id);
if (!ptr)
return 0;
if (READ_BE_UINT32(ptr) == MKTAG('R','I','F','F')) {
byte flags;
int rate;
size = READ_BE_UINT32(ptr + 4);
Common::MemoryReadStream stream(ptr, size);
if (!Audio::loadWAVFromStream(stream, size, rate, flags)) {
error("getSoundResourceSize: Not a valid WAV file");
}
} else {
ptr += 8 + READ_BE_UINT32(ptr + 12);
if (READ_BE_UINT32(ptr) == MKTAG('S','B','N','G')) {
ptr += READ_BE_UINT32(ptr + 4);
}
assert(READ_BE_UINT32(ptr) == MKTAG('S','D','A','T'));
size = READ_BE_UINT32(ptr + 4) - 8;
}
}
return size;
}
byte *ScummEngine_v72he::getStringAddress(ResId idx) {
byte *addr = getResourceAddress(rtString, idx);
if (addr == NULL)
return NULL;
return ((ScummEngine_v72he::ArrayHeader *)addr)->data;
}
byte *ScummEngine::get2byteCharPtr(int idx) {
switch (_language) {
case Common::KO_KOR:
idx = ((idx % 256) - 0xb0) * 94 + (idx / 256) - 0xa1;
break;
case Common::JA_JPN:
if (_game.id == GID_LOOM && _game.platform == Common::kPlatformPCEngine) {
idx = SJIStoPCEChunk((idx % 256), (idx / 256));
return _2byteFontPtr + (_2byteWidth * _2byteHeight / 8) * idx;
} else if (_game.id == GID_MONKEY && _game.platform == Common::kPlatformSegaCD && _language == Common::JA_JPN) {
// init pointer to charset resource
if (_2byteFontPtr[0] == 0xFF) {
int charsetId = 5;
int numChar = 1413;
byte *charsetPtr = getResourceAddress(rtCharset, charsetId);
if (charsetPtr == 0)
error("ScummEngine::get2byteCharPtr: charset %d not found", charsetId);
memcpy(_2byteFontPtr, charsetPtr + 46, _2byteWidth * _2byteHeight * numChar / 8);
}
idx = (SWAP_CONSTANT_16(idx) & 0x7fff) - 1;
}
break;
case Common::ZH_TWN:
{
int base = 0;
byte low = idx % 256;
int high = 0;
if (low >= 0x20 && low <= 0x7e) {
base = (3 * low + 81012) * 5;
} else {
if (low >= 0xa1 && low <= 0xa3) {
base = 392820;
low += 0x5f;
} else if (low >= 0xa4 && low <= 0xc6) {
base = 0;
low += 0x5c;
} else if (low >= 0xc9 && low <= 0xf9) {
base = 162030;
low += 0x37;
} else {
base = 392820;
low = 0xff;
}
if (low != 0xff) {
high = idx / 256;
if (high >= 0x40 && high <= 0x7e) {
high -= 0x40;
} else {
high -= 0x62;
}
base += (low * 0x9d + high) * 30;
}
}
return _2byteFontPtr + base;
}
case Common::ZH_CNA:
idx = ((idx % 256) - 0xa1)* 94 + ((idx / 256) - 0xa1);
break;
default:
idx = 0;
}
return _2byteFontPtr + ((_2byteWidth + 7) / 8) * _2byteHeight * idx;
}
void ScummEngine_v80he::createSound(int snd1id, int snd2id) {
byte *snd1Ptr, *snd2Ptr;
byte *sbng1Ptr, *sbng2Ptr;
byte *sdat1Ptr, *sdat2Ptr;
byte *src, *dst, *tmp;
int len, offs, size;
int sdat1size, sdat2size;
sbng1Ptr = NULL;
sbng2Ptr = NULL;
if (snd2id == -1) {
_sndPtrOffs = 0;
_sndTmrOffs = 0;
_sndDataSize = 0;
return;
}
if (snd1id != _curSndId) {
_curSndId = snd1id;
_sndPtrOffs = 0;
_sndTmrOffs = 0;
_sndDataSize = 0;
}
snd1Ptr = getResourceAddress(rtSound, snd1id);
assert(snd1Ptr);
snd2Ptr = getResourceAddress(rtSound, snd2id);
assert(snd2Ptr);
int i;
int chan = -1;
for (i = 0; i < ARRAYSIZE(((SoundHE *)_sound)->_heChannel); i++) {
if (((SoundHE *)_sound)->_heChannel[i].sound == snd1id)
chan = i;
}
if (!findSoundTag(MKTAG('d','a','t','a'), snd1Ptr)) {
sbng1Ptr = heFindResource(MKTAG('S','B','N','G'), snd1Ptr);
sbng2Ptr = heFindResource(MKTAG('S','B','N','G'), snd2Ptr);
}
if (sbng1Ptr != NULL && sbng2Ptr != NULL) {
if (chan != -1 && ((SoundHE *)_sound)->_heChannel[chan].codeOffs > 0) {
int curOffs = ((SoundHE *)_sound)->_heChannel[chan].codeOffs;
src = snd1Ptr + curOffs;
dst = sbng1Ptr + 8;
size = READ_BE_UINT32(sbng1Ptr + 4);
len = sbng1Ptr - snd1Ptr + size - curOffs;
byte *data = (byte *)malloc(len);
memcpy(data, src, len);
memcpy(dst, data, len);
free(data);
dst = sbng1Ptr + 8;
while ((size = READ_LE_UINT16(dst)) != 0)
dst += size;
} else {
dst = sbng1Ptr + 8;
}
((SoundHE *)_sound)->_heChannel[chan].codeOffs = sbng1Ptr - snd1Ptr + 8;
tmp = sbng2Ptr + 8;
while ((offs = READ_LE_UINT16(tmp)) != 0) {
tmp += offs;
}
src = sbng2Ptr + 8;
len = tmp - sbng2Ptr - 6;
memcpy(dst, src, len);
int32 time;
while ((size = READ_LE_UINT16(dst)) != 0) {
time = READ_LE_UINT32(dst + 2);
time += _sndTmrOffs;
WRITE_LE_UINT32(dst + 2, time);
dst += size;
}
}
if (findSoundTag(MKTAG('d','a','t','a'), snd1Ptr)) {
sdat1Ptr = findSoundTag(MKTAG('d','a','t','a'), snd1Ptr);
assert(sdat1Ptr);
sdat2Ptr = findSoundTag(MKTAG('d','a','t','a'), snd2Ptr);
assert(sdat2Ptr);
if (!_sndDataSize)
_sndDataSize = READ_LE_UINT32(sdat1Ptr + 4) - 8;
sdat2size = READ_LE_UINT32(sdat2Ptr + 4) - 8;
} else {
sdat1Ptr = heFindResource(MKTAG('S','D','A','T'), snd1Ptr);
assert(sdat1Ptr);
sdat2Ptr = heFindResource(MKTAG('S','D','A','T'), snd2Ptr);
assert(sdat2Ptr);
_sndDataSize = READ_BE_UINT32(sdat1Ptr + 4) - 8;
sdat2size = READ_BE_UINT32(sdat2Ptr + 4) - 8;
}
sdat1size = _sndDataSize - _sndPtrOffs;
if (sdat2size < sdat1size) {
src = sdat2Ptr + 8;
dst = sdat1Ptr + 8 + _sndPtrOffs;
len = sdat2size;
memcpy(dst, src, len);
_sndPtrOffs += sdat2size;
_sndTmrOffs += sdat2size;
} else {
src = sdat2Ptr + 8;
dst = sdat1Ptr + 8 + _sndPtrOffs;
len = sdat1size;
memcpy(dst, src, len);
if (sdat2size != sdat1size) {
src = sdat2Ptr + 8 + sdat1size;
dst = sdat1Ptr + 8;
len = sdat2size - sdat1size;
memcpy(dst, src, len);
}
_sndPtrOffs = sdat2size - sdat1size;
_sndTmrOffs += sdat2size;
}
}
