144 lines
4.6 KiB
C++
144 lines
4.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/file.h"
|
|
#include "common/memstream.h"
|
|
|
|
#include "freescape/freescape.h"
|
|
#include "freescape/games/castle/castle.h"
|
|
#include "freescape/language/8bitDetokeniser.h"
|
|
|
|
namespace Freescape {
|
|
|
|
byte kAmigaCastlePalette[16][3] = {
|
|
{0x00, 0x00, 0x00},
|
|
{0x44, 0x44, 0x44},
|
|
{0x66, 0x66, 0x66},
|
|
{0x88, 0x88, 0x88},
|
|
{0xaa, 0xaa, 0xaa},
|
|
{0xcc, 0xcc, 0xcc},
|
|
{0x00, 0x00, 0x88},
|
|
{0x66, 0xaa, 0x00},
|
|
{0x88, 0xcc, 0x00},
|
|
{0xcc, 0xee, 0x00},
|
|
{0xee, 0xee, 0x66},
|
|
{0x44, 0x88, 0x00},
|
|
{0xee, 0xaa, 0x00},
|
|
{0xcc, 0x44, 0x00},
|
|
{0x88, 0x44, 0x00},
|
|
{0xee, 0xee, 0xee},
|
|
};
|
|
|
|
Graphics::ManagedSurface *CastleEngine::loadFrameFromPlanesVertical(Common::SeekableReadStream *file, int widthInBytes, int height) {
|
|
Graphics::ManagedSurface *surface;
|
|
surface = new Graphics::ManagedSurface();
|
|
surface->create(widthInBytes * 8 / 4, height, Graphics::PixelFormat::createFormatCLUT8());
|
|
surface->fillRect(Common::Rect(0, 0, widthInBytes * 8 / 4, height), 0);
|
|
loadFrameFromPlanesInternalVertical(file, surface, widthInBytes / 4, height, 0);
|
|
loadFrameFromPlanesInternalVertical(file, surface, widthInBytes / 4, height, 1);
|
|
loadFrameFromPlanesInternalVertical(file, surface, widthInBytes / 4, height, 2);
|
|
loadFrameFromPlanesInternalVertical(file, surface, widthInBytes / 4, height, 3);
|
|
return surface;
|
|
}
|
|
|
|
Graphics::ManagedSurface *CastleEngine::loadFrameFromPlanesInternalVertical(Common::SeekableReadStream *file, Graphics::ManagedSurface *surface, int width, int height, int plane) {
|
|
byte *colors = (byte *)malloc(sizeof(byte) * height * width);
|
|
file->read(colors, height * width);
|
|
|
|
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);
|
|
|
|
int bit = ((color >> n) & 0x01) << plane;
|
|
int sample = surface->getPixel(x, y) | bit;
|
|
assert(sample < 16);
|
|
surface->setPixel(x, y, sample);
|
|
}
|
|
}
|
|
free(colors);
|
|
return surface;
|
|
}
|
|
|
|
void CastleEngine::loadAssetsAmigaDemo() {
|
|
Common::File file;
|
|
file.open("x");
|
|
if (!file.isOpen())
|
|
error("Failed to open 'x' file");
|
|
|
|
_viewArea = Common::Rect(40, 29, 280, 154);
|
|
loadMessagesVariableSize(&file, 0x8bb2, 178);
|
|
loadRiddles(&file, 0x96c8 - 2 - 19 * 2, 19);
|
|
|
|
file.seek(0x11eec);
|
|
Common::Array<Graphics::ManagedSurface *> chars;
|
|
for (int i = 0; i < 90; i++) {
|
|
Graphics::ManagedSurface *img = loadFrameFromPlanes(&file, 8, 8);
|
|
//Graphics::ManagedSurface *imgRiddle = new Graphics::ManagedSurface();
|
|
//imgRiddle->copyFrom(*img);
|
|
|
|
chars.push_back(img);
|
|
chars[i]->convertToInPlace(_gfx->_texturePixelFormat, (byte *)kAmigaCastlePalette, 16);
|
|
|
|
//charsRiddle.push_back(imgRiddle);
|
|
//charsRiddle[i]->convertToInPlace(_gfx->_texturePixelFormat, (byte *)&kEGARiddleFontPalette, 16);
|
|
}
|
|
// 0x1356c
|
|
|
|
_font = Font(chars);
|
|
_font.setCharWidth(9);
|
|
|
|
load8bitBinary(&file, 0x162a6, 16);
|
|
for (int i = 0; i < 3; i++) {
|
|
debugC(1, kFreescapeDebugParser, "Continue to parse area index %d at offset %x", _areaMap.size() + i + 1, (int)file.pos());
|
|
Area *newArea = load8bitArea(&file, 16);
|
|
if (newArea) {
|
|
if (!_areaMap.contains(newArea->getAreaID()))
|
|
_areaMap[newArea->getAreaID()] = newArea;
|
|
else
|
|
error("Repeated area ID: %d", newArea->getAreaID());
|
|
} else {
|
|
error("Invalid area %d?", i);
|
|
}
|
|
}
|
|
|
|
loadPalettes(&file, 0x151a6);
|
|
|
|
file.seek(0x2be96); // Area 255
|
|
_areaMap[255] = load8bitArea(&file, 16);
|
|
|
|
file.seek(0x2cf28 + 0x28 - 0x2 + 0x28);
|
|
_border = loadFrameFromPlanesVertical(&file, 160, 200);
|
|
_border->convertToInPlace(_gfx->_texturePixelFormat, (byte *)kAmigaCastlePalette, 16);
|
|
file.close();
|
|
|
|
_areaMap[2]->_groundColor = 1;
|
|
for (auto &it : _areaMap)
|
|
it._value->addStructure(_areaMap[255]);
|
|
}
|
|
|
|
void CastleEngine::drawAmigaAtariSTUI(Graphics::Surface *surface) {
|
|
drawStringInSurface(_currentArea->_name, 97, 182, 0, 0, surface);
|
|
}
|
|
|
|
} // End of namespace Freescape
|