From 75a070de1755fca9244eec1796ea892118afa84b Mon Sep 17 00:00:00 2001 From: Paul Gilbert Date: Sun, 15 Feb 2015 20:47:56 -0500 Subject: XEEN: Implementing combat methods --- engines/xeen/combat.cpp | 401 ++++++++++++++++++++++++++++++++++++++++- engines/xeen/combat.h | 31 +++- engines/xeen/dialogs_items.cpp | 2 +- engines/xeen/interface.cpp | 20 +- engines/xeen/interface.h | 3 - engines/xeen/interface_map.cpp | 69 ++++--- engines/xeen/interface_map.h | 19 +- 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); -- cgit v1.2.3