185 lines
6.1 KiB
C++
185 lines
6.1 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 "agi/agi.h"
|
|
#include "agi/graphics.h"
|
|
#include "agi/picture.h"
|
|
|
|
#include "agi/preagi/picture_troll.h"
|
|
|
|
namespace Agi {
|
|
|
|
// PictureMgr_Troll decodes and draws Troll's Tale picture resources.
|
|
//
|
|
// Troll's Tale supports lines and flood fills. There is no priority screen.
|
|
//
|
|
// There are two unique picture features:
|
|
//
|
|
// 1. The F3 opcode can dynamically act as a no-op or terminator (FF).
|
|
// This allows pictures to have an optional set of instructions for
|
|
// drawing or hiding a room's object or the king's crown.
|
|
//
|
|
// 2. A custom flood fill technique is used for drawing the Troll over
|
|
// room pictures. Normally, flood fill requires an empty (white) area.
|
|
//
|
|
// One quirk is that the xCorner and yCorner instructions contain a redundant
|
|
// coordinate, even though it is ignored because it is derived from the others.
|
|
//
|
|
// Each room picture depends on the game first drawing a frame within the entire
|
|
// picture area. This is not decorative; the flood fill routines rely on this
|
|
// border because they do not do boundary test, and pictures are drawn for it.
|
|
|
|
PictureMgr_Troll::PictureMgr_Troll(AgiBase *agi, GfxMgr *gfx) :
|
|
PictureMgr(agi, gfx) {
|
|
_stopOnF3 = false;
|
|
_trollMode = false;
|
|
}
|
|
|
|
void PictureMgr_Troll::drawPicture() {
|
|
debugC(kDebugLevelPictures, "Drawing picture");
|
|
|
|
_dataOffset = 0;
|
|
_dataOffsetNibble = false;
|
|
_patCode = 0;
|
|
_patNum = 0;
|
|
_priOn = false;
|
|
_scrOn = false;
|
|
_priColor = 4;
|
|
_scrColor = 15;
|
|
|
|
while (_dataOffset < _dataSize) {
|
|
byte curByte = getNextByte();
|
|
|
|
switch (curByte) {
|
|
case 0xf0: // F0 is in all Troll's Tale pictures, but it is a no-op.
|
|
break; // Confirmed in disassembly of opcode table.
|
|
case 0xf1:
|
|
draw_SetColor();
|
|
_scrOn = true;
|
|
break;
|
|
case 0xf3: // F3 would impersonate opcode F0 (no-op) or FF (terminator)
|
|
if (_stopOnF3)
|
|
return;
|
|
break;
|
|
case 0xf8:
|
|
yCorner(true); // skip extra (redundant) coordinates when parsing
|
|
break;
|
|
case 0xf9:
|
|
xCorner(true); // skip extra (redundant) coordinates when parsing
|
|
break;
|
|
case 0xfa: // FA and FB are both used, but they are the same.
|
|
case 0xfb: // Confirmed in disassembly of opcode table.
|
|
draw_LineAbsolute();
|
|
break;
|
|
case 0xfe:
|
|
draw_Fill();
|
|
break;
|
|
case 0xff: // end of data
|
|
return;
|
|
default:
|
|
warning("Unknown picture opcode %02x at %04x", curByte, _dataOffset - 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flood fills from a series of start positions.
|
|
*
|
|
* Troll's Tale contains two separate flood fill implementations to handle the
|
|
* special case of drawing the Troll. The game sets a global before drawing to
|
|
* to activate Troll mode. We implement this by overriding this method and
|
|
* the check method.
|
|
*/
|
|
void PictureMgr_Troll::draw_Fill() {
|
|
draw_SetColor();
|
|
_scrOn = true;
|
|
|
|
byte x, y;
|
|
if (_scrColor == 15) { // white
|
|
// White flood fills are only allowed when drawing the Troll, otherwise they
|
|
// are completely ignored. Several room pictures contain white flood fills.
|
|
while (getNextCoordinates(x, y)) {
|
|
if (_trollMode) {
|
|
PictureMgr::draw_Fill(x, y);
|
|
}
|
|
}
|
|
} else {
|
|
// When not drawing the Troll, do a regular flood fill.
|
|
// When drawing the Troll, first fill with white, and then fill normally.
|
|
byte fillColor = _scrColor;
|
|
while (getNextCoordinates(x, y)) {
|
|
if (_trollMode) {
|
|
_scrColor = 15; // white
|
|
PictureMgr::draw_Fill(x, y);
|
|
_scrColor = fillColor;
|
|
}
|
|
PictureMgr::draw_Fill(x, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if flood fill is allowed at a position.
|
|
*
|
|
* Troll's Tale contains two separate flood fill implementations to handle the
|
|
* special case of drawing the Troll. The game sets a global before drawing to
|
|
* to activate Troll mode.
|
|
*
|
|
* The Troll is a large picture with flood fills that is drawn over many busy
|
|
* room pictures, and always in the same location. This is a problem because the
|
|
* picture format is only meant to fill white areas. Sierra handled this by
|
|
* reserving a color for the Troll's lines (11, light blue) and implementing a
|
|
* second set of routines that fill white and treat the Troll's color as a
|
|
* boundary, and sometimes white as well. When drawing the Troll, a non-white
|
|
* fill is preceded by a special white fill to clear the area. This does not
|
|
* work well if there are existing white pixels, and rooms do have these.
|
|
* The Troll has incomplete fills in these rooms, but this is original behavior.
|
|
* In some rooms, such as those with white checkered floors, the results are
|
|
* so bad that Sierra added them to the list of rooms the Troll never visits.
|
|
*
|
|
* We implement Troll mode without a second flood fill algorithm; instead we
|
|
* override the check method, and our AGI algorithm in the base class provides
|
|
* the context so we know which of the two color checks to use.
|
|
*/
|
|
bool PictureMgr_Troll::draw_FillCheck(int16 x, int16 y, bool horizontalCheck) {
|
|
if (_trollMode && _scrColor == 15) {
|
|
if (!getGraphicsCoordinates(x, y)) {
|
|
return false;
|
|
}
|
|
|
|
byte screenColor = _gfx->getColor(x, y);
|
|
|
|
// when filling white during troll mode...
|
|
if (horizontalCheck) {
|
|
// horizontal checks only stop on troll line color
|
|
return (screenColor != 11);
|
|
} else {
|
|
// all other checks stop on troll line color or white
|
|
return (screenColor != 11) && (screenColor != 15);
|
|
}
|
|
}
|
|
|
|
return PictureMgr::draw_FillCheck(x, y, horizontalCheck);
|
|
}
|
|
|
|
} // End of namespace Agi
|