CGE: Rename Debug channel constants

11 files changed, 136 insertions, 138 deletions

diff --git a/engines/cge/bitmap.cpp b/engines/cge/bitmap.cpp
index 9d898506da..8f335fed60 100644
--- a/engines/cge/bitmap.cpp
+++ b/engines/cge/bitmap.cpp
@@ -48,7 +48,7 @@ void Bitmap::deinit() {
 
 #pragma argsused
 Bitmap::Bitmap(const char *fname, bool rem) : _m(NULL), _v(NULL), _map(0) {
-	debugC(1, kDebugBitmap, "Bitmap::Bitmap(%s, %s)", fname, rem ? "true" : "false");
+	debugC(1, kCGEDebugBitmap, "Bitmap::Bitmap(%s, %s)", fname, rem ? "true" : "false");
 
 	char pat[kMaxPath];
 	forceExt(pat, fname, ".VBM");
@@ -82,7 +82,7 @@ Bitmap::Bitmap(const char *fname, bool rem) : _m(NULL), _v(NULL), _map(0) {
 
 
 Bitmap::Bitmap(uint16 w, uint16 h, uint8 *map) : _w(w), _h(h), _m(map), _v(NULL), _map(0) {
-	debugC(1, kDebugBitmap, "Bitmap::Bitmap(%d, %d, map)", w, h);
+	debugC(1, kCGEDebugBitmap, "Bitmap::Bitmap(%d, %d, map)", w, h);
 	if (map)
 		code();
 }
@@ -96,7 +96,7 @@ Bitmap::Bitmap(uint16 w, uint16 h, uint8 fill)
 	  _h(h),
 	  _m(NULL),
 	  _map(0) {
-	debugC(1, kDebugBitmap, "Bitmap::Bitmap(%d, %d, %d)", w, h, fill);
+	debugC(1, kCGEDebugBitmap, "Bitmap::Bitmap(%d, %d, %d)", w, h, fill);
 
 	uint16 dsiz = _w >> 2;                           // data size (1 plane line size)
 	uint16 lsiz = 2 + dsiz + 2;                     // uint16 for line header, uint16 for gap
@@ -136,7 +136,7 @@ Bitmap::Bitmap(uint16 w, uint16 h, uint8 fill)
 
 
 Bitmap::Bitmap(const Bitmap &bmp) : _w(bmp._w), _h(bmp._h), _m(NULL), _v(NULL), _map(0) {
-	debugC(1, kDebugBitmap, "Bitmap::Bitmap(bmp)");
+	debugC(1, kCGEDebugBitmap, "Bitmap::Bitmap(bmp)");
 	uint8 *v0 = bmp._v;
 	if (v0) {
 		uint16 vsiz = (uint8 *)(bmp._b) - (uint8 *)(v0);
@@ -151,7 +151,7 @@ Bitmap::Bitmap(const Bitmap &bmp) : _w(bmp._w), _h(bmp._h), _m(NULL), _v(NULL),
 
 
 Bitmap::~Bitmap() {
-	debugC(6, kDebugBitmap, "Bitmap::~Bitmap()");
+	debugC(6, kCGEDebugBitmap, "Bitmap::~Bitmap()");
 
 	free(_m);
 	delete[] _v;
@@ -159,7 +159,7 @@ Bitmap::~Bitmap() {
 
 
 Bitmap &Bitmap::operator = (const Bitmap &bmp) {
-	debugC(1, kDebugBitmap, "&Bitmap::operator =");
+	debugC(1, kCGEDebugBitmap, "&Bitmap::operator =");
 
 	uint8 *v0 = bmp._v;
 	_w = bmp._w;
@@ -183,7 +183,7 @@ Bitmap &Bitmap::operator = (const Bitmap &bmp) {
 
 
 uint16 Bitmap::moveVmap(uint8 *buf) {
-	debugC(1, kDebugBitmap, "Bitmap::moveVmap(buf)");
+	debugC(1, kCGEDebugBitmap, "Bitmap::moveVmap(buf)");
 
 	if (_v) {
 		uint16 vsiz = (uint8 *)_b - (uint8 *)_v;
@@ -198,7 +198,7 @@ uint16 Bitmap::moveVmap(uint8 *buf) {
 
 
 BMP_PTR Bitmap::code() {
-	debugC(1, kDebugBitmap, "Bitmap::code()");
+	debugC(1, kCGEDebugBitmap, "Bitmap::code()");
 
 	if (!_m)
 		return false;
@@ -314,7 +314,7 @@ BMP_PTR Bitmap::code() {
 
 
 bool Bitmap::solidAt(int16 x, int16 y) {
-	debugC(6, kDebugBitmap, "Bitmap::solidAt(%d, %d)", x, y);
+	debugC(6, kCGEDebugBitmap, "Bitmap::solidAt(%d, %d)", x, y);
 
 	uint8 *m;
 	uint16 r, n, n0;
@@ -377,7 +377,7 @@ bool Bitmap::solidAt(int16 x, int16 y) {
 
 
 bool Bitmap::saveVBM(XFile *f) {
-	debugC(1, kDebugBitmap, "Bitmap::saveVBM(f)");
+	debugC(1, kCGEDebugBitmap, "Bitmap::saveVBM(f)");
 
 	uint16 p = (_pal != NULL),
 	       n = ((uint16)(((uint8 *)_b) - _v)) + _h * sizeof(HideDesc);
@@ -405,7 +405,7 @@ bool Bitmap::saveVBM(XFile *f) {
 
 
 bool Bitmap::loadVBM(XFile *f) {
-	debugC(5, kDebugBitmap, "Bitmap::loadVBM(f)");
+	debugC(5, kCGEDebugBitmap, "Bitmap::loadVBM(f)");
 
 	uint16 p = 0, n = 0;
 	if (f->_error == 0)
@@ -448,7 +448,7 @@ bool Bitmap::loadVBM(XFile *f) {
 }
 
 bool Bitmap::loadBMP(XFile *f) {
-	debugC(1, kDebugBitmap, "Bitmap::loadBMP(f)");
+	debugC(1, kCGEDebugBitmap, "Bitmap::loadBMP(f)");
 
 	struct {
 		char BM[2];
diff --git a/engines/cge/btfile.cpp b/engines/cge/btfile.cpp
index 8e4e8a756f..e3d9f729d9 100644
--- a/engines/cge/btfile.cpp
+++ b/engines/cge/btfile.cpp
@@ -36,7 +36,7 @@ namespace CGE {
 
 BtFile::BtFile(const char *name, IOMODE mode, CRYPT *crpt)
 	: IoHand(name, mode, crpt) {
-	debugC(1, kDebugFile, "BtFile::BtFile(%s, %d, crpt)", name, mode);
+	debugC(1, kCGEDebugFile, "BtFile::BtFile(%s, %d, crpt)", name, mode);
 
 	for (int i = 0; i < kBtLevel; i++) {
 		_buff[i]._page = new BtPage;
@@ -50,7 +50,7 @@ BtFile::BtFile(const char *name, IOMODE mode, CRYPT *crpt)
 
 
 BtFile::~BtFile() {
-	debugC(1, kDebugFile, "BtFile::~BtFile()");
+	debugC(1, kCGEDebugFile, "BtFile::~BtFile()");
 	for (int i = 0; i < kBtLevel; i++) {
 		putPage(i, false);
 		delete _buff[i]._page;
@@ -59,7 +59,7 @@ BtFile::~BtFile() {
 
 
 void BtFile::putPage(int lev, bool hard) {
-	debugC(1, kDebugFile, "BtFile::putPage(%d, %s)", lev, hard ? "true" : "false");
+	debugC(1, kCGEDebugFile, "BtFile::putPage(%d, %s)", lev, hard ? "true" : "false");
 
 	if (hard || _buff[lev]._updt) {
 		seek(_buff[lev]._pgNo * sizeof(BtPage));
@@ -70,7 +70,7 @@ void BtFile::putPage(int lev, bool hard) {
 
 
 BtPage *BtFile::getPage(int lev, uint16 pgn) {
-	debugC(1, kDebugFile, "BtFile::getPage(%d, %d)", lev, pgn);
+	debugC(1, kCGEDebugFile, "BtFile::getPage(%d, %d)", lev, pgn);
 
 	if (_buff[lev]._pgNo != pgn) {
 		int32 pos = pgn * sizeof(BtPage);
@@ -92,7 +92,7 @@ BtPage *BtFile::getPage(int lev, uint16 pgn) {
 }
 
 BtKeypack *BtFile::find(const char *key) {
-	debugC(1, kDebugFile, "BtFile::find(%s)", key);
+	debugC(1, kCGEDebugFile, "BtFile::find(%s)", key);
 
 	int lev = 0;
 	uint16 nxt = kBtValRoot;
@@ -129,7 +129,7 @@ int keycomp(const void *k1, const void *k2) {
 
 
 void BtFile::make(BtKeypack *keypack, uint16 count) {
-	debugC(1, kDebugFile, "BtFile::make(keypack, %d)", count);
+	debugC(1, kCGEDebugFile, "BtFile::make(keypack, %d)", count);
 
 #if kBtLevel != 2
 #error This tiny BTREE implementation works with exactly 2 levels!
diff --git a/engines/cge/cfile.cpp b/engines/cge/cfile.cpp
index 1486b78902..f0eeb30bff 100644
--- a/engines/cge/cfile.cpp
+++ b/engines/cge/cfile.cpp
@@ -38,7 +38,7 @@ IoBuf::IoBuf(IOMODE mode, CRYPT *crpt)
 	  _bufMark(0),
 	  _ptr(0),
 	  _lim(0) {
-	debugC(1, kDebugFile, "IoBuf::IoBuf(%d, crpt)", mode);
+	debugC(1, kCGEDebugFile, "IoBuf::IoBuf(%d, crpt)", mode);
 
 	_buff = (uint8 *) malloc(sizeof(uint8) * kBufferSize);
 	if (_buff == NULL)
@@ -51,7 +51,7 @@ IoBuf::IoBuf(const char *name, IOMODE mode, CRYPT *crpt)
 	  _bufMark(0),
 	  _ptr(0),
 	  _lim(0) {
-	debugC(1, kDebugFile, "IoBuf::IoBuf(%s, %d, crpt)", name, mode);
+	debugC(1, kCGEDebugFile, "IoBuf::IoBuf(%s, %d, crpt)", name, mode);
 
 	_buff = (uint8 *) malloc(sizeof(uint8) * kBufferSize);
 	if (_buff == NULL)
@@ -59,7 +59,7 @@ IoBuf::IoBuf(const char *name, IOMODE mode, CRYPT *crpt)
 }
 
 IoBuf::~IoBuf() {
-	debugC(6, kDebugFile, "IoBuf::~IoBuf()");
+	debugC(6, kCGEDebugFile, "IoBuf::~IoBuf()");
 
 	if (_mode > REA)
 		writeBuf();
@@ -68,7 +68,7 @@ IoBuf::~IoBuf() {
 
 
 void IoBuf::readBuf() {
-	debugC(4, kDebugFile, "IoBuf::readBuf()");
+	debugC(4, kCGEDebugFile, "IoBuf::readBuf()");
 
 	_bufMark = IoHand::mark();
 	_lim = IoHand::read(_buff, kBufferSize);
@@ -77,7 +77,7 @@ void IoBuf::readBuf() {
 
 
 void IoBuf::writeBuf() {
-	debugC(4, kDebugFile, "IoBuf::writeBuf()");
+	debugC(4, kCGEDebugFile, "IoBuf::writeBuf()");
 
 	if (_lim) {
 		IoHand::write(_buff, _lim);
@@ -88,7 +88,7 @@ void IoBuf::writeBuf() {
 
 
 uint16 IoBuf::read(void *buf, uint16 len) {
-	debugC(4, kDebugFile, "IoBuf::read(buf, %d)", len);
+	debugC(4, kCGEDebugFile, "IoBuf::read(buf, %d)", len);
 
 	uint16 total = 0;
 	while (len) {
@@ -111,7 +111,7 @@ uint16 IoBuf::read(void *buf, uint16 len) {
 
 
 uint16 IoBuf::read(uint8 *buf) {
-	debugC(3, kDebugFile, "IoBuf::read(buf)");
+	debugC(3, kCGEDebugFile, "IoBuf::read(buf)");
 
 	uint16 total = 0;
 
@@ -158,7 +158,7 @@ uint16 IoBuf::read(uint8 *buf) {
 
 
 uint16 IoBuf::write(void *buf, uint16 len) {
-	debugC(1, kDebugFile, "IoBuf::write(buf, %d)", len);
+	debugC(1, kCGEDebugFile, "IoBuf::write(buf, %d)", len);
 
 	uint16 tot = 0;
 	while (len) {
@@ -179,7 +179,7 @@ uint16 IoBuf::write(void *buf, uint16 len) {
 
 
 uint16 IoBuf::write(uint8 *buf) {
-	debugC(1, kDebugFile, "IoBuf::write(buf)");
+	debugC(1, kCGEDebugFile, "IoBuf::write(buf)");
 
 	uint16 len = 0;
 	if (buf) {
@@ -199,7 +199,7 @@ uint16 IoBuf::write(uint8 *buf) {
 
 
 int IoBuf::read() {
-	debugC(1, kDebugFile, "IoBuf::read()");
+	debugC(1, kCGEDebugFile, "IoBuf::read()");
 
 	if (_ptr >= _lim) {
 		readBuf();
@@ -211,7 +211,7 @@ int IoBuf::read() {
 
 
 void IoBuf::write(uint8 b) {
-	debugC(1, kDebugFile, "IoBuf::write(%d)", b);
+	debugC(1, kCGEDebugFile, "IoBuf::write(%d)", b);
 
 	if (_lim >= kBufferSize)
 		writeBuf();
@@ -224,7 +224,7 @@ uint16  CFile::_maxLineLen   = kLineMaxSize;
 
 CFile::CFile(const char *name, IOMODE mode, CRYPT *crpt)
 	: IoBuf(name, mode, crpt) {
-	debugC(1, kDebugFile, "CFile::CFile(%s, %d, crpt)", name, mode);
+	debugC(1, kCGEDebugFile, "CFile::CFile(%s, %d, crpt)", name, mode);
 }
 
 
@@ -233,7 +233,7 @@ CFile::~CFile() {
 
 
 void CFile::flush() {
-	debugC(1, kDebugFile, "CFile::flush()");
+	debugC(1, kCGEDebugFile, "CFile::flush()");
 
 	if (_mode > REA)
 		writeBuf();
@@ -250,14 +250,14 @@ void CFile::flush() {
 
 
 long CFile::mark() {
-	debugC(5, kDebugFile, "CFile::mark()");
+	debugC(5, kCGEDebugFile, "CFile::mark()");
 
 	return _bufMark + ((_mode > REA) ? _lim : _ptr);
 }
 
 
 long CFile::seek(long pos) {
-	debugC(1, kDebugFile, "CFile::seek(%ld)", pos);
+	debugC(1, kCGEDebugFile, "CFile::seek(%ld)", pos);
 
 	if (pos >= _bufMark && pos < _bufMark + _lim) {
 		((_mode == REA) ? _ptr : _lim) = (uint16)(pos - _bufMark);
@@ -275,7 +275,7 @@ long CFile::seek(long pos) {
 
 
 void CFile::append(CFile &f) {
-	debugC(1, kDebugFile, "CFile::append(f)");
+	debugC(1, kCGEDebugFile, "CFile::append(f)");
 
 	seek(size());
 	if (f._error == 0) {
diff --git a/engines/cge/cge.cpp b/engines/cge/cge.cpp
index 239fc89dfc..a3478b14f8 100644
--- a/engines/cge/cge.cpp
+++ b/engines/cge/cge.cpp
@@ -44,10 +44,9 @@ CGEEngine::CGEEngine(OSystem *syst, const ADGameDescription *gameDescription)
 	: Engine(syst), _gameDescription(gameDescription), _randomSource("cge") {
 
 	// Debug/console setup
-	DebugMan.addDebugChannel(kCGEDebug, "general", "CGE general debug channel");
-	DebugMan.addDebugChannel(kDebugBitmap, "bitmap", "CGE Bitmap debug channel");
-	DebugMan.addDebugChannel(kDebugFile, "file", "CGE IO debug channel");
-	DebugMan.addDebugChannel(kDebugEngine, "engine", "CGE Engine debug channel");
+	DebugMan.addDebugChannel(kCGEDebugBitmap, "bitmap", "CGE Bitmap debug channel");
+	DebugMan.addDebugChannel(kCGEDebugFile, "file", "CGE IO debug channel");
+	DebugMan.addDebugChannel(kCGEDebugEngine, "engine", "CGE Engine debug channel");
 
 	_isDemo      = _gameDescription->flags & ADGF_DEMO;
 	_startupMode = 1;
@@ -59,7 +58,7 @@ CGEEngine::CGEEngine(OSystem *syst, const ADGameDescription *gameDescription)
 }
 
 void CGEEngine::setup() {
-	debugC(1, kDebugEngine, "CGEEngine::setup()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::setup()");
 
 	// Initialise fields
 	_lastFrame = 0;
@@ -137,7 +136,7 @@ void CGEEngine::setup() {
 }
 
 CGEEngine::~CGEEngine() {
-	debugC(1, kDebugEngine, "CGEEngine::~CGEEngine()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::~CGEEngine()");
 
 	// Call classes with static members to clear them up
 	Talk::deinit();
@@ -175,7 +174,7 @@ CGEEngine::~CGEEngine() {
 }
 
 Common::Error CGEEngine::run() {
-	debugC(1, kDebugEngine, "CGEEngine::run()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::run()");
 
 	// Initialize graphics using following:
 	initGraphics(320, 200, false);
diff --git a/engines/cge/cge.h b/engines/cge/cge.h
index 011e08bb31..5bc97d6eff 100644
--- a/engines/cge/cge.h
+++ b/engines/cge/cge.h
@@ -44,10 +44,9 @@ class Sprite;
 
 // our engine debug channels
 enum {
-    kCGEDebug = 1 << 0,
-	kDebugBitmap = 1 << 1,
-	kDebugFile = 1 << 2,
-	kDebugEngine = 1 << 3
+	kCGEDebugBitmap = 1 << 0,
+	kCGEDebugFile = 1 << 1,
+	kCGEDebugEngine = 1 << 2
 };
 
 enum SnList {
diff --git a/engines/cge/cge_main.cpp b/engines/cge/cge_main.cpp
index a32356e08a..4b1b0b695e 100644
--- a/engines/cge/cge_main.cpp
+++ b/engines/cge/cge_main.cpp
@@ -104,7 +104,7 @@ Bar _barriers[1 + CAVE_MAX] = { { 0xFF, 0xFF } };
 extern Dac _stdPal[58];
 
 void CGEEngine::syncHeader(Common::Serializer &s) {
-	debugC(1, kDebugEngine, "CGEEngine::syncHeader(s)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::syncHeader(s)");
 
 	int i;
 
@@ -144,7 +144,7 @@ void CGEEngine::syncHeader(Common::Serializer &s) {
 }
 
 bool CGEEngine::loadGame(int slotNumber, SavegameHeader *header, bool tiny) {
-	debugC(1, kDebugEngine, "CGEEngine::loadgame(file, %s)", tiny ? "true" : "false");
+	debugC(1, kCGEDebugEngine, "CGEEngine::loadgame(file, %s)", tiny ? "true" : "false");
 
 	Common::MemoryReadStream *readStream;
 	SavegameHeader saveHeader;
@@ -362,7 +362,7 @@ void CGEEngine::syncGame(Common::SeekableReadStream *readStream, Common::WriteSt
 			}
 		}
 	}
-	debugC(1, kDebugEngine, "CGEEngine::saveSound()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::saveSound()");
 
 }
 
@@ -399,13 +399,13 @@ bool CGEEngine::readSavegameHeader(Common::InSaveFile *in, SavegameHeader &heade
 }
 
 void CGEEngine::heroCover(int cvr) {
-	debugC(1, kDebugEngine, "CGEEngine::heroCover(%d)", cvr);
+	debugC(1, kCGEDebugEngine, "CGEEngine::heroCover(%d)", cvr);
 
 	SNPOST(SNCOVER, 1, cvr, NULL);
 }
 
 void CGEEngine::trouble(int seq, int txt) {
-	debugC(1, kDebugEngine, "CGEEngine::trouble(%d, %d)", seq, txt);
+	debugC(1, kCGEDebugEngine, "CGEEngine::trouble(%d, %d)", seq, txt);
 
 	_hero->park();
 	SNPOST(SNWAIT, -1, -1, _hero);
@@ -416,19 +416,19 @@ void CGEEngine::trouble(int seq, int txt) {
 }
 
 void CGEEngine::offUse() {
-	debugC(1, kDebugEngine, "CGEEngine::offUse()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::offUse()");
 
 	trouble(OFF_USE, OFF_USE_TEXT + new_random(_offUseCount));
 }
 
 void CGEEngine::tooFar() {
-	debugC(1, kDebugEngine, "CGEEngine::tooFar()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::tooFar()");
 
 	trouble(TOO_FAR, TOO_FAR_TEXT);
 }
 
 void CGEEngine::loadHeroXY() {
-	debugC(1, kDebugEngine, "CGEEngine::loadHeroXY()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::loadHeroXY()");
 
 	INI_FILE cf(progName(".HXY"));
 	memset(_heroXY, 0, sizeof(_heroXY));
@@ -437,7 +437,7 @@ void CGEEngine::loadHeroXY() {
 }
 
 void CGEEngine::loadMapping() {
-	debugC(1, kDebugEngine, "CGEEngine::loadMapping()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::loadMapping()");
 
 	if (_now <= CAVE_MAX) {
 		INI_FILE cf(progName(".TAB"));
@@ -480,7 +480,7 @@ void SQUARE::touch(uint16 mask, int x, int y) {
 
 
 void CGEEngine::setMapBrick(int x, int z) {
-	debugC(1, kDebugEngine, "CGEEngine::setMapBrick(%d, %d)", x, z);
+	debugC(1, kCGEDebugEngine, "CGEEngine::setMapBrick(%d, %d)", x, z);
 
 	SQUARE *s = new SQUARE(this);
 	if (s) {
@@ -495,14 +495,14 @@ void CGEEngine::setMapBrick(int x, int z) {
 }
 
 void CGEEngine::keyClick() {
-	debugC(1, kDebugEngine, "CGEEngine::keyClick()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::keyClick()");
 
 	SNPOST_(SNSOUND, -1, 5, NULL);
 }
 
 
 void CGEEngine::resetQSwitch() {
-	debugC(1, kDebugEngine, "CGEEngine::resetQSwitch()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::resetQSwitch()");
 
 	SNPOST_(SNSEQ, 123,  0, NULL);
 	keyClick();
@@ -510,7 +510,7 @@ void CGEEngine::resetQSwitch() {
 
 
 void CGEEngine::quit() {
-	debugC(1, kDebugEngine, "CGEEngine::quit()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::quit()");
 
 	static Choice QuitMenu[] = { 
 		{ NULL, &CGEEngine::startCountDown },
@@ -534,13 +534,13 @@ void CGEEngine::quit() {
 
 
 void CGEEngine::AltCtrlDel() {
-	debugC(1, kDebugEngine, "CGEEngine::AltCtrlDel()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::AltCtrlDel()");
 
 	SNPOST_(SNSAY,  -1, A_C_D_TEXT, _hero);
 }
 
 void CGEEngine::miniStep(int stp) {
-	debugC(1, kDebugEngine, "CGEEngine::miniStep(%d)", stp);
+	debugC(1, kCGEDebugEngine, "CGEEngine::miniStep(%d)", stp);
 
 	if (stp < 0)
 		_miniCave->_flags._hide = true;
@@ -554,14 +554,14 @@ void CGEEngine::miniStep(int stp) {
 }
 
 void CGEEngine::postMiniStep(int step) {
-	debugC(6, kDebugEngine, "CGEEngine::postMiniStep(%d)", step);
+	debugC(6, kCGEDebugEngine, "CGEEngine::postMiniStep(%d)", step);
 
 	if (_miniCave && step != _recentStep)
 		SNPOST2_(SNEXEC, -1, _recentStep = step, kMiniStep);
 }
 
 void CGEEngine::showBak(int ref) {
-	debugC(1, kDebugEngine, "CGEEngine::showBack(%d)", ref);
+	debugC(1, kCGEDebugEngine, "CGEEngine::showBack(%d)", ref);
 
 	Sprite *spr = _vga->_spareQ->locate(ref);
 	if (spr) {
@@ -576,7 +576,7 @@ void CGEEngine::showBak(int ref) {
 }
 
 void CGEEngine::caveUp() {
-	debugC(1, kDebugEngine, "CGEEngine::caveUp()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::caveUp()");
 
 	int BakRef = 1000 * _now;
 	if (_music)
@@ -640,7 +640,7 @@ void CGEEngine::caveUp() {
 
 
 void CGEEngine::caveDown() {
-	debugC(1, kDebugEngine, "CGEEngine::caveDown()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::caveDown()");
 
 	Sprite *spr;
 	if (!_horzLine->_flags._hide)
@@ -659,14 +659,14 @@ void CGEEngine::caveDown() {
 }
 
 void CGEEngine::xCave() {
-	debugC(6, kDebugEngine, "CGEEngine::xCave()");
+	debugC(6, kCGEDebugEngine, "CGEEngine::xCave()");
 
 	caveDown();
 	caveUp();
 }
 
 void CGEEngine::qGame() {
-	debugC(1, kDebugEngine, "CGEEngine::qGame()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::qGame()");
 
 	caveDown();
 	_oldLev = _lev;
@@ -681,7 +681,7 @@ void CGEEngine::qGame() {
 
 
 void CGEEngine::switchCave(int cav) {
-	debugC(1, kDebugEngine, "CGEEngine::switchCave(%d)", cav);
+	debugC(1, kCGEDebugEngine, "CGEEngine::switchCave(%d)", cav);
 
 	if (cav != _now) {
 		_heart->_enable = false;
@@ -918,7 +918,7 @@ void System::tick() {
 }
 
 void CGEEngine::switchColorMode() {
-	debugC(1, kDebugEngine, "CGEEngine::switchColorMode()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::switchColorMode()");
 
 	SNPOST_(SNSEQ, 121, _vga->_mono = !_vga->_mono, NULL);
 	keyClick();
@@ -926,7 +926,7 @@ void CGEEngine::switchColorMode() {
 }
 
 void CGEEngine::switchMusic() {
-	debugC(1, kDebugEngine, "CGEEngine::switchMusic()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::switchMusic()");
 
 	if (_keyboard->_key[ALT]) {
 		if (Vmenu::_addr)
@@ -950,14 +950,14 @@ void CGEEngine::switchMusic() {
 }
 
 void CGEEngine::startCountDown() {
-	debugC(1, kDebugEngine, "CGEEngine::startCountDown()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::startCountDown()");
 
 	//SNPOST(SNSEQ, 123, 0, NULL);
 	switchCave(-1);
 }
 
 void CGEEngine::takeName() {
-	debugC(1, kDebugEngine, "CGEEngine::takeName()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::takeName()");
 
 	if (GetText::_ptr)
 		SNPOST_(SNKILL, -1, 0, GetText::_ptr);
@@ -975,7 +975,7 @@ void CGEEngine::takeName() {
 }
 
 void CGEEngine::switchMapping() {
-	debugC(1, kDebugEngine, "CGEEngine::switchMapping()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::switchMapping()");
 
 	if (_horzLine->_flags._hide) {
 		int i;
@@ -996,7 +996,7 @@ void CGEEngine::switchMapping() {
 }
 
 void CGEEngine::killSprite() {
-	debugC(1, kDebugEngine, "CGEEngine::killSprite()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::killSprite()");
 
 	_sprite->_flags._kill = true;
 	_sprite->_flags._bDel = true;
@@ -1005,7 +1005,7 @@ void CGEEngine::killSprite() {
 }
 
 void CGEEngine::pushSprite() {
-	debugC(1, kDebugEngine, "CGEEngine::pushSprite()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::pushSprite()");
 
 	Sprite *spr = _sprite->_prev;
 	if (spr) {
@@ -1017,7 +1017,7 @@ void CGEEngine::pushSprite() {
 }
 
 void CGEEngine::pullSprite() {
-	debugC(1, kDebugEngine, "CGEEngine::pullSprite()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::pullSprite()");
 
 	bool ok = false;
 	Sprite *spr = _sprite->_next;
@@ -1036,13 +1036,13 @@ void CGEEngine::pullSprite() {
 }
 
 void CGEEngine::nextStep() {
-	debugC(1, kDebugEngine, "CGEEngine::nextStep()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::nextStep()");
 
 	SNPOST_(SNSTEP, 0, 0, _sprite);
 }
 
 void CGEEngine::saveMapping() {
-	debugC(1, kDebugEngine, "CGEEngine::saveMapping()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::saveMapping()");
 
 	IoHand cfTab(progName(".TAB"), UPD);
 	if (!cfTab._error) {
diff --git a/engines/cge/config.cpp b/engines/cge/config.cpp
index b49d2b77ea..2649afc241 100644
--- a/engines/cge/config.cpp
+++ b/engines/cge/config.cpp
@@ -39,7 +39,7 @@ static Choice *_cho;
 static int     _hlp;
 
 void CGEEngine::snSelect() {
-	debugC(1, kDebugEngine, "CGEEngine::snSelect()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSelect()");
 
 	inf(_text->getText(_hlp));
 	_talk->gotoxy(_talk->_x, kFontHigh / 2);
diff --git a/engines/cge/snail.cpp b/engines/cge/snail.cpp
index b0f56be476..c4b4b383d0 100644
--- a/engines/cge/snail.cpp
+++ b/engines/cge/snail.cpp
@@ -46,7 +46,7 @@ extern  Sprite *_pocLight;
 extern  Sprite *_pocket[];
 
 void CGEEngine::snGame(Sprite *spr, int num) {
-	debugC(1, kDebugEngine, "CGEEngine::snGame(spr, %d)", num);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snGame(spr, %d)", num);
 
 	switch (num) {
 	case 1 : {
@@ -257,7 +257,7 @@ void CGEEngine::snGame(Sprite *spr, int num) {
 
 
 void CGEEngine::expandSprite(Sprite *spr) {
-	debugC(5, kDebugEngine, "CGEEngine::expandSprite(spr)");
+	debugC(5, kCGEDebugEngine, "CGEEngine::expandSprite(spr)");
 
 	if (spr)
 		_vga->_showQ->insert(_vga->_spareQ->remove(spr));
@@ -265,14 +265,14 @@ void CGEEngine::expandSprite(Sprite *spr) {
 
 
 void CGEEngine::contractSprite(Sprite *spr) {
-	debugC(1, kDebugEngine, "CGEEngine::contractSprite(spr)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::contractSprite(spr)");
 
 	if (spr)
 		_vga->_spareQ->append(_vga->_showQ->remove(spr));
 }
 
 int CGEEngine::findPocket(Sprite *spr) {
-	debugC(1, kDebugEngine, "CGEEngine::findPocket(spr)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::findPocket(spr)");
 
 	for (int i = 0; i < POCKET_NX; i++)
 	if (_pocket[i] == spr)
@@ -282,7 +282,7 @@ int CGEEngine::findPocket(Sprite *spr) {
 
 
 void CGEEngine::selectPocket(int n) {
-	debugC(1, kDebugEngine, "CGEEngine::selectPocket(%d)", n);
+	debugC(1, kCGEDebugEngine, "CGEEngine::selectPocket(%d)", n);
 
 	if (n < 0 || (_pocLight->_seqPtr && _pocPtr == n)) {
 		_pocLight->step(0);
@@ -299,7 +299,7 @@ void CGEEngine::selectPocket(int n) {
 }
 
 void CGEEngine::pocFul() {
-	debugC(1, kDebugEngine, "CGEEngine::pocFul()");
+	debugC(1, kCGEDebugEngine, "CGEEngine::pocFul()");
 
 	_hero->park();
 	SNPOST(SNWAIT, -1, -1, _hero);
@@ -310,13 +310,13 @@ void CGEEngine::pocFul() {
 }
 
 void CGEEngine::hide1(Sprite *spr) {
-	debugC(1, kDebugEngine, "CGEEngine::hide1(spr)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::hide1(spr)");
 
 	SNPOST_(SNGHOST, -1, 0, spr->ghost());
 }
 
 void CGEEngine::snGhost(Bitmap *bmp) {
-	debugC(1, kDebugEngine, "CGEEngine::snGhost(bmp)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snGhost(bmp)");
 
 	bmp->hide(bmp->_map & 0xFFFF, bmp->_map >> 16);
 	bmp->_m = NULL;
@@ -325,7 +325,7 @@ void CGEEngine::snGhost(Bitmap *bmp) {
 }
 
 void CGEEngine::feedSnail(Sprite *spr, SnList snq) {
-	debugC(1, kDebugEngine, "CGEEngine::feedSnail(spr, snq)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::feedSnail(spr, snq)");
 
 	if (spr)
 		if (spr->active()) {
@@ -473,7 +473,7 @@ void Snail::insCom(SNCOM com, int ref, int val, void *ptr) {
 }
 
 void CGEEngine::snNNext(Sprite *spr, int p) {
-	debugC(1, kDebugEngine, "CGEEngine::snNNext(spr, %d)", p);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snNNext(spr, %d)", p);
 
 	if (spr)
 		if (spr->_nearPtr != NO_PTR)
@@ -481,7 +481,7 @@ void CGEEngine::snNNext(Sprite *spr, int p) {
 }
 
 void CGEEngine::snTNext(Sprite *spr, int p) {
-	debugC(1, kDebugEngine, "CGEEngine::snTNext(spr, %d)", p);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snTNext(spr, %d)", p);
 
 	if (spr)
 		if (spr->_takePtr != NO_PTR)
@@ -489,7 +489,7 @@ void CGEEngine::snTNext(Sprite *spr, int p) {
 }
 
 void CGEEngine::snRNNext(Sprite *spr, int p) {
-	debugC(1, kDebugEngine, "CGEEngine::snRNNext(spr, %d)", p);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snRNNext(spr, %d)", p);
 
 	if (spr)
 		if (spr->_nearPtr != NO_PTR)
@@ -498,7 +498,7 @@ void CGEEngine::snRNNext(Sprite *spr, int p) {
 
 
 void CGEEngine::snRTNext(Sprite *spr, int p) {
-	debugC(1, kDebugEngine, "CGEEngine::snRTNext(spr, %d)", p);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snRTNext(spr, %d)", p);
 
 	if (spr)
 		if (spr->_takePtr != NO_PTR)
@@ -506,7 +506,7 @@ void CGEEngine::snRTNext(Sprite *spr, int p) {
 }
 
 void CGEEngine::snZTrim(Sprite *spr) {
-	debugC(4, kDebugEngine, "CGEEngine::snZTrim(spr)");
+	debugC(4, kCGEDebugEngine, "CGEEngine::snZTrim(spr)");
 
 	if (spr)
 		if (spr->active()) {
@@ -524,7 +524,7 @@ void CGEEngine::snZTrim(Sprite *spr) {
 }
 
 void CGEEngine::snHide(Sprite *spr, int val) {
-	debugC(1, kDebugEngine, "CGEEngine::snHide(spr, %d)", val);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snHide(spr, %d)", val);
 
 	if (spr) {
 		spr->_flags._hide = (val >= 0) ? (val != 0) : (!spr->_flags._hide);
@@ -534,21 +534,21 @@ void CGEEngine::snHide(Sprite *spr, int val) {
 }
 
 void CGEEngine::snRmNear(Sprite *spr) {
-	debugC(1, kDebugEngine, "CGEEngine::snRmNear(spr)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snRmNear(spr)");
 
 	if (spr)
 		spr->_nearPtr = NO_PTR;
 }
 
 void CGEEngine::snRmTake(Sprite *spr) {
-	debugC(1, kDebugEngine, "CGEEngine::snRmTake(spr)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snRmTake(spr)");
 
 	if (spr)
 		spr->_takePtr = NO_PTR;
 }
 
 void CGEEngine::snSeq(Sprite *spr, int val) {
-	debugC(1, kDebugEngine, "CGEEngine::snSeq(spr, %d)", val);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSeq(spr, %d)", val);
 
 	if (spr) {
 		if (spr == _hero && val == 0)
@@ -559,14 +559,14 @@ void CGEEngine::snSeq(Sprite *spr, int val) {
 }
 
 void CGEEngine::snRSeq(Sprite *spr, int val) {
-	debugC(1, kDebugEngine, "CGEEngine::snRSeq(spr, %d)", val);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snRSeq(spr, %d)", val);
 
 	if (spr)
 		snSeq(spr, spr->_seqPtr + val);
 }
 
 void CGEEngine::snSend(Sprite *spr, int val) {
-	debugC(1, kDebugEngine, "CGEEngine::snSend(spr, %d)", val);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSend(spr, %d)", val);
 
 	if (spr) {
 		int was = spr->_cave;
@@ -598,7 +598,7 @@ void CGEEngine::snSend(Sprite *spr, int val) {
 
 
 void CGEEngine::snSwap(Sprite *spr, int xref) {
-	debugC(1, kDebugEngine, "CGEEngine::snSwap(spr, %d)", xref);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSwap(spr, %d)", xref);
 
 	Sprite *xspr = locate(xref);
 	if (spr && xspr) {
@@ -635,7 +635,7 @@ void CGEEngine::snSwap(Sprite *spr, int xref) {
 
 
 void CGEEngine::snCover(Sprite *spr, int xref) {
-	debugC(1, kDebugEngine, "CGEEngine::snCover(spr, %d)", xref);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snCover(spr, %d)", xref);
 
 	Sprite *xspr = locate(xref);
 	if (spr && xspr) {
@@ -654,7 +654,7 @@ void CGEEngine::snCover(Sprite *spr, int xref) {
 
 
 void CGEEngine::snUncover(Sprite *spr, Sprite *xspr) {
-	debugC(1, kDebugEngine, "CGEEngine::snUncover(spr, xspr)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snUncover(spr, xspr)");
 
 	if (spr && xspr) {
 		spr->_flags._hide = false;
@@ -673,33 +673,33 @@ void CGEEngine::snUncover(Sprite *spr, Sprite *xspr) {
 
 
 void CGEEngine::snSetX0(int cav, int x0) {
-	debugC(1, kDebugEngine, "CGEEngine::snSetX0(%d, %d)", cav, x0);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSetX0(%d, %d)", cav, x0);
 
 	_heroXY[cav - 1]._x = x0;
 }
 
 void CGEEngine::snSetY0(int cav, int y0) {
-	debugC(1, kDebugEngine, "CGEEngine::snSetY0(%d, %d)", cav, y0);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSetY0(%d, %d)", cav, y0);
 
 	_heroXY[cav - 1]._y = y0;
 }
 
 void CGEEngine::snSetXY(Sprite *spr, uint16 xy) {
-	debugC(1, kDebugEngine, "CGEEngine::snSetXY(spr, %d)", xy);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSetXY(spr, %d)", xy);
 
 	if (spr)
 		spr->gotoxy(xy % SCR_WID, xy / SCR_WID);
 }
 
 void CGEEngine::snRelX(Sprite *spr, int x) {
-	debugC(1, kDebugEngine, "CGEEngine::snRelX(spr, %d)", x);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snRelX(spr, %d)", x);
 
 	if (spr && _hero)
 		spr->gotoxy(_hero->_x + x, spr->_y);
 }
 
 void CGEEngine::snRelY(Sprite *spr, int y) {
-	debugC(1, kDebugEngine, "CGEEngine::snRelY(spr, %d)", y);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snRelY(spr, %d)", y);
 
 	if (spr && _hero)
 		spr->gotoxy(spr->_x, _hero->_y + y);
@@ -707,7 +707,7 @@ void CGEEngine::snRelY(Sprite *spr, int y) {
 
 
 void CGEEngine::snRelZ(Sprite *spr, int z) {
-	debugC(1, kDebugEngine, "CGEEngine::snRelZ(spr, %d)", z);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snRelZ(spr, %d)", z);
 
 	if (spr && _hero) {
 		spr->_z = _hero->_z + z;
@@ -717,7 +717,7 @@ void CGEEngine::snRelZ(Sprite *spr, int z) {
 
 
 void CGEEngine::snSetX(Sprite *spr, int x) {
-	debugC(1, kDebugEngine, "CGEEngine::snSetX(spr, %d)", x);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSetX(spr, %d)", x);
 
 	if (spr)
 		spr->gotoxy(x, spr->_y);
@@ -725,7 +725,7 @@ void CGEEngine::snSetX(Sprite *spr, int x) {
 
 
 void CGEEngine::snSetY(Sprite *spr, int y) {
-	debugC(1, kDebugEngine, "CGEEngine::snSetY(spr, %d)", y);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSetY(spr, %d)", y);
 
 	if (spr)
 		spr->gotoxy(spr->_x, y);
@@ -733,7 +733,7 @@ void CGEEngine::snSetY(Sprite *spr, int y) {
 
 
 void CGEEngine::snSetZ(Sprite *spr, int z) {
-	debugC(1, kDebugEngine, "CGEEngine::snSetZ(spr, %d)", z);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSetZ(spr, %d)", z);
 
 	if (spr) {
 		spr->_z = z;
@@ -744,7 +744,7 @@ void CGEEngine::snSetZ(Sprite *spr, int z) {
 
 
 void CGEEngine::snSlave(Sprite *spr, int ref) {
-	debugC(1, kDebugEngine, "CGEEngine::snSlave(spr, %d)", ref);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSlave(spr, %d)", ref);
 
 	Sprite *slv = locate(ref);
 	if (spr && slv) {
@@ -759,21 +759,21 @@ void CGEEngine::snSlave(Sprite *spr, int ref) {
 
 
 void CGEEngine::snTrans(Sprite *spr, int trans) {
-	debugC(1, kDebugEngine, "CGEEngine::snTrans(spr, %d)", trans);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snTrans(spr, %d)", trans);
 
 	if (spr)
 		spr->_flags._tran = (trans < 0) ? !spr->_flags._tran : (trans != 0);
 }
 
 void CGEEngine::snPort(Sprite *spr, int port) {
-	debugC(1, kDebugEngine, "CGEEngine::snPort(spr, %d)", port);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snPort(spr, %d)", port);
 
 	if (spr)
 		spr->_flags._port = (port < 0) ? !spr->_flags._port : (port != 0);
 }
 
 void CGEEngine::snKill(Sprite *spr) {
-	debugC(1, kDebugEngine, "CGEEngine::snKill(spr)");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snKill(spr)");
 
 	if (spr) {
 		if (spr->_flags._kept) {
@@ -800,7 +800,7 @@ void CGEEngine::snKill(Sprite *spr) {
 
 
 void CGEEngine::snSound(Sprite *spr, int wav, int cnt) {
-	debugC(1, kDebugEngine, "CGEEngine::snSound(spr, %d, %d)", wav, cnt);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSound(spr, %d, %d)", wav, cnt);
 
 	if (_sndDrvInfo._dDev) {
 		if (wav == -1)
@@ -812,7 +812,7 @@ void CGEEngine::snSound(Sprite *spr, int wav, int cnt) {
 
 
 void CGEEngine::snKeep(Sprite *spr, int stp) {
-	debugC(1, kDebugEngine, "CGEEngine::snKeep(spr, %d)", stp);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snKeep(spr, %d)", stp);
 
 	selectPocket(-1);
 	if (spr && ! spr->_flags._kept && _pocket[_pocPtr] == NULL) {
@@ -830,7 +830,7 @@ void CGEEngine::snKeep(Sprite *spr, int stp) {
 
 
 void CGEEngine::snGive(Sprite *spr, int stp) {
-	debugC(1, kDebugEngine, "CGEEngine::snGive(spr, %d)", stp);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snGive(spr, %d)", stp);
 
 	if (spr) {
 		int p = findPocket(spr);
@@ -847,7 +847,7 @@ void CGEEngine::snGive(Sprite *spr, int stp) {
 
 
 void CGEEngine::snBackPt(Sprite *spr, int stp) {
-	debugC(1, kDebugEngine, "CGEEngine::snBackPt(spr, %d)", stp);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snBackPt(spr, %d)", stp);
 
 	if (spr) {
 		if (stp >= 0)
@@ -857,7 +857,7 @@ void CGEEngine::snBackPt(Sprite *spr, int stp) {
 }
 
 void CGEEngine::snLevel(Sprite *spr, int lev) {
-	debugC(1, kDebugEngine, "CGEEngine::snLevel(spr, %d)", lev);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snLevel(spr, %d)", lev);
 
 	while (_lev < lev) {
 		_lev++;
@@ -878,14 +878,14 @@ void CGEEngine::snFlag(int indx, bool v) {
 }
 
 void CGEEngine::snSetRef(Sprite *spr, int nr) {
-	debugC(1, kDebugEngine, "CGEEngine::snSetRef(spr, %d)", nr);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snSetRef(spr, %d)", nr);
 
 	if (spr)
 		spr->_ref = nr;
 }
 
 void CGEEngine::snFlash(bool on) {
-	debugC(1, kDebugEngine, "CGEEngine::snFlash(%s)", on ? "true" : "false");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snFlash(%s)", on ? "true" : "false");
 
 	if (on) {
 		Dac *pal = (Dac *) malloc(sizeof(Dac) * PAL_CNT);
@@ -909,7 +909,7 @@ void CGEEngine::snFlash(bool on) {
 
 
 void CGEEngine::snLight(bool in) {
-	debugC(1, kDebugEngine, "CGEEngine::snLight(%s)", in ? "true" : "false");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snLight(%s)", in ? "true" : "false");
 
 	if (in)
 		_vga->sunrise(Vga::_sysPal);
@@ -919,13 +919,13 @@ void CGEEngine::snLight(bool in) {
 }
 
 void CGEEngine::snBarrier(int cav, int bar, bool horz) {
-	debugC(1, kDebugEngine, "CGEEngine::snBarrier(%d, %d, %s)", cav, bar, horz ? "true" : "false");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snBarrier(%d, %d, %s)", cav, bar, horz ? "true" : "false");
 
 	((uint8 *)(_barriers + ((cav > 0) ? cav : _now)))[horz] = bar;
 }
 
 void CGEEngine::snWalk(Sprite *spr, int x, int y) {
-	debugC(1, kDebugEngine, "CGEEngine::snWalk(spr, %d, %d)", x, y);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snWalk(spr, %d, %d)", x, y);
 
 	if (_hero) {
 		if (spr && y < 0)
@@ -936,14 +936,14 @@ void CGEEngine::snWalk(Sprite *spr, int x, int y) {
 }
 
 void CGEEngine::snReach(Sprite *spr, int mode) {
-	debugC(1, kDebugEngine, "CGEEngine::snReach(spr, %d)", mode);
+	debugC(1, kCGEDebugEngine, "CGEEngine::snReach(spr, %d)", mode);
 
 	if (_hero)
 		_hero->reach(spr, mode);
 }
 
 void CGEEngine::snMouse(bool on) {
-	debugC(1, kDebugEngine, "CGEEngine::snMouse(%s)", on ? "true" : "false");
+	debugC(1, kCGEDebugEngine, "CGEEngine::snMouse(%s)", on ? "true" : "false");
 
 	if (on)
 		_mouse->on();
diff --git a/engines/cge/text.cpp b/engines/cge/text.cpp
index fd37dada8b..1ed640be8a 100644
--- a/engines/cge/text.cpp
+++ b/engines/cge/text.cpp
@@ -218,7 +218,7 @@ void Text::say(const char *txt, Sprite *spr) {
 }
 
 void CGEEngine::inf(const char *txt) {
-	debugC(1, kDebugEngine, "CGEEngine::inf(%s)", txt);
+	debugC(1, kCGEDebugEngine, "CGEEngine::inf(%s)", txt);
 
 	killText();
 	_talk = new Talk(this, txt, RECT);
diff --git a/engines/cge/vga13h.cpp b/engines/cge/vga13h.cpp
index 6fc17dc37b..6093681292 100644
--- a/engines/cge/vga13h.cpp
+++ b/engines/cge/vga13h.cpp
@@ -1213,7 +1213,7 @@ void Vga::copyPage(uint16 d, uint16 s) {
 //--------------------------------------------------------------------------
 
 void Bitmap::xShow(int16 x, int16 y) {
-	debugC(4, kDebugBitmap, "Bitmap::xShow(%d, %d)", x, y);
+	debugC(4, kCGEDebugBitmap, "Bitmap::xShow(%d, %d)", x, y);
 
 	const byte *srcP = (const byte *)_v;
 	byte *destEndP = (byte *)Vga::_page[1]->pixels + (SCR_WID * SCR_HIG);
@@ -1266,7 +1266,7 @@ void Bitmap::xShow(int16 x, int16 y) {
 
 
 void Bitmap::show(int16 x, int16 y) {
-	debugC(5, kDebugBitmap, "Bitmap::show(%d, %d)", x, y);
+	debugC(5, kCGEDebugBitmap, "Bitmap::show(%d, %d)", x, y);
 
 	const byte *srcP = (const byte *)_v;
 	byte *destEndP = (byte *)Vga::_page[1]->pixels + (SCR_WID * SCR_HIG);
@@ -1330,7 +1330,7 @@ void Bitmap::show(int16 x, int16 y) {
 
 
 void Bitmap::hide(int16 x, int16 y) {
-	debugC(5, kDebugBitmap, "Bitmap::hide(%d, %d)", x, y);
+	debugC(5, kCGEDebugBitmap, "Bitmap::hide(%d, %d)", x, y);
 
 	for (int yp = y; yp < y + _h; yp++) {
 		const byte *srcP = (const byte *)Vga::_page[2]->getBasePtr(x, yp);
diff --git a/engines/cge/vol.cpp b/engines/cge/vol.cpp
index 94ec2fc7ad..63f3fadd1c 100644
--- a/engines/cge/vol.cpp
+++ b/engines/cge/vol.cpp
@@ -47,13 +47,13 @@ Dat::Dat():
 	_file(DAT_NAME, REA, CRP)
 #endif
 {
-	debugC(1, kDebugFile, "Dat::Dat()");
+	debugC(1, kCGEDebugFile, "Dat::Dat()");
 }
 
 /*-----------------------------------------------------------------------*/
 
 void VFile::init() {
-	debugC(1, kDebugFile, "VFile::init()");
+	debugC(1, kCGEDebugFile, "VFile::init()");
 
 	_dat = new Dat();
 #ifdef VOL_UPD
@@ -72,7 +72,7 @@ void VFile::deinit() {
 
 VFile::VFile(const char *name, IOMODE mode)
 	: IoBuf(mode) {
-	debugC(3, kDebugFile, "VFile::VFile(%s, %d)", name, mode);
+	debugC(3, kCGEDebugFile, "VFile::VFile(%s, %d)", name, mode);
 
 	if (mode == REA) {
 		if (_dat->_file._error || _cat->_error)
@@ -96,14 +96,14 @@ VFile::~VFile() {
 
 
 bool VFile::exist(const char *name) {
-	debugC(1, kDebugFile, "VFile::exist(%s)", name);
+	debugC(1, kCGEDebugFile, "VFile::exist(%s)", name);
 
 	return scumm_stricmp(_cat->find(name)->_key, name) == 0;
 }
 
 
 void VFile::readBuf() {
-	debugC(3, kDebugFile, "VFile::readBuf()");
+	debugC(3, kCGEDebugFile, "VFile::readBuf()");
 
 	if (_recent != this) {
 		_dat->_file.seek(_bufMark + _lim);
@@ -118,19 +118,19 @@ void VFile::readBuf() {
 }
 
 long VFile::mark() {
-	debugC(5, kDebugFile, "VFile::mark()");
+	debugC(5, kCGEDebugFile, "VFile::mark()");
 
 	return (_bufMark + _ptr) - _begMark;
 }
 
 long VFile::size() {
-	debugC(1, kDebugFile, "VFile::size()");
+	debugC(1, kCGEDebugFile, "VFile::size()");
 
 	return _endMark - _begMark;
 }
 
 long VFile::seek(long pos) {
-	debugC(1, kDebugFile, "VFile::seel(%ld)", pos);
+	debugC(1, kCGEDebugFile, "VFile::seel(%ld)", pos);
 
 	_recent = NULL;
 	_lim = 0;