CGE: Rename Snail into CommandHandler, plus some associated renamings

9 files changed, 364 insertions, 364 deletions

diff --git a/engines/cge/cge.cpp b/engines/cge/cge.cpp
index b8ccbc8638..4ed2932cd9 100644
--- a/engines/cge/cge.cpp
+++ b/engines/cge/cge.cpp
@@ -100,8 +100,8 @@ void CGEEngine::init() {
 	_infoLine = new InfoLine(this, kInfoW);
 	_sceneLight = new SceneLight(this);
 	_debugLine = new InfoLine(this, kScrWidth);
-	_snail = new Snail(this, false);
-	_snail_ = new Snail(this, true);
+	_commandHandler = new CommandHandler(this, false);
+	_commandHandlerTurbo = new CommandHandler(this, true);
 	_midiPlayer = new MusicPlayer(this);
 	_mouse = new Mouse(this);
 	_keyboard = new Keyboard(this);
@@ -164,8 +164,8 @@ void CGEEngine::deinit() {
 	delete _fx;
 	delete _sound;
 	delete _font;
-	delete _snail;
-	delete _snail_;
+	delete _commandHandler;
+	delete _commandHandlerTurbo;
 	delete _hero;
 	delete _resman;
 
diff --git a/engines/cge/cge.h b/engines/cge/cge.h
index 5731f8f37e..2ce154a4fb 100644
--- a/engines/cge/cge.h
+++ b/engines/cge/cge.h
@@ -48,7 +48,7 @@ class Mouse;
 class HorizLine;
 class InfoLine;
 class SceneLight;
-class Snail;
+class CommandHandler;
 class EventManager;
 class ResourceManager;
 class Walk;
@@ -88,7 +88,7 @@ enum SnList {
 };
 
 enum CallbackType {
-	kNullCB = 0, kQGame, kMiniStep, kXScene, kSndSetVolume
+	kNullCB = 0, kQGame, kMiniStep, kXScene, kSoundSetVolume
 };
 
 struct SavegameHeader {
@@ -183,8 +183,8 @@ public:
 	InfoLine *_infoLine;
 	InfoLine *_debugLine;
 	SceneLight *_sceneLight;
-	Snail *_snail;
-	Snail *_snail_;
+	CommandHandler *_commandHandler;
+	CommandHandler *_commandHandlerTurbo;
 	EventManager *_eventManager;
 	Fx *_fx;
 	Sound *_sound;
diff --git a/engines/cge/cge_main.cpp b/engines/cge/cge_main.cpp
index d2ca81bfce..51cf3bb621 100644
--- a/engines/cge/cge_main.cpp
+++ b/engines/cge/cge_main.cpp
@@ -281,7 +281,7 @@ Common::Error CGEEngine::loadGameState(int slot) {
 
 	// Load the game
 	loadGame(slot, NULL);
-	_snail->addCommand(kSnLevel, -1, _oldLev, &_sceneLight);
+	_commandHandler->addCommand(kCmdLevel, -1, _oldLev, &_sceneLight);
 	_sceneLight->gotoxy(kSceneX + ((_now - 1) % kSceneNx) * kSceneDx + kSceneSX,
 	                  kSceneY + ((_now - 1) / kSceneNx) * kSceneDy + kSceneSY);
 	sceneUp();
@@ -442,18 +442,18 @@ bool CGEEngine::readSavegameHeader(Common::InSaveFile *in, SavegameHeader &heade
 void CGEEngine::heroCover(int cvr) {
 	debugC(1, kCGEDebugEngine, "CGEEngine::heroCover(%d)", cvr);
 
-	_snail->addCommand(kSnCover, 1, cvr, NULL);
+	_commandHandler->addCommand(kCmdCover, 1, cvr, NULL);
 }
 
 void CGEEngine::trouble(int seq, int text) {
 	debugC(1, kCGEDebugEngine, "CGEEngine::trouble(%d, %d)", seq, text);
 
 	_hero->park();
-	_snail->addCommand(kSnWait, -1, -1, _hero);
-	_snail->addCommand(kSnSeq, -1, seq, _hero);
-	_snail->addCommand(kSnSound, -1, 2, _hero);
-	_snail->addCommand(kSnWait, -1, -1, _hero);
-	_snail->addCommand(kSnSay,  1, text, _hero);
+	_commandHandler->addCommand(kCmdWait, -1, -1, _hero);
+	_commandHandler->addCommand(kCmdSeq, -1, seq, _hero);
+	_commandHandler->addCommand(kCmdSound, -1, 2, _hero);
+	_commandHandler->addCommand(kCmdWait, -1, -1, _hero);
+	_commandHandler->addCommand(kCmdSay,  1, text, _hero);
 }
 
 void CGEEngine::offUse() {
@@ -517,7 +517,7 @@ void Square::touch(uint16 mask, int x, int y) {
 	Sprite::touch(mask, x, y);
 	if (mask & kMouseLeftUp) {
 		_vm->XZ(_x + x, _y + y).cell() = 0;
-		_vm->_snail_->addCommand(kSnKill, -1, 0, this);
+		_vm->_commandHandlerTurbo->addCommand(kCmdKill, -1, 0, this);
 	}
 }
 
@@ -538,13 +538,13 @@ void CGEEngine::setMapBrick(int x, int z) {
 void CGEEngine::keyClick() {
 	debugC(1, kCGEDebugEngine, "CGEEngine::keyClick()");
 
-	_snail_->addCommand(kSnSound, -1, 5, NULL);
+	_commandHandlerTurbo->addCommand(kCmdSound, -1, 5, NULL);
 }
 
 void CGEEngine::resetQSwitch() {
 	debugC(1, kCGEDebugEngine, "CGEEngine::resetQSwitch()");
 
-	_snail_->addCommand(kSnSeq, 123,  0, NULL);
+	_commandHandlerTurbo->addCommand(kCmdSeq, 123,  0, NULL);
 	keyClick();
 }
 
@@ -557,15 +557,15 @@ void CGEEngine::quit() {
 		{ NULL, &CGEEngine::dummy          }
 	};
 
-	if (_snail->idle() && !_hero->_flags._hide) {
+	if (_commandHandler->idle() && !_hero->_flags._hide) {
 		if (Vmenu::_addr) {
-			_snail_->addCommand(kSnKill, -1, 0, Vmenu::_addr);
+			_commandHandlerTurbo->addCommand(kCmdKill, -1, 0, Vmenu::_addr);
 			resetQSwitch();
 		} else {
 			QuitMenu[0]._text = _text->getText(kQuit);
 			QuitMenu[1]._text = _text->getText(kNoQuit);
 			(new Vmenu(this, QuitMenu, -1, -1))->setName(_text->getText(kQuitTitle));
-			_snail_->addCommand(kSnSeq, 123, 1, NULL);
+			_commandHandlerTurbo->addCommand(kCmdSeq, 123, 1, NULL);
 			keyClick();
 		}
 	}
@@ -586,7 +586,7 @@ void CGEEngine::postMiniStep(int step) {
 	debugC(6, kCGEDebugEngine, "CGEEngine::postMiniStep(%d)", step);
 
 	if (_miniScene && step != _recentStep)
-		_snail_->addCallback(kSnExec, -1, _recentStep = step, kMiniStep);
+		_commandHandlerTurbo->addCallback(kCmdExec, -1, _recentStep = step, kMiniStep);
 }
 
 void CGEEngine::showBak(int ref) {
@@ -708,8 +708,8 @@ void CGEEngine::switchScene(int newScene) {
 		return;
 
 	if (newScene < 0) {
-		_snail->addCommand(kSnLabel, -1, 0, NULL);  // wait for repaint
-		_snail->addCallback(kSnExec,  -1, 0, kQGame); // quit game
+		_commandHandler->addCommand(kCmdLabel, -1, 0, NULL);  // wait for repaint
+		_commandHandler->addCallback(kCmdExec,  -1, 0, kQGame); // quit game
 	} else {
 		_now = newScene;
 		_mouse->off();
@@ -723,8 +723,8 @@ void CGEEngine::switchScene(int newScene) {
 		killText();
 		if (!_startupMode)
 			keyClick();
-		_snail->addCommand(kSnLabel, -1, 0, NULL);  // wait for repaint
-		_snail->addCallback(kSnExec,  0, 0, kXScene); // switch scene
+		_commandHandler->addCommand(kCmdLabel, -1, 0, NULL);  // wait for repaint
+		_commandHandler->addCallback(kCmdExec,  0, 0, kXScene); // switch scene
 	}
 }
 
@@ -756,7 +756,7 @@ void System::touch(uint16 mask, int x, int y) {
 		_vm->keyClick();
 		_vm->killText();
 		if (_vm->_startupMode == 1) {
-			_vm->_snail->addCommand(kSnClear, -1, 0, NULL);
+			_vm->_commandHandler->addCommand(kCmdClear, -1, 0, NULL);
 			return;
 		}
 		switch (x) {
@@ -770,7 +770,7 @@ void System::touch(uint16 mask, int x, int y) {
 		case '3':
 		case '4':
 			if (_vm->_keyboard->_key[kKeyAlt]) {
-				_vm->_snail->addCommand(kSnLevel, -1, x - '0', NULL);
+				_vm->_commandHandler->addCommand(kCmdLevel, -1, x - '0', NULL);
 				break;
 			}
 			break;
@@ -802,7 +802,7 @@ void System::touch(uint16 mask, int x, int y) {
 		_vm->postMiniStep(selectedScene - 1);
 
 		if (mask & kMouseLeftUp) {
-			if (selectedScene && _vm->_snail->idle() && _vm->_hero->_tracePtr < 0)
+			if (selectedScene && _vm->_commandHandler->idle() && _vm->_hero->_tracePtr < 0)
 				_vm->switchScene(selectedScene);
 
 			if (_vm->_horzLine && !_vm->_horzLine->_flags._hide) {
@@ -814,7 +814,7 @@ void System::touch(uint16 mask, int x, int y) {
 					_vm->setMapBrick(x1, z1);
 				}
 			} else {
-				if (!_vm->_talk && _vm->_snail->idle() && _vm->_hero
+				if (!_vm->_talk && _vm->_commandHandler->idle() && _vm->_hero
 				        && y >= kMapTop && y < kMapTop + kMapHig && !_vm->_game) {
 					_vm->_hero->findWay(_vm->XZ(x, y));
 				}
@@ -827,7 +827,7 @@ void System::tick() {
 	if (!_vm->_startupMode)
 		if (--_funDel == 0) {
 			_vm->killText();
-			if (_vm->_snail->idle()) {
+			if (_vm->_commandHandler->idle()) {
 				if (_vm->_flag[0]) // Pain flag
 					_vm->heroCover(9);
 				else { // CHECKME: Before, was: if (Startup::_core >= CORE_MID) {
@@ -850,7 +850,7 @@ void System::tick() {
 void CGEEngine::switchColorMode() {
 	debugC(1, kCGEDebugEngine, "CGEEngine::switchColorMode()");
 
-	_snail_->addCommand(kSnSeq, 121, _vga->_mono = !_vga->_mono, NULL);
+	_commandHandlerTurbo->addCommand(kCmdSeq, 121, _vga->_mono = !_vga->_mono, NULL);
 	keyClick();
 	_vga->setColors(_vga->_sysPal, 64);
 }
@@ -858,7 +858,7 @@ void CGEEngine::switchColorMode() {
 void CGEEngine::switchMusic() {
 	debugC(1, kCGEDebugEngine, "CGEEngine::switchMusic()");
 
-	_snail_->addCommand(kSnSeq, 122, (_music = !_music), NULL);
+	_commandHandlerTurbo->addCommand(kCmdSeq, 122, (_music = !_music), NULL);
 	keyClick();
 
 	if (_music)
@@ -887,7 +887,7 @@ void CGEEngine::switchMapping() {
 	} else {
 		for (Sprite *s = _vga->_showQ->first(); s; s = s->_next)
 			if (s->_w == kMapGridX && s->_h == kMapGridZ)
-				_snail_->addCommand(kSnKill, -1, 0, s);
+				_commandHandlerTurbo->addCommand(kCmdKill, -1, 0, s);
 	}
 	_horzLine->_flags._hide = !_horzLine->_flags._hide;
 }
@@ -897,7 +897,7 @@ void CGEEngine::killSprite() {
 
 	_sprite->_flags._kill = true;
 	_sprite->_flags._bDel = true;
-	_snail_->addCommand(kSnKill, -1, 0, _sprite);
+	_commandHandlerTurbo->addCommand(kCmdKill, -1, 0, _sprite);
 	_sprite = NULL;
 }
 
@@ -946,7 +946,7 @@ void Sprite::touch(uint16 mask, int x, int y) {
 			mask |= kMouseRightUp;
 		}
 
-	if ((mask & kMouseRightUp) && _vm->_snail->idle()) {
+	if ((mask & kMouseRightUp) && _vm->_commandHandler->idle()) {
 		Sprite *ps = (_vm->_pocLight->_seqPtr) ? _vm->_pocket[_vm->_pocPtr] : NULL;
 		if (ps) {
 			if (_flags._kept || _vm->_hero->distance(this) < kDistMax) {
@@ -966,13 +966,13 @@ void Sprite::touch(uint16 mask, int x, int y) {
 						if (_vm->findPocket(NULL) < 0) {
 							_vm->pocFul();
 						} else {
-							_vm->_snail->addCommand(kSnReach, -1, -1, this);
-							_vm->_snail->addCommand(kSnKeep, -1, -1, this);
+							_vm->_commandHandler->addCommand(kCmdReach, -1, -1, this);
+							_vm->_commandHandler->addCommand(kCmdKeep, -1, -1, this);
 							_flags._port = false;
 						}
 					} else {
 						if (_takePtr != kNoPtr) {
-							if (snList(kTake)[_takePtr]._com == kSnNext)
+							if (snList(kTake)[_takePtr]._commandType == kCmdNext)
 								_vm->offUse();
 							else
 								_vm->feedSnail(this, kTake);
@@ -987,7 +987,7 @@ void Sprite::touch(uint16 mask, int x, int y) {
 		}
 	}
 
-	if ((mask & kMouseLeftUp) && _vm->_snail->idle()) {
+	if ((mask & kMouseLeftUp) && _vm->_commandHandler->idle()) {
 		if (_flags._kept) {
 			for (int n = 0; n < kPocketNX; n++) {
 				if (_vm->_pocket[n] == this) {
@@ -996,7 +996,7 @@ void Sprite::touch(uint16 mask, int x, int y) {
 				}
 			}
 		} else {
-			_vm->_snail->addCommand(kSnWalk, -1, -1, this); // Hero->FindWay(this);
+			_vm->_commandHandler->addCommand(kCmdWalk, -1, -1, this); // Hero->FindWay(this);
 		}
 	}
 }
@@ -1229,14 +1229,14 @@ void CGEEngine::killText() {
 	if (!_talk)
 		return;
 
-	_snail_->addCommand(kSnKill, -1, 0, _talk);
+	_commandHandlerTurbo->addCommand(kCmdKill, -1, 0, _talk);
 	_talk = NULL;
 }
 
 void CGEEngine::mainLoop() {
 	_vga->show();
-	_snail_->runCommand();
-	_snail->runCommand();
+	_commandHandlerTurbo->runCommand();
+	_commandHandler->runCommand();
 
 	// Handle a delay between game frames
 	handleFrame();
@@ -1332,10 +1332,10 @@ void CGEEngine::runGame() {
 //    ~~~~~~~~~~~
 
 	if ((_sprite = _vga->_spareQ->locate(121)) != NULL)
-		_snail_->addCommand(kSnSeq, -1, _vga->_mono, _sprite);
+		_commandHandlerTurbo->addCommand(kCmdSeq, -1, _vga->_mono, _sprite);
 	if ((_sprite = _vga->_spareQ->locate(122)) != NULL)
 		_sprite->step(_music);
-	_snail_->addCommand(kSnSeq, -1, _music, _sprite);
+	_commandHandlerTurbo->addCommand(kCmdSeq, -1, _music, _sprite);
 	if (!_music)
 		_midiPlayer->killMidi();
 
@@ -1390,7 +1390,7 @@ void CGEEngine::runGame() {
 
 	_startupMode = 0;
 
-	_snail->addCommand(kSnLevel, -1, _oldLev, &_sceneLight);
+	_commandHandler->addCommand(kCmdLevel, -1, _oldLev, &_sceneLight);
 	_sceneLight->gotoxy(kSceneX + ((_now - 1) % kSceneNx) * kSceneDx + kSceneSX,
 	                  kSceneY + ((_now - 1) / kSceneNx) * kSceneDy + kSceneSY);
 	sceneUp();
@@ -1399,7 +1399,7 @@ void CGEEngine::runGame() {
 	// main loop
 	while (!_finis && !_eventManager->_quitFlag) {
 		if (_flag[3])
-			_snail->addCallback(kSnExec,  -1, 0, kQGame);
+			_commandHandler->addCallback(kCmdExec,  -1, 0, kQGame);
 		mainLoop();
 	}
 
@@ -1408,8 +1408,8 @@ void CGEEngine::runGame() {
 		qGame();
 
 	_keyboard->setClient(NULL);
-	_snail->addCommand(kSnClear, -1, 0, NULL);
-	_snail_->addCommand(kSnClear, -1, 0, NULL);
+	_commandHandler->addCommand(kCmdClear, -1, 0, NULL);
+	_commandHandlerTurbo->addCommand(kCmdClear, -1, 0, NULL);
 	_mouse->off();
 	_vga->_showQ->clear();
 	_vga->_spareQ->clear();
@@ -1432,12 +1432,12 @@ void CGEEngine::movie(const char *ext) {
 		feedSnail(_vga->_showQ->locate(999), kTake);
 		_vga->_showQ->append(_mouse);
 		_keyboard->setClient(_sys);
-		while (!_snail->idle() && !_eventManager->_quitFlag)
+		while (!_commandHandler->idle() && !_eventManager->_quitFlag)
 			mainLoop();
 
 		_keyboard->setClient(NULL);
-		_snail->addCommand(kSnClear, -1, 0, NULL);
-		_snail_->addCommand(kSnClear, -1, 0, NULL);
+		_commandHandler->addCommand(kCmdClear, -1, 0, NULL);
+		_commandHandlerTurbo->addCommand(kCmdClear, -1, 0, NULL);
 		_vga->_showQ->clear();
 		_vga->_spareQ->clear();
 	}
@@ -1475,7 +1475,7 @@ bool CGEEngine::showTitle(const char *name) {
 		_vga->copyPage(0, 1);
 		_vga->_showQ->append(_mouse);
 		_mouse->on();
-		for (; !_snail->idle() || Vmenu::_addr;) {
+		for (; !_commandHandler->idle() || Vmenu::_addr;) {
 			mainLoop();
 			if (_eventManager->_quitFlag)
 				return false;
diff --git a/engines/cge/snail.cpp b/engines/cge/snail.cpp
index 175cf93d23..74bc6acdf8 100644
--- a/engines/cge/snail.cpp
+++ b/engines/cge/snail.cpp
@@ -36,7 +36,7 @@
 
 namespace CGE {
 
-const char *Snail::_comText[] = {
+const char *CommandHandler::_commandText[] = {
 	"LABEL",  "PAUSE",  "WAIT",    "LEVEL",   "HIDE",
 	"SAY",    "INF",    "TIME",    "CAVE",    "KILL",
 	"RSEQ",   "SEQ",    "SEND",    "SWAP",    "KEEP",
@@ -50,31 +50,31 @@ const char *Snail::_comText[] = {
 	"MOUSE",  "SOUND",  "COUNT",   NULL
 };
 
-Snail::Snail(CGEEngine *vm, bool turbo)
+CommandHandler::CommandHandler(CGEEngine *vm, bool turbo)
 	: _turbo(turbo), _busy(false), _textDelay(false),
 	  _timerExpiry(0), _talkEnable(true),
-	  _head(0), _tail(0), _snList((Command *)malloc(sizeof(Command) * 256)), _vm(vm) {
+	  _head(0), _tail(0), _commandList((Command *)malloc(sizeof(Command) * 256)), _vm(vm) {
 }
 
-Snail::~Snail() {
-	free(_snList);
+CommandHandler::~CommandHandler() {
+	free(_commandList);
 }
 
 /**
- * Add a Command on the head of _snList
+ * Add a Command on the head of _commandList
  * @param com			Command
  * @param ref			Reference
  * @param val			Value
  * @param ptr			Sprite pointer
  */
-void Snail::addCommand(SnCom com, int ref, int val, void *ptr) {
-	Command *snc = &_snList[_head++];
-	snc->_com = com;
-	snc->_ref = ref;
-	snc->_val = val;
-	snc->_spritePtr = ptr;
-	snc->_cbType = kNullCB;
-	if (com == kSnClear) {
+void CommandHandler::addCommand(CommandType com, int ref, int val, void *ptr) {
+	Command *headCmd = &_commandList[_head++];
+	headCmd->_commandType = com;
+	headCmd->_ref = ref;
+	headCmd->_val = val;
+	headCmd->_spritePtr = ptr;
+	headCmd->_cbType = kNullCB;
+	if (headCmd->_commandType == kCmdClear) {
 		_tail = _head;
 		_vm->killText();
 		_timerExpiry = 0;
@@ -82,20 +82,20 @@ void Snail::addCommand(SnCom com, int ref, int val, void *ptr) {
 }
 
 /**
- * Add a Callback on the head of _snList
+ * Add a Callback on the head of _commandList
  * @param com			Command
  * @param ref			Reference
  * @param val			Value
  * @param CallbackType	Callback type
  */
-void Snail::addCallback(SnCom com, int ref, int val, CallbackType cbType) {
-	Command *snc = &_snList[_head++];
-	snc->_com = com;
-	snc->_ref = ref;
-	snc->_val = val;
-	snc->_spritePtr = NULL;
-	snc->_cbType = cbType;
-	if (com == kSnClear) {
+void CommandHandler::addCallback(CommandType com, int ref, int val, CallbackType cbType) {
+	Command *headCmd = &_commandList[_head++];
+	headCmd->_commandType = com;
+	headCmd->_ref = ref;
+	headCmd->_val = val;
+	headCmd->_spritePtr = NULL;
+	headCmd->_cbType = cbType;
+	if (headCmd->_commandType == kCmdClear) {
 		_tail = _head;
 		_vm->killText();
 		_timerExpiry = 0;
@@ -103,41 +103,41 @@ void Snail::addCallback(SnCom com, int ref, int val, CallbackType cbType) {
 }
 
 /**
- * Add a Command on the tail of _snList
+ * Add a Command on the tail of _commandList
  * @param com			Command
  * @param ref			Reference
  * @param val			Value
  * @param ptr			Sprite pointer
  */
-void Snail::insertCommand(SnCom com, int ref, int val, void *ptr) {
-	Command *snc;
+void CommandHandler::insertCommand(CommandType com, int ref, int val, void *ptr) {
+	Command *tailCmd;
 
 	if (_busy) {
-		_snList[(_tail - 1) & 0xFF] = _snList[_tail];
-		snc = &_snList[_tail];
+		_commandList[(_tail - 1) & 0xFF] = _commandList[_tail];
+		tailCmd = &_commandList[_tail];
 	} else
-		snc = &_snList[(_tail - 1) & 0xFF];
+		tailCmd = &_commandList[(_tail - 1) & 0xFF];
 	_tail--;
-	snc->_com = com;
-	snc->_ref = ref;
-	snc->_val = val;
-	snc->_spritePtr = ptr;
-	snc->_cbType = kNullCB;
-	if (com == kSnClear) {
+	tailCmd->_commandType = com;
+	tailCmd->_ref = ref;
+	tailCmd->_val = val;
+	tailCmd->_spritePtr = ptr;
+	tailCmd->_cbType = kNullCB;
+	if (tailCmd->_commandType == kCmdClear) {
 		_tail = _head;
 		_vm->killText();
 		_timerExpiry = 0;
 	}
 }
 
-void Snail::runCommand() {
+void CommandHandler::runCommand() {
 	if (_busy)
 		return;
 
 	_busy = true;
 	uint8 tmpHead = _head;
 	while (_tail != tmpHead) {
-		Command *snc = &_snList[_tail];
+		Command *tailCmd = &_commandList[_tail];
 
 		if (!_turbo) { // only for the slower one
 			if (_timerExpiry) {
@@ -154,210 +154,210 @@ void Snail::runCommand() {
 					_textDelay = false;
 				}
 			}
-			if (_vm->_talk && snc->_com != kSnPause)
+			if (_vm->_talk && tailCmd->_commandType != kCmdPause)
 				break;
 		}
 
-		Sprite *spr = ((snc->_ref >= 0) ? _vm->locate(snc->_ref) : ((Sprite *) snc->_spritePtr));
-		switch (snc->_com) {
-		case kSnLabel:
+		Sprite *spr = ((tailCmd->_ref >= 0) ? _vm->locate(tailCmd->_ref) : ((Sprite *) tailCmd->_spritePtr));
+		switch (tailCmd->_commandType) {
+		case kCmdLabel:
 			break;
-		case kSnPause    :
-			_timerExpiry = g_system->getMillis() + snc->_val * kSnailFrameDelay;
+		case kCmdPause    :
+			_timerExpiry = g_system->getMillis() + tailCmd->_val * kCommandFrameDelay;
 			if (_vm->_talk)
 				_textDelay = true;
 			break;
-		case kSnWait:
+		case kCmdWait:
 			if (spr) {
-				if (spr->seqTest(snc->_val) &&
-					(snc->_val >= 0 || spr != _vm->_hero || _vm->_hero->_tracePtr < 0)) {
-					_timerExpiry = g_system->getMillis() + spr->_time * kSnailFrameDelay;
+				if (spr->seqTest(tailCmd->_val) &&
+					(tailCmd->_val >= 0 || spr != _vm->_hero || _vm->_hero->_tracePtr < 0)) {
+					_timerExpiry = g_system->getMillis() + spr->_time * kCommandFrameDelay;
 				} else {
 					_busy = false;
 					return;
 				}
 			}
 			break;
-		case kSnLevel:
-			_vm->snLevel(spr, snc->_val);
+		case kCmdLevel:
+			_vm->snLevel(spr, tailCmd->_val);
 			break;
-		case kSnHide:
-			_vm->snHide(spr, snc->_val);
+		case kCmdHide:
+			_vm->snHide(spr, tailCmd->_val);
 			break;
-		case kSnSay:
+		case kCmdSay:
 			if (spr && _talkEnable) {
 				if (spr == _vm->_hero && spr->seqTest(-1))
 					spr->step(kSeqHTalk);
-				_vm->_text->say(_vm->_text->getText(snc->_val), spr);
+				_vm->_text->say(_vm->_text->getText(tailCmd->_val), spr);
 				_vm->_sys->_funDel = kHeroFun0;
 			}
 			break;
-		case kSnInf:
+		case kCmdInf:
 			if (_talkEnable) {
-				_vm->inf(_vm->_text->getText(snc->_val));
+				_vm->inf(_vm->_text->getText(tailCmd->_val));
 				_vm->_sys->_funDel = kHeroFun0;
 			}
 			break;
-		case kSnTime:
+		case kCmdTime:
 			if (spr && _talkEnable) {
 				if (spr == _vm->_hero && spr->seqTest(-1))
 					spr->step(kSeqHTalk);
 				_vm->_text->sayTime(spr);
 			}
 			break;
-		case kSnCave:
-			_vm->switchScene(snc->_val);
+		case kCmdCave:
+			_vm->switchScene(tailCmd->_val);
 			break;
-		case kSnKill:
+		case kCmdKill:
 			_vm->snKill(spr);
 			break;
-		case kSnSeq:
-			_vm->snSeq(spr, snc->_val);
+		case kCmdSeq:
+			_vm->snSeq(spr, tailCmd->_val);
 			break;
-		case kSnRSeq:
-			_vm->snRSeq(spr, snc->_val);
+		case kCmdRSeq:
+			_vm->snRSeq(spr, tailCmd->_val);
 			break;
-		case kSnSend:
-			_vm->snSend(spr, snc->_val);
+		case kCmdSend:
+			_vm->snSend(spr, tailCmd->_val);
 			break;
-		case kSnSwap:
-			_vm->snSwap(spr, snc->_val);
+		case kCmdSwap:
+			_vm->snSwap(spr, tailCmd->_val);
 			break;
-		case kSnCover:
-			_vm->snCover(spr, snc->_val);
+		case kCmdCover:
+			_vm->snCover(spr, tailCmd->_val);
 			break;
-		case kSnUncover:
-			_vm->snUncover(spr, (snc->_val >= 0) ? _vm->locate(snc->_val) : ((Sprite *) snc->_spritePtr));
+		case kCmdUncover:
+			_vm->snUncover(spr, (tailCmd->_val >= 0) ? _vm->locate(tailCmd->_val) : ((Sprite *) tailCmd->_spritePtr));
 			break;
-		case kSnKeep:
-			_vm->snKeep(spr, snc->_val);
+		case kCmdKeep:
+			_vm->snKeep(spr, tailCmd->_val);
 			break;
-		case kSnGive:
-			_vm->snGive(spr, snc->_val);
+		case kCmdGive:
+			_vm->snGive(spr, tailCmd->_val);
 			break;
-		case kSnGame:
-			_vm->snGame(spr, snc->_val);
+		case kCmdGame:
+			_vm->snGame(spr, tailCmd->_val);
 			break;
-		case kSnSetX0:
-			_vm->snSetX0(snc->_ref, snc->_val);
+		case kCmdSetX0:
+			_vm->snSetX0(tailCmd->_ref, tailCmd->_val);
 			break;
-		case kSnSetY0:
-			_vm->snSetY0(snc->_ref, snc->_val);
+		case kCmdSetY0:
+			_vm->snSetY0(tailCmd->_ref, tailCmd->_val);
 			break;
-		case kSnSetXY:
-			_vm->snSetXY(spr, snc->_val);
+		case kCmdSetXY:
+			_vm->snSetXY(spr, tailCmd->_val);
 			break;
-		case kSnRelX:
-			_vm->snRelX(spr, snc->_val);
+		case kCmdRelX:
+			_vm->snRelX(spr, tailCmd->_val);
 			break;
-		case kSnRelY:
-			_vm->snRelY(spr, snc->_val);
+		case kCmdRelY:
+			_vm->snRelY(spr, tailCmd->_val);
 			break;
-		case kSnRelZ:
-			_vm->snRelZ(spr, snc->_val);
+		case kCmdRelZ:
+			_vm->snRelZ(spr, tailCmd->_val);
 			break;
-		case kSnSetX:
-			_vm->snSetX(spr, snc->_val);
+		case kCmdSetX:
+			_vm->snSetX(spr, tailCmd->_val);
 			break;
-		case kSnSetY:
-			_vm->snSetY(spr, snc->_val);
+		case kCmdSetY:
+			_vm->snSetY(spr, tailCmd->_val);
 			break;
-		case kSnSetZ:
-			_vm->snSetZ(spr, snc->_val);
+		case kCmdSetZ:
+			_vm->snSetZ(spr, tailCmd->_val);
 			break;
-		case kSnSlave:
-			_vm->snSlave(spr, snc->_val);
+		case kCmdSlave:
+			_vm->snSlave(spr, tailCmd->_val);
 			break;
-		case kSnTrans:
-			_vm->snTrans(spr, snc->_val);
+		case kCmdTrans:
+			_vm->snTrans(spr, tailCmd->_val);
 			break;
-		case kSnPort:
-			_vm->snPort(spr, snc->_val);
+		case kCmdPort:
+			_vm->snPort(spr, tailCmd->_val);
 			break;
-		case kSnNext:
-		case kSnIf:
-		case kSnTalk:
+		case kCmdNext:
+		case kCmdIf:
+		case kCmdTalk:
 			break;
-		case kSnMouse:
-			_vm->snMouse(snc->_val != 0);
+		case kCmdMouse:
+			_vm->snMouse(tailCmd->_val != 0);
 			break;
-		case kSnNNext:
-			_vm->snNNext(spr, snc->_val);
+		case kCmdNNext:
+			_vm->snNNext(spr, tailCmd->_val);
 			break;
-		case kSnTNext:
-			_vm->snTNext(spr, snc->_val);
+		case kCmdTNext:
+			_vm->snTNext(spr, tailCmd->_val);
 			break;
-		case kSnRNNext:
-			_vm->snRNNext(spr, snc->_val);
+		case kCmdRNNext:
+			_vm->snRNNext(spr, tailCmd->_val);
 			break;
-		case kSnRTNext:
-			_vm->snRTNext(spr, snc->_val);
+		case kCmdRTNext:
+			_vm->snRTNext(spr, tailCmd->_val);
 			break;
-		case kSnRMNear:
+		case kCmdRMNear:
 			_vm->snRmNear(spr);
 			break;
-		case kSnRmTake:
+		case kCmdRmTake:
 			_vm->snRmTake(spr);
 			break;
-		case kSnFlag:
-			_vm->snFlag(snc->_ref & 3, snc->_val != 0);
+		case kCmdFlag:
+			_vm->snFlag(tailCmd->_ref & 3, tailCmd->_val != 0);
 			break;
-		case kSnSetRef:
-			_vm->snSetRef(spr, snc->_val);
+		case kCmdSetRef:
+			_vm->snSetRef(spr, tailCmd->_val);
 			break;
-		case kSnBackPt:
-			_vm->snBackPt(spr, snc->_val);
+		case kCmdBackPt:
+			_vm->snBackPt(spr, tailCmd->_val);
 			break;
-		case kSnFlash:
-			_vm->snFlash(snc->_val != 0);
+		case kCmdFlash:
+			_vm->snFlash(tailCmd->_val != 0);
 			break;
-		case kSnLight:
-			_vm->snLight(snc->_val != 0);
+		case kCmdLight:
+			_vm->snLight(tailCmd->_val != 0);
 			break;
-		case kSnSetHBarrier:
-			_vm->snHBarrier(snc->_ref, snc->_val);
+		case kCmdSetHBarrier:
+			_vm->snHBarrier(tailCmd->_ref, tailCmd->_val);
 			break;
-		case kSnSetVBarrier:
-			_vm->snVBarrier(snc->_ref, snc->_val);
+		case kCmdSetVBarrier:
+			_vm->snVBarrier(tailCmd->_ref, tailCmd->_val);
 			break;
-		case kSnWalk:
-			_vm->snWalk(spr, snc->_ref, snc->_val);
+		case kCmdWalk:
+			_vm->snWalk(spr, tailCmd->_ref, tailCmd->_val);
 			break;
-		case kSnReach:
-			_vm->snReach(spr, snc->_val);
+		case kCmdReach:
+			_vm->snReach(spr, tailCmd->_val);
 			break;
-		case kSnSound:
-			_vm->snSound(spr, snc->_val);
+		case kCmdSound:
+			_vm->snSound(spr, tailCmd->_val);
 			break;
-		case kSnCount:
-			_vm->_sound->setRepeat(snc->_val);
+		case kCmdCount:
+			_vm->_sound->setRepeat(tailCmd->_val);
 			break;
-		case kSnExec:
-			switch (snc->_cbType) {
+		case kCmdExec:
+			switch (tailCmd->_cbType) {
 			case kQGame:
 				_vm->qGame();
 				break;
 			case kMiniStep:
-				_vm->miniStep(snc->_val);
+				_vm->miniStep(tailCmd->_val);
 				break;
 			case kXScene:
 				_vm->xScene();
 				break;
-			case kSndSetVolume:
+			case kSoundSetVolume:
 				_vm->sndSetVolume();
 				break;
 			default:
 				error("Unknown Callback Type in SNEXEC");
 			}
 			break;
-		case kSnStep:
+		case kCmdStep:
 			spr->step();
 			break;
-		case kSnZTrim:
+		case kCmdZTrim:
 			_vm->snZTrim(spr);
 			break;
-		case kSnGhost:
-			_vm->snGhost((Bitmap *) snc->_spritePtr);
+		case kCmdGhost:
+			_vm->snGhost((Bitmap *) tailCmd->_spritePtr);
 			break;
 		default:
 			warning("Unhandled snc->_com in SNMouse(bool)");
@@ -371,7 +371,7 @@ void Snail::runCommand() {
 	_busy = false;
 }
 
-bool Snail::idle() {
+bool CommandHandler::idle() {
 	return (_head == _tail);
 }
 
@@ -402,66 +402,66 @@ void CGEEngine::snGame(Sprite *spr, int num) {
 			if (hand && Stage > kDressed)
 				++hand;
 			if (i >= 0 || (dup[i] == spr && newRandom(3) == 0)) {
-				_snail->addCommand(kSnSeq, -1, 3, dup[0]);               // yes
-				_snail->addCommand(kSnSeq, -1, 3, dup[1]);               // yes
-				_snail->addCommand(kSnSeq, -1, 3, dup[2]);               // yes
-				_snail->addCommand(kSnTNext, -1, 0, dup[0]);             // reset Take
-				_snail->addCommand(kSnTNext, -1, 0, dup[1]);             // reset Take
-				_snail->addCommand(kSnTNext, -1, 0, dup[2]);             // reset Take
-				_snail->addCommand(kSnNNext, -1, 0, dup[0]);             // reset Near
-				_snail->addCommand(kSnPause, -1, 72, NULL);              // little rest
-				_snail->addCommand(kSnSay, 1, 16009, NULL);              // hura
-				_snail->addCommand(kSnSay, buref, 16010, NULL);          // siadaj
-				_snail->addCommand(kSnSay, 1, 16011, NULL);              // postoj‘
+				_commandHandler->addCommand(kCmdSeq, -1, 3, dup[0]);               // yes
+				_commandHandler->addCommand(kCmdSeq, -1, 3, dup[1]);               // yes
+				_commandHandler->addCommand(kCmdSeq, -1, 3, dup[2]);               // yes
+				_commandHandler->addCommand(kCmdTNext, -1, 0, dup[0]);             // reset Take
+				_commandHandler->addCommand(kCmdTNext, -1, 0, dup[1]);             // reset Take
+				_commandHandler->addCommand(kCmdTNext, -1, 0, dup[2]);             // reset Take
+				_commandHandler->addCommand(kCmdNNext, -1, 0, dup[0]);             // reset Near
+				_commandHandler->addCommand(kCmdPause, -1, 72, NULL);              // little rest
+				_commandHandler->addCommand(kCmdSay, 1, 16009, NULL);              // hura
+				_commandHandler->addCommand(kCmdSay, buref, 16010, NULL);          // siadaj
+				_commandHandler->addCommand(kCmdSay, 1, 16011, NULL);              // postoj‘
 
 				if (hand) {
-					_snail->addCommand(kSnSend, 16060 + hand, 16, NULL);   // dawaj r‘k‘
-					_snail->addCommand(kSnSeq, buref, 4, NULL);            // zdejmowanie
-					_snail->addCommand(kSnSeq, 16060 + hand, 1, NULL);     // ruch
-					_snail->addCommand(kSnSound, 16060 + hand, 16002, NULL); // szelest
-					_snail->addCommand(kSnWait, 16060 + hand, 3, NULL);    // podniesie
-					_snail->addCommand(kSnSwap, buref, buref + 100, NULL); // rozdziana
-					_snail->addCommand(kSnSeq, 16016, Stage, NULL);        // rožnie kupa
-					_snail->addCommand(kSnSend, 16060 + hand, -1, NULL);   // chowaj r‘k‘
-					_snail->addCommand(kSnWait, 16060 + hand, -1, NULL);   // r‘ka zamar’a
+					_commandHandler->addCommand(kCmdSend, 16060 + hand, 16, NULL);   // dawaj r‘k‘
+					_commandHandler->addCommand(kCmdSeq, buref, 4, NULL);            // zdejmowanie
+					_commandHandler->addCommand(kCmdSeq, 16060 + hand, 1, NULL);     // ruch
+					_commandHandler->addCommand(kCmdSound, 16060 + hand, 16002, NULL); // szelest
+					_commandHandler->addCommand(kCmdWait, 16060 + hand, 3, NULL);    // podniesie
+					_commandHandler->addCommand(kCmdSwap, buref, buref + 100, NULL); // rozdziana
+					_commandHandler->addCommand(kCmdSeq, 16016, Stage, NULL);        // rožnie kupa
+					_commandHandler->addCommand(kCmdSend, 16060 + hand, -1, NULL);   // chowaj r‘k‘
+					_commandHandler->addCommand(kCmdWait, 16060 + hand, -1, NULL);   // r‘ka zamar’a
 				} else {
-					_snail->addCommand(kSnSeq, buref, 4, NULL);            // zdejmowanie
-					_snail->addCommand(kSnSound, 16060 + hand, 16002, NULL); // szelest
-					_snail->addCommand(kSnWait, buref, -1, NULL);          // zdejmie
-					_snail->addCommand(kSnSwap, buref, buref + 100, NULL); // rozdziana
-					_snail->addCommand(kSnSeq, 16016, Stage, NULL);        // rožnie kupa
+					_commandHandler->addCommand(kCmdSeq, buref, 4, NULL);            // zdejmowanie
+					_commandHandler->addCommand(kCmdSound, 16060 + hand, 16002, NULL); // szelest
+					_commandHandler->addCommand(kCmdWait, buref, -1, NULL);          // zdejmie
+					_commandHandler->addCommand(kCmdSwap, buref, buref + 100, NULL); // rozdziana
+					_commandHandler->addCommand(kCmdSeq, 16016, Stage, NULL);        // rožnie kupa
 				}
 				//SNPOST(SNSEQ, buref+100, 0, NULL);        // reset
-				_snail->addCommand(kSnPause, -1, 72, NULL);              // chwilk‘...
-				_snail->addCommand(kSnSeq, -1, 0, dup[1]);               // odstaw Go
-				_snail->addCommand(kSnSetXY, -1, 203 + kScrWidth * 49, dup[1]);
-				_snail->addCommand(kSnSetZ, -1, 7, dup[1]);
-				_snail->addCommand(kSnSeq, -1, 0, dup[2]);               // odstaw J†
-				_snail->addCommand(kSnSetXY, -1, 182 + kScrWidth * 62, dup[2]);
-				_snail->addCommand(kSnSetZ, -1, 9, dup[2]);
+				_commandHandler->addCommand(kCmdPause, -1, 72, NULL);              // chwilk‘...
+				_commandHandler->addCommand(kCmdSeq, -1, 0, dup[1]);               // odstaw Go
+				_commandHandler->addCommand(kCmdSetXY, -1, 203 + kScrWidth * 49, dup[1]);
+				_commandHandler->addCommand(kCmdSetZ, -1, 7, dup[1]);
+				_commandHandler->addCommand(kCmdSeq, -1, 0, dup[2]);               // odstaw J†
+				_commandHandler->addCommand(kCmdSetXY, -1, 182 + kScrWidth * 62, dup[2]);
+				_commandHandler->addCommand(kCmdSetZ, -1, 9, dup[2]);
 				_game = 0;
 				return;
 			} else {
-				_snail->addCommand(kSnSeq, -1, 2, dup[0]);               // no
-				_snail->addCommand(kSnSeq, -1, 2, dup[1]);               // no
-				_snail->addCommand(kSnSeq, -1, 2, dup[2]);               // no
-				_snail->addCommand(kSnPause, -1, 72, NULL);              // 1 sec
+				_commandHandler->addCommand(kCmdSeq, -1, 2, dup[0]);               // no
+				_commandHandler->addCommand(kCmdSeq, -1, 2, dup[1]);               // no
+				_commandHandler->addCommand(kCmdSeq, -1, 2, dup[2]);               // no
+				_commandHandler->addCommand(kCmdPause, -1, 72, NULL);              // 1 sec
 			}
 		}
-		_snail->addCommand(kSnWalk, 198, 134, NULL);                 // na miejsce
-		_snail->addCommand(kSnWait, 1, -1, NULL);                    // stoi
-		_snail->addCommand(kSnCover, 1, 16101, NULL);                // ch’op do bicia
-		_snail->addCommand(kSnSeq, 16101, 1, NULL);                  // wystaw
-		_snail->addCommand(kSnWait, 16101, 5, NULL);                 // czekaj
-		_snail->addCommand(kSnPause, 16101, 24, NULL);               // czekaj chwil‘
-		_snail->addCommand(kSnSeq, 16040, 1, NULL);                  // plask
-		_snail->addCommand(kSnSound, 16101, 16001, NULL);            // plask!
-		_snail->addCommand(kSnPause, 16101, 24, NULL);               // czekaj chwil‘
-		_snail->addCommand(kSnSeq, 16040, 0, NULL);                  // schowaj plask
-		_snail->addCommand(kSnWait, 16101, -1, NULL);                // stoi
-		_snail->addCommand(kSnUncover, 1, 16101, NULL);              // SDS
+		_commandHandler->addCommand(kCmdWalk, 198, 134, NULL);                 // na miejsce
+		_commandHandler->addCommand(kCmdWait, 1, -1, NULL);                    // stoi
+		_commandHandler->addCommand(kCmdCover, 1, 16101, NULL);                // ch’op do bicia
+		_commandHandler->addCommand(kCmdSeq, 16101, 1, NULL);                  // wystaw
+		_commandHandler->addCommand(kCmdWait, 16101, 5, NULL);                 // czekaj
+		_commandHandler->addCommand(kCmdPause, 16101, 24, NULL);               // czekaj chwil‘
+		_commandHandler->addCommand(kCmdSeq, 16040, 1, NULL);                  // plask
+		_commandHandler->addCommand(kCmdSound, 16101, 16001, NULL);            // plask!
+		_commandHandler->addCommand(kCmdPause, 16101, 24, NULL);               // czekaj chwil‘
+		_commandHandler->addCommand(kCmdSeq, 16040, 0, NULL);                  // schowaj plask
+		_commandHandler->addCommand(kCmdWait, 16101, -1, NULL);                // stoi
+		_commandHandler->addCommand(kCmdUncover, 1, 16101, NULL);              // SDS
 		if (!_game) {
-			_snail->addCommand(kSnSay, buref, 16008, NULL);            // zgadnij!
+			_commandHandler->addCommand(kCmdSay, buref, 16008, NULL);            // zgadnij!
 			_game = true;
 		}
 		}
@@ -475,7 +475,7 @@ void CGEEngine::snGame(Sprite *spr, int num) {
 		}
 
 		if (!_game) { // init
-			_snail->addCommand(kSnGame, 20002, 2, NULL);
+			_commandHandler->addCommand(kCmdGame, 20002, 2, NULL);
 			_game = true;
 			break;
 		}
@@ -491,23 +491,23 @@ void CGEEngine::snGame(Sprite *spr, int num) {
 			_sprK3->step(5);
 		}
 
-		_snail->addCommand(kSnSetZ, 20700, 0, NULL);
+		_commandHandler->addCommand(kCmdSetZ, 20700, 0, NULL);
 		bool hit = (_sprK1->_seqPtr + _sprK2->_seqPtr + _sprK3->_seqPtr == 15);
 		if (hit) {
 			if (spr->_ref == 1) {
-				_snail->addCommand(kSnSay,       1, 20003, NULL);       // hura!
-				_snail->addCommand(kSnSeq,   20011,     2, NULL);       // kamera won
-				_snail->addCommand(kSnSend,  20701,    -1, NULL);       // k1 won
-				_snail->addCommand(kSnSend,  20702,    -1, NULL);       // k2 won
-				_snail->addCommand(kSnSend,  20703,    -1, NULL);       // k3 won
-				_snail->addCommand(kSnSend,  20700,    -1, NULL);       // tv won
-				_snail->addCommand(kSnKeep,  20007,     0, NULL);       // do kieszeni
-				_snail->addCommand(kSnSend,  20006,    20, NULL);       // bilon
-				_snail->addCommand(kSnSound, 20006, 20002, NULL);      // bilon!
-				_snail->addCommand(kSnSay,   20002, 20004, NULL);
-				_snail->addCommand(kSnSend,  20010,    20, NULL);       // papier
-				_snail->addCommand(kSnSound, 20010, 20003, NULL);      // papier!
-				_snail->addCommand(kSnSay,   20001, 20005, NULL);
+				_commandHandler->addCommand(kCmdSay,       1, 20003, NULL);       // hura!
+				_commandHandler->addCommand(kCmdSeq,   20011,     2, NULL);       // kamera won
+				_commandHandler->addCommand(kCmdSend,  20701,    -1, NULL);       // k1 won
+				_commandHandler->addCommand(kCmdSend,  20702,    -1, NULL);       // k2 won
+				_commandHandler->addCommand(kCmdSend,  20703,    -1, NULL);       // k3 won
+				_commandHandler->addCommand(kCmdSend,  20700,    -1, NULL);       // tv won
+				_commandHandler->addCommand(kCmdKeep,  20007,     0, NULL);       // do kieszeni
+				_commandHandler->addCommand(kCmdSend,  20006,    20, NULL);       // bilon
+				_commandHandler->addCommand(kCmdSound, 20006, 20002, NULL);       // bilon!
+				_commandHandler->addCommand(kCmdSay,   20002, 20004, NULL);
+				_commandHandler->addCommand(kCmdSend,  20010,    20, NULL);       // papier
+				_commandHandler->addCommand(kCmdSound, 20010, 20003, NULL);       // papier!
+				_commandHandler->addCommand(kCmdSay,   20001, 20005, NULL);
 				_game = false;
 				return;
 			} else
@@ -517,13 +517,13 @@ void CGEEngine::snGame(Sprite *spr, int num) {
 		if (_gameCase2Cpt < 100) {
 			switch (_gameCase2Cpt) {
 			case 15:
-				_snail->addCommand(kSnSay, 20003, 20021, NULL);
+				_commandHandler->addCommand(kCmdSay, 20003, 20021, NULL);
 				break;
 			case 30:
 			case 45:
 			case 60:
 			case 75:
-				_snail->addCommand(kSnSay, 20003, 20022, NULL);
+				_commandHandler->addCommand(kCmdSay, 20003, 20022, NULL);
 				break;
 			}
 			_gameCase2Cpt++;
@@ -531,49 +531,49 @@ void CGEEngine::snGame(Sprite *spr, int num) {
 
 		switch (spr->_ref) {
 		case 1:
-			_snail->addCommand(kSnSay,   20001, 20011, NULL);        // zapro
-			_snail->addCommand(kSnSeq,   20001,     1, NULL);        // rzuŤ
-			_snail->addCommand(kSnWait,  20001,     1, NULL);        // czekaj
-			_snail->addCommand(kSnSetZ,  20700,     2, NULL);        // skryj k
-			_snail->addCommand(kSnHide,  20007,     1, NULL);        // skryj k
-			_snail->addCommand(kSnWait,  20001,    16, NULL);        // czekaj
-			_snail->addCommand(kSnSeq,   20007,     1, NULL);        // lec†
-			_snail->addCommand(kSnHide,  20007,     0, NULL);        // poka§
-			_snail->addCommand(kSnSound, 20007, 20001, NULL);        // grzech
-			_snail->addCommand(kSnWait,  20007,    -1, NULL);        // koniec
-			_snail->addCommand(kSnGame,  20001,     2, NULL);        // again!
+			_commandHandler->addCommand(kCmdSay,   20001, 20011, NULL);        // zapro
+			_commandHandler->addCommand(kCmdSeq,   20001,     1, NULL);        // rzuŤ
+			_commandHandler->addCommand(kCmdWait,  20001,     1, NULL);        // czekaj
+			_commandHandler->addCommand(kCmdSetZ,  20700,     2, NULL);        // skryj k
+			_commandHandler->addCommand(kCmdHide,  20007,     1, NULL);        // skryj k
+			_commandHandler->addCommand(kCmdWait,  20001,    16, NULL);        // czekaj
+			_commandHandler->addCommand(kCmdSeq,   20007,     1, NULL);        // lec†
+			_commandHandler->addCommand(kCmdHide,  20007,     0, NULL);        // poka§
+			_commandHandler->addCommand(kCmdSound, 20007, 20001, NULL);        // grzech
+			_commandHandler->addCommand(kCmdWait,  20007,    -1, NULL);        // koniec
+			_commandHandler->addCommand(kCmdGame,  20001,     2, NULL);        // again!
 			break;
 
 		case 20001:
-			_snail->addCommand(kSnSay,   20002, 20012, NULL);        // zapro
-			_snail->addCommand(kSnSeq,   20002,     1, NULL);        // rzuŤ
-			_snail->addCommand(kSnWait,  20002,     3, NULL);        // czekaj
-			_snail->addCommand(kSnSetZ,  20700,     2, NULL);        // skryj k
-			_snail->addCommand(kSnHide,  20007,     1, NULL);        // skryj k
-			_snail->addCommand(kSnWait,  20002,    10, NULL);        // czekaj
-			_snail->addCommand(kSnSeq,   20007,     2, NULL);        // lec†
-			_snail->addCommand(kSnHide,  20007,     0, NULL);        // poka§
-			_snail->addCommand(kSnSound, 20007, 20001, NULL);        // grzech
-			_snail->addCommand(kSnWait,  20007,    -1, NULL);        // koniec
-			_snail->addCommand(kSnGame,  20002,     2, NULL);        // again!
+			_commandHandler->addCommand(kCmdSay,   20002, 20012, NULL);        // zapro
+			_commandHandler->addCommand(kCmdSeq,   20002,     1, NULL);        // rzuŤ
+			_commandHandler->addCommand(kCmdWait,  20002,     3, NULL);        // czekaj
+			_commandHandler->addCommand(kCmdSetZ,  20700,     2, NULL);        // skryj k
+			_commandHandler->addCommand(kCmdHide,  20007,     1, NULL);        // skryj k
+			_commandHandler->addCommand(kCmdWait,  20002,    10, NULL);        // czekaj
+			_commandHandler->addCommand(kCmdSeq,   20007,     2, NULL);        // lec†
+			_commandHandler->addCommand(kCmdHide,  20007,     0, NULL);        // poka§
+			_commandHandler->addCommand(kCmdSound, 20007, 20001, NULL);        // grzech
+			_commandHandler->addCommand(kCmdWait,  20007,    -1, NULL);        // koniec
+			_commandHandler->addCommand(kCmdGame,  20002,     2, NULL);        // again!
 			break;
 
 		case 20002:
-			_snail->addCommand(kSnSay,   20002, 20010, NULL);        // zapro
-			_snail->addCommand(kSnWalk,  20005,    -1, NULL);        // do stol
-			_snail->addCommand(kSnWait,      1,    -1, NULL);        // stoi
-			_snail->addCommand(kSnCover,     1, 20101, NULL);        // grasol
-			_snail->addCommand(kSnSeq,   20101,     1, NULL);        // rzuŤ
-			_snail->addCommand(kSnWait,  20101,     5, NULL);        // czekaj
-			_snail->addCommand(kSnSetZ,  20700,     2, NULL);        // skryj k
-			_snail->addCommand(kSnHide,  20007,     1, NULL);        // skryj k
-			_snail->addCommand(kSnWait,  20101,    15, NULL);        // czekaj
-			_snail->addCommand(kSnSeq,   20007,     1, NULL);        // lec†
-			_snail->addCommand(kSnHide,  20007,     0, NULL);        // poka§
-			_snail->addCommand(kSnSound, 20007, 20001, NULL);        // grzech
-			_snail->addCommand(kSnWait,  20101,    -1, NULL);        // koniec
-			_snail->addCommand(kSnUncover,   1, 20101, NULL);        // SDS
-			_snail->addCommand(kSnGame,      1,     2, NULL);        // again!
+			_commandHandler->addCommand(kCmdSay,   20002, 20010, NULL);        // zapro
+			_commandHandler->addCommand(kCmdWalk,  20005,    -1, NULL);        // do stol
+			_commandHandler->addCommand(kCmdWait,      1,    -1, NULL);        // stoi
+			_commandHandler->addCommand(kCmdCover,     1, 20101, NULL);        // grasol
+			_commandHandler->addCommand(kCmdSeq,   20101,     1, NULL);        // rzuŤ
+			_commandHandler->addCommand(kCmdWait,  20101,     5, NULL);        // czekaj
+			_commandHandler->addCommand(kCmdSetZ,  20700,     2, NULL);        // skryj k
+			_commandHandler->addCommand(kCmdHide,  20007,     1, NULL);        // skryj k
+			_commandHandler->addCommand(kCmdWait,  20101,    15, NULL);        // czekaj
+			_commandHandler->addCommand(kCmdSeq,   20007,     1, NULL);        // lec†
+			_commandHandler->addCommand(kCmdHide,  20007,     0, NULL);        // poka§
+			_commandHandler->addCommand(kCmdSound, 20007, 20001, NULL);        // grzech
+			_commandHandler->addCommand(kCmdWait,  20101,    -1, NULL);        // koniec
+			_commandHandler->addCommand(kCmdUncover,   1, 20101, NULL);        // SDS
+			_commandHandler->addCommand(kCmdGame,      1,     2, NULL);        // again!
 			break;
 		}
 	}
@@ -623,17 +623,17 @@ void CGEEngine::pocFul() {
 	debugC(1, kCGEDebugEngine, "CGEEngine::pocFul()");
 
 	_hero->park();
-	_snail->addCommand(kSnWait, -1, -1, _hero);
-	_snail->addCommand(kSnSeq, -1, kSeqPocketFull, _hero);
-	_snail->addCommand(kSnSound, -1, 2, _hero);
-	_snail->addCommand(kSnWait, -1, -1, _hero);
-	_snail->addCommand(kSnSay,  1, kPocketFull, _hero);
+	_commandHandler->addCommand(kCmdWait, -1, -1, _hero);
+	_commandHandler->addCommand(kCmdSeq, -1, kSeqPocketFull, _hero);
+	_commandHandler->addCommand(kCmdSound, -1, 2, _hero);
+	_commandHandler->addCommand(kCmdWait, -1, -1, _hero);
+	_commandHandler->addCommand(kCmdSay,  1, kPocketFull, _hero);
 }
 
 void CGEEngine::hide1(Sprite *spr) {
 	debugC(1, kCGEDebugEngine, "CGEEngine::hide1(spr)");
 
-	_snail_->addCommand(kSnGhost, -1, 0, spr->ghost());
+	_commandHandlerTurbo->addCommand(kCmdGhost, -1, 0, spr->ghost());
 }
 
 void CGEEngine::snGhost(Bitmap *bmp) {
@@ -656,13 +656,13 @@ void CGEEngine::feedSnail(Sprite *spr, SnList snq) {
 	if (ptr == kNoPtr)
 		return;
 
-	Snail::Command *comtab = spr->snList(snq);
-	Snail::Command *c = comtab + ptr;
+	CommandHandler::Command *comtab = spr->snList(snq);
+	CommandHandler::Command *c = comtab + ptr;
 
 	if (findPocket(NULL) < 0) {                 // no empty pockets?
-		Snail::Command *p;
-		for (p = c; p->_com != kSnNext; p++) {     // find KEEP command
-			if (p->_com == kSnKeep) {
+		CommandHandler::Command *p;
+		for (p = c; p->_commandType != kCmdNext; p++) {     // find KEEP command
+			if (p->_commandType == kCmdKeep) {
 				pocFul();
 				return;
 			}
@@ -671,11 +671,11 @@ void CGEEngine::feedSnail(Sprite *spr, SnList snq) {
 		}
 	}
 	while (true) {
-		if (c->_com == kSnTalk) {
-			if ((_snail->_talkEnable = (c->_val != 0)) == false)
+		if (c->_commandType == kCmdTalk) {
+			if ((_commandHandler->_talkEnable = (c->_val != 0)) == false)
 				killText();
 		}
-		if (c->_com == kSnNext) {
+		if (c->_commandType == kCmdNext) {
 			Sprite *s = (c->_ref < 0) ? spr : locate(c->_ref);
 			if (s) {
 				uint8 *idx = (snq == kTake) ? &s->_takePtr : &s->_nearPtr;
@@ -702,7 +702,7 @@ void CGEEngine::feedSnail(Sprite *spr, SnList snq) {
 			if (s == spr)
 				break;
 		}
-		if (c->_com == kSnIf) {
+		if (c->_commandType == kCmdIf) {
 			Sprite *s = (c->_ref < 0) ? spr : locate(c->_ref);
 			if (s) { // sprite extsts
 				if (! s->seqTest(-1))
@@ -712,7 +712,7 @@ void CGEEngine::feedSnail(Sprite *spr, SnList snq) {
 			} else
 				++c;
 		} else {
-			_snail->addCommand(c->_com, c->_ref, c->_val, spr);
+			_commandHandler->addCommand(c->_commandType, c->_ref, c->_val, spr);
 			if (c->_spritePtr)
 				break;
 			else
diff --git a/engines/cge/snail.h b/engines/cge/snail.h
index 883c2b9766..3acbbd0e5f 100644
--- a/engines/cge/snail.h
+++ b/engines/cge/snail.h
@@ -25,50 +25,50 @@
  * Copyright (c) 1994-1995 Janus B. Wisniewski and L.K. Avalon
  */
 
-#ifndef CGE_SNAIL_H
-#define CGE_SNAIL_H
+#ifndef CGE_COMMANDHANDLER_H
+#define CGE_COMMANDHANDLER_H
 
 #include "cge/cge.h"
 
 namespace CGE {
 
-#define kSnailFrameRate 80
-#define kSnailFrameDelay (1000 / kSnailFrameRate)
+#define kCommandFrameRate 80
+#define kCommandFrameDelay (1000 / kCommandFrameRate)
 #define kDressed 3
 
-enum SnCom {
-	kSnLabel,  kSnPause,  kSnWait,        kSnLevel,       kSnHide,
-	kSnSay,    kSnInf,    kSnTime,        kSnCave,        kSnKill,
-	kSnRSeq,   kSnSeq,    kSnSend,        kSnSwap,        kSnKeep,
-	kSnGive,   kSnIf,     kSnGame,        kSnSetX0,       kSnSetY0,
-	kSnSlave,  kSnSetXY,  kSnRelX,        kSnRelY,        kSnRelZ,
-	kSnSetX,   kSnSetY,   kSnSetZ,        kSnTrans,       kSnPort,
-	kSnNext,   kSnNNext,  kSnTNext,       kSnRNNext,      kSnRTNext,
-	kSnRMNear, kSnRmTake, kSnFlag,        kSnSetRef,      kSnBackPt,
-	kSnFlash,  kSnLight,  kSnSetHBarrier, kSnSetVBarrier, kSnWalk,
-	kSnReach,  kSnCover,  kSnUncover,     kSnClear,       kSnTalk,
-	kSnMouse,  kSnSound,  kSnCount,       kSnExec,        kSnStep,
-	kSnZTrim,  kSnGhost
+enum CommandType {
+	kCmdLabel,  kCmdPause,  kCmdWait,        kCmdLevel,       kCmdHide,
+	kCmdSay,    kCmdInf,    kCmdTime,        kCmdCave,        kCmdKill,
+	kCmdRSeq,   kCmdSeq,    kCmdSend,        kCmdSwap,        kCmdKeep,
+	kCmdGive,   kCmdIf,     kCmdGame,        kCmdSetX0,       kCmdSetY0,
+	kCmdSlave,  kCmdSetXY,  kCmdRelX,        kCmdRelY,        kCmdRelZ,
+	kCmdSetX,   kCmdSetY,   kCmdSetZ,        kCmdTrans,       kCmdPort,
+	kCmdNext,   kCmdNNext,  kCmdTNext,       kCmdRNNext,      kCmdRTNext,
+	kCmdRMNear, kCmdRmTake, kCmdFlag,        kCmdSetRef,      kCmdBackPt,
+	kCmdFlash,  kCmdLight,  kCmdSetHBarrier, kCmdSetVBarrier, kCmdWalk,
+	kCmdReach,  kCmdCover,  kCmdUncover,     kCmdClear,       kCmdTalk,
+	kCmdMouse,  kCmdSound,  kCmdCount,       kCmdExec,        kCmdStep,
+	kCmdZTrim,  kCmdGhost
 };
 
-class Snail {
+class CommandHandler {
 public:
 	struct Command {
-		SnCom _com;
+		CommandType _commandType;
 		int _ref;
 		int _val;
 		void *_spritePtr;
 		CallbackType _cbType;
-	} *_snList;
-	static const char *_comText[];
+	} *_commandList;
+	static const char *_commandText[];
 	bool _talkEnable;
 
-	Snail(CGEEngine *vm, bool turbo);
-	~Snail();
+	CommandHandler(CGEEngine *vm, bool turbo);
+	~CommandHandler();
 	void runCommand();
-	void addCommand(SnCom com, int ref, int val, void *ptr);
-	void addCallback(SnCom com, int ref, int val, CallbackType cbType);
-	void insertCommand(SnCom com, int ref, int val, void *ptr);
+	void addCommand(CommandType com, int ref, int val, void *ptr);
+	void addCallback(CommandType com, int ref, int val, CallbackType cbType);
+	void insertCommand(CommandType com, int ref, int val, void *ptr);
 	bool idle();
 private:
 	CGEEngine *_vm;
diff --git a/engines/cge/vga13h.cpp b/engines/cge/vga13h.cpp
index 02ed4ba74c..49cfcd3084 100644
--- a/engines/cge/vga13h.cpp
+++ b/engines/cge/vga13h.cpp
@@ -126,11 +126,11 @@ bool Sprite::works(Sprite *spr) {
 	if (!spr || !spr->_ext)
 		return false;
 
-	Snail::Command *c = spr->_ext->_take;
+	CommandHandler::Command *c = spr->_ext->_take;
 	if (c != NULL) {
 		c += spr->_takePtr;
 		if (c->_ref == _ref)
-			if (c->_com != kSnLabel || (c->_val == 0 || c->_val == _vm->_now))
+			if (c->_commandType != kCmdLabel || (c->_val == 0 || c->_val == _vm->_now))
 				return true;
 	}
 
@@ -162,7 +162,7 @@ bool Sprite::seqTest(int n) {
 	return true;
 }
 
-Snail::Command *Sprite::snList(SnList type) {
+CommandHandler::Command *Sprite::snList(SnList type) {
 	SprExt *e = _ext;
 	if (e)
 		return (type == kNear) ? e->_near : e->_take;
@@ -208,8 +208,8 @@ Sprite *Sprite::expand() {
 	    maxnow = 0,
 	    maxnxt = 0;
 
-	Snail::Command *nearList = NULL;
-	Snail::Command *takeList = NULL;
+	CommandHandler::Command *nearList = NULL;
+	CommandHandler::Command *takeList = NULL;
 	_vm->mergeExt(fname, _file, kSprExt);
 	if (_vm->_resman->exist(fname)) { // sprite description file exist
 		EncryptedStream sprf(_vm, fname);
@@ -226,7 +226,7 @@ Sprite *Sprite::expand() {
 			if (len == 0 || *tmpStr == '.')
 				continue;
 
-			Snail::Command *c;
+			CommandHandler::Command *c;
 			switch (_vm->takeEnum(Comd, strtok(tmpStr, " =\t"))) {
 			case 0:
 				// Name
@@ -269,10 +269,10 @@ Sprite *Sprite::expand() {
 				// Near
 				if (_nearPtr == kNoPtr)
 					break;
-				nearList = (Snail::Command *)realloc(nearList, (nearCount + 1) * sizeof(*nearList));
+				nearList = (CommandHandler::Command *)realloc(nearList, (nearCount + 1) * sizeof(*nearList));
 				assert(nearList != NULL);
 				c = &nearList[nearCount++];
-				if ((c->_com = (SnCom)_vm->takeEnum(Snail::_comText, strtok(NULL, " \t,;/"))) < 0)
+				if ((c->_commandType = (CommandType)_vm->takeEnum(CommandHandler::_commandText, strtok(NULL, " \t,;/"))) < 0)
 					error("Bad NEAR in %d [%s]", lcnt, fname);
 				c->_ref = atoi(strtok(NULL, " \t,;/"));
 				c->_val = atoi(strtok(NULL, " \t,;/"));
@@ -282,10 +282,10 @@ Sprite *Sprite::expand() {
 				// Take
 				if (_takePtr == kNoPtr)
 					break;
-				takeList = (Snail::Command *)realloc(takeList, (takeCount + 1) * sizeof(*takeList));
+				takeList = (CommandHandler::Command *)realloc(takeList, (takeCount + 1) * sizeof(*takeList));
 				assert(takeList != NULL);
 				c = &takeList[takeCount++];
-				if ((c->_com = (SnCom)_vm->takeEnum(Snail::_comText, strtok(NULL, " \t,;/"))) < 0)
+				if ((c->_commandType = (CommandType)_vm->takeEnum(CommandHandler::_commandText, strtok(NULL, " \t,;/"))) < 0)
 					error("Bad NEAR in %d [%s]", lcnt, fname);
 				c->_ref = atoi(strtok(NULL, " \t,;/"));
 				c->_val = atoi(strtok(NULL, " \t,;/"));
diff --git a/engines/cge/vga13h.h b/engines/cge/vga13h.h
index b64920acb7..0c514c4a66 100644
--- a/engines/cge/vga13h.h
+++ b/engines/cge/vga13h.h
@@ -69,8 +69,8 @@ public:
 	BitmapPtr *_shpList;
 	Seq *_seq;
 	char *_name;
-	Snail::Command *_near;
-	Snail::Command *_take;
+	CommandHandler::Command *_near;
+	CommandHandler::Command *_take;
 	SprExt() :
 		_x0(0), _y0(0),
 		_x1(0), _y1(0),
@@ -146,7 +146,7 @@ public:
 	void killXlat();
 	void step(int nr = -1);
 	Seq *setSeq(Seq *seq);
-	Snail::Command *snList(SnList type);
+	CommandHandler::Command *snList(SnList type);
 	virtual void touch(uint16 mask, int x, int y);
 	virtual void tick();
 	void sync(Common::Serializer &s);
diff --git a/engines/cge/vmenu.cpp b/engines/cge/vmenu.cpp
index 2303d0fafa..a317a765d4 100644
--- a/engines/cge/vmenu.cpp
+++ b/engines/cge/vmenu.cpp
@@ -112,7 +112,7 @@ void Vmenu::touch(uint16 mask, int x, int y) {
 
 	if (ok && (mask & kMouseLeftUp)) {
 		_items = 0;
-		_vm->_snail_->addCommand(kSnKill, -1, 0, this);
+		_vm->_commandHandlerTurbo->addCommand(kCmdKill, -1, 0, this);
 		_recent = n;
 		assert(_menu[n].Proc);
 		CALL_MEMBER_FN(*_vm, _menu[n].Proc)();
diff --git a/engines/cge/walk.cpp b/engines/cge/walk.cpp
index 64f75983c3..31ea1909d8 100644
--- a/engines/cge/walk.cpp
+++ b/engines/cge/walk.cpp
@@ -103,7 +103,7 @@ void Walk::tick() {
 	} else {
 		// take current Z position
 		_z = _here._pt.y;
-		_vm->_snail_->addCommand(kSnZTrim, -1, 0, this);    // update Hero's pos in show queue
+		_vm->_commandHandlerTurbo->addCommand(kCmdZTrim, -1, 0, this);    // update Hero's pos in show queue
 	}
 }
 
@@ -195,10 +195,10 @@ void Walk::reach(Sprite *spr, int mode) {
 		}
 	}
 	// note: insert SNAIL commands in reverse order
-	_vm->_snail->insertCommand(kSnPause, -1, 64, NULL);
-	_vm->_snail->insertCommand(kSnSeq, -1, kTSeq + mode, this);
+	_vm->_commandHandler->insertCommand(kCmdPause, -1, 64, NULL);
+	_vm->_commandHandler->insertCommand(kCmdSeq, -1, kTSeq + mode, this);
 	if (spr) {
-		_vm->_snail->insertCommand(kSnWait, -1, -1, _vm->_hero);
+		_vm->_commandHandler->insertCommand(kCmdWait, -1, -1, _vm->_hero);
 		//SNINSERT(SNWALK, -1, -1, spr);
 	}
 	// sequence is not finished,