libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-02-23 04:33:09 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

CHEWY: More renaming in atds.h

Browse Source
This commit is contained in:
Strangerke 2022-03-11 00:07:29 +01:00
parent b8aa4aedba
commit 6e870796a9
67 changed files with 478 additions and 479 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
engines/chewy/ani_dat.h
View File

@ -26,10 +26,10 @@ namespace Chewy {
#define SIB_CABLE_R1 1
#define SIB_MONOCLE 6
#define SIB_GBUCH 7
#define SIB_NOTEBOOK 7
#define SIB_TERMINAL_R5 8
#define SIB_BUTTON_R5 9
#define SIB_TUERE_R5 10
#define SIB_DOOR_R5 10
#define SIB_TBUTTON1_R6 11
#define SIB_SEIL 12
#define SIB_TBUTTON2_R6 13

426
engines/chewy/atds.cpp
View File

@ -89,7 +89,7 @@ bool AtsStrHeader::load(Common::SeekableReadStream *src) {
Atdsys::Atdsys() {
SplitStringInit init_ssi = { nullptr, 0, 0, 220, 4, SPLIT_MITTE, 8, 8,};
SplitStringInit init_ssi = { nullptr, 0, 0, 220, 4, SPLIT_CENTER, 8, 8,};
_aadv._dialog = false;
_aadv._strNr = -1;
_aadv._silentCount = false;
@ -102,9 +102,9 @@ Atdsys::Atdsys() {
_atdsv._delay = &_tmpDelay;
_tmpDelay = 1;
_atdsv._silent = false;
_atdsv.Display = DISPLAY_TXT;
_atdsv._display = DISPLAY_TXT;
_atdsv._diaNr = -1;
_atdsv.aad_str = 0;
_atdsv.aad_str = nullptr;
_atdsv._vocNr = -1;
_atdsv._eventsEnabled = true;
_ssret._next = false;
@ -137,8 +137,8 @@ void Atdsys::set_delay(int16 *delay, int16 silent) {
}
void Atdsys::set_string_end_func
(void (*str_func)(int16 dia_nr, int16 str_nr, int16 person_nr, int16 mode)) {
_atdsv.aad_str = str_func;
(void (*strFunc)(int16 diaNr, int16 strNr, int16 personNr, int16 mode)) {
_atdsv.aad_str = strFunc;
}
void Atdsys::setHasSpeech(bool hasSpeech) {
@ -148,16 +148,16 @@ void Atdsys::setHasSpeech(bool hasSpeech) {
void Atdsys::updateSoundSettings() {
if (!_hasSpeech)
_atdsv.Display = DISPLAY_TXT;
_atdsv._display = DISPLAY_TXT;
else
_atdsv.Display = g_engine->_sound->getSpeechSubtitlesMode();
_atdsv._display = g_engine->_sound->getSpeechSubtitlesMode();
}
int16 Atdsys::get_delay(int16 txt_len) {
int16 z_len = (_ssi->_width / _ssi->Fvorx) + 1;
int16 max_len = z_len * _ssi->_lines;
if (txt_len > max_len)
txt_len = max_len;
int16 maxLen = z_len * _ssi->_lines;
if (txt_len > maxLen)
txt_len = maxLen;
int16 ret = *_atdsv._delay * (txt_len + z_len);
return ret;
@ -174,10 +174,10 @@ SplitStringRet *Atdsys::split_string(SplitStringInit *ssi_) {
char *str_adr = ssi_->_str;
int16 count = 0;
int16 tmp_count = 0;
bool ende = false;
bool endLoop = false;
char *start_adr = str_adr;
while (!ende) {
while (!endLoop) {
switch (*str_adr) {
case 0:
if (str_adr[1] != ATDS_END_TEXT) {
@ -197,25 +197,25 @@ SplitStringRet *Atdsys::split_string(SplitStringInit *ssi_) {
} else {
_splitPtr[_ssret._nr] = start_adr;
start_adr[tmp_count] = 0;
if (ssi_->_mode == SPLIT_MITTE)
if (ssi_->_mode == SPLIT_CENTER)
_splitX[_ssret._nr] = ssi_->_x + ((ssi_->_width - (strlen(start_adr) * ssi_->Fvorx)) >> 1);
else
_splitX[_ssret._nr] = ssi_->_x;
++_ssret._nr;
if (_ssret._nr == ssi_->_lines) {
ende = true;
bool ende1 = false;
while (!ende1) {
endLoop = true;
bool endInnerLoop = false;
while (!endInnerLoop) {
if (*str_adr == ATDS_END_TEXT)
ende1 = true;
endInnerLoop = true;
else if (*str_adr != ' ' && *str_adr != 0) {
ende1 = true;
endInnerLoop = true;
_ssret._next = true;
}
++str_adr;
}
} else if (*str_adr == 0 && count < zeichen_anz) {
ende = true;
endLoop = true;
} else {
str_adr = start_adr + tmp_count + 1;
start_adr = str_adr;
@ -240,11 +240,11 @@ SplitStringRet *Atdsys::split_string(SplitStringInit *ssi_) {
if ((_ssret._nr + test_zeilen) >= ssi_->_lines) {
if (count < zeichen_anz) {
tmp_count = count;
ende = true;
endLoop = true;
}
_splitPtr[_ssret._nr] = start_adr;
start_adr[tmp_count] = 0;
if (ssi_->_mode == SPLIT_MITTE)
if (ssi_->_mode == SPLIT_CENTER)
_splitX[_ssret._nr] = ssi_->_x + ((ssi_->_width - (strlen(start_adr) * ssi_->Fvorx)) >> 1);
else
_splitX[_ssret._nr] = ssi_->_x;
@ -259,7 +259,7 @@ SplitStringRet *Atdsys::split_string(SplitStringInit *ssi_) {
}
++str_adr;
}
if (!ende) {
if (!endLoop) {
str_adr = start_adr + tmp_count + 1;
start_adr = str_adr;
count = 0;
@ -287,11 +287,11 @@ SplitStringRet *Atdsys::split_string(SplitStringInit *ssi_) {
return &_ssret;
}
void Atdsys::str_null2leer(char *str_start, char *str_end) {
while (str_start < str_end) {
if (*str_start == 0)
*str_start = 32;
++str_start;
void Atdsys::str_null2leer(char *strStart, char *strEnd) {
while (strStart < strEnd) {
if (*strStart == 0)
*strStart = 32;
++strStart;
}
}
@ -321,24 +321,24 @@ Common::Stream *Atdsys::pool_handle(const char *fname) {
Common::File *f = new Common::File();
f->open(fname);
if (f->isOpen()) {
_atdshandle[ATDS_HANDLE] = f;
_atdsHandle[ATDS_HANDLE] = f;
} else {
error("Error reading from %s", fname);
}
return f;
}
void Atdsys::set_handle(const char *fname, int16 mode, Common::Stream *handle, int16 chunk_start, int16 chunk_anz) {
void Atdsys::set_handle(const char *fname, int16 mode, Common::Stream *handle, int16 chunkStart, int16 chunkNr) {
Common::SeekableReadStream *rs = dynamic_cast<Common::SeekableReadStream *>(handle);
ChunkHead Ch;
char *tmp_adr = atds_adr(fname, chunk_start, chunk_anz);
char *tmp_adr = atds_adr(fname, chunkStart, chunkNr);
if (rs) {
_atdshandle[mode] = rs;
_atdsmem[mode] = tmp_adr;
_atdspooloff[mode] = chunk_start;
_atdsHandle[mode] = rs;
_atdsMem[mode] = tmp_adr;
_atdsPoolOff[mode] = chunkStart;
switch (mode) {
case INV_USE_DATA:
_G(mem)->file->selectPoolItem(rs, _atdspooloff[mode]);
_G(mem)->file->selectPoolItem(rs, _atdsPoolOff[mode]);
rs->seek(-ChunkHead::SIZE(), SEEK_CUR);
if (!Ch.load(rs)) {
@ -367,14 +367,14 @@ void Atdsys::open_handle(const char *fname, int16 mode) {
char *tmp_adr = nullptr;
if (mode == ADH_DATA) {
if (_atdsmem[mode])
free(_atdsmem[mode]);
if (_atdsMem[mode])
free(_atdsMem[mode]);
// Set to nullptr on purpose, this shouldn't be used
_atdshandle[mode] = nullptr;
_atdsHandle[mode] = nullptr;
// +3 bytes to signify the end of the stream (BLOCKENDE)
_atdsmem[mode] = (char *)MALLOC(MAX_DIALOG_DATA_SIZE + 3);
_adsBlock = (AdsBlock *)_atdsmem[mode];
_atdsMem[mode] = (char *)MALLOC(MAX_DIALOG_DATA_SIZE + 3);
_adsBlock = (AdsBlock *)_atdsMem[mode];
return;
}
@ -385,39 +385,39 @@ void Atdsys::open_handle(const char *fname, int16 mode) {
f->open(fname);
if (f->isOpen()) {
close_handle(mode);
_atdshandle[mode] = f;
_atdsmem[mode] = tmp_adr;
_atdsHandle[mode] = f;
_atdsMem[mode] = tmp_adr;
if (mode == INV_IDX_DATA)
_atdsmem[INV_IDX_HANDLE] = (char *)MALLOC(INV_STRC_NR * sizeof(InvUse));
_atdsMem[INV_IDX_HANDLE] = (char *)MALLOC(INV_STRC_NR * sizeof(InvUse));
} else {
error("Error reading from %s", fname);
}
}
void Atdsys::close_handle(int16 mode) {
Common::Stream *stream = _atdshandle[mode];
Common::Stream *stream = _atdsHandle[mode];
if (stream) {
delete _atdshandle[mode];
_atdshandle[mode] = nullptr;
delete _atdsHandle[mode];
_atdsHandle[mode] = nullptr;
for (int i = 0; i < MAX_HANDLE; ++i) {
if (i == ADH_HANDLE)
continue;
if (_atdshandle[i] == stream)
_atdshandle[i] = nullptr;
if (_atdsHandle[i] == stream)
_atdsHandle[i] = nullptr;
}
}
if (_atdsmem[mode])
free(_atdsmem[mode]);
_atdsmem[mode] = nullptr;
if (_atdsMem[mode])
free(_atdsMem[mode]);
_atdsMem[mode] = nullptr;
}
char *Atdsys::atds_adr(const char *fname, int16 chunk_start, int16 chunk_anz) {
char *Atdsys::atds_adr(const char *fname, int16 chunkStart, int16 chunkNr) {
char *tmp_adr = nullptr;
uint32 size = _G(mem)->file->getPoolSize(fname, chunk_start, chunk_anz);
uint32 size = _G(mem)->file->getPoolSize(fname, chunkStart, chunkNr);
if (size) {
tmp_adr = (char *)MALLOC(size + 3);
}
@ -425,15 +425,15 @@ char *Atdsys::atds_adr(const char *fname, int16 chunk_start, int16 chunk_anz) {
return tmp_adr;
}
void Atdsys::load_atds(int16 chunk_nr, int16 mode) {
char *txt_adr = _atdsmem[mode];
void Atdsys::load_atds(int16 chunkNr, int16 mode) {
char *txt_adr = _atdsMem[mode];
if (mode == ADH_DATA) {
Chunk *chunk = _dialogResource->getChunk(chunk_nr);
uint8 *chunkData = _dialogResource->getChunkData(chunk_nr);
Chunk *chunk = _dialogResource->getChunk(chunkNr);
uint8 *chunkData = _dialogResource->getChunkData(chunkNr);
assert(chunk->size <= MAX_DIALOG_DATA_SIZE);
memcpy(_atdsmem[ADH_HANDLE], chunkData, chunk->size);
memcpy(_atdsMem[ADH_HANDLE], chunkData, chunk->size);
delete[] chunkData;
txt_adr[chunk->size] = (char)BLOCKENDE;
@ -443,10 +443,10 @@ void Atdsys::load_atds(int16 chunk_nr, int16 mode) {
}
ChunkHead Ch;
Common::SeekableReadStream *stream = dynamic_cast<Common::SeekableReadStream *>(_atdshandle[mode]);
Common::SeekableReadStream *stream = dynamic_cast<Common::SeekableReadStream *>(_atdsHandle[mode]);
if (stream && txt_adr) {
_G(mem)->file->selectPoolItem(stream, chunk_nr + _atdspooloff[mode]);
_G(mem)->file->selectPoolItem(stream, chunkNr + _atdsPoolOff[mode]);
stream->seek(-ChunkHead::SIZE(), SEEK_CUR);
if (!Ch.load(stream)) {
error("load_atds error");
@ -467,8 +467,8 @@ void Atdsys::load_atds(int16 chunk_nr, int16 mode) {
}
}
void Atdsys::save_ads_header(int16 dia_nr) {
_dialogResource->updateChunk(dia_nr, (byte *)_atdsmem[ADH_HANDLE]);
void Atdsys::save_ads_header(int16 diaNr) {
_dialogResource->updateChunk(diaNr, (byte *)_atdsMem[ADH_HANDLE]);
}
void Atdsys::crypt(char *txt, uint32 size) {
@ -479,22 +479,22 @@ void Atdsys::crypt(char *txt, uint32 size) {
}
}
void Atdsys::init_ats_mode(int16 mode, uint8 *atsheader) {
void Atdsys::init_ats_mode(int16 mode, uint8 *atsHeader) {
switch (mode) {
case ATS_DATA:
_ats_st_header[0] = atsheader;
_ats_st_header[0] = atsHeader;
break;
case INV_USE_DATA:
_ats_st_header[1] = atsheader;
_ats_st_header[1] = atsHeader;
break;
case INV_USE_DEF:
_ats_st_header[2] = atsheader;
_ats_st_header[2] = atsHeader;
break;
case INV_ATS_DATA:
_ats_st_header[3] = atsheader;
_ats_st_header[3] = atsHeader;
break;
default:
@ -506,22 +506,22 @@ void Atdsys::set_ats_mem(int16 mode) {
switch (mode) {
case ATS_DATA:
_ats_sheader = _ats_st_header[0];
_atsmem = _atdsmem[mode];
_atsMem = _atdsMem[mode];
break;
case INV_USE_DATA:
_ats_sheader = _ats_st_header[1];
_atsmem = _atdsmem[mode];
_atsMem = _atdsMem[mode];
break;
case INV_USE_DEF:
_ats_sheader = _ats_st_header[2];
_atsmem = _invUseMem;
_atsMem = _invUseMem;
break;
case INV_ATS_DATA:
_ats_sheader = _ats_st_header[3];
_atsmem = _atdsmem[mode];
_atsMem = _atdsMem[mode];
break;
default:
@ -529,32 +529,32 @@ void Atdsys::set_ats_mem(int16 mode) {
}
}
DisplayMode Atdsys::start_ats(int16 txt_nr, int16 txt_mode, int16 color, int16 mode, int16 *voc_nr) {
*voc_nr = -1;
DisplayMode Atdsys::start_ats(int16 txtNr, int16 txtMode, int16 color, int16 mode, int16 *vocNr) {
*vocNr = -1;
set_ats_mem(mode);
_atsv._display = DISPLAY_NONE;
if (_atsmem) {
if (_atsMem) {
if (_atsv._display != DISPLAY_NONE)
stop_ats();
int16 txt_anz;
_atsv._ptr = ats_get_txt(txt_nr, txt_mode, &txt_anz, mode);
_atsv._ptr = ats_get_txt(txtNr, txtMode, &txt_anz, mode);
if (_atsv._ptr) {
_atsv._display = _atdsv.Display;
_atsv._display = _atdsv._display;
char *ptr = _atsv._ptr;
_atsv._txtLen = 0;
while (*ptr++ != ATDS_END_TEXT)
++_atsv._txtLen;
*voc_nr = _atsv._strHeader._vocNr - ATDS_VOC_OFFSET;
*vocNr = _atsv._strHeader._vocNr - ATDS_VOC_OFFSET;
if ((byte)*_atsv._ptr == 248) {
// Special code for no message to display
_atsv._display = (_atdsv.Display == DISPLAY_TXT || *voc_nr == -1) ?
_atsv._display = (_atdsv._display == DISPLAY_TXT || *vocNr == -1) ?
DISPLAY_NONE : DISPLAY_VOC;
} else {
@ -563,8 +563,8 @@ DisplayMode Atdsys::start_ats(int16 txt_nr, int16 txt_mode, int16 color, int16 m
_atsv._color = color;
_mousePush = true;
if (*voc_nr == -1) {
_atsv._display = (_atdsv.Display == DISPLAY_VOC) ?
if (*vocNr == -1) {
_atsv._display = (_atdsv._display == DISPLAY_VOC) ?
DISPLAY_NONE : DISPLAY_TXT;
}
}
@ -582,7 +582,7 @@ DisplayMode &Atdsys::ats_get_status() {
return _atsv._display;
}
void Atdsys::print_ats(int16 x, int16 y, int16 scrx, int16 scry) {
void Atdsys::print_ats(int16 x, int16 y, int16 scrX, int16 scrY) {
if (_atsv._display == DISPLAY_TXT || _atsv._display == DISPLAY_ALL) {
if (_atdsv._eventsEnabled) {
switch (_G(in)->getSwitchCode()) {
@ -613,8 +613,8 @@ void Atdsys::print_ats(int16 x, int16 y, int16 scrx, int16 scry) {
_atsSsi._str = tmp_ptr;
_atsSsi.Fvorx = _G(fontMgr)->getFont()->getDataWidth();
_atsSsi.FHoehe = _G(fontMgr)->getFont()->getDataHeight();
_atsSsi._x = x - scrx;
_atsSsi._y = y - scry;
_atsSsi._x = x - scrX;
_atsSsi._y = y - scrY;
char *start_ptr = tmp_ptr;
str_null2leer(start_ptr, start_ptr + _atsv._txtLen - 1);
SplitStringInit tmp_ssi = _atsSsi;
@ -663,39 +663,39 @@ void Atdsys::print_ats(int16 x, int16 y, int16 scrx, int16 scry) {
}
}
char *Atdsys::ats_get_txt(int16 txt_nr, int16 txt_mode, int16 *txt_anz, int16 mode) {
char *Atdsys::ats_get_txt(int16 txtNr, int16 txtMode, int16 *retNr, int16 mode) {
char *str_ = nullptr;
set_ats_mem(mode);
_atsv._txtMode = txt_mode;
_atsv._txtMode = txtMode;
if (!get_steuer_bit(txt_nr, ATS_AKTIV_BIT, mode)) {
uint8 status = _ats_sheader[(txt_nr * MAX_ATS_STATUS) + (_atsv._txtMode + 1) / 2];
if (!getControlBit(txtNr, ATS_ACTIVE_BIT, mode)) {
uint8 status = _ats_sheader[(txtNr * MAX_ATS_STATUS) + (_atsv._txtMode + 1) / 2];
int16 ak_nybble = (_atsv._txtMode + 1) % 2;
uint8 lo_hi[2];
lo_hi[1] = status >> 4;
lo_hi[0] = status &= 15;
str_ = ats_search_block(_atsv._txtMode, _atsmem);
str_ = ats_search_block(_atsv._txtMode, _atsMem);
if (str_ != nullptr) {
ats_search_nr(txt_nr, &str_);
ats_search_nr(txtNr, &str_);
if (str_ != nullptr) {
ats_search_str(txt_anz, &lo_hi[ak_nybble], (uint8)_ats_sheader[txt_nr * MAX_ATS_STATUS], &str_);
ats_search_str(retNr, &lo_hi[ak_nybble], (uint8)_ats_sheader[txtNr * MAX_ATS_STATUS], &str_);
if (str_ != nullptr) {
status = 0;
lo_hi[1] <<= 4;
status |= lo_hi[0];
status |= lo_hi[1];
_ats_sheader[(txt_nr * MAX_ATS_STATUS) + (_atsv._txtMode + 1) / 2] = status;
_ats_sheader[(txtNr * MAX_ATS_STATUS) + (_atsv._txtMode + 1) / 2] = status;
}
}
}
}
// WORKAROUND: Proper word wrapping some inventory items' look desc
if (txt_mode == TXT_MARK_LOOK && str_ != nullptr) {
switch (txt_nr) {
if (txtMode == TXT_MARK_LOOK && str_ != nullptr) {
switch (txtNr) {
case CYB_KRONE_INV:
if (str_[37] == ' ' && str_[56] == '\0') {
str_[37] = '\0';
@ -711,7 +711,7 @@ char *Atdsys::ats_get_txt(int16 txt_nr, int16 txt_mode, int16 *txt_anz, int16 mo
case PAPIER_INV:
if (str_[32] == ' ') {
str_[32] = '\0';
*txt_anz = 2;
*retNr = 2;
}
break;
default:
@ -722,31 +722,31 @@ char *Atdsys::ats_get_txt(int16 txt_nr, int16 txt_mode, int16 *txt_anz, int16 mo
return str_;
}
void Atdsys::set_ats_str(int16 txt_nr, int16 txt_mode, int16 str_nr, int16 mode) {
void Atdsys::set_ats_str(int16 txtNr, int16 txtMode, int16 strNr, int16 mode) {
set_ats_mem(mode);
uint8 status = _ats_sheader[(txt_nr * MAX_ATS_STATUS) + (txt_mode + 1) / 2];
int16 ak_nybble = (txt_mode + 1) % 2;
uint8 status = _ats_sheader[(txtNr * MAX_ATS_STATUS) + (txtMode + 1) / 2];
int16 ak_nybble = (txtMode + 1) % 2;
uint8 lo_hi[2];
lo_hi[1] = status >> 4;
lo_hi[0] = status &= 15;
lo_hi[ak_nybble] = str_nr;
lo_hi[ak_nybble] = strNr;
status = 0;
lo_hi[1] <<= 4;
status |= lo_hi[0];
status |= lo_hi[1];
_ats_sheader[(txt_nr * MAX_ATS_STATUS) + (txt_mode + 1) / 2] = status;
_ats_sheader[(txtNr * MAX_ATS_STATUS) + (txtMode + 1) / 2] = status;
}
void Atdsys::set_ats_str(int16 txt_nr, int16 str_nr, int16 mode) {
void Atdsys::set_ats_str(int16 txtNr, int16 strNr, int16 mode) {
for (int16 i = 0; i < 5; i++)
set_ats_str(txt_nr, i, str_nr, mode);
set_ats_str(txtNr, i, strNr, mode);
}
int16 Atdsys::get_ats_str(int16 txt_nr, int16 txt_mode, int16 mode) {
int16 Atdsys::get_ats_str(int16 txtNr, int16 txtMode, int16 mode) {
set_ats_mem(mode);
uint8 status = _ats_sheader[(txt_nr * MAX_ATS_STATUS) + (txt_mode + 1) / 2];
int16 ak_nybble = (txt_mode + 1) % 2;
uint8 status = _ats_sheader[(txtNr * MAX_ATS_STATUS) + (txtMode + 1) / 2];
int16 ak_nybble = (txtMode + 1) % 2;
uint8 lo_hi[2];
lo_hi[1] = status >> 4;
@ -755,24 +755,24 @@ int16 Atdsys::get_ats_str(int16 txt_nr, int16 txt_mode, int16 mode) {
return (int16)lo_hi[ak_nybble];
}
int16 Atdsys::get_steuer_bit(int16 txt_nr, int16 bit_idx, int16 mode) {
int16 Atdsys::getControlBit(int16 txtNr, int16 bitIdx, int16 mode) {
set_ats_mem(mode);
int16 ret = _G(bit)->is_bit(_ats_sheader[txt_nr * MAX_ATS_STATUS], bit_idx);
int16 ret = _G(bit)->is_bit(_ats_sheader[txtNr * MAX_ATS_STATUS], bitIdx);
return ret;
}
void Atdsys::set_steuer_bit(int16 txt_nr, int16 bit_idx, int16 mode) {
void Atdsys::setControlBit(int16 txtNr, int16 bitIdx, int16 mode) {
set_ats_mem(mode);
_G(bit)->set_bit(&_ats_sheader[txt_nr * MAX_ATS_STATUS], bit_idx);
_G(bit)->set_bit(&_ats_sheader[txtNr * MAX_ATS_STATUS], bitIdx);
}
void Atdsys::del_steuer_bit(int16 txt_nr, int16 bit_idx, int16 mode) {
void Atdsys::delControlBit(int16 txtNr, int16 bitIdx, int16 mode) {
set_ats_mem(mode);
_G(bit)->del_bit(&_ats_sheader[txt_nr * MAX_ATS_STATUS], bit_idx);
_G(bit)->del_bit(&_ats_sheader[txtNr * MAX_ATS_STATUS], bitIdx);
}
char *Atdsys::ats_search_block(int16 txt_mode, char *txt_adr) {
char *strP = txt_adr;
char *Atdsys::ats_search_block(int16 txtMode, char *txtAdr) {
char *strP = txtAdr;
int ende = 0;
for (; !ende; ++strP) {
@ -781,7 +781,7 @@ char *Atdsys::ats_search_block(int16 txt_mode, char *txt_adr) {
strP[2] == (char)BLOCKENDE) {
ende = 2;
} else if (strP[0] == (char)0xf2 && strP[1] == (char)0xfe) {
if (strP[2] == (char)txt_mode)
if (strP[2] == (char)txtMode)
ende = 1;
strP += 2;
}
@ -793,7 +793,7 @@ char *Atdsys::ats_search_block(int16 txt_mode, char *txt_adr) {
return strP;
}
void Atdsys::ats_search_nr(int16 txt_nr, char **str) {
void Atdsys::ats_search_nr(int16 txtNr, char **str) {
char *start_str = *str;
bool done1 = false;
@ -802,7 +802,7 @@ void Atdsys::ats_search_nr(int16 txt_nr, char **str) {
_atsv._txtHeader.load(&rs1);
if (READ_LE_UINT16(start_str) == 0xFEF0 &&
_atsv._txtHeader._txtNr == txt_nr) {
_atsv._txtHeader._txtNr == txtNr) {
// Found match
*str = start_str + 2 + AtsTxtHeader::SIZE();
@ -839,19 +839,19 @@ void Atdsys::ats_search_nr(int16 txt_nr, char **str) {
}
}
void Atdsys::ats_search_str(int16 *anz, uint8 *status, uint8 steuer, char **str) {
void Atdsys::ats_search_str(int16 *nr, uint8 *status, uint8 controlByte, char **str) {
char *tmp_str = *str;
char *start_str = *str;
*anz = 0;
bool ende = false;
*nr = 0;
bool endLoop = false;
int16 count = 0;
while (!ende) {
while (!endLoop) {
if (count == *status) {
if (!*tmp_str) {
++*anz;
++*nr;
} else if (*tmp_str == ATDS_END_TEXT) {
ende = true;
endLoop = true;
*str = start_str;
start_str -= AtsStrHeader::SIZE();
@ -862,19 +862,19 @@ void Atdsys::ats_search_str(int16 *anz, uint8 *status, uint8 steuer, char **str)
}
if (tmp_str[1] != ATDS_END) {
if (!_G(bit)->is_bit(steuer, ATS_COUNT_BIT))
if (!_G(bit)->is_bit(controlByte, ATS_COUNT_BIT))
++*status;
} else {
if (_G(bit)->is_bit(steuer, ATS_RESET_BIT))
if (_G(bit)->is_bit(controlByte, ATS_RESET_BIT))
*status = 0;
}
}
} else {
if (*tmp_str == ATDS_END_TEXT) {
if (tmp_str[1] == ATDS_END) {
ende = false;
*anz = 0;
endLoop = false;
*nr = 0;
*status = count;
*str = start_str;
start_str -= AtsStrHeader::SIZE();
@ -893,8 +893,8 @@ void Atdsys::ats_search_str(int16 *anz, uint8 *status, uint8 steuer, char **str)
(tmp_str[0] == (char)BLOCKENDE &&
tmp_str[1] == (char)BLOCKENDE &&
tmp_str[2] == (char)BLOCKENDE)) {
ende = false;
*anz = 0;
endLoop = false;
*nr = 0;
*str = nullptr;
}
}
@ -903,13 +903,13 @@ void Atdsys::ats_search_str(int16 *anz, uint8 *status, uint8 steuer, char **str)
}
}
int16 Atdsys::start_aad(int16 dia_nr) {
int16 Atdsys::start_aad(int16 diaNr) {
if (_aadv._dialog)
stopAad();
if (_atdsmem[AAD_HANDLE]) {
_aadv._ptr = _atdsmem[AAD_HANDLE];
aad_search_dia(dia_nr, &_aadv._ptr);
if (_atdsMem[AAD_HANDLE]) {
_aadv._ptr = _atdsMem[AAD_HANDLE];
aad_search_dia(diaNr, &_aadv._ptr);
if (_aadv._ptr) {
_aadv._person.load(_aadv._ptr, _aadv._txtHeader->_perNr);
_aadv._ptr += _aadv._txtHeader->_perNr * sizeof(AadInfo);
@ -923,7 +923,7 @@ int16 Atdsys::start_aad(int16 dia_nr) {
_aadv._delayCount = get_delay(txt_len);
_printDelayCount1 = _aadv._delayCount / 10;
_atdsv._diaNr = dia_nr;
_atdsv._diaNr = diaNr;
if (_atdsv.aad_str != nullptr)
_atdsv.aad_str(_atdsv._diaNr, 0, _aadv._strHeader->_akPerson, AAD_STR_START);
_mousePush = true;
@ -940,7 +940,7 @@ void Atdsys::stopAad() {
_aadv._strNr = -1;
}
void Atdsys::print_aad(int16 scrx, int16 scry) {
void Atdsys::print_aad(int16 scrX, int16 scrY) {
if (_aadv._dialog) {
if (_atdsv._eventsEnabled) {
switch (_G(in)->getSwitchCode()) {
@ -971,10 +971,10 @@ void Atdsys::print_aad(int16 scrx, int16 scry) {
char *tmp_ptr = _aadv._ptr;
_ssi[_aadv._strHeader->_akPerson]._str = tmp_ptr;
if (_aadv._person[_aadv._strHeader->_akPerson]._x != -1) {
_ssi[_aadv._strHeader->_akPerson]._x = _aadv._person[_aadv._strHeader->_akPerson]._x - scrx;
_ssi[_aadv._strHeader->_akPerson]._x = _aadv._person[_aadv._strHeader->_akPerson]._x - scrX;
}
if (_aadv._person[_aadv._strHeader->_akPerson]._y != -1) {
_ssi[_aadv._strHeader->_akPerson]._y = _aadv._person[_aadv._strHeader->_akPerson]._y - scry;
_ssi[_aadv._strHeader->_akPerson]._y = _aadv._person[_aadv._strHeader->_akPerson]._y - scrY;
}
_ssi[_aadv._strHeader->_akPerson].Fvorx = _G(fontMgr)->getFont()->getDataWidth();
_ssi[_aadv._strHeader->_akPerson].FHoehe = _G(fontMgr)->getFont()->getDataHeight();
@ -985,7 +985,7 @@ void Atdsys::print_aad(int16 scrx, int16 scry) {
SplitStringInit tmp_ssi = _ssi[_aadv._strHeader->_akPerson];
_ssr = split_string(&tmp_ssi);
if (_atdsv.Display != DISPLAY_VOC ||
if (_atdsv._display != DISPLAY_VOC ||
(_aadv._strHeader->_vocNr - ATDS_VOC_OFFSET) == -1) {
for (int16 i = 0; i < _ssr->_nr; i++) {
_G(out)->printxy(_ssr->_x[i] + 1,
@ -1010,23 +1010,23 @@ void Atdsys::print_aad(int16 scrx, int16 scry) {
}
if (_atdsv.Display != DISPLAY_TXT &&
if (_atdsv._display != DISPLAY_TXT &&
(_aadv._strHeader->_vocNr - ATDS_VOC_OFFSET) != -1) {
if (_atdsv._vocNr != _aadv._strHeader->_vocNr - ATDS_VOC_OFFSET) {
_atdsv._vocNr = _aadv._strHeader->_vocNr - ATDS_VOC_OFFSET;
g_engine->_sound->playSpeech(_atdsv._vocNr,
_atdsv.Display == DISPLAY_VOC);
_atdsv._display == DISPLAY_VOC);
int16 vocx = _G(spieler_vector)[_aadv._strHeader->_akPerson].Xypos[0] -
_G(spieler).scrollx + _G(spieler_mi)[_aadv._strHeader->_akPerson].HotX;
g_engine->_sound->setSoundChannelBalance(0, getStereoPos(vocx));
if (_atdsv.Display == DISPLAY_VOC) {
if (_atdsv._display == DISPLAY_VOC) {
_aadv._strNr = -1;
_aadv._delayCount = 1;
}
}
if (_atdsv.Display != DISPLAY_ALL) {
if (_atdsv._display != DISPLAY_ALL) {
for (int16 i = 0; i < _ssr->_nr; i++) {
tmp_ptr += strlen(_ssr->_strPtr[i]) + 1;
}
@ -1039,7 +1039,7 @@ void Atdsys::print_aad(int16 scrx, int16 scry) {
while (*tmp_ptr == ' ' || *tmp_ptr == 0)
++tmp_ptr;
if (tmp_ptr[1] == ATDS_END ||
tmp_ptr[1] == ATDS_END_EINTRAG) {
tmp_ptr[1] == ATDS_END_ENTRY) {
if (_atdsv.aad_str != 0)
_atdsv.aad_str(_atdsv._diaNr, _aadv._strNr, _aadv._strHeader->_akPerson, AAD_STR_END);
_aadv._dialog = false;
@ -1068,11 +1068,11 @@ void Atdsys::print_aad(int16 scrx, int16 scry) {
_aadv._silentCount = _atdsv._silent;
}
} else {
if (_atdsv.Display != DISPLAY_VOC ||
if (_atdsv._display != DISPLAY_VOC ||
(_aadv._strHeader->_vocNr - ATDS_VOC_OFFSET) == -1)
--_aadv._delayCount;
else if (_atdsv.Display == DISPLAY_VOC) {
else if (_atdsv._display == DISPLAY_VOC) {
warning("FIXME - unknown constant SMP_PLAYING");
_aadv._delayCount = 0;
@ -1088,20 +1088,20 @@ int16 Atdsys::aadGetStatus() {
return _aadv._strNr;
}
int16 Atdsys::aad_get_zeilen(char *str, int16 *txt_len) {
*txt_len = 0;
int16 Atdsys::aad_get_zeilen(char *str, int16 *txtLen) {
*txtLen = 0;
char *ptr = str;
int16 zeilen = 0;
while (*str != ATDS_END_TEXT) {
if (*str++ == 0)
++zeilen;
}
*txt_len = (str - ptr) - 1;
*txtLen = (str - ptr) - 1;
return zeilen;
}
void Atdsys::aad_search_dia(int16 dia_nr, char **ptr) {
void Atdsys::aad_search_dia(int16 diaNr, char **ptr) {
char *start_ptr = *ptr;
if (start_ptr[0] == (char)BLOCKENDE &&
@ -1112,7 +1112,7 @@ void Atdsys::aad_search_dia(int16 dia_nr, char **ptr) {
bool ende = false;
while (!ende) {
uint16 *pos = (uint16 *)start_ptr;
if (pos[0] == dia_nr) {
if (pos[0] == diaNr) {
ende = true;
_aadv._txtHeader = (AadTxtHeader *)start_ptr;
*ptr = start_ptr + sizeof(AadTxtHeader);
@ -1141,27 +1141,27 @@ void Atdsys::aad_search_dia(int16 dia_nr, char **ptr) {
}
}
bool Atdsys::ads_start(int16 dia_nr) {
bool Atdsys::ads_start(int16 diaNr) {
bool ret = false;
load_atds(dia_nr, ADS_DATA);
load_atds(diaNr, ADS_DATA);
bool ende = false;
if (_atdsmem[ADS_HANDLE][0] == (char)BLOCKENDE &&
_atdsmem[ADS_HANDLE][1] == (char)BLOCKENDE &&
_atdsmem[ADS_HANDLE][2] == (char)BLOCKENDE)
if (_atdsMem[ADS_HANDLE][0] == (char)BLOCKENDE &&
_atdsMem[ADS_HANDLE][1] == (char)BLOCKENDE &&
_atdsMem[ADS_HANDLE][2] == (char)BLOCKENDE)
ende = true;
if (!ende) {
_adsv._ptr = _atdsmem[ADS_HANDLE];
_adsv._ptr = _atdsMem[ADS_HANDLE];
_adsv._txtHeader.load(_adsv._ptr);
if (_adsv._txtHeader._diaNr == dia_nr) {
if (_adsv._txtHeader._diaNr == diaNr) {
ret = true;
_adsv._ptr += AdsTxtHeader::SIZE();
_adsv._person.load(_adsv._ptr, _adsv._txtHeader._perNr);
_adsv._ptr += _adsv._txtHeader._perNr * AadInfo::SIZE();
_adsv._dialog = dia_nr;
_adsv._dialog = diaNr;
_adsv._strNr = 0;
_adsStack[0] = 0;
_adsStackPtr = 1;
@ -1180,12 +1180,12 @@ int16 Atdsys::ads_get_status() {
return _adsv._dialog;
}
int16 Atdsys::check_item(int16 block_nr, int16 item_nr) {
int16 Atdsys::check_item(int16 blockNr, int16 itemNr) {
int16 ret = true;
char *tmp_adr = _adsv._ptr;
ads_search_block(block_nr, &tmp_adr);
ads_search_block(blockNr, &tmp_adr);
if (tmp_adr) {
ads_search_item(item_nr, &tmp_adr);
ads_search_item(itemNr, &tmp_adr);
if (tmp_adr) {
ret = true;
}
@ -1193,12 +1193,12 @@ int16 Atdsys::check_item(int16 block_nr, int16 item_nr) {
return ret;
}
char **Atdsys::ads_item_ptr(int16 block_nr, int16 *anzahl) {
*anzahl = 0;
char **Atdsys::ads_item_ptr(int16 blockNr, int16 *retNr) {
*retNr = 0;
memset(_ePtr, 0, sizeof(char *) * ADS_MAX_BL_EIN);
if (_adsv._dialog != -1) {
_adsv._blkPtr = _adsv._ptr;
ads_search_block(block_nr, &_adsv._blkPtr);
ads_search_block(blockNr, &_adsv._blkPtr);
if (_adsv._blkPtr) {
for (int16 i = 0; i < ADS_MAX_BL_EIN; i++) {
char *tmp_adr = _adsv._blkPtr;
@ -1206,10 +1206,10 @@ char **Atdsys::ads_item_ptr(int16 block_nr, int16 *anzahl) {
if (tmp_adr) {
char nr = tmp_adr[-1];
tmp_adr += sizeof(AadStrHeader);
if (_adsBlock[block_nr]._show[(int16)nr] == true) {
_ePtr[*anzahl] = tmp_adr;
_eNr[*anzahl] = (int16)nr;
++(*anzahl);
if (_adsBlock[blockNr]._show[(int16)nr] == true) {
_ePtr[*retNr] = tmp_adr;
_eNr[*retNr] = (int16)nr;
++(*retNr);
}
}
}
@ -1219,17 +1219,17 @@ char **Atdsys::ads_item_ptr(int16 block_nr, int16 *anzahl) {
return _ePtr;
}
AdsNextBlk *Atdsys::ads_item_choice(int16 blk_nr, int16 item_nr) {
_adsnb._blkNr = blk_nr;
AdsNextBlk *Atdsys::ads_item_choice(int16 blockNr, int16 itemNr) {
_adsnb._blkNr = blockNr;
if (!_aadv._dialog) {
if (!_adsv._autoDia) {
ads_search_item(_eNr[item_nr], &_adsv._blkPtr);
ads_search_item(_eNr[itemNr], &_adsv._blkPtr);
if (_adsv._blkPtr) {
if (start_ads_auto_dia(_adsv._blkPtr))
_adsv._autoDia = true;
if (_G(bit)->is_bit((uint8)_adsBlock[blk_nr].Steuer[_eNr[item_nr]], ADS_EXIT_BIT) == true) {
if (_G(bit)->is_bit((uint8)_adsBlock[blockNr]._control[_eNr[itemNr]], ADS_EXIT_BIT) == true) {
stop_ads();
_adsnb._endNr = _eNr[item_nr];
_adsnb._endNr = _eNr[itemNr];
_adsnb._blkNr = -1;
}
}
@ -1239,17 +1239,17 @@ AdsNextBlk *Atdsys::ads_item_choice(int16 blk_nr, int16 item_nr) {
return &_adsnb;
}
AdsNextBlk *Atdsys::calc_next_block(int16 blk_nr, int16 item_nr) {
if (_G(bit)->is_bit((uint8)_adsBlock[blk_nr].Steuer[_eNr[item_nr]], ADS_SHOW_BIT) == false)
_adsBlock[blk_nr]._show[_eNr[item_nr]] = false;
_adsnb._endNr = _eNr[item_nr];
if (_G(bit)->is_bit((uint8)_adsBlock[blk_nr].Steuer[_eNr[item_nr]], ADS_RESTART_BIT) == true) {
AdsNextBlk *Atdsys::calc_next_block(int16 blockNr, int16 itemNr) {
if (_G(bit)->is_bit((uint8)_adsBlock[blockNr]._control[_eNr[itemNr]], ADS_SHOW_BIT) == false)
_adsBlock[blockNr]._show[_eNr[itemNr]] = false;
_adsnb._endNr = _eNr[itemNr];
if (_G(bit)->is_bit((uint8)_adsBlock[blockNr]._control[_eNr[itemNr]], ADS_RESTART_BIT) == true) {
_adsnb._blkNr = 0;
_adsStackPtr = 0;
} else {
if (_adsBlock[blk_nr]._next[_eNr[item_nr]]) {
_adsnb._blkNr = _adsBlock[blk_nr]._next[_eNr[item_nr]];
if (_adsBlock[blockNr]._next[_eNr[itemNr]]) {
_adsnb._blkNr = _adsBlock[blockNr]._next[_eNr[itemNr]];
int16 anzahl = 0;
while (!anzahl && _adsnb._blkNr != -1) {
@ -1290,11 +1290,11 @@ int16 Atdsys::return_block(AdsBlock *ab) {
return ret;
}
void Atdsys::ads_search_block(int16 blk_nr, char **ptr) {
void Atdsys::ads_search_block(int16 blockNr, char **ptr) {
char *start_ptr = *ptr;
bool ende = false;
while (!ende) {
if (*start_ptr == (char)blk_nr) {
if (*start_ptr == (char)blockNr) {
ende = true;
*ptr = start_ptr;
} else {
@ -1309,29 +1309,29 @@ void Atdsys::ads_search_block(int16 blk_nr, char **ptr) {
}
}
void Atdsys::ads_search_item(int16 item_nr, char **blk_adr) {
char *start_ptr = *blk_adr + 1;
void Atdsys::ads_search_item(int16 itemNr, char **blkAdr) {
char *start_ptr = *blkAdr + 1;
bool ende = false;
while (!ende) {
if (*start_ptr == item_nr) {
if (*start_ptr == itemNr) {
ende = true;
*blk_adr = start_ptr + 1;
*blkAdr = start_ptr + 1;
} else {
start_ptr += 1 + sizeof(AadStrHeader);
while (*start_ptr++ != ATDS_END_EINTRAG);
while (*start_ptr++ != ATDS_END_ENTRY);
if (*start_ptr == ATDS_END_BLOCK) {
ende = true;
*blk_adr = nullptr;
*blkAdr = nullptr;
}
}
}
}
int16 Atdsys::start_ads_auto_dia(char *item_adr) {
int16 Atdsys::start_ads_auto_dia(char *itemAdr) {
_aadv._dialog = false;
if (item_adr) {
if (itemAdr) {
_aadv._person = _adsv._person;
_aadv._ptr = item_adr;
_aadv._ptr = itemAdr;
_aadv._dialog = true;
_aadv._strNr = 0;
_aadv._strHeader = (AadStrHeader *)_aadv._ptr;
@ -1352,44 +1352,44 @@ int16 Atdsys::start_ads_auto_dia(char *item_adr) {
return _aadv._dialog;
}
void Atdsys::hide_item(int16 dia_nr, int16 blk_nr, int16 item_nr) {
if (_adsv._dialog == dia_nr) {
if (check_item(blk_nr, item_nr))
_adsBlock[blk_nr]._show[item_nr] = false;
void Atdsys::hide_item(int16 diaNr, int16 blockNr, int16 itemNr) {
if (_adsv._dialog == diaNr) {
if (check_item(blockNr, itemNr))
_adsBlock[blockNr]._show[itemNr] = false;
} else {
load_atds(dia_nr, ADH_DATA);
if (check_item(blk_nr, item_nr))
_adsBlock[blk_nr]._show[item_nr] = false;
save_ads_header(dia_nr);
load_atds(diaNr, ADH_DATA);
if (check_item(blockNr, itemNr))
_adsBlock[blockNr]._show[itemNr] = false;
save_ads_header(diaNr);
}
}
void Atdsys::show_item(int16 dia_nr, int16 blk_nr, int16 item_nr) {
if (_adsv._dialog == dia_nr) {
if (check_item(blk_nr, item_nr))
_adsBlock[blk_nr]._show[item_nr] = true;
void Atdsys::show_item(int16 diaNr, int16 blockNr, int16 itemNr) {
if (_adsv._dialog == diaNr) {
if (check_item(blockNr, itemNr))
_adsBlock[blockNr]._show[itemNr] = true;
} else {
load_atds(dia_nr, ADH_DATA);
if (check_item(blk_nr, item_nr))
_adsBlock[blk_nr]._show[item_nr] = true;
save_ads_header(dia_nr);
load_atds(diaNr, ADH_DATA);
if (check_item(blockNr, itemNr))
_adsBlock[blockNr]._show[itemNr] = true;
save_ads_header(diaNr);
}
}
int16 Atdsys::calc_inv_no_use(int16 cur_inv, int16 test_nr, int16 mode) {
int16 Atdsys::calc_inv_no_use(int16 curInv, int16 testNr, int16 mode) {
int16 txt_nr = -1;
if (cur_inv != -1) {
if (_invBlockNr != cur_inv) {
_invBlockNr = cur_inv + 1;
load_atds(_invBlockNr + _atdspooloff[mode], INV_USE_DATA);
if (curInv != -1) {
if (_invBlockNr != curInv) {
_invBlockNr = curInv + 1;
load_atds(_invBlockNr + _atdsPoolOff[mode], INV_USE_DATA);
Common::SeekableReadStream *rs = dynamic_cast<Common::SeekableReadStream *>(
_atdshandle[INV_IDX_HANDLE]);
_atdsHandle[INV_IDX_HANDLE]);
if (rs) {
rs->seek(InvUse::SIZE() * _invBlockNr
* INV_STRC_NR, SEEK_SET);
InvUse *iu = (InvUse *)_atdsmem[INV_IDX_HANDLE];
InvUse *iu = (InvUse *)_atdsMem[INV_IDX_HANDLE];
for (int16 i = 0; i < INV_STRC_NR; ++i, ++iu) {
if (!iu->load(rs)) {
error("calc_inv_no_use error");
@ -1401,12 +1401,12 @@ int16 Atdsys::calc_inv_no_use(int16 cur_inv, int16 test_nr, int16 mode) {
}
}
InvUse *iu = (InvUse *)_atdsmem[INV_IDX_HANDLE];
InvUse *iu = (InvUse *)_atdsMem[INV_IDX_HANDLE];
bool ok = false;
for (int16 i = 0; i < INV_STRC_NR && !ok; i++) {
if (iu[i]._objId == mode) {
if (iu[i]._objNr == test_nr) {
if (iu[i]._objNr == testNr) {
txt_nr = iu[i]._txtNr;
ok = true;
}

117
engines/chewy/atds.h
View File

@ -22,7 +22,6 @@
#ifndef CHEWY_ATDS_H
#define CHEWY_ATDS_H
#include "common/memstream.h"
#include "chewy/resource.h"
namespace Chewy {
@ -60,19 +59,19 @@ enum DisplayMode {
#define MAX_STR_SPLIT 10
#define SPLIT_MITTE 1
#define SPLIT_CENTER 1
#define SPLIT_LEFT 2
#define ATDS_END_ZEILE 0
#define ATDS_END_LINE 0
#define ATDS_END_BLOCK 0x0b
#define ATDS_END_EINTRAG 0x0c
#define ATDS_END_ENTRY 0x0c
#define ATDS_END_TEXT 0x0d
#define ATDS_END 0x0e
#define BLOCKENDE 0x0f
#define MAX_ATS_ROOM 100
#define ATS_AKTIV_BIT 1
#define ATS_ACTIVE_BIT 1
#define ATS_COUNT_BIT 2
#define ATS_RESET_BIT 4
#define ATS_ACTION_BIT 8
@ -85,7 +84,7 @@ enum DisplayMode {
#define TXT_MARK_WALK 3
#define TXT_MARK_TALK 4
#define STEUERBYTE 0xff
#define CONTROL_BYTE 0xff
#define MAX_ADS_DIALOG 500
#define ADS_MAX_BL_EIN 6
@ -106,20 +105,20 @@ struct AdsBlock {
bool _show[ADS_MAX_BL_EIN];
uint8 _next[ADS_MAX_BL_EIN];
uint8 Steuer[ADS_MAX_BL_EIN];
uint8 _control[ADS_MAX_BL_EIN];
} PACKED_STRUCT;
#include "common/pack-end.h" // END STRUCT PACKING
struct AtdsVar {
int16 _silent = 0;
int16 *_delay = 0;
int16 *_delay = nullptr;
int16 _diaNr = 0;
DisplayMode Display = DISPLAY_TXT;
DisplayMode _display = DISPLAY_TXT;
bool _eventsEnabled = false;
int16 _vocNr = 0;
void (*aad_str)(int16 dia_nr, int16 str_nr, int16 person_nr, int16 mode) = nullptr;
void (*aad_str)(int16 diaNr, int16 strNr, int16 personNr, int16 mode) = nullptr;
};
#define IUID_IIB 0
@ -268,59 +267,59 @@ public:
void set_split_win(int16 nr, int16 x, int16 y);
SplitStringRet *split_string(SplitStringInit *ssi);
void calc_txt_win(SplitStringInit *ssi);
void str_null2leer(char *str_start, char *str_end);
char *atds_adr(const char *fname, int16 chunk_start, int16 chunk_anz);
void load_atds(int16 chunk_nr, int16 mode);
void save_ads_header(int16 dia_nr);
void str_null2leer(char *strStart, char *strEnd);
char *atds_adr(const char *fname, int16 chunkStart, int16 chunkNr);
void load_atds(int16 chunkNr, int16 mode);
void save_ads_header(int16 diaNr);
Common::Stream *pool_handle(const char *fname);
void set_handle(const char *fname, int16 mode, Common::Stream *handle, int16 chunk_start, int16 chunk_anz);
void set_handle(const char *fname, int16 mode, Common::Stream *handle, int16 chunkStart, int16 chunkNr);
void open_handle(const char *fname, int16 mode);
void close_handle(int16 mode);
void crypt(char *txt, uint32 size);
void init_ats_mode(int16 mode, uint8 *atsheader);
DisplayMode start_ats(int16 txt_nr, int16 txt_mode, int16 color, int16 mode, int16 *voc_nr);
void init_ats_mode(int16 mode, uint8 *atsHeader);
DisplayMode start_ats(int16 txtNr, int16 txtMode, int16 color, int16 mode, int16 *vocNr);
void stop_ats();
DisplayMode &ats_get_status();
void print_ats(int16 x, int16 y, int16 scrx, int16 scry);
int16 get_steuer_bit(int16 txt_nr, int16 bit_idx, int16 mode);
void set_steuer_bit(int16 txt_nr, int16 bit_idx, int16 mode);
void del_steuer_bit(int16 txt_nr, int16 bit_idx, int16 mode);
void set_ats_str(int16 txt_nr, int16 txt_mode, int16 str_nr, int16 mode);
void set_ats_str(int16 txt_nr, int16 str_nr, int16 mode);
int16 get_ats_str(int16 txt_nr, int16 txt_mode, int16 mode);
char *ats_get_txt(int16 txt_nr, int16 txt_mode, int16 *txt_anz, int16 mode);
char *ats_search_block(int16 txt_mode, char *txt_adr);
void ats_search_nr(int16 txt_nr, char **str);
void ats_search_str(int16 *anz, uint8 *status, uint8 steuer, char **str);
void print_ats(int16 x, int16 y, int16 scrX, int16 scrY);
int16 getControlBit(int16 txtNr, int16 bitIdx, int16 mode);
void setControlBit(int16 txtNr, int16 bitIdx, int16 mode);
void delControlBit(int16 txtNr, int16 bitIdx, int16 mode);
void set_ats_str(int16 txtNr, int16 txtMode, int16 strNr, int16 mode);
void set_ats_str(int16 txtNr, int16 strNr, int16 mode);
int16 get_ats_str(int16 txtNr, int16 txtMode, int16 mode);
char *ats_get_txt(int16 txtNr, int16 txtMode, int16 *retNr, int16 mode);
char *ats_search_block(int16 txtMode, char *txtAdr);
void ats_search_nr(int16 txtNr, char **str);
void ats_search_str(int16 *nr, uint8 *status, uint8 controlByte, char **str);
void set_ats_mem(int16 mode);
int16 start_aad(int16 dia_nr);
int16 start_aad(int16 diaNr);
void stopAad();
void print_aad(int16 scrx, int16 scry);
void print_aad(int16 scrX, int16 scrY);
int16 aadGetStatus();
void set_string_end_func(void (*str_func)(int16 dia_nr, int16 str_nr, int16 person_nr, int16 mode));
void aad_search_dia(int16 dia_nr, char **ptr);
int16 aad_get_zeilen(char *str, int16 *txt_len);
bool ads_start(int16 dia_nr);
void set_string_end_func(void (*strFunc)(int16 diaNr, int16 strNr, int16 personNr, int16 mode));
void aad_search_dia(int16 diaNr, char **ptr);
int16 aad_get_zeilen(char *str, int16 *txtLen);
bool ads_start(int16 diaNr);
void stop_ads();
char **ads_item_ptr(int16 block_nr, int16 *anzahl);
AdsNextBlk *ads_item_choice(int16 blk_nr, int16 item_nr);
AdsNextBlk *calc_next_block(int16 blk_nr, int16 item_nr);
char **ads_item_ptr(int16 blockNr, int16 *retNr);
AdsNextBlk *ads_item_choice(int16 blockNr, int16 itemNr);
AdsNextBlk *calc_next_block(int16 blockNr, int16 itemNr);
int16 ads_get_status();
void hide_item(int16 dia_nr, int16 blk_nr, int16 item_nr);
void show_item(int16 dia_nr, int16 blk_nr, int16 item_nr);
void hide_item(int16 diaNr, int16 blockNr, int16 itemNr);
void show_item(int16 diaNr, int16 blockNr, int16 itemNr);
int16 return_block(AdsBlock *ab);
void ads_search_block(int16 blk_nr, char **ptr);
void ads_search_item(int16 item_nr, char **blk_adr);
int16 start_ads_auto_dia(char *item_adr);
int16 check_item(int16 block_nr, int16 item_nr);
int16 calc_inv_no_use(int16 cur_inv, int16 test_nr, int16 mode);
void ads_search_block(int16 blockNr, char **ptr);
void ads_search_item(int16 itemNr, char **blkAdr);
int16 start_ads_auto_dia(char *itemAdr);
int16 check_item(int16 blockNr, int16 itemNr);
int16 calc_inv_no_use(int16 curInv, int16 testNr, int16 mode);
int16 getStereoPos(int16 x);
void enableEvents(bool nr) {
_atdsv._eventsEnabled = nr;
}
int getAtdDisplay() const {
return _atdsv.Display;
return _atdsv._display;
}
void saveAtdsStream(Common::WriteStream *stream);
@ -330,10 +329,10 @@ public:
private:
int16 get_delay(int16 txt_len);
Common::Stream *_atdshandle[MAX_HANDLE] = { nullptr };
char *_atdsmem[MAX_HANDLE] = { nullptr };
int16 _atdspooloff[MAX_HANDLE] = { 0 };
char *_atsmem = nullptr;
Common::Stream *_atdsHandle[MAX_HANDLE] = { nullptr };
char *_atdsMem[MAX_HANDLE] = { nullptr };
int16 _atdsPoolOff[MAX_HANDLE] = { 0 };
char *_atsMem = nullptr;
uint8 *_ats_sheader = nullptr;
uint8 *_ats_st_header[4];
char *_atds_id_ptr = nullptr;
@ -351,16 +350,16 @@ private:
SplitStringRet *_ssr = nullptr;
SplitStringInit _ssi[AAD_MAX_PERSON] = {
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_MITTE, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
{ 0, 100, 0, 200, 4, SPLIT_CENTER, 8, 8 },
};
SplitStringInit _atsSsi;

6
engines/chewy/defines.h
View File

@ -165,7 +165,7 @@ enum SetupScreenMode {
#define EPISODE1_TGP 0
#define GBOOK_TGP 1
#define EPISODE1 "back/episode1.tgp"
#define BUCH_START 2
#define NOTEBOOK_START 2
#define DIARY_START 3
#define EPISODE1_GEP "back/episode1.gep"
@ -297,8 +297,8 @@ enum SetupScreenMode {
#define RED_CARD_INV 2
#define KABEL_INV 3
#define MONOCLE_INV 4
#define GBUCH_INV 5
#define GBUCH_OPEN_INV 6
#define NOTEBOOK_INV 5
#define NOTEBOOK_OPEN_INV 6
#define DEFEKT_INV 7
#define STAHLSEIL_INV 8
#define BECHER_LEER_INV 9

10
engines/chewy/detail.cpp
View File

@ -191,8 +191,8 @@ void Detail::load_rdi(const char *fname_, int16 room_nr) {
_rdi.dptr = tmprdi;
}
void Detail::load_rdi_taf(const char *fname_, int16 load_flag) {
if (_tafName.compareToIgnoreCase(fname_)) {
void Detail::load_rdi_taf(const char *filename, int16 load_flag) {
if (_tafName.compareToIgnoreCase(filename)) {
if (_rdi.dptr) {
if (_fullTaf) {
free(_rdi.dptr);
@ -202,12 +202,12 @@ void Detail::load_rdi_taf(const char *fname_, int16 load_flag) {
del_taf_tbl(_rdi.dptr);
}
}
_tafName = Common::String(fname_);
_tafName = Common::String(filename);
if (!load_flag) {
_rdi.dptr = init_taf_tbl(fname_);
_rdi.dptr = init_taf_tbl(filename);
load_taf_tbl(_rdi.dptr);
} else {
_rdi.dptr = _G(mem)->taf_adr(fname_);
_rdi.dptr = _G(mem)->taf_adr(filename);
_fullTaf = true;
}
} else if (!_fullTaf)

12
engines/chewy/dialogs/inventory.cpp
View File

@ -579,14 +579,14 @@ void Inventory::look_screen(int16 txt_mode, int16 txt_nr) {
break;
}
if (_G(atds)->get_steuer_bit(txt_nr, ATS_ACTION_BIT, ATS_DATA)) {
if (_G(atds)->getControlBit(txt_nr, ATS_ACTION_BIT, ATS_DATA)) {
atsAction(txt_nr, m_mode, ATS_ACTION_VOR);
}
if (ok) {
startAtsWait(txt_nr, m_mode, 14, ATS_DATA);
}
if (_G(atds)->get_steuer_bit(txt_nr, ATS_ACTION_BIT, ATS_DATA))
if (_G(atds)->getControlBit(txt_nr, ATS_ACTION_BIT, ATS_DATA))
atsAction(txt_nr, m_mode, ATS_ACTION_NACH);
if (_G(menu_item) == CUR_USE)
_G(flags).StaticUseTxt = true;
@ -629,10 +629,10 @@ bool Inventory::calc_use_invent(int16 invNr) {
default:
break;
}
} else if (_G(menu_item) == CUR_USE && invNr == GBUCH_INV) {
int16 id = del_invent_slot(GBUCH_INV);
_G(spieler).InventSlot[id] = GBUCH_OPEN_INV;
_G(obj)->changeInventory(GBUCH_INV, GBUCH_OPEN_INV, &_G(room_blk));
} else if (_G(menu_item) == CUR_USE && invNr == NOTEBOOK_INV) {
int16 id = del_invent_slot(NOTEBOOK_INV);
_G(spieler).InventSlot[id] = NOTEBOOK_OPEN_INV;
_G(obj)->changeInventory(NOTEBOOK_INV, NOTEBOOK_OPEN_INV, &_G(room_blk));
retVal = true;
}

12
engines/chewy/main.cpp
View File

@ -1368,7 +1368,7 @@ int16 calcMouseText(int16 x, int16 y, int16 mode) {
}
int16 action_ret = 0;
if (!_G(atds)->get_steuer_bit(txtNr, ATS_AKTIV_BIT, ATS_DATA)) {
if (!_G(atds)->getControlBit(txtNr, ATS_ACTIVE_BIT, ATS_DATA)) {
if (_G(menu_item) != CUR_WALK && _G(menu_item) != CUR_USE) {
if (x + _G(spieler).scrollx > _G(spieler_vector)[P_CHEWY].Xypos[0])
setPersonSpr(P_RIGHT, P_CHEWY);
@ -1377,18 +1377,18 @@ int16 calcMouseText(int16 x, int16 y, int16 mode) {
}
}
if (_G(atds)->get_steuer_bit(txtNr, ATS_ACTION_BIT, ATS_DATA)) {
if (_G(atds)->getControlBit(txtNr, ATS_ACTION_BIT, ATS_DATA)) {
action_ret = atsAction(txtNr, txtMode, ATS_ACTION_VOR);
}
if (ok && !_G(atds)->get_steuer_bit(txtNr, ATS_AKTIV_BIT, ATS_DATA)) {
if (ok && !_G(atds)->getControlBit(txtNr, ATS_ACTIVE_BIT, ATS_DATA)) {
if (startAtsWait(txtNr, txtMode, 14, ATS_DATA))
dispFl = false;
} else {
ret = -1;
}
if (_G(atds)->get_steuer_bit(txtNr, ATS_ACTION_BIT, ATS_DATA)) {
if (_G(atds)->getControlBit(txtNr, ATS_ACTION_BIT, ATS_DATA)) {
action_ret = atsAction(txtNr, txtMode, ATS_ACTION_NACH);
actionFl = true;
if (action_ret)
@ -1396,7 +1396,7 @@ int16 calcMouseText(int16 x, int16 y, int16 mode) {
}
if (!ok && !action_ret) {
if (inv_no_use_mode != -1 && !_G(atds)->get_steuer_bit(txtNr, ATS_AKTIV_BIT, ATS_DATA)) {
if (inv_no_use_mode != -1 && !_G(atds)->getControlBit(txtNr, ATS_ACTIVE_BIT, ATS_DATA)) {
actionFl = calc_inv_no_use(idx + (_G(spieler)._personRoomNr[P_CHEWY] * 100), inv_no_use_mode);
if (actionFl)
ret = txtNr;
@ -1404,7 +1404,7 @@ int16 calcMouseText(int16 x, int16 y, int16 mode) {
}
if (ok && !action_ret && txtMode == TXT_MARK_USE && dispFl) {
if (!_G(atds)->get_steuer_bit(txtNr, ATS_AKTIV_BIT, ATS_DATA)) {
if (!_G(atds)->getControlBit(txtNr, ATS_ACTIVE_BIT, ATS_DATA)) {
if (_G(menu_item) != CUR_WALK) {
if (x + _G(spieler).scrollx > _G(spieler_vector)[P_CHEWY].Xypos[0])
setPersonSpr(P_RIGHT, P_CHEWY);

22
engines/chewy/r_event.cpp
View File

@ -462,7 +462,7 @@ void exit_room(int16 eib_nr) {
break;
case 11:
_G(atds)->set_steuer_bit(121, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(121, ATS_ACTIVE_BIT, ATS_DATA);
break;
case 13:
@ -994,15 +994,15 @@ int16 sib_event_no_inv(int16 sib_nr) {
case SIB_MONOCLE:
_G(spieler).R0Monocle = true;
_G(obj)->hide_sib(SIB_MONOCLE);
if (_G(spieler).R0GBuch)
_G(atds)->del_steuer_bit(12, ATS_AKTIV_BIT, ATS_DATA);
if (_G(spieler).R0Noteboook)
_G(atds)->delControlBit(12, ATS_ACTIVE_BIT, ATS_DATA);
break;
case SIB_GBUCH:
_G(spieler).R0GBuch = true;
_G(obj)->hide_sib(SIB_GBUCH);
case SIB_NOTEBOOK:
_G(spieler).R0Noteboook = true;
_G(obj)->hide_sib(SIB_NOTEBOOK);
if (_G(spieler).R0Monocle)
_G(atds)->del_steuer_bit(12, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(12, ATS_ACTIVE_BIT, ATS_DATA);
break;
case SIB_TERMINAL_R5:
@ -1076,7 +1076,7 @@ int16 sib_event_no_inv(int16 sib_nr) {
_G(obj)->calc_rsi_flip_flop(SIB_RHAKEN_R7);
_G(atds)->set_ats_str(54, TXT_MARK_LOOK, 1, ATS_DATA);
_G(atds)->set_ats_str(55, TXT_MARK_LOOK, 1, ATS_DATA);
_G(atds)->del_steuer_bit(56, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(56, ATS_ACTIVE_BIT, ATS_DATA);
start_aad(9);
} else {
_G(obj)->set_rsi_flip_flop(SIB_LHAKEN_R7, 2);
@ -1167,7 +1167,7 @@ int16 sib_event_no_inv(int16 sib_nr) {
break;
case SIB_SEIL_R21:
_G(atds)->set_steuer_bit(129, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(129, ATS_ACTIVE_BIT, ATS_DATA);
break;
case SIB_GITTER1_R21:
@ -1175,7 +1175,7 @@ int16 sib_event_no_inv(int16 sib_nr) {
break;
case SIB_CART1_R18:
_G(atds)->set_steuer_bit(155, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(155, ATS_ACTIVE_BIT, ATS_DATA);
break;
case SIB_DOORKNOB_R18:
@ -1262,7 +1262,7 @@ int16 sib_event_no_inv(int16 sib_nr) {
break;
case SIB_LAMPE_R52:
_G(atds)->del_steuer_bit(338, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(338, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R52LichtAn ^= 1;
check_shad(2 * (_G(spieler).R52LichtAn + 1), 1);
break;

4
engines/chewy/rooms/room00.cpp
View File

@ -133,7 +133,7 @@ bool Room0::getPillow() {
invent_2_slot(0);
_G(menu_item) = CUR_WALK;
cursorChoice(CUR_WALK);
_G(atds)->set_steuer_bit(174, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(174, ATS_ACTIVE_BIT, ATS_DATA);
_G(det)->hideStaticSpr(6);
_G(flags).AutoAniPlay = false;
@ -159,7 +159,7 @@ bool Room0::pullSlime() {
invent_2_slot(1);
_G(menu_item) = CUR_WALK;
cursorChoice(CUR_WALK);
_G(atds)->set_steuer_bit(175, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(175, ATS_ACTIVE_BIT, ATS_DATA);
_G(flags).AutoAniPlay = false;
showCur();

2
engines/chewy/rooms/room01.cpp
View File

@ -32,7 +32,7 @@ void Room1::gottenCard() {
_G(det)->hideStaticSpr(2);
startSetAILWait(4, 1, ANI_FRONT);
_G(spieler)._personHide[P_CHEWY] = false;
_G(atds)->del_steuer_bit(7, ATS_COUNT_BIT, ATS_DATA);
_G(atds)->delControlBit(7, ATS_COUNT_BIT, ATS_DATA);
int16 tmp;
_G(atds)->ats_get_txt(7, TXT_MARK_LOOK, &tmp, ATS_DATA);
}

10
engines/chewy/rooms/room02.cpp
View File

@ -64,11 +64,11 @@ void Room2::electrifyWalkway1() {
_G(spieler).R2ElectrocutedBork = true;
delInventory(_G(spieler).AkInvent);
_G(atds)->del_steuer_bit(11, ATS_COUNT_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(11, ATS_ACTION_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(19, ATS_COUNT_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(25, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(8, ATS_COUNT_BIT, ATS_DATA);
_G(atds)->delControlBit(11, ATS_COUNT_BIT, ATS_DATA);
_G(atds)->delControlBit(11, ATS_ACTION_BIT, ATS_DATA);
_G(atds)->delControlBit(19, ATS_COUNT_BIT, ATS_DATA);
_G(atds)->delControlBit(25, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(8, ATS_COUNT_BIT, ATS_DATA);
_G(atds)->set_ats_str(11, 1, ATS_DATA);
}

2
engines/chewy/rooms/room03.cpp
View File

@ -305,7 +305,7 @@ void Room3::probeTransfer() {
_G(auto_mov_vector)[SONDE_OBJ].Delay = _G(spieler).DelaySpeed;
_G(auto_mov_obj)[SONDE_OBJ].Mode = true;
init_auto_obj(SONDE_OBJ, &SONDE_PHASEN[0][0], 2, (const MovLine *)SONDE_MPKT1);
_G(atds)->set_ats_str(24, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_ats_str(24, ATS_ACTIVE_BIT, ATS_DATA);
while (_G(mov_phasen)[SONDE_OBJ].Repeat != -1) {
set_ani_screen();

6
engines/chewy/rooms/room05.cpp
View File

@ -37,7 +37,7 @@ void Room5::entry() {
void Room5::pushButton() {
if (_G(spieler).R5Terminal) {
int16 strNr;
if (_G(spieler).R5Tuer == false) {
if (_G(spieler).R5Door == false) {
startSetAILWait(9, 1, ANI_FRONT);
_G(spieler).room_e_obj[6].Attribut = EXIT_TOP;
strNr = 1;
@ -47,8 +47,8 @@ void Room5::pushButton() {
strNr = 0;
}
_G(atds)->set_ats_str(29, strNr, ATS_DATA);
_G(spieler).R5Tuer ^= 1;
_G(obj)->calc_rsi_flip_flop(SIB_TUERE_R5);
_G(spieler).R5Door ^= 1;
_G(obj)->calc_rsi_flip_flop(SIB_DOOR_R5);
} else {
startAadWait(1);
}

6
engines/chewy/rooms/room06.cpp
View File

@ -60,7 +60,7 @@ void Room6::entry() {
if (_G(spieler).R6BolaSchild && _G(spieler).R6RaumBetreten < 2) {
_G(det)->startDetail(7, 255, ANI_FRONT);
_G(atds)->del_steuer_bit(44, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(44, ATS_ACTIVE_BIT, ATS_DATA);
if (!_G(flags).LoadGame)
++_G(spieler).R6RaumBetreten;
@ -72,7 +72,7 @@ void Room6::entry() {
_G(spieler).R6BolaOk = true;
_G(obj)->show_sib(SIB_BOLA_BUTTON_R6);
_G(obj)->hide_sib(SIB_BOLA_R6);
_G(atds)->set_steuer_bit(44, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(44, ATS_ACTIVE_BIT, ATS_DATA);
showCur();
}
}
@ -102,7 +102,7 @@ void Room6::bola_button() {
_G(obj)->calc_rsi_flip_flop(SIB_BOLA_FLECK_R6);
waitDetail(2);
_G(obj)->calc_rsi_flip_flop(SIB_BOLA_SCHACHT);
_G(atds)->del_steuer_bit(42, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(42, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(41, TXT_MARK_LOOK, 1, ATS_DATA);
_G(obj)->calc_rsi_flip_flop(SIB_BOLA_BUTTON_R6);
_G(obj)->hide_sib(SIB_BOLA_BUTTON_R6);

2
engines/chewy/rooms/room07.cpp
View File

@ -60,7 +60,7 @@ void Room7::hook(int16 sibNr) {
_G(obj)->calc_rsi_flip_flop(SIB_LHAKEN_R7);
_G(obj)->calc_rsi_flip_flop(SIB_RHAKEN_R7);
}
_G(atds)->del_steuer_bit(56, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(56, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(55, TXT_MARK_LOOK, 1, ATS_DATA);
diaNr = 9;
} else {

2
engines/chewy/rooms/room08.cpp
View File

@ -160,7 +160,7 @@ void Room8::open_gdoor() {
_G(det)->hideStaticSpr(17);
_G(spieler)._personHide[P_CHEWY] = false;
setPersonPos(204, 274, P_CHEWY, P_LEFT);
_G(atds)->del_steuer_bit(69, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(69, ATS_ACTIVE_BIT, ATS_DATA);
_G(obj)->hide_sib(31);
_G(spieler).R8GTuer = true;
_G(spieler).room_e_obj[15].Attribut = EXIT_BOTTOM;

8
engines/chewy/rooms/room09.cpp
View File

@ -64,9 +64,9 @@ void Room9::gtuer() {
_G(det)->showStaticSpr(5);
startSetAILWait(6, 1, ANI_FRONT);
setPersonPos(74, 93, P_CHEWY, P_LEFT);
_G(atds)->del_steuer_bit(74, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(75, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(76, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(74, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(75, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(76, ATS_ACTIVE_BIT, ATS_DATA);
_G(obj)->show_sib(34);
_G(atds)->set_ats_str(73, 1, ATS_DATA);
}
@ -76,7 +76,7 @@ void Room9::surimy() {
_G(spieler).R9Surimy = true;
const int16 tmp = _G(spieler_vector)[P_CHEWY].Count;
stopPerson(P_CHEWY);
_G(atds)->set_steuer_bit(75, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(75, ATS_ACTIVE_BIT, ATS_DATA);
_G(det)->hideStaticSpr(4);
_G(room)->set_timer_status(7, TIMER_STOP);
surimy_ani();

2
engines/chewy/rooms/room11.cpp
View File

@ -59,7 +59,7 @@ void Room11::entry() {
_G(obj)->hide_sib(SIB_TBUTTON3_R11);
_G(spieler).room_e_obj[20].Attribut = 255;
_G(spieler).room_e_obj[21].Attribut = 255;
_G(atds)->del_steuer_bit(121, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(121, ATS_ACTIVE_BIT, ATS_DATA);
if (!_G(flags).LoadGame) {
startAniBlock(2, ABLOCK17);

12
engines/chewy/rooms/room13.cpp
View File

@ -75,7 +75,7 @@ void Room13::entry() {
if (!_G(flags).LoadGame && _G(spieler).R13Band) {
_G(spieler).room_e_obj[25].Attribut = EXIT_TOP;
_G(atds)->set_steuer_bit(100, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(100, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R13Band = false;
}
@ -86,7 +86,7 @@ void Room13::entry() {
void Room13::xit() {
_G(spieler).room_e_obj[25].Attribut = EXIT_TOP;
_G(atds)->set_steuer_bit(100, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(100, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R13Band = false;
}
@ -133,8 +133,8 @@ void Room13::talk_bork() {
_G(auto_obj) = 0;
_G(flags).NoScroll = false;
_G(atds)->set_steuer_bit(122, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(92, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(122, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(92, ATS_ACTIVE_BIT, ATS_DATA);
_G(obj)->show_sib(SIB_BANDBUTTON_R13);
setPersonPos(153, 138, P_CHEWY, P_LEFT);
@ -157,7 +157,7 @@ void Room13::jmp_band() {
if (!_G(spieler).R13Bandlauf) {
_G(obj)->hide_sib(SIB_BANDBUTTON_R13);
_G(spieler).room_e_obj[25].Attribut = 255;
_G(atds)->del_steuer_bit(100, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(100, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R13Band = true;
autoMove(3, P_CHEWY);
_G(spieler)._personHide[P_CHEWY] = true;
@ -201,7 +201,7 @@ void Room13::jmp_floor() {
_G(obj)->show_sib(SIB_BANDBUTTON_R13);
_G(spieler).room_e_obj[25].Attribut = EXIT_TOP;
_G(atds)->set_steuer_bit(100, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(100, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R13Band = false;
autoMove(5, P_CHEWY);
_G(spieler)._personHide[P_CHEWY] = true;

4
engines/chewy/rooms/room16.cpp
View File

@ -35,11 +35,11 @@ void Room16::entry() {
if (!_G(spieler).R16F5Exit) {
_G(det)->showStaticSpr(4);
_G(spieler).room_e_obj[32].Attribut = 255;
_G(atds)->del_steuer_bit(124, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(124, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(det)->hideStaticSpr(4);
_G(spieler).room_e_obj[32].Attribut = EXIT_LEFT;
_G(atds)->set_steuer_bit(124, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(124, ATS_ACTIVE_BIT, ATS_DATA);
}
}

2
engines/chewy/rooms/room17.cpp
View File

@ -147,7 +147,7 @@ int16 Room17::use_seil() {
_G(spieler)._personHide[P_CHEWY] = true;
startSetAILWait(10, 1, ANI_FRONT);
_G(spieler).R17Seil = true;
_G(atds)->del_steuer_bit(139, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(139, ATS_ACTIVE_BIT, ATS_DATA);
plot_seil();
_G(spieler)._personHide[P_CHEWY] = false;
_G(flags).AutoAniPlay = false;

4
engines/chewy/rooms/room18.cpp
View File

@ -315,9 +315,9 @@ int16 Room18::calc_surimy() {
_G(atds)->set_ats_str(149, TXT_MARK_LOOK, 1, ATS_DATA);
for (int16 i = 0; i < 3; i++)
_G(atds)->del_steuer_bit(158 + i, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(158 + i, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(179, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(179, ATS_ACTIVE_BIT, ATS_DATA);
showCur();
_G(det)->del_taf_tbl(245, 50, nullptr);
}

16
engines/chewy/rooms/room21.cpp
View File

@ -86,31 +86,31 @@ void Room21::calc_laser() {
if (_G(spieler).R21Hebel1 && !_G(spieler).R21Hebel2 && _G(spieler).R21Hebel3) {
_G(spieler).R21Laser1Weg = true;
_G(det)->stop_detail(3);
_G(atds)->set_steuer_bit(134, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(133, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(134, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(133, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(spieler).R21Laser1Weg = false;
_G(det)->startDetail(3, 255, ANI_FRONT);
_G(atds)->del_steuer_bit(134, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(133, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(134, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(133, ATS_ACTIVE_BIT, ATS_DATA);
}
if (!_G(spieler).R21Hebel1 && _G(spieler).R21Hebel2 && !_G(spieler).R21Hebel3) {
if (!_G(obj)->checkInventory(SEIL_INV) && !_G(spieler).R17Seil) {
_G(obj)->show_sib(SIB_SEIL_R21);
_G(atds)->del_steuer_bit(129, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(129, ATS_ACTIVE_BIT, ATS_DATA);
}
_G(spieler).R21Laser2Weg = true;
_G(det)->stop_detail(4);
_G(atds)->set_steuer_bit(135, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(135, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(obj)->hide_sib(SIB_SEIL_R21);
_G(atds)->set_steuer_bit(129, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(129, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R21Laser2Weg = false;
_G(det)->startDetail(4, 255, ANI_FRONT);
_G(atds)->del_steuer_bit(135, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(135, ATS_ACTIVE_BIT, ATS_DATA);
}
}

10
engines/chewy/rooms/room22.cpp
View File

@ -121,7 +121,7 @@ void Room22::bork(int16 t_nr) {
bork_walk1();
} else {
if (!_G(spieler).R22ChewyPlatt) {
_G(atds)->set_steuer_bit(79, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(79, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R22ChewyPlatt = true;
}
@ -154,9 +154,9 @@ void Room22::bork_walk2() {
flic_cut(FCUT_008);
register_cutscene(3);
_G(det)->showStaticSpr(4);
_G(atds)->del_steuer_bit(81, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(81, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R22BorkPlatt = true;
_G(atds)->set_steuer_bit(79, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(79, ATS_ACTIVE_BIT, ATS_DATA);
}
void Room22::get_bork() {
@ -169,7 +169,7 @@ void Room22::get_bork() {
startAadWait(11);
_G(det)->stop_detail(3);
_G(spieler)._personHide[P_CHEWY] = false;
_G(atds)->set_steuer_bit(81, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(81, ATS_ACTIVE_BIT, ATS_DATA);
invent_2_slot(BORK_INV);
_G(spieler).R22GetBork = true;
@ -196,7 +196,7 @@ int16 Room22::malen() {
if (!_G(spieler).R22ChewyPlatt) {
_G(spieler).R22ChewyPlatt = true;
_G(atds)->set_steuer_bit(79, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(79, ATS_ACTIVE_BIT, ATS_DATA);
}
}

4
engines/chewy/rooms/room23.cpp
View File

@ -132,7 +132,7 @@ void Room23::use_cartridge() {
_G(spieler).R23Cartridge = true;
if (_G(spieler).R18CartSave) {
_G(atds)->del_steuer_bit(171, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(171, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(111, 2, ATS_DATA);
startSetAILWait(4, 1, ANI_FRONT);
_G(det)->showStaticSpr(3);
@ -145,7 +145,7 @@ void Room23::use_cartridge() {
void Room23::get_cartridge() {
_G(atds)->set_ats_str(111, 0, ATS_DATA);
_G(atds)->set_steuer_bit(171, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(171, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R23Cartridge = false;
_G(det)->hideStaticSpr(3);

4
engines/chewy/rooms/room27.cpp
View File

@ -32,9 +32,9 @@ void Room27::entry() {
if (_G(spieler)._personRoomNr[P_HOWARD] == 27) {
_G(timer_nr)[0] = _G(room)->set_timer(0, 5);
_G(det)->set_static_ani(0, -1);
_G(atds)->del_steuer_bit(274, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(274, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(atds)->set_steuer_bit(274, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(274, ATS_ACTIVE_BIT, ATS_DATA);
}
_G(spieler)._personHide[P_HOWARD] = true;

8
engines/chewy/rooms/room29.cpp
View File

@ -52,7 +52,7 @@ void Room29::entry() {
if (_G(spieler).R29AutoSitz) {
if (_G(spieler).ChewyAni == CHEWY_ROCKER)
_G(atds)->set_steuer_bit(212, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(212, ATS_ACTIVE_BIT, ATS_DATA);
else
_G(det)->showStaticSpr(9);
}
@ -78,7 +78,7 @@ int16 Room29::use_pumpe() {
autoMove(1, P_CHEWY);
start_spz_wait(CH_LGET_O, 1, false, P_CHEWY);
_G(det)->showStaticSpr(7);
_G(atds)->del_steuer_bit(218, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(218, ATS_ACTIVE_BIT, ATS_DATA);
delInventory(SCHLAUCH_INV);
} else if (!_G(spieler).inv_cur) {
action_flag = true;
@ -120,7 +120,7 @@ bool Room29::use_schlauch() {
startSetAILWait(4, 1, ANI_FRONT);
_G(det)->showStaticSpr(8);
_G(det)->showStaticSpr(10);
_G(atds)->del_steuer_bit(219, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(219, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(218, 1, ATS_DATA);
_G(spieler).R29Schlauch1 = false;
@ -148,7 +148,7 @@ void Room29::schlitz_sitz() {
startAadWait(63);
_G(det)->stop_detail(2);
_G(atds)->del_steuer_bit(212, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(212, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler)._personHide[P_CHEWY] = false;
_G(mouseLeftClick) = false;
g_events->_kbInfo._scanCode = Common::KEYCODE_INVALID;

4
engines/chewy/rooms/room31.cpp
View File

@ -78,7 +78,7 @@ void Room31::calc_luke() {
_G(det)->showStaticSpr(5 + i);
_G(atds)->set_ats_str(244, 1, ATS_DATA);
_G(atds)->del_steuer_bit(245, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(245, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).room_e_obj[75].Attribut = EXIT_BOTTOM;
} else {
@ -86,7 +86,7 @@ void Room31::calc_luke() {
_G(det)->hideStaticSpr(5 + i);
_G(atds)->set_ats_str(244, 0, ATS_DATA);
_G(atds)->set_steuer_bit(245, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(245, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).room_e_obj[75].Attribut = 255;
}
}

2
engines/chewy/rooms/room32.cpp
View File

@ -47,7 +47,7 @@ int16 Room32::use_howard() {
remove_inventory(MUNTER_INV);
register_cutscene(11);
flic_cut(FCUT_043);
_G(atds)->set_steuer_bit(230, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(230, ATS_ACTIVE_BIT, ATS_DATA);
start_spz(CH_TALK12, 255, ANI_FRONT, P_CHEWY);
startAadWait(75);
waitShowScreen(5);

4
engines/chewy/rooms/room33.cpp
View File

@ -167,7 +167,7 @@ void Room33::use_maschine() {
_G(spieler)._personHide[P_CHEWY] = false;
start_spz(CH_TALK3, 255, ANI_FRONT, P_CHEWY);
startAadWait(71);
_G(atds)->del_steuer_bit(225, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(225, ATS_ACTIVE_BIT, ATS_DATA);
}
if (hocker) {
@ -205,7 +205,7 @@ int16 Room33::get_munter() {
autoMove(4, P_CHEWY);
start_spz_wait(CH_LGET_O, 1, false, P_CHEWY);
invent_2_slot(MUNTER_INV);
_G(atds)->set_steuer_bit(225, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(225, ATS_ACTIVE_BIT, ATS_DATA);
_G(det)->hideStaticSpr(3);
start_spz(CH_TALK3, 255, ANI_FRONT, P_CHEWY);
startAadWait(72);

2
engines/chewy/rooms/room35.cpp
View File

@ -99,7 +99,7 @@ int16 Room35::use_cat() {
_G(obj)->show_sib(SIB_KNOCHEN_R35);
_G(obj)->calc_rsi_flip_flop(SIB_KNOCHEN_R35);
_G(det)->showStaticSpr(7);
_G(atds)->del_steuer_bit(237, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(237, ATS_ACTIVE_BIT, ATS_DATA);
while (_G(det)->get_ani_status(2) && !SHOULD_QUIT) {
setupScreen(DO_SETUP);

8
engines/chewy/rooms/room37.cpp
View File

@ -150,7 +150,7 @@ int16 Room37::use_glas() {
_G(det)->hideStaticSpr(9);
_G(atds)->set_ats_str(250, 1, ATS_DATA);
_G(atds)->set_ats_str(256, 1, ATS_DATA);
_G(atds)->del_steuer_bit(251, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(251, ATS_ACTIVE_BIT, ATS_DATA);
_G(obj)->show_sib(SIB_HFUTTER2_R37);
_G(spieler).R37Gebiss = true;
start_spz(CH_TALK3, 255, ANI_FRONT, P_CHEWY);
@ -292,9 +292,9 @@ void Room37::use_hahn() {
_G(spieler).scrollx = 320;
_G(flags).NoScroll = false;
_G(atds)->set_steuer_bit(251, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(250, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(256, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(251, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(250, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(256, ATS_ACTIVE_BIT, ATS_DATA);
_G(det)->hideStaticSpr(8);
start_spz(CH_TALK5, 255, ANI_FRONT, P_CHEWY);
startAadWait(141);

4
engines/chewy/rooms/room39.cpp
View File

@ -59,10 +59,10 @@ void Room39::entry() {
else
_G(det)->set_static_ani(5, -1);
_G(atds)->del_steuer_bit(62, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(62, ATS_ACTIVE_BIT, ATS_DATA);
}
} else {
_G(atds)->set_steuer_bit(62, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(62, ATS_ACTIVE_BIT, ATS_DATA);
}
set_tv();

10
engines/chewy/rooms/room40.cpp
View File

@ -55,7 +55,7 @@ void Room40::entry(int16 eib_nr) {
if (_G(spieler).R40PoliceWeg == false) {
_G(timer_nr)[0] = _G(room)->set_timer(255, 10);
_G(atds)->del_steuer_bit(275, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(275, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(det)->hideStaticSpr(15);
}
@ -246,7 +246,7 @@ void Room40::setup_func() {
_G(uhr)->resetTimer(_G(timer_nr)[0], 0);
_G(det)->hideStaticSpr(15);
_G(det)->startDetail(POLICE_LEFT, 1, ANI_FRONT);
_G(atds)->set_steuer_bit(275, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(275, ATS_ACTIVE_BIT, ATS_DATA);
}
switch (_G(spieler).R40PoliceAniStatus) {
@ -271,7 +271,7 @@ void Room40::setup_func() {
_G(spieler).R40PoliceAniStatus = 255;
_G(room)->set_timer_status(255, TIMER_START);
_G(uhr)->resetTimer(_G(timer_nr)[0], 0);
_G(atds)->del_steuer_bit(275, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(275, ATS_ACTIVE_BIT, ATS_DATA);
}
break;
@ -295,7 +295,7 @@ void Room40::setup_func() {
_G(flags).MouseLeft = false;
_G(flags).MainInput = true;
_G(spieler).R40HoUse = false;
_G(atds)->set_steuer_bit(276, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(276, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(det)->startDetail(POLICE_RIGHT, 1, ANI_FRONT);
@ -454,7 +454,7 @@ int16 Room40::use_haendler() {
_G(spieler).R40HaendlerOk = true;
_G(spieler).R40TeilKarte = true;
_G(spieler).R40DuengerMit = true;
_G(atds)->set_steuer_bit(283, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(283, ATS_ACTIVE_BIT, ATS_DATA);
autoMove(10, P_CHEWY);
autoMove(11, P_HOWARD);
startAadWait(208);

6
engines/chewy/rooms/room41.cpp
View File

@ -54,13 +54,13 @@ void Room41::entry() {
}
if (_G(spieler).R41Einbruch) {
_G(atds)->del_steuer_bit(271, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(271, ATS_ACTIVE_BIT, ATS_DATA);
_G(det)->showStaticSpr(6);
_G(det)->showStaticSpr(7);
}
if (_G(spieler).ChewyAni == CHEWY_ROCKER) {
_G(atds)->set_steuer_bit(269, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(269, ATS_ACTIVE_BIT, ATS_DATA);
}
if (!_G(flags).LoadGame)
@ -200,7 +200,7 @@ int16 Room41::use_lola() {
setPersonPos(127, 112, P_CHEWY, P_LEFT);
_G(det)->stop_detail(6);
_G(atds)->del_steuer_bit(267, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(267, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(267, 1, ATS_DATA);
_G(atds)->hide_item(11, 0, 3);
showCur();

6
engines/chewy/rooms/room48.cpp
View File

@ -50,7 +50,7 @@ bool Room48::timer(int16 t_nr, int16 ani_nr) {
void Room48::calc_pic() {
for (int16 i = 0; i < 2; i++) {
_G(atds)->set_steuer_bit(312 + i, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(312 + i, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R48Auswahl[3 + i] = 0;
}
@ -60,13 +60,13 @@ void Room48::calc_pic() {
if (_G(obj)->checkInventory(VCARD_INV)) {
_G(spieler).R48Auswahl[3] = 1;
_G(atds)->del_steuer_bit(312, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(312, ATS_ACTIVE_BIT, ATS_DATA);
_G(det)->showStaticSpr(4);
}
if (_G(obj)->checkInventory(KAPPE_INV)) {
_G(spieler).R48Auswahl[4] = 1;
_G(atds)->del_steuer_bit(313, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(313, ATS_ACTIVE_BIT, ATS_DATA);
_G(det)->showStaticSpr(4);
}
}

2
engines/chewy/rooms/room49.cpp
View File

@ -197,7 +197,7 @@ void Room49::use_boy_cigar() {
_G(obj)->addInventory(GUM_INV, &_G(room_blk));
inventory_2_cur(GUM_INV);
_G(atds)->set_steuer_bit(318, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(318, ATS_ACTIVE_BIT, ATS_DATA);
_G(SetUpScreenFunc) = setup_func;
_G(spieler).R49BoyWeg = true;

2
engines/chewy/rooms/room52.cpp
View File

@ -108,7 +108,7 @@ int16 Room52::use_hot_dog() {
startSetAILWait(7, 1, ANI_BACK);
g_engine->_sound->stopSound(0);
_G(spieler)._personHide[P_CHEWY] = false;
_G(atds)->set_steuer_bit(341, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(341, ATS_ACTIVE_BIT, ATS_DATA);
startAadWait(303);
_G(atds)->set_ats_str(KILLER_INV, 1, INV_ATS_DATA);
_G(spieler).R52KakerWeg = true;

6
engines/chewy/rooms/room53.cpp
View File

@ -43,7 +43,7 @@ static const AniBlock ABLOCK35[7] = {
void Room53::entry() {
hideCur();
_G(obj)->hide_sib(SIB_VISIT_R53);
_G(atds)->del_steuer_bit(319, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(319, ATS_ACTIVE_BIT, ATS_DATA);
startSetAILWait(0, 1, ANI_FRONT);
_G(det)->set_static_ani(1, -1);
_G(timer_nr)[0] = _G(room)->set_timer(1, 7);
@ -54,7 +54,7 @@ void Room53::man_go() {
_G(room)->set_timer_status(1, TIMER_STOP);
_G(det)->del_static_ani(1);
startSetAILWait(5, 1, ANI_FRONT);
_G(atds)->set_steuer_bit(319, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(319, ATS_ACTIVE_BIT, ATS_DATA);
if (!_G(spieler).R53Visit)
_G(obj)->show_sib(SIB_VISIT_R53);
}
@ -88,7 +88,7 @@ int16 Room53::use_man() {
startAniBlock(7, ABLOCK35);
_G(obj)->addInventory(JMKOST_INV, &_G(room_blk));
inventory_2_cur(JMKOST_INV);
_G(atds)->set_steuer_bit(319, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(319, ATS_ACTIVE_BIT, ATS_DATA);
showCur();
}

2
engines/chewy/rooms/room54.cpp
View File

@ -165,7 +165,7 @@ int16 Room54::use_schalter() {
startSetAILWait(4, 1, ANI_FRONT);
aad_nr = 296;
_G(spieler).R54FputzerWeg = true;
_G(atds)->del_steuer_bit(345, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(345, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(349, 1, ATS_DATA);
_G(atds)->set_ats_str(351, 1, ATS_DATA);
}

16
engines/chewy/rooms/room55.cpp
View File

@ -78,7 +78,7 @@ void Room55::entry() {
startSetAILWait(3, 1, ANI_FRONT);
_G(spieler)._personHide[P_CHEWY] = false;
_G(zoom_horizont) = 1;
_G(atds)->del_steuer_bit(340, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(340, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(spieler).scrollx = 0;
@ -289,9 +289,9 @@ void Room55::get_job() {
int16 r_nr;
if (_G(spieler).R55Job) {
r_nr = 55;
_G(atds)->del_steuer_bit(357, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(354, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(355, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(357, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(354, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(355, ATS_ACTIVE_BIT, ATS_DATA);
} else {
r_nr = 54;
mans2rock();
@ -346,7 +346,7 @@ void Room55::strasse(int16 mode) {
_G(room)->set_timer_status(4, TIMER_STOP);
_G(det)->del_static_ani(4);
_G(det)->stop_detail(4);
_G(atds)->set_steuer_bit(340, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(340, ATS_ACTIVE_BIT, ATS_DATA);
startSetAILWait(3, 1, ANI_BACK);
_G(spieler).scrollx = 0;
@ -377,10 +377,10 @@ int16 Room55::use_kammeraus() {
_G(det)->hideStaticSpr(10);
_G(spieler).R55ExitDia = 322;
_G(spieler).R55SekWeg = true;
_G(atds)->set_steuer_bit(352, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(352, ATS_ACTIVE_BIT, ATS_DATA);
delInventory(_G(spieler).AkInvent);
_G(atds)->set_steuer_bit(345, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(346, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(345, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(346, ATS_ACTIVE_BIT, ATS_DATA);
strasse(1);
showCur();
}

10
engines/chewy/rooms/room56.cpp
View File

@ -116,9 +116,9 @@ void Room56::entry() {
_G(spieler).flags34_8 = true;
mode = 2;
} else if (_G(spieler).flags34_40) {
_G(atds)->del_steuer_bit(362, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(367, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(366, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(362, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(367, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(366, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).room_e_obj[137].Attribut = 3;
if (_G(spieler).flags33_80) {
_G(out)->setPointer(nullptr);
@ -286,7 +286,7 @@ int16 Room56::use_man() {
int16 Room56::use_kneipe() {
int16 action_ret = false;
if (!_G(spieler).flags32_10) {
if (_G(menu_item) == CUR_WALK && !_G(spieler).inv_cur && _G(atds)->get_steuer_bit(362, ATS_AKTIV_BIT, ATS_DATA) == 0) {
if (_G(menu_item) == CUR_WALK && !_G(spieler).inv_cur && _G(atds)->getControlBit(362, ATS_ACTIVE_BIT, ATS_DATA) == 0) {
action_ret = true;
hideCur();
if (_G(spieler).R56Kneipe) {
@ -432,7 +432,7 @@ void Room56::setup_func() {
if (_G(spieler).flags32_10)
return;
if (!_G(atds)->get_steuer_bit(362, ATS_AKTIV_BIT, ATS_DATA) && _G(menu_item) == CUR_WALK) {
if (!_G(atds)->getControlBit(362, ATS_ACTIVE_BIT, ATS_DATA) && _G(menu_item) == CUR_WALK) {
if (g_events->_mousePos.x + _G(spieler).scrollx >= 157 && g_events->_mousePos.x + _G(spieler).scrollx <= 204 && g_events->_mousePos.y >= 28 && g_events->_mousePos.y <= 89)
cursorChoice(CUR_EXIT_TOP);
else

2
engines/chewy/rooms/room57.cpp
View File

@ -140,7 +140,7 @@ int16 Room57::use_pfoertner() {
_G(det)->hideStaticSpr(4);
startSetAILWait(6, 1, ANI_WAIT);
g_engine->_sound->stopSound(0);
_G(atds)->set_steuer_bit(358, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(358, ATS_ACTIVE_BIT, ATS_DATA);
} else {
startAadWait(349);
goAutoXy(176, 130, P_HOWARD, ANI_WAIT);

10
engines/chewy/rooms/room63.cpp
View File

@ -53,7 +53,7 @@ void Room63::entry() {
_G(det)->showStaticSpr(10);
_G(det)->showStaticSpr(12);
} else if (_G(spieler).R62LauraVerwandlung) {
_G(atds)->set_steuer_bit(383, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(383, ATS_ACTIVE_BIT, ATS_DATA);
_G(SetUpScreenFunc) = setup_func;
cur_2_inventory();
_G(spieler).scrollx = 176;
@ -209,7 +209,7 @@ int16 Room63::use_fx_man() {
_G(det)->stop_detail(7);
startSetAILWait(8, 1, ANI_FRONT);
_G(spieler).R63FxMannWeg = true;
_G(atds)->set_steuer_bit(384, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(384, ATS_ACTIVE_BIT, ATS_DATA);
showCur();
}
return action_ret;
@ -283,7 +283,7 @@ int16 Room63::use_girl() {
_G(det)->showStaticSpr(12);
_G(atds)->set_ats_str(381, 1, ATS_DATA);
_G(atds)->set_ats_str(382, 1, ATS_DATA);
_G(atds)->set_steuer_bit(380, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(380, ATS_ACTIVE_BIT, ATS_DATA);
startAadWait(367);
showCur();
}
@ -311,8 +311,8 @@ int16 Room63::use_aschenbecher() {
_G(det)->hideStaticSpr(12);
startAadWait(368);
flic_cut(FCUT_080);
_G(atds)->set_steuer_bit(381, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(382, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(381, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(382, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(383, 1, ATS_DATA);
_G(spieler).R63Feuer = true;
_G(spieler)._personHide[P_CHEWY] = false;

6
engines/chewy/rooms/room64.cpp
View File

@ -45,7 +45,7 @@ void Room64::entry() {
_G(spieler).R64ManWeg = true;
_G(det)->del_static_ani(1);
_G(room)->set_timer_status(1, TIMER_STOP);
_G(atds)->set_steuer_bit(376, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(376, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).R64Moni1Ani = 5;
calc_monitor();
hideCur();
@ -147,11 +147,11 @@ int16 Room64::use_tasche() {
hideCur();
if (!_G(spieler).inv_cur) {
if (_G(spieler).R64ManWeg) {
if (!_G(atds)->get_steuer_bit(375, ATS_AKTIV_BIT, ATS_DATA)) {
if (!_G(atds)->getControlBit(375, ATS_ACTIVE_BIT, ATS_DATA)) {
autoMove(3, P_CHEWY);
start_spz_wait(CH_ROCK_GET1, 1, false, P_CHEWY);
new_invent_2_cur(GERAET_INV);
_G(atds)->set_steuer_bit(375, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(375, ATS_ACTIVE_BIT, ATS_DATA);
startAadWait(353);
} else {
showCur();

4
engines/chewy/rooms/room66.cpp
View File

@ -88,8 +88,8 @@ void Room66::entry(int16 eib_nr) {
void Room66::xit(int16 eib_nr) {
_G(spieler).ScrollxStep = 1;
_G(atds)->set_steuer_bit(415, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(417, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(415, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(417, ATS_ACTIVE_BIT, ATS_DATA);
if (_G(spieler)._personRoomNr[P_HOWARD] != 66)
return;

2
engines/chewy/rooms/room67.cpp
View File

@ -168,7 +168,7 @@ int16 Room67::talk_papagei() {
_G(det)->showStaticSpr(0);
invent_2_slot(PAPAGEI_INV);
showCur();
_G(atds)->set_steuer_bit(394, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(394, ATS_ACTIVE_BIT, ATS_DATA);
}
showCur();
}

6
engines/chewy/rooms/room68.cpp
View File

@ -251,7 +251,7 @@ int16 Room68::use_papagei() {
start_spz_wait(CH_LGET_O, 1, false, P_CHEWY);
_G(det)->showStaticSpr(12);
_G(det)->startDetail(21, 255, ANI_FRONT);
_G(atds)->del_steuer_bit(408, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(408, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(407, 1, ATS_DATA);
showCur();
}
@ -324,8 +324,8 @@ int16 Room68::use_diva() {
register_cutscene(22);
_G(det)->del_static_ani(18);
startSetAILWait(7, 1, ANI_FRONT);
_G(atds)->set_steuer_bit(407, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(412, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(407, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(412, ATS_ACTIVE_BIT, ATS_DATA);
setPersonSpr(P_RIGHT, P_CHEWY);
startAadWait(402);
} else

6
engines/chewy/rooms/room71.cpp
View File

@ -213,8 +213,8 @@ void Room71::proc2() {
_G(det)->startDetail(2, 255, false);
_G(det)->stop_detail(5);
_G(det)->showStaticSpr(8);
_G(atds)->set_steuer_bit(442, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(446, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(442, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(446, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler)._personHide[P_HOWARD] = false;
_G(spieler)._personHide[P_NICHELLE] = false;
_G(spieler)._personHide[P_CHEWY] = false;
@ -274,7 +274,7 @@ int Room71::proc6() {
_G(spieler).flags28_4 = true;
_G(room)->set_timer_status(0, TIMER_STOP);
_G(det)->del_static_ani(0);
_G(atds)->set_steuer_bit(443, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(443, ATS_ACTIVE_BIT, ATS_DATA);
autoMove(3, P_CHEWY);
_G(spieler_mi)[P_CHEWY].Mode = false;

2
engines/chewy/rooms/room72.cpp
View File

@ -85,7 +85,7 @@ void Room72::xit(int16 eib_nr) {
}
void Room72::proc1(int16 flicNr) {
_G(atds)->set_steuer_bit(389, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(389, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).flags28_10 = true;
waitShowScreen(7);
startAadWait(437);

6
engines/chewy/rooms/room73.cpp
View File

@ -87,8 +87,8 @@ int Room73::proc1() {
_G(spieler).flags28_20 = true;
autoMove(3, P_CHEWY);
start_spz_wait(13, 1, false, P_CHEWY);
_G(atds)->del_steuer_bit(433, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(432, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(433, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(432, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(430, 1, ATS_DATA);
_G(det)->showStaticSpr(3);
showCur();
@ -106,7 +106,7 @@ int Room73::proc2() {
start_spz_wait(13, 1, false, P_CHEWY);
_G(det)->hideStaticSpr(3);
_G(det)->hideStaticSpr(4);
_G(atds)->set_steuer_bit(433, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(433, ATS_ACTIVE_BIT, ATS_DATA);
new_invent_2_cur(99);
showCur();

2
engines/chewy/rooms/room74.cpp
View File

@ -104,7 +104,7 @@ int Room74::proc1() {
_G(atds)->set_ats_str(435, 1, ATS_DATA);
} else if (!_G(spieler).inv_cur && _G(spieler).R74CutRubberPlant) {
_G(atds)->set_steuer_bit(435, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(435, ATS_ACTIVE_BIT, ATS_DATA);
autoMove(5, P_CHEWY);
start_spz_wait(13, 1, false, P_CHEWY);
new_invent_2_cur(RUBBER_INV);

12
engines/chewy/rooms/room76.cpp
View File

@ -47,18 +47,18 @@ void Room76::entry() {
_G(spieler)._personHide[P_NICHELLE] = true;
if (!_G(spieler).flags29_4) {
_G(atds)->del_steuer_bit(453, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(457, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(458, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(453, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(457, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(458, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(det)->del_static_ani(2);
for (int i = 0; i < 3; ++i)
_G(det)->hideStaticSpr(8 + i);
_G(atds)->set_steuer_bit(453, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(457, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(458, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(453, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(457, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(458, ATS_ACTIVE_BIT, ATS_DATA);
}
if (_G(flags).LoadGame)

2
engines/chewy/rooms/room77.cpp
View File

@ -44,7 +44,7 @@ void Room77::entry() {
for (int i = 0; i < 3; ++i) {
_G(det)->showStaticSpr(2 + i);
_G(atds)->del_steuer_bit(460 + i, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(460 + i, ATS_ACTIVE_BIT, ATS_DATA);
}
}

4
engines/chewy/rooms/room80.cpp
View File

@ -40,9 +40,9 @@ void Room80::entry() {
g_engine->_sound->playSound(0, 2, false);
if (_G(spieler).gottenDiary) {
_G(atds)->del_steuer_bit(476, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(476, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(atds)->set_steuer_bit(476, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(476, ATS_ACTIVE_BIT, ATS_DATA);
}
if (_G(spieler).flags32_1) {

6
engines/chewy/rooms/room81.cpp
View File

@ -39,7 +39,7 @@ void Room81::entry() {
_G(spieler).DiaAMov = 0;
if (_G(spieler).r88DestRoom == 84) {
_G(det)->showStaticSpr(0);
_G(atds)->del_steuer_bit(488, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(488, ATS_ACTIVE_BIT, ATS_DATA);
}
proc3();
@ -147,8 +147,8 @@ void Room81::proc3() {
_G(det)->startDetail(3 + i, 255, false);
_G(det)->stop_detail(2);
_G(atds)->del_steuer_bit(486, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(490, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(486, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(490, ATS_ACTIVE_BIT, ATS_DATA);
}
} // namespace Rooms

4
engines/chewy/rooms/room82.cpp
View File

@ -40,8 +40,8 @@ void Room82::entry() {
if (_G(spieler).R88UsedMonkey) {
_G(det)->showStaticSpr(6);
_G(atds)->set_steuer_bit(473, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(467, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(473, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(467, ATS_ACTIVE_BIT, ATS_DATA);
}
if (_G(spieler).flags37_20)

14
engines/chewy/rooms/room84.cpp
View File

@ -46,27 +46,27 @@ void Room84::entry() {
_G(det)->del_static_ani(3);
_G(det)->stop_detail(0);
_G(spieler).room_e_obj[124].Attribut = EXIT_TOP;
_G(atds)->set_steuer_bit(478, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(479, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(478, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(479, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(485, 1, ATS_DATA);
}
if (_G(spieler).flags32_10) {
_G(det)->startDetail(7, 255, false);
_G(atds)->del_steuer_bit(504, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(504, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler).room_e_obj[124].Attribut = 255;
_G(atds)->set_ats_str(485, 2, ATS_DATA);
}
if (_G(spieler).r88DestRoom == 84) {
_G(det)->showStaticSpr(7);
_G(atds)->del_steuer_bit(481, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(482, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(481, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(482, ATS_ACTIVE_BIT, ATS_DATA);
}
if (_G(spieler).flags32_40) {
_G(atds)->set_steuer_bit(481, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(482, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(481, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(482, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(485, 1, ATS_DATA);
_G(spieler).room_e_obj[124].Attribut = EXIT_TOP;
}

4
engines/chewy/rooms/room85.cpp
View File

@ -50,7 +50,7 @@ void Room85::entry(int16 eib_nr) {
if (_G(spieler).flags32_10) {
_G(det)->showStaticSpr(4);
_G(atds)->del_steuer_bit(495, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(495, ATS_ACTIVE_BIT, ATS_DATA);
}
if (_G(flags).LoadGame)
@ -65,7 +65,7 @@ void Room85::entry(int16 eib_nr) {
_G(mouseLeftClick) = false;
_G(spieler).scrollx = 78;
if (_G(spieler).flags32_40) {
_G(atds)->del_steuer_bit(506, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(506, ATS_ACTIVE_BIT, ATS_DATA);
_G(det)->startDetail(1, 255, false);
setPersonPos(195, 146, P_CHEWY, P_RIGHT);
setPersonPos(186, 142, P_HOWARD, P_RIGHT);

2
engines/chewy/rooms/room86.cpp
View File

@ -155,7 +155,7 @@ int Room86::proc2() {
delInventory(_G(spieler).AkInvent);
autoMove(3, P_CHEWY);
proc3(true);
_G(atds)->del_steuer_bit(499, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(499, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(497, 1, ATS_DATA);
_G(atds)->set_ats_str(498, 1, ATS_DATA);
_G(spieler).flags32_2 = true;

2
engines/chewy/rooms/room87.cpp
View File

@ -137,7 +137,7 @@ int Room87::proc2(int16 txt_nr) {
_G(atds)->set_ats_str(txt_nr, 1, ATS_DATA);
_G(det)->showStaticSpr(movNr);
if (_G(spieler).flags32_4 && _G(spieler).flags32_8)
_G(atds)->del_steuer_bit(502, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(502, ATS_ACTIVE_BIT, ATS_DATA);
}
showCur();
return 1;

2
engines/chewy/rooms/room88.cpp
View File

@ -43,7 +43,7 @@ void Room88::entry() {
if (_G(spieler).flags32_10) {
_G(det)->startDetail(4, 255, false);
_G(atds)->del_steuer_bit(505, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(505, ATS_ACTIVE_BIT, ATS_DATA);
}
}

10
engines/chewy/rooms/room90.cpp
View File

@ -272,8 +272,8 @@ int Room90::getHubcaps() {
startAadWait(517);
_G(spieler).flags35_1 = false;
_G(atds)->set_steuer_bit(517, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(519, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(517, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(519, ATS_ACTIVE_BIT, ATS_DATA);
showCur();
return 1;
@ -307,8 +307,8 @@ int Room90::shootControlUnit() {
_G(HowardMov) = 0;
_G(spieler).flags33_40 = true;
_G(det)->stop_detail(12);
_G(atds)->set_steuer_bit(519, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(520, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(519, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(520, ATS_ACTIVE_BIT, ATS_DATA);
_G(flags).ZoomMov = true;
showCur();
@ -334,7 +334,7 @@ int Room90::useSurimyOnWreck() {
_G(spieler).scrollx = 176;
start_spz(45, 255, false, P_CHEWY);
startAadWait(519);
_G(atds)->set_steuer_bit(520, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(520, ATS_ACTIVE_BIT, ATS_DATA);
showCur();
return 1;

2
engines/chewy/rooms/room94.cpp
View File

@ -158,7 +158,7 @@ int Room94::giveGhostBottle() {
startSetAILWait(4, 1, ANI_FRONT);
_G(spieler).flags35_10 = true;
_G(spieler).room_e_obj[138].Attribut = EXIT_TOP;
_G(atds)->set_steuer_bit(522, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(522, ATS_ACTIVE_BIT, ATS_DATA);
new_invent_2_cur(114);
showCur();

32
engines/chewy/rooms/room97.cpp
View File

@ -74,9 +74,9 @@ void Room97::entry() {
if (_G(spieler).flags36_40) {
_G(det)->startDetail(14, 255, ANI_FRONT);
_G(det)->showStaticSpr(13);
_G(atds)->del_steuer_bit(543, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(543, ATS_ACTIVE_BIT, ATS_DATA);
} else {
_G(atds)->set_steuer_bit(543, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(543, ATS_ACTIVE_BIT, ATS_DATA);
}
if (_G(spieler).flags36_20) {
@ -434,10 +434,10 @@ int Room97::proc6() {
_G(det)->stop_detail(5);
_G(det)->showStaticSpr(15);
_G(spieler).flags36_2 = true;
_G(atds)->del_steuer_bit(538, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(531, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(538, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(531, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(530, 1, ATS_DATA);
_G(atds)->set_steuer_bit(532, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(532, ATS_ACTIVE_BIT, ATS_DATA);
_G(spieler_mi)[P_CHEWY].Mode = false;
_G(spieler).flags36_8 = true;
@ -455,7 +455,7 @@ int Room97::proc7() {
_G(spieler)._personHide[P_CHEWY] = true;
_G(det)->hideStaticSpr(17);
startSetAILWait(22, 1, ANI_FRONT);
_G(atds)->set_steuer_bit(538, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(538, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(530, 2, ATS_DATA);
new_invent_2_cur(SLIME_INV);
_G(spieler).flags36_4 = true;
@ -487,7 +487,7 @@ int Room97::proc8() {
_G(spieler).flags36_8 = false;
_G(det)->startDetail(12, 255, false);
_G(atds)->set_ats_str(530, 3, ATS_DATA);
_G(atds)->del_steuer_bit(532, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(532, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->set_ats_str(532, 1, ATS_DATA);
_G(det)->startDetail(6, 255, false);
_G(det)->hideStaticSpr(14);
@ -513,8 +513,8 @@ int Room97::proc8() {
_G(det)->startDetail(28, 255, false);
_G(det)->setSetailPos(27, 272, 110);
_G(det)->startDetail(27, 255, false);
_G(atds)->set_steuer_bit(533, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->set_steuer_bit(534, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(533, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->setControlBit(534, ATS_ACTIVE_BIT, ATS_DATA);
}
if (diaNr != -1) {
@ -544,10 +544,10 @@ int Room97::proc9() {
_G(det)->startDetail(14, 255, false);
startAadWait(555);
_G(spieler).flags36_40 = true;
_G(atds)->set_steuer_bit(539, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(537, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(535, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->del_steuer_bit(543, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(539, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(537, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(535, ATS_ACTIVE_BIT, ATS_DATA);
_G(atds)->delControlBit(543, ATS_ACTIVE_BIT, ATS_DATA);
}
showCur();
@ -566,7 +566,7 @@ int Room97::proc10() {
startSetAILWait(7, 1, ANI_FRONT);
_G(det)->showStaticSpr(19);
_G(spieler).flags37_1 = true;
_G(atds)->set_steuer_bit(543, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(543, ATS_ACTIVE_BIT, ATS_DATA);
_G(menu_item) = CUR_WALK;
cursorChoice(CUR_WALK);
@ -678,7 +678,7 @@ void Room97::sensorAnim() {
_G(menu_item) = CUR_USE;
cursorChoice(CUR_USE);
setPersonPos(294, 42, P_CHEWY, P_LEFT);
_G(atds)->del_steuer_bit(541, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(541, ATS_ACTIVE_BIT, ATS_DATA);
_slimeThrown = false;
_G(det)->startDetail(16, 1, 0);
@ -738,7 +738,7 @@ void Room97::sensorAnim() {
_G(spieler).flags37_2 = true;
}
_G(atds)->set_steuer_bit(541, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(541, ATS_ACTIVE_BIT, ATS_DATA);
showCur();
_G(flags).AutoAniPlay = false;
}

10
engines/chewy/t_event.cpp
View File

@ -66,7 +66,7 @@ void setSsiPos() {
int16 atsAction(int16 txtNr, int16 txtMode, int16 mode) {
int16 retValue;
if (!_G(atds)->get_steuer_bit(txtNr, ATS_AKTIV_BIT, ATS_DATA)) {
if (!_G(atds)->getControlBit(txtNr, ATS_ACTIVE_BIT, ATS_DATA)) {
retValue = true;
if (_G(flags).AtsAction == false) {
_G(flags).AtsAction = true;
@ -286,7 +286,7 @@ int16 atsAction(int16 txtNr, int16 txtMode, int16 mode) {
if (_G(spieler).R16F5Exit) {
invent_2_slot(29);
_G(det)->hideStaticSpr(19);
_G(atds)->set_steuer_bit(158, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->setControlBit(158, ATS_ACTIVE_BIT, ATS_DATA);
}
switchRoom(18);
break;
@ -1179,7 +1179,7 @@ void selectDialogOption(int16 diaNr, int16 blkNr, int16 strEndNr) {
case 16:
if (blkNr == 0 && strEndNr == 2 && !_G(spieler).R56Kneipe)
_G(atds)->del_steuer_bit(362, ATS_AKTIV_BIT, ATS_DATA);
_G(atds)->delControlBit(362, ATS_ACTIVE_BIT, ATS_DATA);
break;
@ -2161,14 +2161,14 @@ void calc_inv_use_txt(int16 test_nr) {
int16 ret;
switch (test_nr) {
case GBUCH_OPEN_INV:
case NOTEBOOK_OPEN_INV:
case MONOCLE_INV:
scrollx = _G(spieler).scrollx;
scrolly = _G(spieler).scrolly;
_G(spieler).scrollx = 0;
_G(spieler).scrolly = 0;
_G(room)->load_tgp(BUCH_START, &_G(room_blk), GBOOK_TGP, 0, GBOOK);
_G(room)->load_tgp(NOTEBOOK_START, &_G(room_blk), GBOOK_TGP, 0, GBOOK);
_G(out)->setPointer(_G(workptr));
_G(out)->map_spr2screen(_G(ablage)[_G(room_blk).AkAblage], _G(spieler).scrollx, _G(spieler).scrolly);
_G(out)->back2screen(_G(workpage));

4
engines/chewy/types.h
View File

@ -34,11 +34,11 @@ struct SpielerFlags {
bool R0SlimeUsed : 1;
bool R0PillowThrow : 1;
bool R0Monocle : 1;
bool R0GBuch : 1;
bool R0Noteboook : 1;
bool R2ElectrocutedBork : 1;
bool R2FussSchleim : 1;
bool R5Terminal : 1;
bool R5Tuer : 1;
bool R5Door : 1;
bool R6BolaSchild : 1;
bool R6BolaOk : 1;