mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-14 13:50:13 +00:00
405 lines
9.6 KiB
C++
405 lines
9.6 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 "common/system.h"
|
|
|
|
#include "trecision/scheduler.h"
|
|
#include "trecision/text.h"
|
|
#include "trecision/defines.h"
|
|
#include "trecision/graphics.h"
|
|
#include "trecision/trecision.h"
|
|
#include "trecision/struct.h"
|
|
|
|
namespace Trecision {
|
|
|
|
char *TrecisionEngine::getNextSentence() {
|
|
while (*_textPtr) {
|
|
*_textPtr = ~(*_textPtr);
|
|
++_textPtr;
|
|
}
|
|
|
|
++_textPtr;
|
|
return _textPtr;
|
|
}
|
|
|
|
/**
|
|
* Compute string length from character begin to end
|
|
*/
|
|
uint16 TrecisionEngine::textLength(const Common::String &text, uint16 begin, uint16 end) {
|
|
if (text.empty())
|
|
return 0;
|
|
|
|
if (end == 0)
|
|
end = text.size();
|
|
|
|
uint16 retVal = 0;
|
|
for (uint16 c = begin; c < end; ++c)
|
|
retVal += _graphicsMgr->getCharWidth(text[c]);
|
|
|
|
return retVal;
|
|
}
|
|
|
|
uint16 TrecisionEngine::getKey() {
|
|
Common::KeyCode key = _curKey;
|
|
uint16 ascii = _curAscii;
|
|
_curKey = Common::KEYCODE_INVALID;
|
|
_curAscii = 0;
|
|
|
|
switch (key) {
|
|
case Common::KEYCODE_SPACE:
|
|
case Common::KEYCODE_ESCAPE:
|
|
case Common::KEYCODE_RETURN:
|
|
case Common::KEYCODE_CLEAR:
|
|
case Common::KEYCODE_BACKSPACE:
|
|
return key;
|
|
case Common::KEYCODE_F1:
|
|
case Common::KEYCODE_F2:
|
|
case Common::KEYCODE_F3:
|
|
case Common::KEYCODE_F4:
|
|
case Common::KEYCODE_F5:
|
|
case Common::KEYCODE_F6:
|
|
return 0x3B + key - Common::KEYCODE_F1;
|
|
default:
|
|
if (ascii)
|
|
return ascii;
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
Common::KeyCode TrecisionEngine::waitKey() {
|
|
_graphicsMgr->hideCursor();
|
|
while (_curKey == Common::KEYCODE_INVALID)
|
|
checkSystem();
|
|
_graphicsMgr->showCursor();
|
|
|
|
Common::KeyCode t = _curKey;
|
|
_curKey = Common::KEYCODE_INVALID;
|
|
|
|
return t;
|
|
}
|
|
|
|
void TrecisionEngine::waitDelay(uint32 val) {
|
|
uint32 sv = readTime();
|
|
|
|
while (sv + val > readTime())
|
|
checkSystem();
|
|
}
|
|
|
|
void TrecisionEngine::freeKey() {
|
|
_curKey = Common::KEYCODE_INVALID;
|
|
}
|
|
|
|
uint32 TrecisionEngine::readTime() {
|
|
return (g_system->getMillis() * 3) / 50;
|
|
}
|
|
|
|
bool TrecisionEngine::checkMask(Common::Point pos) {
|
|
for (int8 i = MAXOBJINROOM - 1; i >= 0; --i) {
|
|
uint16 checkedObj = _room[_curRoom]._object[i];
|
|
Common::Rect lim = _obj[checkedObj]._area;
|
|
lim.translate(0, TOP);
|
|
// Trecision includes the bottom and right coordinates
|
|
++lim.right;
|
|
++lim.bottom;
|
|
|
|
if (checkedObj && isObjectVisible(checkedObj)) {
|
|
if (lim.contains(pos)) {
|
|
|
|
if (_obj[checkedObj].isModeFull() || _obj[checkedObj].isModeLim()) {
|
|
_curObj = checkedObj;
|
|
return true;
|
|
}
|
|
|
|
if (_obj[checkedObj].isModeMask()) {
|
|
uint8 *mask = _objectGraphics[i].mask;
|
|
int16 d = _obj[checkedObj]._rect.left;
|
|
uint16 max = _obj[checkedObj]._rect.bottom;
|
|
|
|
for (uint16 j = _obj[checkedObj]._rect.top; j < max; ++j) {
|
|
bool insideObj = false;
|
|
int16 e = 0;
|
|
while (e < _obj[checkedObj]._rect.width()) {
|
|
if (!insideObj) { // not inside an object
|
|
if (j + TOP == pos.y) {
|
|
if ((pos.x >= d + e) && (pos.x < d + e + *mask)) {
|
|
_curObj = 0;
|
|
}
|
|
}
|
|
|
|
e += *mask;
|
|
++mask;
|
|
insideObj = true;
|
|
} else { // inside an object
|
|
if (j + TOP == pos.y) {
|
|
if ((pos.x >= d + e) && (pos.x < d + e + *mask)) {
|
|
_curObj = checkedObj;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
e += *mask;
|
|
++mask;
|
|
insideObj = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_curObj = 0;
|
|
return false;
|
|
}
|
|
|
|
float TrecisionEngine::sinCosAngle(float sinus, float cosinus) {
|
|
if (floatComp(sinus, 0.0f) == 0 && floatComp(cosinus, 0.0f) == 0)
|
|
return 0;
|
|
|
|
float t = (float)sqrt((double)(sinus * sinus) + (double)(cosinus * cosinus));
|
|
cosinus /= t;
|
|
sinus /= t;
|
|
|
|
// 1e3 & 2e4 quad
|
|
if (floatComp(sinus, 0.0f) >= 0)
|
|
// 1 & 2 quad
|
|
return (float)acos(cosinus);
|
|
|
|
// 3 quad
|
|
return PI2 - (float)acos(cosinus);
|
|
}
|
|
|
|
void TrecisionEngine::processTime() {
|
|
_curTime = readTime();
|
|
|
|
if (_curTime >= _nextRefresh) {
|
|
if (_inventoryStatus == INV_PAINT || _inventoryStatus == INV_DEPAINT)
|
|
rollInventory(_inventoryStatus);
|
|
|
|
if (_inventoryStatus != INV_OFF) {
|
|
refreshInventory(_inventoryRefreshStartIcon, _inventoryRefreshStartLine);
|
|
}
|
|
|
|
_textMgr->drawTexts();
|
|
_graphicsMgr->paintScreen(false);
|
|
_textMgr->clearTextStack();
|
|
|
|
uint32 paintTime = readTime();
|
|
if (paintTime - _curTime >= 5)
|
|
_nextRefresh = paintTime + 1;
|
|
else
|
|
_nextRefresh = _curTime + 5;
|
|
}
|
|
}
|
|
|
|
void TrecisionEngine::processMouse() {
|
|
int16 mx = _mousePos.x;
|
|
int16 my = _mousePos.y;
|
|
|
|
checkSystem();
|
|
|
|
if (!_graphicsMgr->isCursorVisible())
|
|
return;
|
|
|
|
if (_mouseLeftBtn) {
|
|
_scheduler->leftClick(mx, my);
|
|
_mouseLeftBtn = false;
|
|
} else if (_mouseRightBtn) {
|
|
_scheduler->rightClick(mx, my);
|
|
_mouseRightBtn = false;
|
|
} else {
|
|
if (!_flagScriptActive && _mouseMoved) {
|
|
processMouseMovement();
|
|
_mouseMoved = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fake distance between two 2D points
|
|
*/
|
|
float TrecisionEngine::dist2D(float x1, float y1, float x2, float y2) {
|
|
const double dx = x1 - x2;
|
|
const double dy = y1 - y2;
|
|
|
|
return (float)sqrt(dx * dx + dy * dy);
|
|
}
|
|
|
|
/**
|
|
* Distance between two 3D points
|
|
*/
|
|
float TrecisionEngine::dist3D(float x1, float y1, float z1, float x2, float y2, float z2) {
|
|
const double dx = x1 - x2;
|
|
const double dy = y1 - y2;
|
|
const double dz = z1 - z2;
|
|
return (float)sqrt(dx * dx + dy * dy + dz * dz);
|
|
}
|
|
|
|
bool TrecisionEngine::isBetween(int a, int x, int b) {
|
|
return x >= a && x <= b;
|
|
}
|
|
|
|
bool TrecisionEngine::isGameArea(Common::Point pos) {
|
|
return isBetween(TOP, pos.y, TOP + AREA - 1);
|
|
}
|
|
|
|
bool TrecisionEngine::isInventoryArea(Common::Point pos) {
|
|
return pos.y >= TOP + AREA;
|
|
}
|
|
|
|
bool TrecisionEngine::isIconArea(Common::Point pos) {
|
|
return pos.y >= TOP + AREA && pos.y < MAXY && pos.x >= ICONMARGSX && pos.x <= MAXX - ICONMARGDX;
|
|
}
|
|
|
|
int TrecisionEngine::getRoomObjectIndex(uint16 objectId) {
|
|
for (uint16 index = 0; index < MAXOBJINROOM; ++index) {
|
|
const uint16 curObjId = _room[_curRoom]._object[index];
|
|
if (curObjId == 0)
|
|
return -1;
|
|
if (curObjId == objectId)
|
|
return index;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/************************************************
|
|
* SDText
|
|
************************************************/
|
|
void SDText::set(SDText *org) {
|
|
set(org->_rect, org->_subtitleRect, org->_textColor, org->_text);
|
|
}
|
|
|
|
void SDText::set(Common::Rect rect, Common::Rect subtitleRect, uint16 textCol, const Common::String &text) {
|
|
_rect = rect;
|
|
_subtitleRect = subtitleRect;
|
|
_textColor = textCol;
|
|
_text = text;
|
|
|
|
// Clean output buffer
|
|
for (int i = 0; i < MAXDTEXTLINES; ++i)
|
|
_drawTextLines[i] = "";
|
|
}
|
|
|
|
/**
|
|
* calcHeight - Computes and returns the dy of the current text
|
|
*/
|
|
uint16 SDText::calcHeight(TrecisionEngine *vm) {
|
|
if (_text.empty())
|
|
return 0;
|
|
|
|
uint8 curLine = 0;
|
|
if (vm->textLength(_text) <= _rect.width()) {
|
|
_drawTextLines[curLine] = _text;
|
|
return CARHEI;
|
|
}
|
|
|
|
uint16 index = 0;
|
|
uint16 tmpDy = 0;
|
|
uint16 lastSpace = 0;
|
|
uint16 curInit = 0;
|
|
|
|
while (index < _text.size()) {
|
|
++index;
|
|
if (index < _text.size() && _text[index] == ' ') {
|
|
if (vm->textLength(_text, curInit, index) <= _rect.width())
|
|
lastSpace = index;
|
|
else if (vm->textLength(_text, curInit, lastSpace) <= _rect.width()) {
|
|
_drawTextLines[curLine] = _text.substr(curInit, lastSpace - curInit);
|
|
|
|
++curLine;
|
|
curInit = lastSpace + 1;
|
|
|
|
tmpDy += CARHEI;
|
|
index = curInit;
|
|
} else
|
|
return 0;
|
|
} else if (index == _text.size()) {
|
|
if (vm->textLength(_text, curInit, index) <= _rect.width()) {
|
|
_drawTextLines[curLine] = _text.substr(curInit, index - curInit);
|
|
|
|
tmpDy += CARHEI;
|
|
return tmpDy;
|
|
}
|
|
|
|
if (vm->textLength(_text, curInit, lastSpace) <= _rect.width()) {
|
|
_drawTextLines[curLine] = _text.substr(curInit, lastSpace - curInit);
|
|
|
|
++curLine;
|
|
curInit = lastSpace + 1;
|
|
tmpDy += CARHEI;
|
|
|
|
if (curInit < _text.size()) {
|
|
_drawTextLines[curLine] = _text.substr(curInit);
|
|
tmpDy += CARHEI;
|
|
}
|
|
return tmpDy;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void SDText::draw(TrecisionEngine *vm, bool hideLastChar, Graphics::Surface *externalSurface) {
|
|
uint16 textColor = vm->_graphicsMgr->convertToScreenFormat(_textColor);
|
|
|
|
if (_text.empty())
|
|
return;
|
|
|
|
const uint16 curDy = calcHeight(vm);
|
|
|
|
for (uint16 line = 0; line < curDy / CARHEI; ++line) {
|
|
Common::String curText = _drawTextLines[line];
|
|
uint16 inc = (_rect.width() - vm->textLength(curText)) / 2;
|
|
|
|
if (curText.size() >= MAXCHARS) {
|
|
curText = vm->_sysText[kMessageError];
|
|
}
|
|
|
|
for (uint index = 0; index < curText.size(); ++index) {
|
|
const byte curChar = curText[index];
|
|
|
|
if (index == curText.size() - 1 && hideLastChar)
|
|
textColor = vm->_graphicsMgr->convertToScreenFormat(0);
|
|
|
|
vm->_graphicsMgr->drawChar(curChar, textColor, line, _rect, _subtitleRect, inc, externalSurface);
|
|
|
|
inc += vm->_graphicsMgr->getCharWidth(curChar);
|
|
}
|
|
}
|
|
}
|
|
|
|
int TrecisionEngine::floatComp(float f1, float f2) const {
|
|
static const float epsilon = 1.0e-05f;
|
|
|
|
const float diff = f1 - f2;
|
|
if (ABS(diff) < epsilon)
|
|
// equality
|
|
return 0;
|
|
|
|
if (f1 > f2)
|
|
return 1;
|
|
|
|
return -1;
|
|
}
|
|
} // End of namespace Trecision
|