477 lines
17 KiB
C++
477 lines
17 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/file.h"
|
|
#include "common/memstream.h"
|
|
|
|
#include "freescape/freescape.h"
|
|
#include "freescape/games/castle/castle.h"
|
|
#include "freescape/language/8bitDetokeniser.h"
|
|
|
|
namespace Freescape {
|
|
|
|
Common::SeekableReadStream *CastleEngine::decryptFile(const Common::Path &filename) {
|
|
Common::File file;
|
|
file.open(filename);
|
|
if (!file.isOpen())
|
|
error("Failed to open %s", filename.toString().c_str());
|
|
|
|
int size = file.size();
|
|
byte *encryptedBuffer = (byte *)malloc(size);
|
|
file.read(encryptedBuffer, size);
|
|
file.close();
|
|
|
|
int seed = 24;
|
|
for (int i = 0; i < size; i++) {
|
|
if (i > 1)
|
|
encryptedBuffer[i] ^= seed;
|
|
seed = (seed + 1) & 0xff;
|
|
}
|
|
|
|
return (new Common::MemoryReadStream(encryptedBuffer, size));
|
|
}
|
|
|
|
extern byte kEGADefaultPalette[16][3];
|
|
extern Common::MemoryReadStream *unpackEXE(Common::File &ms);
|
|
|
|
byte kEGARiddleFontPalette[16][3] = {
|
|
{0x00, 0x00, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00},
|
|
{0xaa, 0x55, 0x00}
|
|
};
|
|
|
|
Graphics::ManagedSurface *CastleEngine::loadFrameFromPlanes(Common::SeekableReadStream *file, int widthInBytes, int height) {
|
|
Graphics::ManagedSurface *surface = new Graphics::ManagedSurface();
|
|
surface->create(widthInBytes * 8 / 4, height, Graphics::PixelFormat::createFormatCLUT8());
|
|
surface->fillRect(Common::Rect(0, 0, widthInBytes * 8 / 4, height), 0);
|
|
loadFrameFromPlanesInternal(file, surface, widthInBytes, height);
|
|
return surface;
|
|
}
|
|
|
|
Graphics::ManagedSurface *CastleEngine::loadFrameFromPlanesInternal(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int width, int height) {
|
|
byte *colors = (byte *)malloc(sizeof(byte) * height * width);
|
|
file->read(colors, height * width);
|
|
|
|
for (int p = 0; p < 4; p++) {
|
|
for (int i = 0; i < height * width; i++) {
|
|
byte color = colors[i];
|
|
for (int n = 0; n < 8; n++) {
|
|
int y = i / width;
|
|
int x = (i % width) * 8 + (7 - n);
|
|
// Check that we are in the right plane
|
|
if (x < width * (8 / 4) * p || x >= width * (8 / 4) * (p + 1))
|
|
continue;
|
|
|
|
int bit = ((color >> n) & 0x01) << p;
|
|
int sample = surface->getPixel(x % (width * 8 / 4), y) | bit;
|
|
assert(sample < 16);
|
|
surface->setPixel(x % (width * 8 / 4), y, sample);
|
|
}
|
|
}
|
|
}
|
|
return surface;
|
|
}
|
|
|
|
Common::Array <Graphics::ManagedSurface *>CastleEngine::loadFramesWithHeaderDOS(Common::SeekableReadStream *file, int numFrames) {
|
|
uint8 header1 = file->readByte();
|
|
uint8 header2 = file->readByte();
|
|
int height = file->readByte();
|
|
uint8 mask = file->readByte();
|
|
int size = file->readUint16LE();
|
|
|
|
assert(size % height == 0);
|
|
int widthBytes = (size / height);
|
|
|
|
Common::Array<Graphics::ManagedSurface *> frames;
|
|
for (int i = 0; i < numFrames; i++) {
|
|
Graphics::ManagedSurface *frame = loadFrameFromPlanes(file, widthBytes, height);
|
|
frame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
frames.push_back(frame);
|
|
}
|
|
|
|
debug("header: %x %x, height: %d, mask: %x, widthBytes: %d, size: %d", header1, header2, height, mask, widthBytes, size);
|
|
return frames;
|
|
}
|
|
|
|
Graphics::ManagedSurface *CastleEngine::loadFrameWithHeaderDOS(Common::SeekableReadStream *file) {
|
|
uint8 header1 = file->readByte();
|
|
uint8 header2 = file->readByte();
|
|
int height = file->readByte();
|
|
uint8 mask = file->readByte();
|
|
int size = file->readUint16LE();
|
|
|
|
assert(size % height == 0);
|
|
int widthBytes = (size / height);
|
|
|
|
Graphics::ManagedSurface *frame = loadFrameFromPlanes(file, widthBytes, height);
|
|
frame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
|
|
debug("header: %x %x, height: %d, mask: %x, widthBytes: %d, size: %d", header1, header2, height, mask, widthBytes, size);
|
|
debug("pos: %x", (int32)file->pos());
|
|
return frame;
|
|
}
|
|
|
|
void CastleEngine::initDOS() {
|
|
_viewArea = Common::Rect(40, 33 - 2, 280, 152);
|
|
}
|
|
|
|
void CastleEngine::loadAssetsDOSFullGame() {
|
|
Common::File file;
|
|
Common::SeekableReadStream *stream = nullptr;
|
|
|
|
if (_renderMode == Common::kRenderEGA) {
|
|
file.open("CME.EXE");
|
|
stream = unpackEXE(file);
|
|
if (stream) {
|
|
loadSpeakerFxDOS(stream, 0x636d + 0x200, 0x63ed + 0x200, 30);
|
|
|
|
stream->seek(0x197c0);
|
|
_endGameBackgroundFrame = loadFrameFromPlanes(stream, 112, 108);
|
|
_endGameBackgroundFrame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
|
|
_background = loadFrameFromPlanes(stream, 504, 18);
|
|
_background->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
debug("%x", (int32)stream->pos());
|
|
// Eye widget is next to 0x1f058
|
|
|
|
stream->seek(0x1f4e3);
|
|
for (int i = 0; i < 6; i++)
|
|
debug("i: %d -> %x", i, stream->readByte());
|
|
debug("%x", (int32)stream->pos());
|
|
debug("extra: %x", stream->readByte());
|
|
|
|
for (int i = 0; i < 10; i++) {
|
|
Graphics::ManagedSurface *frame = loadFrameFromPlanes(stream, 8, 14);
|
|
frame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
_keysBorderFrames.push_back(frame);
|
|
}
|
|
|
|
for (int i = 0; i < 10; i++) {
|
|
Graphics::ManagedSurface *frame = loadFrameFromPlanes(stream, 8, 14);
|
|
frame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
_keysMenuFrames.push_back(frame);
|
|
}
|
|
|
|
//for (int i = 0; i < 6; i++)
|
|
// debug("i: %d -> %x", i, stream->readByte());
|
|
|
|
//loadFrameWithHeaderDOS(stream);
|
|
//debug("%lx", stream->pos());
|
|
//assert(0);
|
|
|
|
stream->seek(0x20262);
|
|
_strenghtBackgroundFrame = loadFrameWithHeaderDOS(stream);
|
|
_strenghtBarFrame = loadFrameWithHeaderDOS(stream);
|
|
_strenghtWeightsFrames = loadFramesWithHeaderDOS(stream, 4);
|
|
_spiritsMeterIndicatorBackgroundFrame = loadFrameWithHeaderDOS(stream);
|
|
_spiritsMeterIndicatorFrame = loadFrameWithHeaderDOS(stream);
|
|
_spiritsMeterIndicatorSideFrame = loadFrameWithHeaderDOS(stream); // side
|
|
loadFrameWithHeaderDOS(stream); // ???
|
|
|
|
/*for (int i = 0; i < 6; i++)
|
|
debug("i: %d -> %x", i, stream->readByte());
|
|
debug("%lx", stream->pos());*/
|
|
//assert(0);
|
|
|
|
stream->seek(0x221ae);
|
|
// No header?
|
|
_menu = loadFrameFromPlanes(stream, 112, 115);
|
|
_menu->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
|
|
Common::Array <Graphics::ManagedSurface *> menuFrames = loadFramesWithHeaderDOS(stream, 5);
|
|
_menuCrawlIndicator = menuFrames[0];
|
|
_menuWalkIndicator = menuFrames[1];
|
|
_menuRunIndicator = menuFrames[2];
|
|
_menuFxOffIndicator = menuFrames[3];
|
|
_menuFxOnIndicator = menuFrames[4];
|
|
|
|
_flagFrames = loadFramesWithHeaderDOS(stream, 4);
|
|
_riddleTopFrame = loadFrameWithHeaderDOS(stream);
|
|
_riddleBackgroundFrame = loadFrameWithHeaderDOS(stream);
|
|
_riddleBottomFrame = loadFrameWithHeaderDOS(stream);
|
|
_endGameThroneFrame = loadFrameWithHeaderDOS(stream);
|
|
// No header
|
|
Graphics::ManagedSurface *thunderFrame = loadFrameFromPlanes(stream, 32, 128);
|
|
thunderFrame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
_thunderFrames.push_back(thunderFrame);
|
|
|
|
stream->seek(0x29696);
|
|
Common::Array<Graphics::ManagedSurface *> chars;
|
|
Common::Array<Graphics::ManagedSurface *> charsRiddle;
|
|
for (int i = 0; i < 90; i++) {
|
|
Graphics::ManagedSurface *img = loadFrameFromPlanes(stream, 8, 8);
|
|
Graphics::ManagedSurface *imgRiddle = new Graphics::ManagedSurface();
|
|
imgRiddle->copyFrom(*img);
|
|
|
|
chars.push_back(img);
|
|
chars[i]->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
|
|
charsRiddle.push_back(imgRiddle);
|
|
charsRiddle[i]->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGARiddleFontPalette, 16);
|
|
}
|
|
_font = Font(chars);
|
|
_font.setCharWidth(9);
|
|
|
|
_fontRiddle = Font(charsRiddle);
|
|
_fontRiddle.setCharWidth(9);
|
|
_fontLoaded = true;
|
|
}
|
|
|
|
delete stream;
|
|
file.close();
|
|
|
|
file.open("CMLE.DAT");
|
|
_title = load8bitBinImage(&file, 0x0);
|
|
_title->setPalette((byte *)&kEGADefaultPalette, 0, 16);
|
|
file.close();
|
|
|
|
file.open("CMOE.DAT");
|
|
_option = load8bitBinImage(&file, 0x0);
|
|
_option->setPalette((byte *)&kEGADefaultPalette, 0, 16);
|
|
file.close();
|
|
|
|
file.open("CME.DAT");
|
|
_border = load8bitBinImage(&file, 0x0);
|
|
_border->setPalette((byte *)&kEGADefaultPalette, 0, 16);
|
|
file.close();
|
|
|
|
switch (_language) {
|
|
case Common::ES_ESP:
|
|
stream = decryptFile("CMLS");
|
|
loadRiddles(stream, 0xaae - 2 - 22 * 2, 22);
|
|
// Fixes for incorrect or wrong translations
|
|
Common::replace(_riddleList[16]._lines[5]._text, "IN", "EN");
|
|
break;
|
|
case Common::FR_FRA:
|
|
stream = decryptFile("CMLF");
|
|
loadRiddles(stream, 0xaae - 2 - 22 * 2, 22);
|
|
break;
|
|
case Common::DE_DEU:
|
|
stream = decryptFile("CMLG");
|
|
loadRiddles(stream, 0xaae - 2 - 22 * 2, 22);
|
|
break;
|
|
case Common::EN_ANY:
|
|
stream = decryptFile("CMLE");
|
|
loadRiddles(stream, 0xaae - 2 - 22 * 2, 22);
|
|
break;
|
|
default:
|
|
error("Invalid or unsupported language: %x", _language);
|
|
}
|
|
|
|
loadMessagesVariableSize(stream, 0x11, 164);
|
|
delete stream;
|
|
|
|
stream = decryptFile("CMEDF");
|
|
load8bitBinary(stream, 0, 16);
|
|
delete stream;
|
|
} else
|
|
error("Not implemented yet");
|
|
|
|
|
|
// CPC
|
|
// file = gameDir.createReadStreamForMember("cm.bin");
|
|
// if (file == nullptr)
|
|
// error("Failed to open cm.bin");
|
|
// load8bitBinary(file, 0x791a, 16);
|
|
}
|
|
|
|
void CastleEngine::loadAssetsDOSDemo() {
|
|
Common::File file;
|
|
Common::SeekableReadStream *stream = nullptr;
|
|
|
|
if (_renderMode == Common::kRenderEGA) {
|
|
file.open("CMDE.EXE");
|
|
stream = unpackEXE(file);
|
|
if (stream) {
|
|
loadSpeakerFxDOS(stream, 0x636d + 0x200, 0x63ed + 0x200, 30);
|
|
|
|
stream->seek(0x197c0 - 0x2a0);
|
|
_endGameBackgroundFrame = loadFrameFromPlanes(stream, 112, 108);
|
|
_endGameBackgroundFrame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
|
|
_background = loadFrameFromPlanes(stream, 504, 18);
|
|
_background->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
|
|
stream->seek(0x1f4e3 - 0x2a0);
|
|
for (int i = 0; i < 6; i++)
|
|
debug("i: %d -> %x", i, stream->readByte());
|
|
debug("%x", (int32)stream->pos());
|
|
debug("extra: %x", stream->readByte());
|
|
|
|
for (int i = 0; i < 9; i++) {
|
|
Graphics::ManagedSurface *frame = loadFrameFromPlanes(stream, 8, 14);
|
|
frame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
_keysBorderFrames.push_back(frame);
|
|
}
|
|
|
|
for (int i = 0; i < 11; i++) {
|
|
Graphics::ManagedSurface *frame = loadFrameFromPlanes(stream, 8, 14);
|
|
frame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
_keysMenuFrames.push_back(frame);
|
|
}
|
|
|
|
stream->seek(0x20262 - 0x2a0);
|
|
_strenghtBackgroundFrame = loadFrameWithHeaderDOS(stream);
|
|
_strenghtBarFrame = loadFrameWithHeaderDOS(stream);
|
|
_strenghtWeightsFrames = loadFramesWithHeaderDOS(stream, 4);
|
|
_spiritsMeterIndicatorBackgroundFrame = loadFrameWithHeaderDOS(stream);
|
|
_spiritsMeterIndicatorFrame = loadFrameWithHeaderDOS(stream);
|
|
_spiritsMeterIndicatorSideFrame = loadFrameWithHeaderDOS(stream); // side
|
|
loadFrameWithHeaderDOS(stream); // ???
|
|
|
|
stream->seek(0x221ae - 0x2a0);
|
|
// No header?
|
|
_menu = loadFrameFromPlanes(stream, 112, 115);
|
|
_menu->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
|
|
Common::Array <Graphics::ManagedSurface *> menuFrames = loadFramesWithHeaderDOS(stream, 5);
|
|
_menuCrawlIndicator = menuFrames[0];
|
|
_menuWalkIndicator = menuFrames[1];
|
|
_menuRunIndicator = menuFrames[2];
|
|
_menuFxOffIndicator = menuFrames[3];
|
|
_menuFxOnIndicator = menuFrames[4];
|
|
|
|
_flagFrames = loadFramesWithHeaderDOS(stream, 4);
|
|
_riddleTopFrame = loadFrameWithHeaderDOS(stream);
|
|
_riddleBackgroundFrame = loadFrameWithHeaderDOS(stream);
|
|
_riddleBottomFrame = loadFrameWithHeaderDOS(stream);
|
|
_endGameThroneFrame = loadFrameWithHeaderDOS(stream);
|
|
// No header
|
|
Graphics::ManagedSurface *thunderFrame = loadFrameFromPlanes(stream, 32, 128);
|
|
thunderFrame->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
_thunderFrames.push_back(thunderFrame);
|
|
|
|
stream->seek(0x293f6); // TODO: check this
|
|
Common::Array<Graphics::ManagedSurface *> chars;
|
|
Common::Array<Graphics::ManagedSurface *> charsRiddle;
|
|
for (int i = 0; i < 90; i++) {
|
|
Graphics::ManagedSurface *img = loadFrameFromPlanes(stream, 8, 8);
|
|
Graphics::ManagedSurface *imgRiddle = new Graphics::ManagedSurface();
|
|
imgRiddle->copyFrom(*img);
|
|
|
|
chars.push_back(img);
|
|
chars[i]->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGADefaultPalette, 16);
|
|
|
|
charsRiddle.push_back(imgRiddle);
|
|
charsRiddle[i]->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGARiddleFontPalette, 16);
|
|
}
|
|
_font = Font(chars);
|
|
_font.setCharWidth(9);
|
|
|
|
_fontRiddle = Font(charsRiddle);
|
|
_fontRiddle.setCharWidth(9);
|
|
_fontLoaded = true;
|
|
}
|
|
|
|
delete stream;
|
|
file.close();
|
|
|
|
file.open("CMLE.DAT");
|
|
_title = load8bitBinImage(&file, 0x0);
|
|
_title->setPalette((byte *)&kEGADefaultPalette, 0, 16);
|
|
file.close();
|
|
|
|
file.open("CMOE.DAT");
|
|
_option = load8bitBinImage(&file, 0x0);
|
|
_option->setPalette((byte *)&kEGADefaultPalette, 0, 16);
|
|
file.close();
|
|
|
|
file.open("CME.DAT");
|
|
_border = load8bitBinImage(&file, 0x0);
|
|
_border->setPalette((byte *)&kEGADefaultPalette, 0, 16);
|
|
file.close();
|
|
|
|
stream = decryptFile("CMLD"); // Only english
|
|
loadMessagesVariableSize(stream, 0x11, 164);
|
|
loadRiddles(stream, 0xaae - 2 - 22 * 2, 22);
|
|
delete stream;
|
|
|
|
stream = decryptFile("CDEDF");
|
|
load8bitBinary(stream, 0, 16);
|
|
delete stream;
|
|
} else
|
|
error("Not implemented yet");
|
|
|
|
}
|
|
|
|
void CastleEngine::drawDOSUI(Graphics::Surface *surface) {
|
|
uint32 color = 10;
|
|
uint32 black = _gfx->_texturePixelFormat.ARGBToColor(0xFF, 0x00, 0x00, 0x00);
|
|
uint8 r, g, b;
|
|
drawLiftingGate(surface);
|
|
drawDroppingGate(surface);
|
|
|
|
_gfx->readFromPalette(color, r, g, b);
|
|
uint32 front = _gfx->_texturePixelFormat.ARGBToColor(0xFF, r, g, b);
|
|
|
|
color = 0;
|
|
|
|
_gfx->readFromPalette(color, r, g, b);
|
|
uint32 back = _gfx->_texturePixelFormat.ARGBToColor(0xFF, r, g, b);
|
|
|
|
Common::Rect backRect(97, 181, 232, 190);
|
|
surface->fillRect(backRect, back);
|
|
|
|
Common::String message;
|
|
int deadline = -1;
|
|
getLatestMessages(message, deadline);
|
|
if (deadline > 0 && deadline <= _countdown) {
|
|
drawStringInSurface(message, 97, 182, front, back, surface);
|
|
_temporaryMessages.push_back(message);
|
|
_temporaryMessageDeadlines.push_back(deadline);
|
|
} else {
|
|
if (_gameStateControl != kFreescapeGameStateEnd) {
|
|
if (ghostInArea())
|
|
drawStringInSurface(_messagesList[116], 97, 182, front, back, surface);
|
|
else
|
|
drawStringInSurface(_currentArea->_name, 97, 182, front, back, surface);
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < int(_keysCollected.size()); k++) {
|
|
surface->copyRectToSurfaceWithKey((const Graphics::Surface)*_keysBorderFrames[k], 76 - k * 3, 179, Common::Rect(0, 0, 6, 14), black);
|
|
}
|
|
|
|
drawEnergyMeter(surface, Common::Point(38, 158));
|
|
int flagFrameIndex = (_ticks / 10) % 4;
|
|
surface->copyRectToSurface(*_flagFrames[flagFrameIndex], 285, 5, Common::Rect(0, 0, _flagFrames[flagFrameIndex]->w, _flagFrames[flagFrameIndex]->h));
|
|
|
|
surface->copyRectToSurface((const Graphics::Surface)*_spiritsMeterIndicatorBackgroundFrame, 136, 162, Common::Rect(0, 0, _spiritsMeterIndicatorBackgroundFrame->w, _spiritsMeterIndicatorBackgroundFrame->h));
|
|
surface->copyRectToSurfaceWithKey((const Graphics::Surface)*_spiritsMeterIndicatorFrame, 125 + 6 + _spiritsMeterPosition, 161, Common::Rect(0, 0, _spiritsMeterIndicatorFrame->w, _spiritsMeterIndicatorFrame->h), black);
|
|
surface->copyRectToSurface((const Graphics::Surface)*_spiritsMeterIndicatorSideFrame, 122 + 5 + 1, 157 + 5 - 1, Common::Rect(0, 0, _spiritsMeterIndicatorSideFrame->w / 2, _spiritsMeterIndicatorSideFrame->h));
|
|
//surface->copyRectToSurface(*_spiritsMeterIndicatorFrame, 100, 50, Common::Rect(0, 0, _spiritsMeterIndicatorFrame->w, _spiritsMeterIndicatorFrame->h));
|
|
}
|
|
|
|
} // End of namespace Freescape
|