mirror of
https://github.com/libretro/scummvm.git
synced 2024-11-27 11:20:40 +00:00
5dcdfd2600
The major contributors provided their consent: DrMcCoy, Strangerke, sdelamarre, sev. The goal is to allow the re-release of this code under Switch, which is incompatible with pure GPL
590 lines
15 KiB
C++
590 lines
15 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/>.
|
|
*
|
|
*
|
|
* This file is dual-licensed.
|
|
* In addition to the GPLv3 license mentioned above, this code is also
|
|
* licensed under LGPL 2.1. See LICENSES/COPYING.LGPL file for the
|
|
* full text of the license.
|
|
*
|
|
*/
|
|
|
|
#include "gob/global.h"
|
|
#include "gob/gob.h"
|
|
#include "gob/goblin.h"
|
|
#include "gob/inter.h"
|
|
#include "gob/map.h"
|
|
#include "gob/mult.h"
|
|
#include "gob/scenery.h"
|
|
#include "gob/videoplayer.h"
|
|
|
|
namespace Gob {
|
|
|
|
Goblin_v7::Goblin_v7(GobEngine *vm) : Goblin_v4(vm) {
|
|
}
|
|
|
|
void Goblin_v7::setGoblinState(Mult::Mult_Object *obj, int16 animState) {
|
|
char str[128];
|
|
obj->pAnimData->layer &= 3;
|
|
int32 var_4 = 0;
|
|
Common::strlcpy(str, obj->animName, 128);
|
|
if (obj->pAnimData->curLookDir >= 10) {
|
|
if (obj->pAnimData->curLookDir == 26 ||
|
|
obj->pAnimData->curLookDir == 36) {
|
|
if (str[strlen(str) - 1] == 'U') {
|
|
str[strlen(str) - 3] = '\0';
|
|
} else
|
|
str[strlen(str) - 2] = '\0';
|
|
} else {
|
|
str[strlen(str) - 3] = '\0';
|
|
}
|
|
} else {
|
|
str[strlen(str) - 2] = '\0';
|
|
}
|
|
|
|
if (animState < 100)
|
|
var_4 = 1;
|
|
else
|
|
var_4 = 0;
|
|
|
|
animState %= 100;
|
|
obj->pAnimData->curLookDir = animState;
|
|
|
|
int16 newXCorrection = 0;
|
|
int16 newYCorrection = 0;
|
|
while (true) {
|
|
// obj->animVariables[1]: number of fields per state
|
|
// obj->animVariables[2]: max number of states
|
|
if (animState <= 0 || animState > obj->animVariables[2]) {
|
|
obj->pAnimData->animType = 11;
|
|
return;
|
|
} else {
|
|
int16 *animVariablesForState = obj->animVariables + animState * obj->animVariables[1];
|
|
if (animVariablesForState[0] == 0) {
|
|
newXCorrection = animVariablesForState[1];
|
|
newYCorrection = animVariablesForState[2];
|
|
} else {
|
|
if (animVariablesForState[0] == -2) {
|
|
// Reflexion relative to Y axis:
|
|
// Some videos exist only for "west" directions (W, NW, SW, N S),
|
|
// "east" directions (E, NE, SE) are then obtained by symmetry
|
|
switch (animState) {
|
|
case 1:
|
|
animState = 5;
|
|
break;
|
|
case 2:
|
|
animState = 4;
|
|
break;
|
|
case 4:
|
|
animState = 2;
|
|
break;
|
|
case 5:
|
|
animState = 1;
|
|
break;
|
|
case 6:
|
|
animState = 8;
|
|
break;
|
|
case 8:
|
|
animState = 6;
|
|
break;
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37:
|
|
animState -= 10;
|
|
break;
|
|
default: // 3, 7, 9-30, > 36
|
|
obj->pAnimData->animType = 11;
|
|
return;
|
|
}
|
|
|
|
obj->pAnimData->layer |= 0x80;
|
|
newXCorrection = animVariablesForState[1];
|
|
newYCorrection = animVariablesForState[2];
|
|
} else if (animVariablesForState[0] == -1) {
|
|
obj->pAnimData->animType = 11;
|
|
return;
|
|
} else {
|
|
animState = animVariablesForState[0];
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (obj->pAnimData->stateType == 1) {
|
|
if (animState == 22)
|
|
animState = 27;
|
|
else if (animState == 25)
|
|
animState = 26;
|
|
}
|
|
|
|
switch (animState) {
|
|
case 1:
|
|
Common::strlcat(str, "GG", 128);
|
|
break;
|
|
case 2:
|
|
Common::strlcat(str, "GH", 128);
|
|
break;
|
|
case 3:
|
|
Common::strlcat(str, "HH", 128);
|
|
break;
|
|
case 4:
|
|
Common::strlcat(str, "DH", 128);
|
|
break;
|
|
case 5:
|
|
Common::strlcat(str, "DD", 128);
|
|
break;
|
|
case 6:
|
|
Common::strlcat(str, "DB", 128);
|
|
break;
|
|
case 7:
|
|
Common::strlcat(str, "BB", 128);
|
|
break;
|
|
case 8:
|
|
Common::strlcat(str, "GB", 128);
|
|
break;
|
|
case 21:
|
|
Common::strlcat(str, "COG", 128);
|
|
break;
|
|
case 22: {
|
|
uint animIndex = _vm->_rnd.getRandomNumber(1);
|
|
switch (animIndex) {
|
|
case 0:
|
|
Common::strlcat(str, "EFR", 128); // scared (EFFRAYE)
|
|
break;
|
|
case 1:
|
|
Common::strlcat(str, "EF1", 128);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 23:
|
|
Common::strlcat(str, "EXP", 128);
|
|
break;
|
|
case 24:
|
|
Common::strlcat(str, "FRA", 128);
|
|
break;
|
|
case 25: {
|
|
uint animIndex = _vm->_rnd.getRandomNumber(3);
|
|
switch (animIndex) {
|
|
case 0:
|
|
Common::strlcat(str, "PAR", 128); // talking (PARLE)
|
|
break;
|
|
case 1:
|
|
Common::strlcat(str, "PA1", 128);
|
|
break;
|
|
case 2:
|
|
Common::strlcat(str, "PA2", 128);
|
|
break;
|
|
case 3:
|
|
Common::strlcat(str, "PA3", 128);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
case 26: {
|
|
uint animIndex = _vm->_rnd.getRandomNumber(3);
|
|
switch (animIndex) {
|
|
case 0:
|
|
Common::strlcat(str, "PAU", 128); // taking a break (PAUSE)
|
|
break;
|
|
case 1:
|
|
Common::strlcat(str, "P1", 128);
|
|
break;
|
|
case 2:
|
|
Common::strlcat(str, "P2", 128);
|
|
break;
|
|
case 3:
|
|
Common::strlcat(str, "P3", 128);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 27: {
|
|
uint animIndex = _vm->_rnd.getRandomNumber(1);
|
|
switch (animIndex) {
|
|
case 0:
|
|
Common::strlcat(str, "RIR", 128); // laughing (RIRE)
|
|
break;
|
|
case 1:
|
|
Common::strlcat(str, "RI1", 128);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Common::strlcat(str, Common::String::format("%02d", animState).c_str(), 128);
|
|
}
|
|
|
|
if (strcmp(str, obj->animName) != 0) {
|
|
_vm->_mult->closeObjVideo(*obj);
|
|
Common::strlcpy(obj->animName, str, 16);
|
|
}
|
|
|
|
int32 newX = 0;
|
|
int32 newY = 0;
|
|
if (_vm->_map->_usesObliqueCoordinates) {
|
|
// Oblique coordinates to screen coordinates mapping
|
|
newX = (_vm->_map->getTilesWidth() / 2) * obj->pAnimData->destX +
|
|
(_vm->_map->getTilesWidth() / 2) * obj->pAnimData->destY -
|
|
(_vm->_map->getTilesWidth() * 39) / 2;
|
|
|
|
newY = (_vm->_map->getTilesHeight() / 2) * obj->pAnimData->destY -
|
|
(_vm->_map->getTilesHeight() / 2) * obj->pAnimData->destX +
|
|
(_vm->_map->getTilesHeight() * 20);
|
|
|
|
if (animState > 10) {
|
|
obj->destX = obj->pAnimData->destX;
|
|
obj->goblinX = obj->destX;
|
|
obj->destY = obj->pAnimData->destY;
|
|
obj->goblinY = obj->destY;
|
|
}
|
|
} else {
|
|
newY = obj->pAnimData->destY * _vm->_map->getTilesHeight();
|
|
newX = obj->pAnimData->destX * _vm->_map->getTilesWidth();
|
|
}
|
|
|
|
*obj->pPosX = newX + newXCorrection;
|
|
*obj->pPosY = newY + newYCorrection;
|
|
obj->pAnimData->frame = 0;
|
|
if (var_4 == 0) {
|
|
_vm->_mult->closeObjVideo(*obj);
|
|
|
|
VideoPlayer::Properties props;
|
|
props.x = -1;
|
|
props.y = -1;
|
|
props.startFrame = 0;
|
|
props.lastFrame = 0;
|
|
props.breakKey = 0;
|
|
props.flags = 0x1601;
|
|
props.palStart = 0;
|
|
props.palEnd = 0;
|
|
props.sprite = 50 - obj->pAnimData->animation - 1;
|
|
|
|
_vm->_mult->openObjVideo(str, props, obj->pAnimData->animation);
|
|
} else {
|
|
if (obj->videoSlot == 0 ||
|
|
strcmp(obj->animName, str) != 0 ||
|
|
(_vm->_vidPlayer->getFlags(obj->videoSlot - 1) & 0x800)) {
|
|
|
|
VideoPlayer::Properties props;
|
|
props.x = -1;
|
|
props.y = -1;
|
|
props.startFrame = 0;
|
|
props.lastFrame = 0;
|
|
props.breakKey = 0;
|
|
props.flags = 0x1601;
|
|
props.palStart = 0;
|
|
props.palEnd = 0;
|
|
props.sprite = 50 - obj->pAnimData->animation - 1;
|
|
|
|
_vm->_mult->openObjVideo(str, props, obj->pAnimData->animation);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* NOTE: conversion between direction index, coordinates in Map with _map->_usesObliqueCoordinates
|
|
* and screen coordinates
|
|
* -----------------------------------------------------
|
|
* | dir. index | Map obl. | screen |
|
|
* | 0 | ( 0, 0) | ( 0, 0) |
|
|
* | 1 | (-1, -1) | (-1, 0) -> left |
|
|
* | 2 | ( 0, -1) | (-1, -1) -> up-left |
|
|
* | 3 | ( 1, -1) | ( 0, -1) -> up |
|
|
* | 4 | ( 1, 0) | ( 1, -1) -> up-right |
|
|
* | 5 | ( 1, 1) | ( 1, 0) -> right |
|
|
* | 6 | ( 0, 1) | ( 1, 1) -> down-right |
|
|
* | 7 | (-1, 1) | ( 0, 1) -> down |
|
|
* | 8 | (-1, 0) | (-1, 1) -> down-left |
|
|
* | 9 | ( 0, 0) | ( 0, 0) |
|
|
* -----------------------------------------------------
|
|
*/
|
|
|
|
static int8 deltaXFromDirection[10] = {0, -1, 0, 1, 1, 1, 0, -1, -1, 0};
|
|
static int8 deltaYFromDirection[10] = {0, -1, -1, -1, 0, 1, 1, 1, 0, 0};
|
|
|
|
static bool positionWalkable(Map *map, int8 x, int8 y) {
|
|
return !map->getPass(x, y, map->getMapWidth());
|
|
}
|
|
|
|
static void updateGobDest(Map *map, Mult::Mult_Object &obj) {
|
|
if (!positionWalkable(map, obj.gobDestX, obj.gobDestY)) {
|
|
int8 newGobDestX = 0;
|
|
int32 var_8 = 1000;
|
|
int8 newGobDestY = 0;
|
|
for (int32 direction = 2; direction <= 8; direction += 2) {
|
|
int32 nbrOfStepsDir = 0;
|
|
int8 tempGobDestX = obj.gobDestX;
|
|
int8 tempGobDestY = obj.gobDestY;
|
|
|
|
while (true) {
|
|
tempGobDestX += deltaXFromDirection[direction];
|
|
tempGobDestY += deltaYFromDirection[direction];
|
|
nbrOfStepsDir++;
|
|
if (tempGobDestX < 0
|
|
|| tempGobDestX >= map->getMapWidth()
|
|
|| tempGobDestY < 0
|
|
|| tempGobDestY >= map->getMapHeight()) {
|
|
break;
|
|
}
|
|
|
|
if (positionWalkable(map, tempGobDestX, tempGobDestY)) {
|
|
if (nbrOfStepsDir < var_8) {
|
|
newGobDestX = tempGobDestX;
|
|
newGobDestY = tempGobDestY;
|
|
var_8 = nbrOfStepsDir;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (var_8 != 1000) {
|
|
obj.gobDestX = newGobDestX;
|
|
obj.gobDestY = newGobDestY;
|
|
}
|
|
}
|
|
}
|
|
|
|
int8 directionFromDeltaXY(int8 deltaX, int8 deltaY) {
|
|
for (int8 direction = 1; direction <= 8; ++direction) {
|
|
if (deltaXFromDirection[direction] == deltaX &&
|
|
deltaYFromDirection[direction] == deltaY)
|
|
return direction;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool Goblin_v7::directionWalkable(int8 x, int8 y, int8 direction) {
|
|
int8 nextX = x + deltaXFromDirection[direction];
|
|
int8 nextY = y + deltaYFromDirection[direction];
|
|
if (nextX >= 0 &&
|
|
nextX < _vm->_map->getMapWidth() &&
|
|
nextY >= 0 &&
|
|
nextY < _vm->_map->getMapHeight()) {
|
|
return positionWalkable(_vm->_map, nextX, nextY);
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
int32 Goblin_v7::bestWalkableDirectionFromOriginAndDest(int8 x, int8 y, int8 destX, int8 destY) {
|
|
int8 deltaX = 0;
|
|
int8 deltaY = 0;
|
|
|
|
if (destX < x)
|
|
deltaX = -1;
|
|
else if (destX > x)
|
|
deltaX = 1;
|
|
|
|
if (destY < y)
|
|
deltaY = -1;
|
|
else if (destY > y)
|
|
deltaY = 1;
|
|
|
|
int8 direction = directionFromDeltaXY(deltaX, deltaY);
|
|
if (directionWalkable(x, y, direction))
|
|
return direction;
|
|
|
|
// Look for another walkable direction
|
|
direction -= 1;
|
|
if (direction <= 0)
|
|
direction += 8;
|
|
if (directionWalkable(x, y, direction))
|
|
return direction;
|
|
|
|
direction += 2;
|
|
if (direction > 8)
|
|
direction -= 8;
|
|
if (directionWalkable(x, y, direction))
|
|
return direction;
|
|
|
|
direction -= 3;
|
|
if (direction <= 0)
|
|
direction += 8;
|
|
if (directionWalkable(x, y, direction))
|
|
return -direction;
|
|
|
|
direction += 4;
|
|
if (direction > 8)
|
|
direction -= 8;
|
|
if (directionWalkable(x, y, direction))
|
|
return -direction;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int32 Goblin_v7::findPath(int8 x, int8 y, int8 destX, int8 destY) {
|
|
int8 currentX = x;
|
|
int8 currentY = y;
|
|
int8 returnToPreviousStepDir = -1;
|
|
int8 var_8 = 0;
|
|
int8 firstDirection = 0;
|
|
int8 var_1C = 0;
|
|
|
|
while (true) {
|
|
int8 currentDirection = bestWalkableDirectionFromOriginAndDest(currentX, currentY, destX, destY);
|
|
if (currentDirection == 0)
|
|
return 0;
|
|
|
|
if (currentDirection >= 0) {
|
|
if (var_8 == 1) {
|
|
var_8 = 2;
|
|
var_1C = findPath(x, y, currentX, currentY);
|
|
if (var_1C > 0)
|
|
firstDirection = var_1C;
|
|
}
|
|
} else {
|
|
currentDirection = -currentDirection;
|
|
if (var_8 == 0)
|
|
var_8 = 1;
|
|
}
|
|
|
|
if (returnToPreviousStepDir > 0) {
|
|
returnToPreviousStepDir += 4;
|
|
if (returnToPreviousStepDir > 8)
|
|
returnToPreviousStepDir -= 8;
|
|
}
|
|
|
|
if (currentDirection == returnToPreviousStepDir) {
|
|
currentDirection += 4;
|
|
if (currentDirection > 8)
|
|
currentDirection -= 8;
|
|
|
|
if (!directionWalkable(currentX, currentY, currentDirection))
|
|
return 0;
|
|
}
|
|
|
|
if (firstDirection == 0)
|
|
firstDirection = currentDirection;
|
|
|
|
returnToPreviousStepDir = currentDirection; // Will be inverted later
|
|
currentX += deltaXFromDirection[currentDirection];
|
|
currentY += deltaYFromDirection[currentDirection];
|
|
|
|
if (currentX != destX || currentY != destY)
|
|
continue;
|
|
else
|
|
return firstDirection;
|
|
}
|
|
}
|
|
|
|
int32 Goblin_v7::computeObjNextDirection(Mult::Mult_Object &obj) {
|
|
Mult::Mult_AnimData animData = *obj.pAnimData;
|
|
if (animData.stateType == 1) {
|
|
warning("STUB: Goblin_v7::computeObjNextDirection animData.stateType == 1");
|
|
return 0;
|
|
} else {
|
|
updateGobDest(_vm->_map, obj);
|
|
int32 direction = findPath(obj.goblinX, obj.goblinY, obj.gobDestX, obj.gobDestY);
|
|
if (direction == 0) {
|
|
direction = bestWalkableDirectionFromOriginAndDest(obj.goblinX, obj.goblinY, obj.gobDestX, obj.gobDestY);
|
|
if (direction < 0)
|
|
direction = -direction;
|
|
}
|
|
|
|
if (animData.newState > 0) {
|
|
int32 newState = animData.newState + 4;
|
|
if (newState > 8) {
|
|
newState -= 8;
|
|
}
|
|
|
|
if (direction == newState) {
|
|
direction = animData.newState;
|
|
if (!directionWalkable(obj.goblinX, obj.goblinY, direction))
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (direction < 0)
|
|
return 0;
|
|
|
|
obj.destX = obj.goblinX + deltaXFromDirection[direction];
|
|
obj.destY = obj.goblinY + deltaYFromDirection[direction];
|
|
return direction;
|
|
}
|
|
}
|
|
|
|
void Goblin_v7::initiateMove(Mult::Mult_Object *obj) {
|
|
int32 animState = 0;
|
|
if (obj->goblinX != obj->gobDestX || obj->goblinY != obj->gobDestY) {
|
|
debugC(5, kDebugGameFlow, "Computing Obj %s new state (obj->goblinX = %d, obj->gobDestX = %d, obj->goblinY = %d, obj->gobDestY = %d)",
|
|
obj->animName, obj->goblinX , obj->gobDestX , obj->goblinY ,obj->gobDestY);
|
|
|
|
animState = computeObjNextDirection(*obj);
|
|
|
|
debugC(5, kDebugGameFlow, "Obj %s new state = %d (obj->goblinX = %d, obj->gobDestX = %d, obj->goblinY = %d, obj->gobDestY = %d)",
|
|
obj->animName, animState, obj->goblinX , obj->gobDestX , obj->goblinY ,obj->gobDestY);
|
|
}
|
|
|
|
debugC(5, kDebugGameFlow, "Obj %s initiateMove (lookDir=%d, obj->posX=%d, obj->posY=%d, obj->goblinX = %d, obj->gobDestX = %d, obj->goblinY = %d, obj->gobDestY = %d)",
|
|
obj->animName, obj->pAnimData->curLookDir, (int16) *obj->pPosX, (int16) *obj->pPosY, obj->goblinX , obj->gobDestX , obj->goblinY , obj->gobDestY);
|
|
|
|
if (animState != 0) {
|
|
obj->pAnimData->newState = animState;
|
|
setGoblinState(obj, animState);
|
|
} else {
|
|
if (obj->pAnimData->destX != obj->pAnimData->gobDestX_maybe || obj->pAnimData->destY != obj->pAnimData->gobDestY_maybe)
|
|
obj->pAnimData->pathExistence = 2;
|
|
else
|
|
obj->pAnimData->pathExistence = 1;
|
|
|
|
obj->pAnimData->animType = 12;
|
|
if (obj->pAnimData->curLookDir >= 20) {
|
|
if (obj->pAnimData->curLookDir >= 30) {
|
|
if (obj->pAnimData->curLookDir >= 40)
|
|
return;
|
|
else {
|
|
setGoblinState(obj, 105);
|
|
obj->pAnimData->pathExistence = 3;
|
|
}
|
|
} else {
|
|
setGoblinState(obj, 101);
|
|
obj->pAnimData->pathExistence = 3;
|
|
}
|
|
} else {
|
|
setGoblinState(obj, obj->pAnimData->curLookDir + 100);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // End of namespace Gob
|