381 lines
9.2 KiB
C++
381 lines
9.2 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 "got/game/move.h"
|
|
#include "got/events.h"
|
|
#include "got/game/back.h"
|
|
#include "got/game/move_patterns.h"
|
|
#include "got/game/shot_movement.h"
|
|
#include "got/game/shot_pattern.h"
|
|
#include "got/game/status.h"
|
|
#include "got/vars.h"
|
|
|
|
namespace Got {
|
|
|
|
void nextFrame(Actor *actor) {
|
|
const int fcount = actor->_frameCount - 1;
|
|
|
|
if (fcount <= 0) {
|
|
actor->_nextFrame++;
|
|
|
|
if (actor->_nextFrame > 3)
|
|
actor->_nextFrame = 0;
|
|
|
|
actor->_frameCount = actor->_frameSpeed;
|
|
} else
|
|
actor->_frameCount = fcount;
|
|
}
|
|
|
|
bool pointWithin(int x, int y, int x1, int y1, int x2, int y2) {
|
|
return ((x >= x1) && (x <= x2) && (y >= y1) && (y <= y2));
|
|
}
|
|
|
|
bool overlap(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
|
|
if ((x1 >= x3) && (x1 <= x4) && (y1 >= y3) && (y1 <= y4))
|
|
return true;
|
|
if ((x2 >= x3) && (x2 <= x4) && (y2 >= y3) && (y2 <= y4))
|
|
return true;
|
|
if ((x1 >= x3) && (x1 <= x4) && (y2 >= y3) && (y2 <= y4))
|
|
return true;
|
|
if ((x2 >= x3) && (x2 <= x4) && (y1 >= y3) && (y1 <= y4))
|
|
return true;
|
|
if ((x3 >= x1) && (x3 <= x2) && (y3 >= y1) && (y3 <= y2))
|
|
return true;
|
|
if ((x4 >= x1) && (x4 <= x2) && (y4 >= y1) && (y4 <= y2))
|
|
return true;
|
|
if ((x3 >= x1) && (x3 <= x2) && (y4 >= y1) && (y4 <= y2))
|
|
return true;
|
|
if ((x4 >= x1) && (x4 <= x2) && (y3 >= y1) && (y3 <= y2))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
int reverseDirection(Actor *actor) {
|
|
if (actor->_dir == 1)
|
|
return 0;
|
|
if (actor->_dir == 2)
|
|
return 3;
|
|
if (actor->_dir == 3)
|
|
return 2;
|
|
return 1;
|
|
}
|
|
|
|
void thorShoots() {
|
|
if (!_G(hammer)->_active && (!_G(hammer)->_dead) && (!_G(thor)->_shotCountdown)) {
|
|
playSound(SWISH, false);
|
|
_G(thor)->_shotCountdown = 20;
|
|
_G(hammer)->_active = true;
|
|
_G(hammer)->_dir = _G(thor)->_dir;
|
|
_G(hammer)->_lastDir = _G(thor)->_dir;
|
|
_G(hammer)->_x = _G(thor)->_x;
|
|
_G(hammer)->_y = _G(thor)->_y + 2;
|
|
_G(hammer)->_moveType = 2;
|
|
_G(hammer)->_nextFrame = 0;
|
|
_G(hammer)->_lastX[0] = _G(hammer)->_x;
|
|
_G(hammer)->_lastX[1] = _G(hammer)->_x;
|
|
_G(hammer)->_lastY[0] = _G(hammer)->_y;
|
|
_G(hammer)->_lastY[1] = _G(hammer)->_y;
|
|
}
|
|
}
|
|
|
|
int killGoodGuy() {
|
|
if (!_G(killGoodGuyInform) && !_G(thunderSnakeCounter)) {
|
|
odinSpeaks(2010, 0);
|
|
_G(killGoodGuyInform) = true;
|
|
}
|
|
|
|
addScore(-1000);
|
|
return 0;
|
|
}
|
|
|
|
void actorDamaged(Actor *actor, int damage) {
|
|
if (!_G(setup)._difficultyLevel)
|
|
damage *= 2;
|
|
else if (_G(setup)._difficultyLevel == 2)
|
|
damage /= 2;
|
|
|
|
if (!actor->_vulnerableCountdown && actor->_type != 3 && (actor->_solid & 0x7f) != 2) {
|
|
actor->_vulnerableCountdown = STAMINA;
|
|
if (damage >= actor->_health) {
|
|
if (actor->_type != 4) {
|
|
addScore(actor->_initHealth * 10);
|
|
|
|
} else {
|
|
killGoodGuy();
|
|
}
|
|
|
|
actorDestroyed(actor);
|
|
} else {
|
|
actor->_show = 10;
|
|
actor->_health -= damage;
|
|
actor->_moveCountdown += 8;
|
|
}
|
|
} else if (!actor->_vulnerableCountdown) {
|
|
actor->_vulnerableCountdown = STAMINA;
|
|
|
|
if (actor->_funcNum == 4) {
|
|
switchIcons();
|
|
}
|
|
if (actor->_funcNum == 7) {
|
|
rotateArrows();
|
|
}
|
|
}
|
|
}
|
|
|
|
void thorDamaged(Actor *actor) {
|
|
actor->_hitThor = true;
|
|
|
|
// If we're invincible, ignore any damage
|
|
if (_G(cheats)._freezeHealth)
|
|
return;
|
|
|
|
if (GAME3 && actor->_funcNum == 11) {
|
|
if (actor->_talkCounter) {
|
|
actor->_talkCounter--;
|
|
return;
|
|
}
|
|
|
|
const int currType = actor->_type;
|
|
actor->_type = 4;
|
|
actorSpeaks(actor, 0, 0);
|
|
actor->_type = currType;
|
|
actor->_talkCounter = 30;
|
|
return;
|
|
}
|
|
|
|
int damage = actor->_hitStrength;
|
|
if (damage != 255) {
|
|
if (!_G(setup)._difficultyLevel)
|
|
damage /= 2;
|
|
else if (_G(setup)._difficultyLevel == 2)
|
|
damage *= 2;
|
|
}
|
|
if ((!_G(thor)->_vulnerableCountdown && !_G(shieldOn)) || damage == 255) {
|
|
if (damage >= _G(thor)->_health) {
|
|
_G(thor)->_vulnerableCountdown = 40;
|
|
_G(thor)->_show = 0;
|
|
_G(thor)->_health = 0;
|
|
_G(exitFlag) = 2;
|
|
g_events->send(GameMessage("THOR_DIES"));
|
|
} else if (damage) {
|
|
_G(thor)->_vulnerableCountdown = 40;
|
|
_G(sound).playSound(OW, false);
|
|
_G(thor)->_show = 10;
|
|
_G(thor)->_health -= damage;
|
|
}
|
|
}
|
|
}
|
|
|
|
void actorDestroyed(Actor *actor) {
|
|
if (actor->_actorNum > 2) {
|
|
const int curPage = _G(pge);
|
|
|
|
const int x = actor->_lastX[curPage ^ 1];
|
|
const int y = actor->_lastY[curPage ^ 1];
|
|
const int x1 = actor->_lastX[curPage];
|
|
const int y1 = actor->_lastY[curPage];
|
|
const int r = actor->_dropRating;
|
|
const int n = actor->_actorNum;
|
|
const int t = actor->_type;
|
|
|
|
if (actor->_funcNum == 255)
|
|
actor->copyFixedAndPics(_G(explosion));
|
|
else
|
|
actor->copyFixedAndPics(_G(sparkle));
|
|
|
|
actor->_type = t;
|
|
actor->_actorNum = n;
|
|
actor->_dropRating = r;
|
|
actor->_x = x;
|
|
actor->_y = y;
|
|
actor->_lastX[curPage] = x1;
|
|
actor->_lastX[curPage ^ 1] = x;
|
|
actor->_lastY[curPage] = y1;
|
|
actor->_lastY[curPage ^ 1] = y;
|
|
actor->_moveCountdown = actor->_speed;
|
|
actor->_active = true;
|
|
actor->_currNumShots = 3; // used to reverse explosion
|
|
actor->_vulnerableCountdown = 255;
|
|
} else {
|
|
actor->_dead = 2;
|
|
actor->_active = false;
|
|
}
|
|
}
|
|
|
|
int _actor_shoots(Actor *actor, int dir) {
|
|
const int t = actor->_shotType - 1;
|
|
for (int i = MAX_ENEMIES + 3; i < MAX_ACTORS; i++) {
|
|
if ((!_G(actor[i])._active) && (!_G(actor[i])._dead)) {
|
|
Actor *act = &_G(actor[i]);
|
|
*act = _G(shot[t]);
|
|
int cx, cy;
|
|
|
|
if (actor->_sizeY < act->_sizeY)
|
|
cy = actor->_y - ((act->_sizeY - actor->_sizeY) / 2);
|
|
else
|
|
cy = actor->_y + ((actor->_sizeY - act->_sizeY) / 2);
|
|
|
|
if (actor->_sizeX < act->_sizeX)
|
|
cx = actor->_x - ((act->_sizeX - actor->_sizeX) / 2);
|
|
else
|
|
cx = actor->_x + ((actor->_sizeX - act->_sizeX) / 2);
|
|
|
|
if (cy > 174)
|
|
cy = 174;
|
|
|
|
if (cx > 304)
|
|
cx = 304;
|
|
|
|
act->_x = cx;
|
|
act->_y = cy;
|
|
act->_lastDir = dir;
|
|
act->_nextFrame = 0;
|
|
act->_dir = dir;
|
|
if (act->_directions == 1)
|
|
act->_dir = 0;
|
|
else if (act->_directions == 4 && act->_framesPerDirection == 1) {
|
|
act->_nextFrame = dir;
|
|
act->_dir = 0;
|
|
}
|
|
act->_frameCount = act->_frameSpeed;
|
|
act->_moveCountdown = act->_speed;
|
|
act->_lastX[0] = cx;
|
|
act->_lastX[1] = cx;
|
|
act->_lastX[0] = actor->_x;
|
|
act->_lastX[1] = actor->_x;
|
|
act->_lastY[0] = cy;
|
|
act->_lastY[1] = cy;
|
|
act->_active = true;
|
|
act->_creator = actor->_actorNum;
|
|
act->_moveCount = act->_numMoves;
|
|
act->_dead = 0;
|
|
actor->_shotActor = i;
|
|
actor->_currNumShots++;
|
|
actor->_shotCountdown = 20;
|
|
_G(shotOk) = false;
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void actorAlwaysShoots(Actor *actor, int dir) {
|
|
_actor_shoots(actor, dir);
|
|
}
|
|
|
|
int actorShoots(Actor *actor, int dir) {
|
|
const int cx = (actor->_x + (actor->_sizeX / 2)) >> 4;
|
|
const int cy = ((actor->_y + actor->_sizeY) - 2) >> 4;
|
|
|
|
const int tx = _G(thor)->_centerX;
|
|
const int ty = _G(thor)->_centerY;
|
|
|
|
int icn = 140;
|
|
|
|
if (_G(shot[actor->_shotType - 1])._flying)
|
|
icn = 80;
|
|
|
|
switch (dir) {
|
|
case 0:
|
|
for (int i = ty + 1; i <= cy; i++) {
|
|
if (_G(scrn)._iconGrid[i][cx] < icn)
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
for (int i = cy; i <= ty; i++) {
|
|
if (_G(scrn)._iconGrid[i][cx] < icn)
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
for (int i = tx; i < cx; i++) {
|
|
if (_G(scrn)._iconGrid[cy][i] < icn)
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
for (int i = cx; i < tx; i++) {
|
|
if (_G(scrn)._iconGrid[cy][i] < icn)
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return _actor_shoots(actor, dir);
|
|
}
|
|
|
|
void moveActor(Actor *actor) {
|
|
if (actor->_vulnerableCountdown != 0)
|
|
actor->_vulnerableCountdown--;
|
|
if (actor->_shotCountdown != 0)
|
|
actor->_shotCountdown--;
|
|
if (actor->_show != 0)
|
|
actor->_show--;
|
|
|
|
if (!actor->_shotCountdown && _G(shotOk) && actor->_numShotsAllowed && actor->_currNumShots < actor->_numShotsAllowed) {
|
|
shotPatternFunc[actor->_shotPattern](actor);
|
|
}
|
|
|
|
const int scount = actor->_moveCountdown - 1;
|
|
if (scount <= 0) {
|
|
if (!actor->_moveCounter)
|
|
actor->_moveCountdown = actor->_speed;
|
|
else
|
|
actor->_moveCountdown = (actor->_speed << 1);
|
|
|
|
int i;
|
|
|
|
if (actor->_type == 3)
|
|
i = shotMovementFunc[actor->_moveType](actor);
|
|
else
|
|
i = _movementFunc[actor->_moveType](actor);
|
|
|
|
if (actor->_directions == 2)
|
|
i &= 1;
|
|
|
|
if (i != actor->_dir)
|
|
actor->_dir = i;
|
|
|
|
if (actor->_moveType == 0 && _G(currentLevel) != _G(newLevel) && _G(shieldOn)) {
|
|
_G(actor[2])._x = actor->_x - 2;
|
|
if (_G(actor[2])._x < 0)
|
|
_G(actor[2])._x = 0;
|
|
_G(actor[2])._y = actor->_y;
|
|
_G(actor[2])._lastX[0] = _G(actor[2])._x;
|
|
_G(actor[2])._lastX[1] = _G(actor[2])._x;
|
|
_G(actor[2])._lastY[0] = _G(actor[2])._y;
|
|
_G(actor[2])._lastY[1] = _G(actor[2])._y;
|
|
}
|
|
} else
|
|
actor->_moveCountdown = scount;
|
|
|
|
actor->_x &= 0xfffe;
|
|
}
|
|
|
|
} // namespace Got
|