1004 lines
24 KiB
C++
1004 lines
24 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "mm/mm1/views_enh/combat.h"
|
|
#include "mm/mm1/views/character_view_combat.h"
|
|
#include "mm/mm1/game/encounter.h"
|
|
#include "mm/mm1/globals.h"
|
|
#include "mm/mm1/mm1.h"
|
|
#include "mm/mm1/sound.h"
|
|
|
|
namespace MM {
|
|
namespace MM1 {
|
|
namespace ViewsEnh {
|
|
|
|
#define MONSTERS_X 120
|
|
#define BOTTOM_Y 120
|
|
#define LINE_H 8
|
|
#define MONSTER_H 7
|
|
|
|
Combat::Combat() : ScrollView("Combat") {
|
|
}
|
|
|
|
void Combat::setMode(Mode newMode) {
|
|
_mode = newMode;
|
|
clearButtons();
|
|
|
|
if (newMode == SELECT_OPTION) {
|
|
_option = OPTION_NONE;
|
|
MetaEngine::setKeybindingMode(KeybindingMode::KBMODE_COMBAT);
|
|
} else {
|
|
MetaEngine::setKeybindingMode(KeybindingMode::KBMODE_MENUS);
|
|
}
|
|
|
|
if (_mode == MONSTER_SPELL)
|
|
// Make a copy of monster spell
|
|
_monsterSpellLines = getMonsterSpellMessage();
|
|
|
|
if (_mode != MONSTER_ADVANCES && _mode != MONSTER_ATTACK &&
|
|
_mode != MONSTER_SPELL)
|
|
_activeMonsterNum = -1;
|
|
|
|
redraw();
|
|
}
|
|
|
|
void Combat::disableAttacks() {
|
|
_allowFight = false;
|
|
_allowShoot = false;
|
|
_allowCast = false;
|
|
_allowAttack = false;
|
|
}
|
|
|
|
bool Combat::msgFocus(const FocusMessage &msg) {
|
|
g_globals->_currCharacter = g_globals->_combatParty[_currentChar];
|
|
MetaEngine::setKeybindingMode(KeybindingMode::KBMODE_COMBAT);
|
|
_firstDraw = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Combat::msgUnfocus(const UnfocusMessage &msg) {
|
|
MetaEngine::setKeybindingMode(KeybindingMode::KBMODE_MENUS);
|
|
return ScrollView::msgUnfocus(msg);
|
|
}
|
|
|
|
bool Combat::msgGame(const GameMessage &msg) {
|
|
if (msg._name == "COMBAT") {
|
|
// Clear combat data
|
|
clear();
|
|
|
|
loadMonsters();
|
|
setupCanAttacks();
|
|
setupHandicap();
|
|
|
|
addView();
|
|
combatLoop();
|
|
return true;
|
|
|
|
} else if (msg._name == "SPELL_RESULT") {
|
|
assert(msg._value >= 0 && msg._value < 40);
|
|
_spellResult._lines.clear();
|
|
_spellResult._lines.push_back(Line(msg._value, 1, msg._stringValue));
|
|
_spellResult._delaySeconds = 3;
|
|
|
|
setMode(SPELL_RESULT);
|
|
return true;
|
|
|
|
} else if (msg._name == "EXCHANGE" && msg._value != -1) {
|
|
int charNum = msg._value;
|
|
if (g_globals->_combatParty[charNum] != g_globals->_currCharacter)
|
|
exchangeWith(charNum);
|
|
return true;
|
|
|
|
} else if (msg._name == "DISABLE_ATTACKS") {
|
|
disableAttacks();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void Combat::draw() {
|
|
if (_firstDraw) {
|
|
_firstDraw = false;
|
|
if (_mode != SELECT_OPTION) {
|
|
// Do an initial screen draw to get everything displayed
|
|
Mode mode = _mode;
|
|
_mode = SELECT_OPTION;
|
|
draw();
|
|
_mode = mode;
|
|
}
|
|
}
|
|
|
|
switch (_mode) {
|
|
case NEXT_ROUND:
|
|
writeMonsters();
|
|
resetBottom();
|
|
highlightNextRound();
|
|
delaySeconds(1);
|
|
return;
|
|
case MONSTER_ADVANCES:
|
|
writeBottomText(0, 0, _monsterName);
|
|
writeString(STRING["dialogs.combat.advances"]);
|
|
writeRound();
|
|
writeMonsters();
|
|
delaySeconds(2);
|
|
return;
|
|
case MONSTERS_AFFECTED:
|
|
writeMonsterEffects();
|
|
delaySeconds(2);
|
|
return;
|
|
case MONSTER_SPELL:
|
|
writeMonsterSpell();
|
|
delaySeconds(2);
|
|
return;
|
|
case INFILTRATION:
|
|
writeInfiltration();
|
|
delaySeconds(3);
|
|
return;
|
|
case WAITS_FOR_OPENING:
|
|
writeWaitsForOpening();
|
|
delaySeconds(2);
|
|
return;
|
|
case CHAR_ATTACKS:
|
|
writeMonsters();
|
|
writeCharAttackDamage();
|
|
delaySeconds(3);
|
|
return;
|
|
case NO_EFFECT:
|
|
writeCharAttackNoEffect();
|
|
delaySeconds(3);
|
|
return;
|
|
case DEFEATED_MONSTERS:
|
|
writeDefeat();
|
|
Sound::sound2(SOUND_3);
|
|
delaySeconds(5);
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
clearSurface();
|
|
writeStaticContent();
|
|
writeHandicap();
|
|
writeRound();
|
|
writePartyNumbers();
|
|
writeMonsters();
|
|
writeParty();
|
|
|
|
switch (_mode) {
|
|
case SELECT_OPTION:
|
|
writeOptions();
|
|
break;
|
|
|
|
case SPELL_RESULT:
|
|
writeSpellResult();
|
|
if (_spellResult._delaySeconds)
|
|
delaySeconds(_spellResult._delaySeconds);
|
|
break;
|
|
|
|
case MONSTER_ATTACK:
|
|
writeMonsterAttack();
|
|
delaySeconds(2);
|
|
break;
|
|
|
|
case MONSTER_FLEES:
|
|
case MONSTER_WANDERS:
|
|
writeMonsterAction(_mode == MONSTER_FLEES);
|
|
delaySeconds(2);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Combat::timeout() {
|
|
switch (_mode) {
|
|
case NEXT_ROUND:
|
|
nextRound2();
|
|
break;
|
|
case MONSTER_ADVANCES:
|
|
nextRound3();
|
|
break;
|
|
case MONSTERS_AFFECTED:
|
|
case CHAR_ATTACKS:
|
|
case NO_EFFECT:
|
|
case MONSTER_FLEES:
|
|
removeDeadMonsters();
|
|
combatLoop();
|
|
break;
|
|
case MONSTER_WANDERS:
|
|
case INFILTRATION:
|
|
case MONSTER_ATTACK:
|
|
writeParty();
|
|
writeMonsters();
|
|
checkParty();
|
|
break;
|
|
case MONSTER_SPELL:
|
|
checkMonsterSpellDone();
|
|
break;
|
|
case WAITS_FOR_OPENING:
|
|
combatLoop(true);
|
|
break;
|
|
case DEFEATED_MONSTERS:
|
|
combatDone();
|
|
break;
|
|
case SPELL_RESULT:
|
|
if (_spellResult._callback)
|
|
_spellResult._callback();
|
|
else
|
|
// Character is done
|
|
block();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool Combat::msgKeypress(const KeypressMessage &msg) {
|
|
if (endDelay())
|
|
return true;
|
|
|
|
if (_mode == SELECT_OPTION && _option != OPTION_NONE) {
|
|
switch (_option) {
|
|
case OPTION_FIGHT:
|
|
case OPTION_SHOOT:
|
|
if (msg.keycode >= Common::KEYCODE_a &&
|
|
msg.keycode < (int)(Common::KEYCODE_a + _attackableCount)) {
|
|
if (_option == OPTION_FIGHT)
|
|
fightMonster(msg.keycode - Common::KEYCODE_a);
|
|
else
|
|
shootMonster(msg.keycode - Common::KEYCODE_a);
|
|
}
|
|
break;
|
|
|
|
case OPTION_DELAY:
|
|
if (msg.keycode >= Common::KEYCODE_0 &&
|
|
msg.keycode <= Common::KEYCODE_9) {
|
|
g_globals->_delay = msg.keycode - Common::KEYCODE_0;
|
|
combatLoop();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
} else if (_mode == SPELL_RESULT && !isDelayActive()) {
|
|
// Displaying a spell result that required waiting for keypress
|
|
assert(_spellResult._callback);
|
|
_spellResult._callback();
|
|
|
|
} else if (isDelayActive()) {
|
|
// In all other modes, if a delay is active, any keypress
|
|
// will cause the delay to end immediately
|
|
endDelay();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Combat::msgAction(const ActionMessage &msg) {
|
|
if (endDelay())
|
|
return true;
|
|
|
|
if (_mode == SELECT_OPTION && _option != OPTION_NONE &&
|
|
msg._action == KEYBIND_ESCAPE) {
|
|
_option = OPTION_NONE;
|
|
combatLoop();
|
|
return true;
|
|
}
|
|
|
|
if (_mode != SELECT_OPTION || (_option != OPTION_NONE &&
|
|
_option != OPTION_EXCHANGE))
|
|
return false;
|
|
|
|
switch (msg._action) {
|
|
case KEYBIND_VIEW_PARTY1:
|
|
case KEYBIND_VIEW_PARTY2:
|
|
case KEYBIND_VIEW_PARTY3:
|
|
case KEYBIND_VIEW_PARTY4:
|
|
case KEYBIND_VIEW_PARTY5:
|
|
case KEYBIND_VIEW_PARTY6: {
|
|
uint charNum = msg._action - KEYBIND_VIEW_PARTY1;
|
|
if (charNum < g_globals->_combatParty.size()) {
|
|
if (_option == OPTION_EXCHANGE) {
|
|
if (g_globals->_combatParty[charNum] != g_globals->_currCharacter)
|
|
exchangeWith(charNum);
|
|
} else {
|
|
clearBottom();
|
|
g_globals->_currCharacter = g_globals->_combatParty[charNum];
|
|
addView("CharacterViewCombat");
|
|
}
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case KEYBIND_COMBAT_ATTACK:
|
|
attack();
|
|
break;
|
|
case KEYBIND_COMBAT_BLOCK:
|
|
block();
|
|
break;
|
|
case KEYBIND_COMBAT_CAST:
|
|
cast();
|
|
break;
|
|
case KEYBIND_DELAY:
|
|
delay();
|
|
break;
|
|
case KEYBIND_COMBAT_EXCHANGE:
|
|
exchange();
|
|
break;
|
|
case KEYBIND_COMBAT_FIGHT:
|
|
fight();
|
|
break;
|
|
case KEYBIND_PROTECT:
|
|
addView("Protect");
|
|
break;
|
|
case KEYBIND_QUICKREF:
|
|
addView("QuickRef");
|
|
break;
|
|
case KEYBIND_COMBAT_RETREAT:
|
|
retreat();
|
|
break;
|
|
case KEYBIND_COMBAT_SHOOT:
|
|
shoot();
|
|
break;
|
|
case KEYBIND_COMBAT_USE:
|
|
use();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Combat::msgMouseUp(const MouseUpMessage &msg) {
|
|
const KeybindingAction BTN_ACTIONS[8] = {
|
|
KEYBIND_COMBAT_ATTACK, KEYBIND_COMBAT_FIGHT,
|
|
KEYBIND_COMBAT_RETREAT, KEYBIND_COMBAT_EXCHANGE,
|
|
KEYBIND_COMBAT_USE, KEYBIND_COMBAT_BLOCK,
|
|
KEYBIND_COMBAT_SHOOT, KEYBIND_COMBAT_CAST
|
|
};
|
|
|
|
if (_mode == SELECT_OPTION && _option == OPTION_NONE) {
|
|
// Check for option buttons being pressed
|
|
for (int col = 0; col < 3; ++col) {
|
|
for (int row = 0; row < 3; ++row) {
|
|
if (col != 2 || row != 2) {
|
|
Common::Rect r = getOptionButtonRect(col, row);
|
|
if (r.contains(msg._pos)) {
|
|
msgAction(ActionMessage(BTN_ACTIONS[col * 3 + row]));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_mode == SELECT_OPTION && (_option == OPTION_SHOOT ||
|
|
_option == OPTION_FIGHT)) {
|
|
// Check for entries in the monster list being pressed
|
|
if (msg._pos.x >= MONSTERS_X && msg._pos.x < 310
|
|
&& msg._pos.y >= _innerBounds.top && msg._pos.y < 100) {
|
|
uint monsterNum = (msg._pos.y - _innerBounds.top) / MONSTER_H;
|
|
if (monsterNum < _remainingMonsters.size()) {
|
|
char c = 'a' + monsterNum;
|
|
msgKeypress(KeypressMessage(Common::KeyState(
|
|
(Common::KeyCode)(Common::KEYCODE_a + (c - 'a')), c
|
|
)));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ScrollView::msgMouseUp(msg);
|
|
}
|
|
|
|
void Combat::writeOptions() {
|
|
if (_option != OPTION_NONE)
|
|
writeString(30, 170, STRING["enhdialogs.misc.go_back"]);
|
|
|
|
switch (_option) {
|
|
case OPTION_NONE:
|
|
writeAllOptions();
|
|
break;
|
|
case OPTION_DELAY:
|
|
writeDelaySelect();
|
|
break;
|
|
case OPTION_EXCHANGE:
|
|
writeExchangeSelect();
|
|
break;
|
|
case OPTION_FIGHT:
|
|
writeFightSelect();
|
|
break;
|
|
case OPTION_SHOOT:
|
|
writeShootSelect();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Combat::writeAllOptions() {
|
|
const Character &c = *g_globals->_currCharacter;
|
|
writeBottomText(0, 0, STRING["dialogs.combat.options_for"]);
|
|
writeBottomText(0, 2, c._name);
|
|
|
|
// Highlight the currently active character
|
|
writeChar((2 + 4 * (_currentChar % 2)) * 8 + 8, (3 + (_currentChar / 2)) * LINE_H,
|
|
(unsigned char)'1' + _currentChar + 0x80);
|
|
|
|
bool testShoot;
|
|
if (c._canAttack) {
|
|
writeAttackOptions();
|
|
_allowAttack = true;
|
|
_allowFight = true;
|
|
|
|
// Archers can always attack
|
|
testShoot = c._class == ARCHER;
|
|
} else {
|
|
testShoot = true;
|
|
}
|
|
if (testShoot && c._missileAttr._base) {
|
|
_allowShoot = true;
|
|
writeShootOption();
|
|
}
|
|
|
|
if (c._sp._current) {
|
|
writeCastOption();
|
|
_allowCast = true;
|
|
}
|
|
|
|
writeOption(0, 2, 'R', STRING["enhdialogs.combat.retreat"]);
|
|
|
|
writeOption(1, 0, 'E', STRING["enhdialogs.combat.exchange"]);
|
|
writeOption(1, 1, 'U', STRING["enhdialogs.combat.use"]);
|
|
writeOption(1, 2, 'B', STRING["enhdialogs.combat.block"]);
|
|
}
|
|
|
|
void Combat::writeDelaySelect() {
|
|
writeBottomText(0, 0, STRING["dialogs.combat.set_delay"]);
|
|
writeBottomText(0, 3, Common::String::format(
|
|
STRING["dialogs.combat.delay_currently"].c_str(),
|
|
g_globals->_delay));
|
|
}
|
|
|
|
void Combat::writeExchangeSelect() {
|
|
writeBottomText(0, 1, Common::String::format(
|
|
STRING["dialogs.combat.exchange_places"].c_str(),
|
|
'0' + g_globals->_combatParty.size()),
|
|
ALIGN_MIDDLE);
|
|
}
|
|
|
|
void Combat::writeFightSelect() {
|
|
_attackableCount = MIN(_attackersCount, (int)_remainingMonsters.size());
|
|
|
|
writeBottomText(0, 1, Common::String::format(
|
|
STRING["dialogs.combat.fight_which"].c_str(), 'A' + _attackableCount - 1),
|
|
ALIGN_MIDDLE);
|
|
}
|
|
|
|
void Combat::writeShootSelect() {
|
|
_attackableCount = MIN(_attackersCount, (int)_remainingMonsters.size());
|
|
|
|
writeBottomText(0, 1, Common::String::format(
|
|
STRING["dialogs.combat.shoot_which"].c_str(), 'A' + _attackableCount - 1),
|
|
ALIGN_MIDDLE);
|
|
}
|
|
|
|
void Combat::writeAttackOptions() {
|
|
writeOption(0, 0, 'A', STRING["dialogs.combat.attack"]);
|
|
writeOption(0, 1, 'F', STRING["dialogs.combat.fight"]);
|
|
}
|
|
|
|
void Combat::writeCastOption() {
|
|
writeOption(2, 1, 'C', STRING["dialogs.combat.cast"]);
|
|
}
|
|
|
|
void Combat::writeShootOption() {
|
|
writeOption(2, 0, 'S', STRING["dialogs.combat.shoot"]);
|
|
}
|
|
|
|
void Combat::clearSurface() {
|
|
frame();
|
|
fill();
|
|
|
|
clearBottom();
|
|
|
|
drawButtons();
|
|
}
|
|
|
|
void Combat::clearBottom() {
|
|
_bounds = Common::Rect(0, BOTTOM_Y, 320, 200);
|
|
frame();
|
|
fill();
|
|
|
|
_bounds = Common::Rect(0, 0, 320, 200);
|
|
}
|
|
|
|
void Combat::clearArea(const Common::Rect &r) {
|
|
Graphics::ManagedSurface s = getSurface();
|
|
Common::Rect area = r;
|
|
area.translate(_innerBounds.left, _innerBounds.top);
|
|
area.right = MIN(area.right, _innerBounds.right);
|
|
area.bottom = MIN(area.bottom, _innerBounds.bottom);
|
|
|
|
s.fillRect(area, SCROLL_BG_COLOR);
|
|
}
|
|
|
|
|
|
void Combat::resetBottom() {
|
|
clearArea(Common::Rect(0, 19 * LINE_H, 320, 200));
|
|
_allowFight = _allowShoot = false;
|
|
_allowCast = _allowAttack = false;
|
|
}
|
|
|
|
void Combat::writeBottomText(int x, int line, const Common::String &msg,
|
|
TextAlign align) {
|
|
writeString(x, (line + 19) * LINE_H, msg, align);
|
|
}
|
|
|
|
#define BTN_SIZE 10
|
|
|
|
Common::Rect Combat::getOptionButtonRect(uint col, uint row) {
|
|
assert(col < 3 && row < 3);
|
|
|
|
const int x = 80 + col * 80;
|
|
const int y = (19 * LINE_H) + row * BTN_SIZE;
|
|
return Common::Rect(x, y, x + BTN_SIZE, y + BTN_SIZE);
|
|
}
|
|
|
|
void Combat::writeOption(uint col, uint row, char c, const Common::String &msg) {
|
|
Common::Rect r = getOptionButtonRect(col, row);
|
|
const int x = r.left;
|
|
const int y = r.top;
|
|
const int textY = y + (BTN_SIZE - 8) / 2 + 1;
|
|
|
|
// Create a blank button
|
|
Graphics::ManagedSurface btnSmall(BTN_SIZE, BTN_SIZE);
|
|
btnSmall.blitFrom(g_globals->_blankButton, Common::Rect(0, 0, 20, 20),
|
|
Common::Rect(0, 0, BTN_SIZE, BTN_SIZE));
|
|
|
|
// Display button and write character in the middle
|
|
Graphics::ManagedSurface s = getSurface();
|
|
s.blitFrom(btnSmall, Common::Point(x + _innerBounds.left,
|
|
y + _innerBounds.top));
|
|
writeString(x + (BTN_SIZE / 2) + 1, textY,
|
|
Common::String::format("%c", c), ALIGN_MIDDLE);
|
|
|
|
// Write text to the right of the button
|
|
writeString(x + BTN_SIZE + 4, textY, msg);
|
|
}
|
|
|
|
void Combat::writeStaticContent() {
|
|
setReduced(false);
|
|
writeString(0, 0, STRING["dialogs.combat.combat"]);
|
|
writeString(0, 7 * LINE_H, STRING["dialogs.combat.delay"]);
|
|
writeString(0, 8 * LINE_H, STRING["dialogs.combat.protect"]);
|
|
writeString(0, 9 * LINE_H, STRING["dialogs.combat.quickref"]);
|
|
writeString(0, 10 * LINE_H, STRING["dialogs.combat.view_char"]);
|
|
}
|
|
|
|
void Combat::writeHandicap() {
|
|
writeString(0, 12 * LINE_H, STRING["dialogs.combat.handicap"]);
|
|
|
|
clearArea(Common::Rect(0, 13 * LINE_H, 100, 14 * LINE_H));
|
|
|
|
_textPos = Common::Point(0, 13 * LINE_H);
|
|
|
|
switch (_handicap) {
|
|
case HANDICAP_EVEN:
|
|
writeString(STRING["dialogs.combat.even"]);
|
|
break;
|
|
case HANDICAP_PARTY:
|
|
writeString(STRING["dialogs.combat.party_plus"]);
|
|
writeNumber(_handicapDelta);
|
|
break;
|
|
case HANDICAP_MONSTER:
|
|
writeString(STRING["dialogs.combat.monster_plus"]);
|
|
writeNumber(_handicapDelta);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Combat::writeRound() {
|
|
writeString(0, LINE_H, Common::String::format("%s%d",
|
|
STRING["dialogs.combat.round"].c_str(), _roundNum));
|
|
}
|
|
|
|
void Combat::writePartyNumbers() {
|
|
for (uint i = 0; i < g_globals->_combatParty.size(); ++i) {
|
|
writeChar((2 + 4 * (i % 2)) * 8, (3 + (i / 2)) * LINE_H,
|
|
g_globals->_combatParty[i]->_canAttack ? '+' : ' ');
|
|
writeChar('1' + i);
|
|
}
|
|
}
|
|
|
|
void Combat::writeMonsters() {
|
|
Common::String mStr = "A)";
|
|
setReduced(true);
|
|
clearArea(Common::Rect(MONSTERS_X, 0, 320, 100));
|
|
|
|
for (int i = 0; i < (int)_remainingMonsters.size(); ++i) {
|
|
writeString(MONSTERS_X, i * MONSTER_H, (i < _attackersCount) ? "+" : " ");
|
|
|
|
unsigned char c = 'A' + i;
|
|
if ((i == _activeMonsterNum) && (_mode == MONSTER_ADVANCES ||
|
|
_mode == MONSTER_ATTACK || _mode == MONSTER_SPELL))
|
|
c |= 0x80;
|
|
mStr.setChar(c, 0);
|
|
writeString(MONSTERS_X + 16, i * MONSTER_H, mStr, ALIGN_RIGHT);
|
|
|
|
writeString(MONSTERS_X + 22, i * MONSTER_H, _remainingMonsters[i]->_name);
|
|
writeMonsterStatus(i);
|
|
}
|
|
}
|
|
|
|
void Combat::writeMonsterStatus(int monsterNum) {
|
|
auto *currMonster = _monsterP;
|
|
_monsterP = _remainingMonsters[monsterNum];
|
|
monsterIndexOf();
|
|
byte statusBits = _remainingMonsters[monsterNum]->_status;
|
|
|
|
if (statusBits) {
|
|
writeDots();
|
|
|
|
int status;
|
|
if (statusBits == MONFLAG_DEAD) {
|
|
status = MON_DEAD;
|
|
} else {
|
|
for (status = MON_PARALYZED; !(statusBits & 0x80);
|
|
++status, statusBits <<= 1) {
|
|
}
|
|
}
|
|
|
|
writeString(STRING[Common::String::format("dialogs.combat.status.%d",
|
|
status)]);
|
|
} else if (_monsterP->_hp != _monsterP->_defaultHP) {
|
|
writeDots();
|
|
writeString(STRING["dialogs.combat.status.wounded"]);
|
|
}
|
|
|
|
_monsterP = currMonster;
|
|
}
|
|
|
|
void Combat::writeDots() {
|
|
const int dotWidth = getStringWidth(".");
|
|
_textPos.x = ((_textPos.x + dotWidth - 1) / dotWidth) * dotWidth;
|
|
|
|
while (_textPos.x < 240)
|
|
writeChar('.');
|
|
}
|
|
|
|
void Combat::writeParty() {
|
|
clearPartyArea();
|
|
|
|
for (uint i = 0; i < g_globals->_combatParty.size(); ++i) {
|
|
const Character &c = *g_globals->_combatParty[i];
|
|
const int x = 160 * (i % 2);
|
|
const int y = (15 + (i / 2)) * LINE_H;
|
|
|
|
writeChar(x, y, (c._condition == 0) ? ' ' : '*');
|
|
writeString(x + 15, y, Common::String::format("%c)", '1' + i), ALIGN_RIGHT);
|
|
writeChar(' ');
|
|
writeString(c._name);
|
|
}
|
|
}
|
|
|
|
void Combat::clearPartyArea() {
|
|
clearArea(Common::Rect(0, 15 * LINE_H, 320, 18 * LINE_H));
|
|
}
|
|
|
|
void Combat::writeDefeat() {
|
|
Common::String line1 = STRING["dialogs.combat.defeating1"];
|
|
Common::String line2 = STRING["dialogs.combat.defeating2"];
|
|
line1 = Common::String(line1.c_str() + 1, line1.c_str() + line1.size() - 2);
|
|
line2 = Common::String(line2.c_str() + 1, line2.c_str() + line2.size() - 2);
|
|
Common::String line3 = Common::String::format("%d %s",
|
|
_totalExperience, STRING["dialogs.combat.xp"].c_str());
|
|
|
|
setBounds(Common::Rect(50, 40, 270, 100));
|
|
ScrollView::draw();
|
|
writeLine(0, line1, ALIGN_MIDDLE);
|
|
writeLine(2, line2, ALIGN_MIDDLE);
|
|
writeLine(4, line3, ALIGN_MIDDLE);
|
|
}
|
|
|
|
void Combat::highlightNextRound() {
|
|
Common::String s = Common::String::format("%s%d",
|
|
STRING["dialogs.combat.round"].c_str(),
|
|
_roundNum);
|
|
|
|
for (uint i = 0; i < s.size(); ++i)
|
|
s.setChar(s[i] | 0x80, i);
|
|
|
|
setReduced(false);
|
|
writeString(0, LINE_H, s);
|
|
}
|
|
|
|
void Combat::writeMonsterEffects() {
|
|
if (_monstersRegenerate)
|
|
writeString(0, 21, STRING["dialogs.combat.regenerate"]);
|
|
|
|
if (_monstersResistSpells) {
|
|
if (_textPos.y != 21)
|
|
_textPos.y = 20;
|
|
|
|
writeString(0, _textPos.y + 1, STRING["dialogs.combat.overcome"]);
|
|
}
|
|
|
|
writeMonsters();
|
|
}
|
|
|
|
void Combat::writeMonsterAction(bool flees) {
|
|
resetBottom();
|
|
writeString(0, 20, _monsterName);
|
|
writeChar(' ');
|
|
writeString(STRING[flees ?
|
|
"dialogs.combat.monster_flees" : "dialogs.combat.monster_wanders"
|
|
]);
|
|
}
|
|
|
|
void Combat::writeMonsterSpell() {
|
|
resetBottom();
|
|
|
|
for (int i = 0, y = 0; i < (int)_monsterSpellLines.size() &&
|
|
_monsterSpellLines[i].y > y;
|
|
y = _monsterSpellLines[i].y, ++i) {
|
|
Common::String text = _monsterSpellLines[i]._text;
|
|
size_t idx;
|
|
while ((idx = text.findFirstOf(' ')) != Common::String::npos)
|
|
text.deleteChar(idx);
|
|
|
|
writeString(0, _monsterSpellLines[i].y, text);
|
|
}
|
|
}
|
|
|
|
void Combat::writeMonsterAttack() {
|
|
Common::String monsterName = _monsterP->_name;
|
|
Common::String attackStyle = STRING[Common::String::format(
|
|
"dialogs.combat.attack_types.%d", _monsterAttackStyle)];
|
|
Character &c = *g_globals->_currCharacter;
|
|
|
|
Common::String line = Common::String::format("%s %s %s",
|
|
monsterName.c_str(),
|
|
attackStyle.c_str(),
|
|
c._name
|
|
);
|
|
writeBottomText(0, 0, line);
|
|
writeBottomText(0, 1, getAttackString());
|
|
|
|
if (_damage) {
|
|
// Attacks wake up sleeping characters
|
|
if (!(c._condition & BAD_CONDITION))
|
|
c._condition &= ~ASLEEP;
|
|
|
|
// Also check for secondary monster touch action here
|
|
// This returns a text line to display, and can also
|
|
// adjust the damage amount. Another reason why we
|
|
// can't actually apply damage until here
|
|
int yp = 2;
|
|
if (monsterTouch(line))
|
|
writeBottomText(0, yp++, line);
|
|
|
|
Common::String damageStr = subtractDamageFromChar();
|
|
if (!damageStr.empty())
|
|
writeBottomText(0, yp, damageStr);
|
|
}
|
|
}
|
|
|
|
void Combat::writeInfiltration() {
|
|
Common::String line = Common::String::format("%s %s",
|
|
_monsterP->getDisplayName().c_str(),
|
|
STRING["dialogs.combat.infiltration"].c_str());
|
|
|
|
resetBottom();
|
|
writeBottomText(0, 0, line);
|
|
Sound::sound(SOUND_2);
|
|
Sound::sound(SOUND_2);
|
|
}
|
|
|
|
void Combat::writeWaitsForOpening() {
|
|
Common::String line = Common::String::format("%s %s",
|
|
_monsterP->getDisplayName().c_str(),
|
|
STRING["dialogs.combat.infiltration"].c_str()
|
|
);
|
|
|
|
resetBottom();
|
|
writeBottomText(0, 0, line);
|
|
}
|
|
|
|
void Combat::writeSpellResult() {
|
|
for (uint i = 0; i < _spellResult._lines.size(); ++i) {
|
|
const Line &l = _spellResult._lines[i];
|
|
writeBottomText(l.x, l.y, l._text);
|
|
}
|
|
}
|
|
|
|
void Combat::checkMonsterSpellDone() {
|
|
for (uint i = 0; i < _monsterSpellLines.size(); ++i) {
|
|
if (i > 0 && _monsterSpellLines[i].y ==
|
|
_monsterSpellLines[i - 1].y) {
|
|
// Remove the message line just displayed, and redraw
|
|
// so the next one can be shown
|
|
_monsterSpellLines.remove_at(i - 1);
|
|
redraw();
|
|
return;
|
|
}
|
|
}
|
|
|
|
checkParty();
|
|
}
|
|
|
|
void Combat::delay() {
|
|
setOption(OPTION_DELAY);
|
|
}
|
|
|
|
void Combat::exchange() {
|
|
if (g_globals->_combatParty.size() > 1)
|
|
setOption(OPTION_EXCHANGE);
|
|
}
|
|
|
|
void Combat::fight() {
|
|
if (_allowFight) {
|
|
if (_remainingMonsters.size() < 2) {
|
|
attackMonsterPhysical();
|
|
} else {
|
|
setOption(OPTION_FIGHT);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Combat::shoot() {
|
|
if (_allowShoot) {
|
|
if (_remainingMonsters.size() < 2) {
|
|
attackMonsterPhysical();
|
|
} else {
|
|
setOption(OPTION_SHOOT);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Combat::writeMessage() {
|
|
resetBottom();
|
|
for (const auto &line : _message)
|
|
writeString(line.x, line.y, line._text);
|
|
}
|
|
|
|
void Combat::writeCharAttackDamage() {
|
|
resetBottom();
|
|
|
|
writeBottomText(0, 0, Common::String::format("%s %s %s",
|
|
g_globals->_currCharacter->_name,
|
|
STRING[_isShooting ? "dialogs.combat.shoots" :
|
|
"dialogs.combat.attacks"].c_str(),
|
|
_monsterP->_name.c_str()
|
|
));
|
|
_isShooting = false;
|
|
|
|
writeBottomText(0, 1, getAttackString());
|
|
|
|
if (_monsterP->_status == MONFLAG_DEAD) {
|
|
writeBottomText(0, 2, Common::String::format("%s %s",
|
|
_monsterP->_name.c_str(),
|
|
STRING["dialogs.combat.goes_down"].c_str()));
|
|
}
|
|
}
|
|
|
|
void Combat::writeCharAttackNoEffect() {
|
|
resetBottom();
|
|
|
|
writeBottomText(0, 0, Common::String::format("%s %s %s",
|
|
g_globals->_currCharacter->_name,
|
|
STRING[_isShooting ? "dialogs.combat.shoots" :
|
|
"dialogs.combat.attacks"].c_str(),
|
|
_monsterP->_name.c_str()
|
|
));
|
|
_isShooting = false;
|
|
|
|
writeBottomText(0, 1, STRING["dialogs.combat.weapon_no_effect"]);
|
|
}
|
|
|
|
Common::String Combat::getAttackString() {
|
|
Common::String line1;
|
|
if (_numberOfTimes == 1) {
|
|
line1 = STRING["dialogs.combat.once"];
|
|
} else {
|
|
line1 = Common::String::format("%d %s", _numberOfTimes,
|
|
STRING["dialogs.combat.times"].c_str());
|
|
}
|
|
|
|
line1 += Common::String::format(" %s ", STRING["dialogs.combat.and"].c_str());
|
|
|
|
if (_displayedDamage == 0) {
|
|
line1 += STRING["dialogs.combat.misses"];
|
|
} else {
|
|
line1 += STRING["dialogs.combat.hit"];
|
|
|
|
if (_numberOfTimes > 1) {
|
|
line1 += ' ';
|
|
|
|
if (_timesHit == 1) {
|
|
line1 += STRING["dialogs.combat.once"];
|
|
} else {
|
|
line1 += Common::String::format("%d %s", _timesHit,
|
|
STRING["dialogs.combat.times"].c_str());
|
|
}
|
|
}
|
|
|
|
line1 += Common::String::format(" %s %d %s",
|
|
STRING["dialogs.combat.for"].c_str(), _displayedDamage,
|
|
STRING[_damage == 1 ? "dialogs.combat.point" : "dialogs.combat.points"].c_str());
|
|
|
|
if (line1.size() < 30) {
|
|
line1 += ' ';
|
|
line1 += STRING["dialogs.combat.of_damage"];
|
|
} else {
|
|
line1 += '!';
|
|
}
|
|
}
|
|
|
|
return line1;
|
|
}
|
|
|
|
void Combat::setOption(SelectedOption option) {
|
|
MetaEngine::setKeybindingMode((option == OPTION_EXCHANGE) ?
|
|
KeybindingMode::KBMODE_PARTY_MENUS :
|
|
KeybindingMode::KBMODE_MENUS);
|
|
_option = option;
|
|
|
|
if (option == OPTION_EXCHANGE) {
|
|
// Show the view to select which character
|
|
_option = OPTION_NONE;
|
|
addView("WhichCharacter");
|
|
|
|
} else {
|
|
clearButtons();
|
|
if (option != OPTION_NONE) {
|
|
addButton(&g_globals->_escSprites, Common::Point(0, 164),
|
|
0, KEYBIND_ESCAPE);
|
|
}
|
|
|
|
redraw();
|
|
}
|
|
}
|
|
|
|
void Combat::displaySpellResult(const InfoMessage &msg) {
|
|
assert(msg._delaySeconds);
|
|
_spellResult = msg;
|
|
|
|
setMode(SPELL_RESULT);
|
|
}
|
|
|
|
void Combat::combatDone() {
|
|
Game::Combat::combatDone();
|
|
|
|
close();
|
|
g_events->send("Game", GameMessage("UPDATE"));
|
|
}
|
|
|
|
} // namespace ViewsEnh
|
|
} // namespace MM1
|
|
} // namespace MM
|