XEEN: Implementing combat methods

7 files changed, 481 insertions, 64 deletions

diff --git a/engines/xeen/combat.cpp b/engines/xeen/combat.cpp
index 582444d5e5..3797c18139 100644
--- a/engines/xeen/combat.cpp
+++ b/engines/xeen/combat.cpp
@@ -20,12 +20,64 @@
  *
  */
 
-#include "xeen/combat.h"
 #include "common/algorithm.h"
-#include "common/textconsole.h"
+#include "common/rect.h"
+#include "xeen/combat.h"
+#include "xeen/interface.h"
+#include "xeen/xeen.h"
 
 namespace Xeen {
 
+static const int MONSTER_GRID_X[48] = {
+	1, 1, 1, 0, -1, -1, -1, 1, 1, 1, 0, -1,
+	-1, -1, 1, 1, 1, 0, -1, -1, -1, 1, 1, 1,
+	0, -1, -1, -1, 1, 1, 1, 0, -1, -1, -1, 1,
+	1, 1, 0, -1, -1, -1, 1, 1, 1, 0, -1, -1
+};
+
+static const int MONSTER_GRID_Y[48] = {
+	0, 0, 0, -1, 0, 0, 0, 0, 0, 0, -1, 0,
+	0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+	0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0
+};
+
+static const int MONSTER_GRID3[48] = {
+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+	- 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1,
+	0, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+};
+
+static const int MONSTER_GRID_BITINDEX1[48] = {
+	1, 1, 1, 2, 3, 3, 3, 1, 1, 1, 2, 3,
+	3, 3, 1, 1, 1, 2, 3, 3, 3, 1, 1, 1,
+	0, 3, 3, 3, 1, 1, 1, 0, 3, 3, 3, 1,
+	1, 1, 0, 3, 3, 3, 1, 1, 1, 0, 3, 3
+};
+
+static const int MONSTER_GRID_BITINDEX2[48] = {
+	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+	2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
+	0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+static const int MONSTER_GRID_BITMASK[12] = {
+	0xC, 8, 4, 0, 0xF, 0xF000, 0xF00, 0xF0, 0xF00, 0xF0, 0x0F, 0xF000
+};
+
+static const int ATTACK_TYPE_FX[23] = {
+	49, 18, 13, 14, 15, 17, 16, 0, 6, 1, 2, 3,
+	4, 5, 4, 9, 27, 29, 44, 51, 53, 61, 71
+};
+
+static const int MONSTER_SHOOT_POW[7] = { 12, 14, 0, 4, 8, 10, 13 };
+
+static const int COMBAT_SHOOTING[4] = { 1, 1, 2, 3 };
+
+/*------------------------------------------------------------------------*/
+
 Combat::Combat(XeenEngine *vm): _vm(vm) {
 	Common::fill(&_attackMonsters[0], &_attackMonsters[26], 0);
 	Common::fill(&_charsArray1[0], &_charsArray1[12], 0);
@@ -34,9 +86,14 @@ Combat::Combat(XeenEngine *vm): _vm(vm) {
 	Common::fill(&_elemPow[0], &_elemPow[12], 0);
 	Common::fill(&_elemScale[0], &_elemScale[12], 0);
 	Common::fill(&_shooting[0], &_shooting[8], 0);
+	Common::fill(&_monsterMap[0][0], &_monsterMap[32][32], 0);
+	Common::fill(&_monsterMoved[0], &_monsterMoved[MAX_NUM_MONSTERS], false);
+	Common::fill(&_rangeAttacking[0], &_rangeAttacking[MAX_NUM_MONSTERS], false);
+	Common::fill(&_gmonHit[0], &_gmonHit[36], 0);
 	_globalCombat = 0;
 	_whosTurn = -1;
 	_itemFlag = false;
+	_monstersAttacking = false;
 }
 
 void Combat::clear() {
@@ -51,5 +108,345 @@ void Combat::giveCharDamage(int damage, int v2, int v3) {
 	error("TODO: giveCharDamage");
 }
 
+void Combat::moveMonsters() {
+	Interface &intf = *_vm->_interface;
+	Map &map = *_vm->_map;
+	Party &party = *_vm->_party;
+
+	if (!_vm->_moveMonsters)
+		return;
+
+	intf._tillMove = 0;
+	if (intf._charsShooting)
+		return;
+
+	Common::fill(&_monsterMap[0][0], &_monsterMap[32][32], 0);
+	Common::fill(&_monsterMoved[0], &_monsterMoved[MAX_NUM_MONSTERS], false);
+	Common::fill(&_rangeAttacking[0], &_rangeAttacking[MAX_NUM_MONSTERS], false);
+	Common::fill(&_gmonHit[0], &_gmonHit[36], -1);
+	_vm->_dangerSenseAllowed = false;
+
+	for (uint idx = 0; idx < map._mobData._monsters.size(); ++idx) {
+		MazeMonster &monster = map._mobData._monsters[idx];
+		if (monster._position.y < 32) {
+			_monsterMap[monster._position.y][monster._position.x]++;
+		}
+	}
+
+	for (int loopNum = 0; loopNum < 2; ++loopNum) {
+		int arrIndex = -1;
+		for (int yDiff = 3; yDiff >= -3; --yDiff) {
+			for (int xDiff = 3; xDiff >= -3; --xDiff) {
+				Common::Point pt = party._mazePosition + Common::Point(xDiff, yDiff);
+				++arrIndex;
+
+				for (int idx = 0; idx < (int)map._mobData._monsters.size(); ++idx) {
+					MazeMonster &monster = map._mobData._monsters[idx];
+					MonsterStruct &monsterData = map._monsterData[monster._spriteId];
+
+					if (pt == monster._position) {
+						_vm->_dangerSenseAllowed = true;
+						if ((monster._isAttacking || _vm->_mode == MODE_SLEEPING)
+								&& !_monsterMoved[idx]) {
+							if (party._mazePosition.x == pt.x || party._mazePosition.y == pt.y) {
+								// Check for range attacks
+								if (monsterData._rangeAttack && !_rangeAttacking[idx]
+									&& _attackMonsters[0] != idx && _attackMonsters[1] != idx
+									&& _attackMonsters[2] != idx && !monster._field7) {
+									// Setup monster for attacking
+									setupMonsterAttack(monster._spriteId, pt);
+									_rangeAttacking[idx] = true;
+								}
+							}
+						}
+					}
+
+					switch (party._mazeDirection) {
+					case DIR_NORTH:
+					case DIR_SOUTH:
+						if (monsterCanMove(pt, MONSTER_GRID_BITMASK[MONSTER_GRID_BITINDEX1[arrIndex]],
+								MONSTER_GRID_X[arrIndex], MONSTER_GRID_Y[arrIndex], idx)) {
+							// Move the monster
+							moveMonster(idx, Common::Point(MONSTER_GRID_X[arrIndex], MONSTER_GRID_Y[arrIndex]));
+						} else {
+							if (monsterCanMove(pt, MONSTER_GRID_BITMASK[MONSTER_GRID_BITINDEX2[arrIndex]],
+								arrIndex >= 21 && arrIndex <= 27 ? MONSTER_GRID3[arrIndex] : 0,
+								arrIndex >= 21 && arrIndex <= 27 ? 0 : MONSTER_GRID3[arrIndex],
+								idx))
+							if (arrIndex >= 21 && arrIndex <= 27) {
+								moveMonster(idx, Common::Point(MONSTER_GRID3[arrIndex], 0));
+							} else {
+								moveMonster(idx, Common::Point(0, MONSTER_GRID3[arrIndex]));
+							}
+						}
+						break;
+
+					case DIR_EAST:
+					case DIR_WEST:
+						if (monsterCanMove(pt, MONSTER_GRID_BITMASK[MONSTER_GRID_BITINDEX2[arrIndex]],
+							arrIndex >= 21 && arrIndex <= 27 ? MONSTER_GRID3[arrIndex] : 0,
+							arrIndex >= 21 && arrIndex <= 27 ? 0 : MONSTER_GRID3[arrIndex],
+							idx)) {
+							if (arrIndex >= 21 && arrIndex <= 27) {
+								moveMonster(idx, Common::Point(MONSTER_GRID3[arrIndex], 0));
+							} else {
+								moveMonster(idx, Common::Point(0, MONSTER_GRID3[arrIndex]));
+							}
+						} else if (monsterCanMove(pt, MONSTER_GRID_BITMASK[MONSTER_GRID_BITINDEX1[arrIndex]],
+								MONSTER_GRID_X[arrIndex], MONSTER_GRID_Y[arrIndex], idx)) {
+							moveMonster(idx, Common::Point(MONSTER_GRID_X[arrIndex], MONSTER_GRID_Y[arrIndex]));
+						}
+					}
+				}
+			}
+		}
+	}
+
+	monsterOvercome();
+	if (_monstersAttacking)
+		monstersAttack();
+}
+
+void Combat::monstersAttack() {
+	EventsManager &events = *_vm->_events;
+	Interface &intf = *_vm->_interface;
+	Map &map = *_vm->_map;
+	Party &party = *_vm->_party;
+	SoundManager &sound = *_vm->_sound;
+	int powNum = -1;
+	MonsterStruct *monsterData = nullptr;
+	OutdoorDrawList &outdoorList = intf._outdoorList;
+	IndoorDrawList &indoorList = intf._indoorList;
+
+	for (int idx = 0; idx < 36; ++idx) {
+		if (_gmonHit[idx] != -1) {
+			monsterData = &map._monsterData[_gmonHit[idx]];
+			powNum = MONSTER_SHOOT_POW[monsterData->_attackType];
+			if (powNum != 12)
+				break;
+		}
+	}
+
+	_powSprites.load(Common::String::format("pow%d.icn", powNum));
+	sound.playFX(ATTACK_TYPE_FX[monsterData->_attackType]);
+
+	for (int charNum = 0; charNum < MAX_PARTY_COUNT; ++charNum) {
+		if (!_shooting[charNum])
+			continue;
+
+		if (map._isOutdoors) {
+			outdoorList._attackImgs1[charNum]._scale = 3;
+			outdoorList._attackImgs2[charNum]._scale = 7;
+			outdoorList._attackImgs3[charNum]._scale = 11;
+			outdoorList._attackImgs4[charNum]._scale = 15;
+			outdoorList._attackImgs1[charNum]._sprites = nullptr;
+			outdoorList._attackImgs2[charNum]._sprites = nullptr;
+			outdoorList._attackImgs3[charNum]._sprites = nullptr;
+			outdoorList._attackImgs4[charNum]._sprites = nullptr;
+
+			switch (_shooting[charNum]) {
+			case 1:
+				outdoorList._attackImgs1[charNum]._sprites = &_powSprites;
+				break;
+			case 2:
+				outdoorList._attackImgs2[charNum]._sprites = &_powSprites;
+				break;
+			default:
+				outdoorList._attackImgs3[charNum]._sprites = &_powSprites;
+				break;
+			}
+		} else {
+			indoorList._attackImgs1[charNum]._scale = 3;
+			indoorList._attackImgs2[charNum]._scale = 7;
+			indoorList._attackImgs3[charNum]._scale = 11;
+			indoorList._attackImgs4[charNum]._scale = 15;
+			indoorList._attackImgs1[charNum]._sprites = nullptr;
+			indoorList._attackImgs2[charNum]._sprites = nullptr;
+			indoorList._attackImgs3[charNum]._sprites = nullptr;
+			indoorList._attackImgs4[charNum]._sprites = nullptr;
+
+			switch (_shooting[charNum]) {
+			case 1:
+				indoorList._attackImgs1[charNum]._sprites = &_powSprites;
+				break;
+			case 2:
+				indoorList._attackImgs2[charNum]._sprites = &_powSprites;
+				break;
+			default:
+				indoorList._attackImgs3[charNum]._sprites = &_powSprites;
+				break;
+			}
+		}
+	}
+
+	// Wait whilst the attacking effect is done
+	do {
+		intf.draw3d(true);
+		events.pollEventsAndWait();
+	} while (!_vm->shouldQuit() && intf._isAttacking);
+	
+	endAttack();
+
+	if (_vm->_mode != MODE_COMBAT) {
+		// Combat wasn't previously active, but it is now. Set up
+		// the combat party from the currently active party
+		party._combatParty.clear();
+		for (uint idx = 0; idx < party._activeParty.size(); ++idx)
+			party._combatParty.push_back(&party._activeParty[idx]);
+	}
+
+	for (int idx = 0; idx < 36; ++idx) {
+		if (_gmonHit[idx] != -1)
+			attackMonster(_gmonHit[idx]);
+	}
+
+	_monstersAttacking = false;
+
+	if (_vm->_mode != MODE_SLEEPING) {
+		for (uint charNum = 0; charNum < party._activeParty.size(); ++charNum) {
+			Condition condition = party._activeParty[charNum].worstCondition();
+
+			if (condition != ASLEEP && (condition < PARALYZED || condition == NO_CONDITION)) {
+				_vm->_mode = MODE_1;
+				break;
+			}
+		}
+	}
+}
+
+void Combat::setupMonsterAttack(int monsterDataIndex, const Common::Point &pt) {
+	Party &party = *_vm->_party;
+
+	for (int idx = 0; idx < 36; ++idx) {
+		if (_gmonHit[idx] != -1) {
+			int result = stopAttack(pt - party._mazePosition);
+			if (result) {	
+				_monstersAttacking = true;
+				_gmonHit[idx] = monsterDataIndex;
+
+				if (result != 1) {
+					for (int charNum = 0; charNum < MAX_PARTY_COUNT; ++charNum) {
+						if (!_shooting[charNum]) {
+							_shooting[charNum] = COMBAT_SHOOTING[result - 1];
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+bool Combat::monsterCanMove(const Common::Point &pt, int wallShift,
+		int xDiff, int yDiff, int monsterId) {
+	Map &map = *_vm->_map;
+	MazeMonster &monster = map._mobData._monsters[monsterId];
+	MonsterStruct &monsterData = map._monsterData[monster._spriteId];
+
+	Common::Point tempPos = pt;
+	if (map._isOutdoors) {
+		tempPos += Common::Point(xDiff, yDiff);
+		wallShift = 4;
+	}
+	int v = map.mazeLookup(tempPos, wallShift);
+
+	if (!map._isOutdoors) {
+		return v <= map.mazeData()._difficulties._wallNoPass;
+	} else {
+		SurfaceType surfaceType;
+		switch (v) {
+		case 0:
+		case 2:
+		case 3:
+		case 4:
+		case 5:
+		case 6:
+		case 8:
+		case 11:
+		case 13:
+		case 14:
+			surfaceType = (SurfaceType)map.mazeData()._surfaceTypes[map._currentSurfaceId];
+			if (surfaceType == SURFTYPE_WATER || surfaceType == SURFTYPE_DWATER) {
+				return monsterData._flying || monster._spriteId == 59;
+			} else if (surfaceType == SURFTYPE_SPACE) {
+				return monsterData._flying;
+			} else {
+				return _vm->_files->_isDarkCc || monster._spriteId != 59;
+			}
+		default:
+			return v <= map.mazeData()._difficulties._wallNoPass;
+		}
+	}
+}
+
+void Combat::moveMonster(int monsterId, const Common::Point &pt) {
+	Map &map = *_vm->_map;
+	MazeMonster &monster = map._mobData._monsters[monsterId];
+
+	if (_monsterMap[pt.y][pt.x] < 3 && !monster._field7 && _vm->_moveMonsters) {
+		++_monsterMap[pt.y][pt.x];
+		--_monsterMap[monster._position.y][monster._position.x];
+		monster._position = pt;
+		_monsterMoved[monsterId] = true;
+	}
+}
+
+void Combat::endAttack() {
+	Interface &intf = *_vm->_interface;
+	Map &map = *_vm->_map;
+	Party &party = *_vm->_party;
+	intf._isAttacking = false;
+	IndoorDrawList &indoorList = intf._indoorList;
+	OutdoorDrawList &outdoorList = intf._outdoorList;
+
+	for (uint idx = 0; idx < party._activeParty.size(); ++idx) {
+		Character &c = party._activeParty[idx];
+
+		if (map._isOutdoors) {
+			outdoorList._attackImgs1[idx]._scale = 0;
+			outdoorList._attackImgs2[idx]._scale = 0;
+			outdoorList._attackImgs3[idx]._scale = 0;
+			outdoorList._attackImgs4[idx]._scale = 0;
+			outdoorList._attackImgs1[idx]._sprites = nullptr;
+			outdoorList._attackImgs2[idx]._sprites = nullptr;
+			outdoorList._attackImgs3[idx]._sprites = nullptr;
+			outdoorList._attackImgs4[idx]._sprites = nullptr;
+		} else {
+			indoorList._attackImgs1[idx]._scale = 0;
+			indoorList._attackImgs2[idx]._scale = 0;
+			indoorList._attackImgs3[idx]._scale = 0;
+			indoorList._attackImgs4[idx]._scale = 0;
+			indoorList._attackImgs1[idx]._sprites = nullptr;
+			indoorList._attackImgs2[idx]._sprites = nullptr;
+			indoorList._attackImgs3[idx]._sprites = nullptr;
+			indoorList._attackImgs4[idx]._sprites = nullptr;
+		}
+	}
+
+	Common::fill(&_shooting[0], &_shooting[MAX_PARTY_COUNT], false);
+}
+
+void Combat::monsterOvercome() {
+	Map &map = *_vm->_map;
+
+	for (uint idx = 0; idx < map._mobData._monsters.size(); ++idx) {
+		MazeMonster &monster = map._mobData._monsters[idx];
+		int dataIndex = monster._spriteId;
+
+		if (monster._field7 != 0 && monster._field7 != 13) {
+			// Do a saving throw for monster
+			if (dataIndex <= _vm->getRandomNumber(1, dataIndex + 50))
+				monster._field7 = 0;
+		}
+	}
+}
+
+void Combat::attackMonster(int monsterId) {
+
+}
+
+bool Combat::stopAttack(const Common::Point &diffPt) {
+	// TODO
+	return false;
+}
 
 } // End of namespace Xeen
diff --git a/engines/xeen/combat.h b/engines/xeen/combat.h
index 505874264c..977d580047 100644
--- a/engines/xeen/combat.h
+++ b/engines/xeen/combat.h
@@ -24,9 +24,13 @@
 #define XEEN_COMBAT_H
 
 #include "common/scummsys.h"
+#include "common/rect.h"
+#include "xeen/sprites.h"
 
 namespace Xeen {
 
+#define MAX_NUM_MONSTERS 107
+
 enum DamageType {
 	DT_PHYSICAL = 0, DT_MAGICAL = 1, DT_FIRE = 2, DT_ELECTRICAL = 3,
 	DT_COLD = 4, DT_POISON = 5, DT_ENERGY = 6, DT_SLEEP = 7,
@@ -51,16 +55,39 @@ class Combat {
 private:
 	XeenEngine *_vm;
 public:
+	SpriteResource _powSprites;
 	int _attackMonsters[26];
 	int _charsArray1[12];
 	bool _monPow[12];
 	int _monsterScale[12];
 	int _elemPow[12];
 	int _elemScale[12];
-	bool _shooting[8];
+	int _shooting[8];
 	int _globalCombat;
 	int _whosTurn;
 	bool _itemFlag;
+	int _monsterMap[32][32];
+	bool _monsterMoved[MAX_NUM_MONSTERS];
+	bool _rangeAttacking[MAX_NUM_MONSTERS];
+	int _gmonHit[36];
+	bool _monstersAttacking;
+
+	void monstersAttack();
+
+	void setupMonsterAttack(int monsterDataIndex, const Common::Point &pt);
+
+	bool monsterCanMove(const Common::Point &pt, int wallShift,
+		int v1, int v2, int monsterId);
+
+	void moveMonster(int monsterId, const Common::Point &pt);
+
+	void attackMonster(int monsterId);
+
+	void endAttack();
+
+	void monsterOvercome();
+	
+	bool stopAttack(const Common::Point &diffPt);
 public:
 	Combat(XeenEngine *vm);
 
@@ -69,6 +96,8 @@ public:
 	void doCombat();
 
 	void giveCharDamage(int damage, int v2, int v3);
+
+	void moveMonsters();
 };
 
 } // End of namespace Xeen
diff --git a/engines/xeen/dialogs_items.cpp b/engines/xeen/dialogs_items.cpp
index d37d124a7c..29ec4c684b 100644
--- a/engines/xeen/dialogs_items.cpp
+++ b/engines/xeen/dialogs_items.cpp
@@ -1052,7 +1052,7 @@ int ItemsDialog::doItemOptions(Character &c, int actionIndex, int itemIndex, Ite
 	}
 
 	intf._charsShooting = false;
-	intf.moveMonsters();
+	combat.moveMonsters();
 	combat._whosTurn = -1;
 	return true;
 }
diff --git a/engines/xeen/interface.cpp b/engines/xeen/interface.cpp
index 11fc3127cf..db0bd815aa 100644
--- a/engines/xeen/interface.cpp
+++ b/engines/xeen/interface.cpp
@@ -142,7 +142,6 @@ Interface::Interface(XeenEngine *vm) : ButtonContainer(), InterfaceMap(vm),
 	_upDoorText = false;
 	_tillMove = 0;
 
-	Common::fill(&_combatCharIds[0], &_combatCharIds[8], 0);
 	initDrawStructs();
 }
 
@@ -244,6 +243,7 @@ void Interface::setMainButtons() {
  * be animated.
  */
 void Interface::perform() {
+	Combat &combat = *_vm->_combat;
 	EventsManager &events = *_vm->_events;
 	Map &map = *_vm->_map;
 	Party &party = *_vm->_party;
@@ -314,7 +314,7 @@ void Interface::perform() {
 	case Common::KEYCODE_w:
 		// Wait one turn
 		chargeStep();
-		moveMonsters();
+		combat.moveMonsters();
 		_upDoorText = false;
 		_flipDefaultGround = !_flipDefaultGround;
 		_flipGround = !_flipGround;
@@ -456,7 +456,7 @@ void Interface::perform() {
 		if (_buttonValue < (int)party._activeParty.size()) {
 			CharacterInfo::show(_vm, _buttonValue);
 			if (party._stepped)
-				moveMonsters();
+				combat.moveMonsters();
 		}
 		break;
 
@@ -533,7 +533,7 @@ void Interface::chargeStep() {
 	if (_vm->_party->_partyDead) {
 		_vm->_party->changeTime(_vm->_map->_isOutdoors ? 10 : 1);
 		if (!_tillMove) {
-			moveMonsters();
+			_vm->_combat->moveMonsters();
 		}
 
 		_tillMove = 3;
@@ -1181,9 +1181,9 @@ void Interface::draw3d(bool updateFlag) {
 	if (_flipUIFrame == 0)
 		_flipWater = !_flipWater;
 	if (_tillMove && (_vm->_mode == MODE_1 || _vm->_mode == MODE_COMBAT) &&
-		!_flag1 && _vm->_moveMonsters) {
+		!combat._monstersAttacking && _vm->_moveMonsters) {
 		if (--_tillMove == 0)
-			moveMonsters();
+			combat.moveMonsters();
 	}
 
 	// Draw the map
@@ -1213,8 +1213,8 @@ void Interface::draw3d(bool updateFlag) {
 
 	if (combat._attackMonsters[0] != -1 || combat._attackMonsters[1] != -1
 			|| combat._attackMonsters[2] != -1) {
-		if ((_vm->_mode == MODE_1 || _vm->_mode == MODE_SLEEPING) && !_flag1
-				&& !_charsShooting && _vm->_moveMonsters) {
+		if ((_vm->_mode == MODE_1 || _vm->_mode == MODE_SLEEPING) && 
+				!combat._monstersAttacking && !_charsShooting && _vm->_moveMonsters) {
 			combat.doCombat();
 			if (scripts._eventSkipped)
 				scripts.checkEvents();
@@ -1795,8 +1795,4 @@ void Interface::assembleBorder() {
 		screen._windows[12].frame();
 }
 
-void Interface::moveMonsters() {
-	// TODO
-}
-
 } // End of namespace Xeen
diff --git a/engines/xeen/interface.h b/engines/xeen/interface.h
index fa5f1aaec1..297b98465e 100644
--- a/engines/xeen/interface.h
+++ b/engines/xeen/interface.h
@@ -69,7 +69,6 @@ private:
 	SpriteResource _fecpSprites;
 	SpriteResource _blessSprites;
 	DrawStruct _mainList[16];
-	int _combatCharIds[8];
 
 	bool _buttonsLoaded;
 	int _steppingFX;
@@ -140,8 +139,6 @@ public:
 	void draw3d(bool updateFlag);
 
 	void assembleBorder();
-
-	void moveMonsters();
 };
 
 } // End of namespace Xeen
diff --git a/engines/xeen/interface_map.cpp b/engines/xeen/interface_map.cpp
index a3241a133f..d6d15d691f 100644
--- a/engines/xeen/interface_map.cpp
+++ b/engines/xeen/interface_map.cpp
@@ -30,8 +30,8 @@ namespace Xeen {
 static bool debugFlag = false;
 
 OutdoorDrawList::OutdoorDrawList() : _sky1(_data[0]), _sky2(_data[1]), 
-	_groundSprite(_data[2]), _combatImgs1(&_data[124]), _combatImgs2(&_data[95]),
-	_combatImgs3(&_data[76]), _combatImgs4(&_data[53]), _groundTiles(&_data[3]) {
+	_groundSprite(_data[2]), _attackImgs1(&_data[124]), _attackImgs2(&_data[95]),
+	_attackImgs3(&_data[76]), _attackImgs4(&_data[53]), _groundTiles(&_data[3]) {
 	_data[0] = DrawStruct(0, 8, 8);
 	_data[1] = DrawStruct(1, 8, 25);
 	_data[2] = DrawStruct(0, 8, 67);
@@ -190,8 +190,8 @@ IndoorDrawList::IndoorDrawList() :
 	_objects3(_data[127]), _objects4(_data[97]), _objects5(_data[98]),
 	_objects6(_data[99]), _objects7(_data[55]), _objects8(_data[56]),
 	_objects9(_data[58]), _objects10(_data[57]), _objects11(_data[59]),
-	_combatImgs1(&_data[162]), _combatImgs2(&_data[135]),
-	_combatImgs3(&_data[111]), _combatImgs4(&_data[79]) {
+	_attackImgs1(&_data[162]), _attackImgs2(&_data[135]),
+	_attackImgs3(&_data[111]), _attackImgs4(&_data[79]) {
 	// Setup draw structure positions
 	_data[0] = DrawStruct(0, 8, 8);
 	_data[1] = DrawStruct(1, 8, 25);
@@ -375,13 +375,12 @@ InterfaceMap::InterfaceMap(XeenEngine *vm): _vm(vm) {
 	_flipGround = false;
 	_flipSky = false;
 	_flipDefaultGround = false;
-	_isShooting = false;
+	_isAttacking = false;
 	_charsShooting = false;
 	_objNumber = 0;
 	_combatFloatCounter = 0;
 	_thinWall = false;
 	_isAnimReset = false;
-	_flag1 = false;
 	_overallFrame = 0;
 	_openDoor = false;
 }
@@ -430,27 +429,27 @@ void InterfaceMap::drawMap() {
 		for (int idx = 0; idx < 44; ++idx)
 			_outdoorList[OUTDOOR_DRAWSTRCT_INDEXES[idx]]._frame = -1;
 
-		if (_flag1) {
+		if (combat._monstersAttacking) {
 			for (int idx = 0; idx < 8; ++idx) {
-				if (_outdoorList._combatImgs4[idx]._sprites)
-					_outdoorList._combatImgs4[idx]._frame = 0;
-				else if (_outdoorList._combatImgs3[idx]._sprites)
-					_outdoorList._combatImgs3[idx]._frame = 1;
-				else if (_outdoorList._combatImgs2[idx]._sprites)
-					_outdoorList._combatImgs2[idx]._frame = 2;
-				else if (_outdoorList._combatImgs1[idx]._sprites)
-					_outdoorList._combatImgs1[idx]._frame = 0;
+				if (_outdoorList._attackImgs4[idx]._sprites)
+					_outdoorList._attackImgs4[idx]._frame = 0;
+				else if (_outdoorList._attackImgs3[idx]._sprites)
+					_outdoorList._attackImgs3[idx]._frame = 1;
+				else if (_outdoorList._attackImgs2[idx]._sprites)
+					_outdoorList._attackImgs2[idx]._frame = 2;
+				else if (_outdoorList._attackImgs1[idx]._sprites)
+					_outdoorList._attackImgs1[idx]._frame = 0;
 			}
 		} else if (_charsShooting) {
 			for (int idx = 0; idx < 8; ++idx) {
-				if (_outdoorList._combatImgs1[idx]._sprites)
-					_outdoorList._combatImgs1[idx]._frame = 0;
-				else if (_outdoorList._combatImgs2[idx]._sprites)
-					_outdoorList._combatImgs2[idx]._frame = 1;
-				else if (_outdoorList._combatImgs3[idx]._sprites)
-					_outdoorList._combatImgs3[idx]._frame = 2;
-				else if (_outdoorList._combatImgs4[idx]._sprites)
-					_outdoorList._combatImgs1[idx]._frame = 0;
+				if (_outdoorList._attackImgs1[idx]._sprites)
+					_outdoorList._attackImgs1[idx]._frame = 0;
+				else if (_outdoorList._attackImgs2[idx]._sprites)
+					_outdoorList._attackImgs2[idx]._frame = 1;
+				else if (_outdoorList._attackImgs3[idx]._sprites)
+					_outdoorList._attackImgs3[idx]._frame = 2;
+				else if (_outdoorList._attackImgs4[idx]._sprites)
+					_outdoorList._attackImgs1[idx]._frame = 0;
 			}
 		}
 
@@ -557,7 +556,7 @@ void InterfaceMap::drawMap() {
 		for (int idx = 3; idx < _indoorList.size(); ++idx)
 			_indoorList[idx]._frame = -1;
 
-		if (_flag1) {
+		if (combat._monstersAttacking) {
 			for (int idx = 0; idx < 96; ++idx) {
 				if (_indoorList[79 + idx]._sprites != nullptr) {
 					_indoorList[79 + idx]._frame = 0;
@@ -762,12 +761,12 @@ void InterfaceMap::animate3d() {
 		}
 	}
 
-	DrawStruct *combatImgs1 = map._isOutdoors ? _outdoorList._combatImgs1 : _indoorList._combatImgs1;
-	DrawStruct *combatImgs2 = map._isOutdoors ? _outdoorList._combatImgs2 : _indoorList._combatImgs2;
-	DrawStruct *combatImgs3 = map._isOutdoors ? _outdoorList._combatImgs3 : _indoorList._combatImgs3;
-	DrawStruct *combatImgs4 = map._isOutdoors ? _outdoorList._combatImgs4 : _indoorList._combatImgs4;
+	DrawStruct *combatImgs1 = map._isOutdoors ? _outdoorList._attackImgs1 : _indoorList._attackImgs1;
+	DrawStruct *combatImgs2 = map._isOutdoors ? _outdoorList._attackImgs2 : _indoorList._attackImgs2;
+	DrawStruct *combatImgs3 = map._isOutdoors ? _outdoorList._attackImgs3 : _indoorList._attackImgs3;
+	DrawStruct *combatImgs4 = map._isOutdoors ? _outdoorList._attackImgs4 : _indoorList._attackImgs4;
 
-	if (_flag1) {
+	if (combat._monstersAttacking) {
 		for (int idx = 0; idx < 8; ++idx) {
 			if (combatImgs1[idx]._sprites) {
 				combatImgs1[idx]._sprites = nullptr;
@@ -4326,13 +4325,13 @@ void InterfaceMap::drawIndoors() {
 	_vm->_screen->_windows[3].drawList(&_indoorList[0], _indoorList.size());
 
 	// Check for any character shooting
-	_isShooting = false;
+	_isAttacking = false;
 	for (uint idx = 0; idx < _vm->_party->_activeParty.size(); ++idx) {
 		if (_vm->_combat->_shooting[idx])
-			_isShooting = true;
+			_isAttacking = true;
 	}
 	
-	_charsShooting = _isShooting;
+	_charsShooting = _isAttacking;
 }
 
 /**
@@ -4404,13 +4403,13 @@ void InterfaceMap::drawOutdoors() {
 	screen._windows[3].drawList(&_outdoorList[0], _outdoorList.size());
 
 	// Check for any character shooting
-	_isShooting = false;
+	_isAttacking = false;
 	for (uint idx = 0; idx < _vm->_party->_activeParty.size(); ++idx) {
 		if (_vm->_combat->_shooting[idx])
-			_isShooting = true;
+			_isAttacking = true;
 	}
 
-	_charsShooting = _isShooting;
+	_charsShooting = _isAttacking;
 }
 
 } // End of namespace Xeen
diff --git a/engines/xeen/interface_map.h b/engines/xeen/interface_map.h
index 1ff982972f..a37bf349ec 100644
--- a/engines/xeen/interface_map.h
+++ b/engines/xeen/interface_map.h
@@ -37,10 +37,10 @@ public:
 	DrawStruct &_sky1, &_sky2;
 	DrawStruct &_groundSprite;
 	DrawStruct * const _groundTiles;
-	DrawStruct * const _combatImgs1;
-	DrawStruct * const _combatImgs2;
-	DrawStruct * const _combatImgs3;
-	DrawStruct * const _combatImgs4;
+	DrawStruct * const _attackImgs1;
+	DrawStruct * const _attackImgs2;
+	DrawStruct * const _attackImgs3;
+	DrawStruct * const _attackImgs4;
 public:
 	OutdoorDrawList();
 
@@ -73,10 +73,10 @@ public:
 	DrawStruct &_objects0, &_objects1, &_objects2, &_objects3;
 	DrawStruct &_objects4, &_objects5, &_objects6, &_objects7;
 	DrawStruct &_objects8, &_objects9, &_objects10, &_objects11;
-	DrawStruct * const _combatImgs1;
-	DrawStruct * const _combatImgs2;
-	DrawStruct * const _combatImgs3;
-	DrawStruct * const _combatImgs4;
+	DrawStruct * const _attackImgs1;
+	DrawStruct * const _attackImgs2;
+	DrawStruct * const _attackImgs3;
+	DrawStruct * const _attackImgs4;
 public:
 	IndoorDrawList();
 
@@ -104,10 +104,8 @@ protected:
 	bool _flipGround;
 	bool _flipSky;
 	bool _flipDefaultGround;
-	bool _isShooting;
 	bool _thinWall;
 	bool _isAnimReset;
-	bool _flag1;
 
 	void setMazeBits();
 
@@ -122,6 +120,7 @@ public:
 	int _overallFrame;
 	bool _charsShooting;
 	bool _openDoor;
+	bool _isAttacking;
 public:
 	InterfaceMap(XeenEngine *vm);