mirror of
https://github.com/libretro/scummvm.git
synced 2025-01-15 06:18:33 +00:00
678 lines
17 KiB
C++
678 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 2
|
|
* 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, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
*/
|
|
#include "allfiles.h"
|
|
#include "sprites.h"
|
|
#include "fonttext.h"
|
|
#include "newfatal.h"
|
|
#include "variable.h"
|
|
#include "CommonCode/version.h"
|
|
#include "language.h"
|
|
#include "moreio.h"
|
|
#include "sludger.h"
|
|
#include "people.h"
|
|
#include "talk.h"
|
|
#include "objtypes.h"
|
|
#include "backdrop.h"
|
|
#include "region.h"
|
|
#include "floor.h"
|
|
#include "zbuffer.h"
|
|
#include "cursors.h"
|
|
#include "statusba.h"
|
|
#include "sound.h"
|
|
#include "fileset.h"
|
|
#include "debug.h"
|
|
#include "loadsave.h"
|
|
|
|
namespace Sludge {
|
|
|
|
//----------------------------------------------------------------------
|
|
// From elsewhere
|
|
//----------------------------------------------------------------------
|
|
|
|
extern loadedFunction *allRunningFunctions; // In sludger.cpp
|
|
extern char *typeName[]; // In variable.cpp
|
|
extern int numGlobals; // In sludger.cpp
|
|
extern variable *globalVars; // In sludger.cpp
|
|
extern flor *currentFloor; // In floor.cpp
|
|
extern zBufferData zBuffer; // In zbuffer.cpp
|
|
extern speechStruct *speech; // In talk.cpp
|
|
extern personaAnimation *mouseCursorAnim; // In cursor.cpp
|
|
extern int mouseCursorFrameNum; // " " "
|
|
extern int loadedFontNum, fontHeight, fontTableSize; // In fonttext.cpp
|
|
extern int numFontColours; // " " "
|
|
extern char *fontOrderString; // " " "
|
|
extern FILETIME fileTime; // In sludger.cpp
|
|
extern int speechMode; // " " "
|
|
extern int lightMapNumber; // In backdrop.cpp
|
|
extern unsigned int sceneWidth, sceneHeight; // " " "
|
|
extern int cameraX, cameraY; // " " "
|
|
extern float cameraZoom;
|
|
extern unsigned char brightnessLevel; // " " "
|
|
extern short fontSpace; // in textfont.cpp
|
|
extern unsigned char fadeMode; // In transition.cpp
|
|
extern bool captureAllKeys;
|
|
extern bool allowAnyFilename;
|
|
extern unsigned short saveEncoding; // in savedata.cpp
|
|
extern unsigned char currentBurnR, currentBurnG, currentBurnB;
|
|
extern unsigned int currentBlankColour; // in backdrop.cpp
|
|
extern parallaxLayer *parallaxStuff; // "
|
|
extern int lightMapMode; // "
|
|
extern int languageNum;
|
|
|
|
//----------------------------------------------------------------------
|
|
// Globals (so we know what's saved already and what's a reference
|
|
//----------------------------------------------------------------------
|
|
|
|
struct stackLibrary {
|
|
stackHandler *stack;
|
|
stackLibrary *next;
|
|
};
|
|
|
|
int stackLibTotal = 0;
|
|
stackLibrary *stackLib = NULL;
|
|
|
|
//----------------------------------------------------------------------
|
|
// For saving and loading stacks...
|
|
//----------------------------------------------------------------------
|
|
void saveStack(variableStack *vs, Common::WriteStream *stream) {
|
|
int elements = 0;
|
|
int a;
|
|
|
|
variableStack *search = vs;
|
|
while (search) {
|
|
elements++;
|
|
search = search->next;
|
|
}
|
|
|
|
stackDebug((stackfp, " stack contains %d elements\n", elements));
|
|
|
|
stream->writeUint16BE(elements);
|
|
search = vs;
|
|
for (a = 0; a < elements; a++) {
|
|
saveVariable(&search->thisVar, stream);
|
|
search = search->next;
|
|
}
|
|
}
|
|
|
|
variableStack *loadStack(Common::SeekableReadStream *stream, variableStack **last) {
|
|
int elements = stream->readUint16BE();
|
|
int a;
|
|
variableStack *first = NULL;
|
|
variableStack * * changeMe = &first;
|
|
|
|
for (a = 0; a < elements; a++) {
|
|
variableStack *nS = new variableStack;
|
|
if (!checkNew(nS))
|
|
return NULL;
|
|
loadVariable(&(nS->thisVar), stream);
|
|
if (last && a == elements - 1) {
|
|
stackDebug((stackfp, "Setting last to %p\n", nS));
|
|
*last = nS;
|
|
}
|
|
nS->next = NULL;
|
|
(*changeMe) = nS;
|
|
changeMe = &(nS->next);
|
|
}
|
|
|
|
return first;
|
|
}
|
|
|
|
bool saveStackRef(stackHandler *vs, Common::WriteStream *stream) {
|
|
stackLibrary *s = stackLib;
|
|
int a = 0;
|
|
while (s) {
|
|
if (s->stack == vs) {
|
|
stream->writeByte(1);
|
|
stream->writeUint16BE(stackLibTotal - a);
|
|
return true;
|
|
}
|
|
s = s->next;
|
|
a++;
|
|
}
|
|
stream->writeByte(0);
|
|
saveStack(vs->first, stream);
|
|
s = new stackLibrary;
|
|
stackLibTotal++;
|
|
if (!checkNew(s))
|
|
return false;
|
|
s->next = stackLib;
|
|
s->stack = vs;
|
|
stackLib = s;
|
|
return true;
|
|
}
|
|
|
|
void clearStackLib() {
|
|
stackLibrary *k;
|
|
while (stackLib) {
|
|
k = stackLib;
|
|
stackLib = stackLib->next;
|
|
delete k;
|
|
}
|
|
stackLibTotal = 0;
|
|
}
|
|
|
|
stackHandler *getStackFromLibrary(int n) {
|
|
n = stackLibTotal - n;
|
|
while (n) {
|
|
stackLib = stackLib->next;
|
|
n--;
|
|
}
|
|
return stackLib->stack;
|
|
}
|
|
|
|
stackHandler *loadStackRef(Common::SeekableReadStream *stream) {
|
|
stackHandler *nsh;
|
|
|
|
if (stream->readByte()) { // It's one we've loaded already...
|
|
stackDebug((stackfp, "loadStackRef (duplicate, get from library)\n"));
|
|
|
|
nsh = getStackFromLibrary(stream->readUint16BE());
|
|
nsh->timesUsed++;
|
|
} else {
|
|
stackDebug((stackfp, "loadStackRef (new one)\n"));
|
|
|
|
// Load the new stack
|
|
|
|
nsh = new stackHandler;
|
|
if (!checkNew(nsh))
|
|
return NULL;
|
|
nsh->last = NULL;
|
|
nsh->first = loadStack(stream, &nsh->last);
|
|
nsh->timesUsed = 1;
|
|
stackDebug((stackfp, " first = %p\n", nsh->first));
|
|
if (nsh->first)
|
|
stackDebug((stackfp, " first->next = %p\n", nsh->first->next));
|
|
stackDebug((stackfp, " last = %p\n", nsh->last));
|
|
if (nsh->last)
|
|
stackDebug((stackfp, " last->next = %p\n", nsh->last->next));
|
|
|
|
// Add it to the library of loaded stacks
|
|
|
|
stackLibrary *s = new stackLibrary;
|
|
if (!checkNew(s))
|
|
return NULL;
|
|
s->stack = nsh;
|
|
s->next = stackLib;
|
|
stackLib = s;
|
|
stackLibTotal++;
|
|
}
|
|
return nsh;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// For saving and loading variables...
|
|
//----------------------------------------------------------------------
|
|
bool saveVariable(variable *from, Common::WriteStream *stream) {
|
|
#if DEBUG_STACKINESS
|
|
{
|
|
char *str = getTextFromAnyVar(*from);
|
|
stackDebug((stackfp, "in saveVariable, type %d, %s\n", from->varType, str));
|
|
delete str;
|
|
}
|
|
#endif
|
|
|
|
stream->writeByte(from->varType);
|
|
switch (from->varType) {
|
|
case SVT_INT:
|
|
case SVT_FUNC:
|
|
case SVT_BUILT:
|
|
case SVT_FILE:
|
|
case SVT_OBJTYPE:
|
|
stream->writeUint32LE(from->varData.intValue);
|
|
return true;
|
|
|
|
case SVT_STRING:
|
|
writeString(from->varData.theString, stream);
|
|
return true;
|
|
|
|
case SVT_STACK:
|
|
return saveStackRef(from->varData.theStack, stream);
|
|
|
|
case SVT_COSTUME:
|
|
saveCostume(from->varData.costumeHandler, stream);
|
|
return false;
|
|
|
|
case SVT_ANIM:
|
|
saveAnim(from->varData.animHandler, stream);
|
|
return false;
|
|
|
|
case SVT_NULL:
|
|
return false;
|
|
|
|
default:
|
|
fatal("Can't save variables of this type:", (from->varType < SVT_NUM_TYPES) ? typeName[from->varType] : "bad ID");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool loadVariable(variable *to, Common::SeekableReadStream *stream) {
|
|
to->varType = (variableType)stream->readByte();
|
|
switch (to->varType) {
|
|
case SVT_INT:
|
|
case SVT_FUNC:
|
|
case SVT_BUILT:
|
|
case SVT_FILE:
|
|
case SVT_OBJTYPE:
|
|
to->varData.intValue = stream->readUint32LE();
|
|
return true;
|
|
|
|
case SVT_STRING:
|
|
to->varData.theString = readString(stream);
|
|
return true;
|
|
|
|
case SVT_STACK:
|
|
to->varData.theStack = loadStackRef(stream);
|
|
#if DEBUG_STACKINESS
|
|
{
|
|
char *str = getTextFromAnyVar(*to);
|
|
stackDebug((stackfp, "just loaded %s\n", str));
|
|
delete str;
|
|
}
|
|
#endif
|
|
return true;
|
|
|
|
case SVT_COSTUME:
|
|
to->varData.costumeHandler = new persona;
|
|
if (!checkNew(to->varData.costumeHandler))
|
|
return false;
|
|
loadCostume(to->varData.costumeHandler, stream);
|
|
return true;
|
|
|
|
case SVT_ANIM:
|
|
to->varData.animHandler = new personaAnimation;
|
|
if (!checkNew(to->varData.animHandler))
|
|
return false;
|
|
loadAnim(to->varData.animHandler, stream);
|
|
return true;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// For saving and loading functions
|
|
//----------------------------------------------------------------------
|
|
void saveFunction(loadedFunction *fun, Common::WriteStream *stream) {
|
|
int a;
|
|
stream->writeUint16BE(fun->originalNumber);
|
|
if (fun->calledBy) {
|
|
stream->writeByte(1);
|
|
saveFunction(fun->calledBy, stream);
|
|
} else {
|
|
stream->writeByte(0);
|
|
}
|
|
stream->writeUint32LE(fun->timeLeft);
|
|
stream->writeUint16BE(fun->runThisLine);
|
|
stream->writeByte(fun->cancelMe);
|
|
stream->writeByte(fun->returnSomething);
|
|
stream->writeByte(fun->isSpeech);
|
|
saveVariable(&(fun->reg), stream);
|
|
|
|
if (fun->freezerLevel) {
|
|
fatal(ERROR_GAME_SAVE_FROZEN);
|
|
}
|
|
saveStack(fun->stack, stream);
|
|
for (a = 0; a < fun->numLocals; a++) {
|
|
saveVariable(&(fun->localVars[a]), stream);
|
|
}
|
|
}
|
|
|
|
loadedFunction *loadFunction(Common::SeekableReadStream *stream) {
|
|
int a;
|
|
|
|
// Reserve memory...
|
|
|
|
loadedFunction *buildFunc = new loadedFunction;
|
|
if (!checkNew(buildFunc))
|
|
return NULL;
|
|
|
|
// See what it was called by and load if we need to...
|
|
|
|
buildFunc->originalNumber = stream->readUint16BE();
|
|
buildFunc->calledBy = NULL;
|
|
if (stream->readByte()) {
|
|
buildFunc->calledBy = loadFunction(stream);
|
|
if (!buildFunc->calledBy)
|
|
return NULL;
|
|
}
|
|
|
|
buildFunc->timeLeft = stream->readUint32LE();
|
|
buildFunc->runThisLine = stream->readUint16BE();
|
|
buildFunc->freezerLevel = 0;
|
|
buildFunc->cancelMe = stream->readByte();
|
|
buildFunc->returnSomething = stream->readByte();
|
|
buildFunc->isSpeech = stream->readByte();
|
|
loadVariable(&(buildFunc->reg), stream);
|
|
loadFunctionCode(buildFunc);
|
|
|
|
buildFunc->stack = loadStack(stream, NULL);
|
|
|
|
for (a = 0; a < buildFunc->numLocals; a++) {
|
|
loadVariable(&(buildFunc->localVars[a]), stream);
|
|
}
|
|
|
|
return buildFunc;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Save everything
|
|
//----------------------------------------------------------------------
|
|
|
|
bool saveGame(char *fname) {
|
|
#if 0
|
|
int a;
|
|
|
|
FILE *fp = fopen(fname, "wb");
|
|
if (fp == NULL) return false;
|
|
|
|
fprintf(fp, "SLUDSA");
|
|
fputc(0, fp);
|
|
fputc(0, fp);
|
|
fputc(MAJOR_VERSION, fp);
|
|
fputc(MINOR_VERSION, fp);
|
|
|
|
if (! saveThumbnail(fp)) return false;
|
|
|
|
fwrite(&fileTime, sizeof(FILETIME), 1, fp);
|
|
|
|
// DON'T ADD ANYTHING NEW BEFORE THIS POINT!
|
|
|
|
fputc(allowAnyFilename, fp);
|
|
fputc(captureAllKeys, fp);
|
|
fputc(true, fp);// updateDisplay
|
|
fputc(fontTableSize > 0, fp);
|
|
|
|
if (fontTableSize > 0) {
|
|
fp->writeUint16BE(loadedFontNum);
|
|
fp->writeUint16BE(fontHeight);
|
|
writeString(fontOrderString, fp);
|
|
}
|
|
putSigned(fontSpace, fp);
|
|
|
|
// Save backdrop
|
|
fp->writeUint16BE(cameraX);
|
|
fp->writeUint16BE(cameraY);
|
|
putFloat(cameraZoom, fp);
|
|
|
|
fputc(brightnessLevel, fp);
|
|
saveHSI(fp);
|
|
|
|
// Save event handlers
|
|
saveHandlers(fp);
|
|
|
|
// Save regions
|
|
saveRegions(fp);
|
|
|
|
saveAnim(mouseCursorAnim, fp);
|
|
fp->writeUint16BE(mouseCursorFrameNum);
|
|
|
|
// Save functions
|
|
loadedFunction *thisFunction = allRunningFunctions;
|
|
int countFunctions = 0;
|
|
while (thisFunction) {
|
|
countFunctions ++;
|
|
thisFunction = thisFunction->next;
|
|
}
|
|
fp->writeUint16BE(countFunctions);
|
|
|
|
thisFunction = allRunningFunctions;
|
|
while (thisFunction) {
|
|
saveFunction(thisFunction, fp);
|
|
thisFunction = thisFunction->next;
|
|
}
|
|
|
|
for (a = 0; a < numGlobals; a++) {
|
|
saveVariable(&globalVars[a], fp);
|
|
}
|
|
|
|
savePeople(fp);
|
|
|
|
if (currentFloor->numPolygons) {
|
|
fputc(1, fp);
|
|
fp->writeUint16BE(currentFloor->originalNum);
|
|
} else fputc(0, fp);
|
|
|
|
if (zBuffer.tex) {
|
|
fputc(1, fp);
|
|
fp->writeUint16BE(zBuffer.originalNum);
|
|
} else fputc(0, fp);
|
|
|
|
if (lightMap.data) {
|
|
fputc(1, fp);
|
|
fp->writeUint16BE(lightMapNumber);
|
|
} else fputc(0, fp);
|
|
|
|
fputc(lightMapMode, fp);
|
|
fputc(speechMode, fp);
|
|
fputc(fadeMode, fp);
|
|
saveSpeech(speech, fp);
|
|
saveStatusBars(fp);
|
|
saveSounds(fp);
|
|
|
|
fp->writeUint16BE(saveEncoding);
|
|
|
|
blur_saveSettings(fp);
|
|
|
|
fp->writeUint16BE(currentBlankColour);
|
|
fputc(currentBurnR, fp);
|
|
fputc(currentBurnG, fp);
|
|
fputc(currentBurnB, fp);
|
|
|
|
saveParallaxRecursive(parallaxStuff, fp);
|
|
fputc(0, fp);
|
|
|
|
fputc(languageNum, fp); // Selected language
|
|
|
|
saveSnapshot(fp);
|
|
|
|
fclose(fp);
|
|
#endif
|
|
clearStackLib();
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Load everything
|
|
//----------------------------------------------------------------------
|
|
|
|
int ssgVersion;
|
|
|
|
bool loadGame(char *fname) {
|
|
#if 0
|
|
FILE *fp;
|
|
FILETIME savedGameTime;
|
|
int a;
|
|
|
|
while (allRunningFunctions) finishFunction(allRunningFunctions);
|
|
|
|
fp = openAndVerify(fname, 'S', 'A', ERROR_GAME_LOAD_NO, ssgVersion);
|
|
if (fp == NULL) return false;
|
|
|
|
if (ssgVersion >= VERSION(1, 4)) {
|
|
if (! skipThumbnail(fp)) return fatal(ERROR_GAME_LOAD_CORRUPT, fname);
|
|
}
|
|
|
|
size_t bytes_read = fread(&savedGameTime, sizeof(FILETIME), 1, fp);
|
|
if (bytes_read != sizeof(FILETIME) && ferror(fp)) {
|
|
debugOut("Reading error in loadGame.\n");
|
|
}
|
|
|
|
if (savedGameTime.dwLowDateTime != fileTime.dwLowDateTime ||
|
|
savedGameTime.dwHighDateTime != fileTime.dwHighDateTime) {
|
|
return fatal(ERROR_GAME_LOAD_WRONG, fname);
|
|
}
|
|
|
|
// DON'T ADD ANYTHING NEW BEFORE THIS POINT!
|
|
|
|
if (ssgVersion >= VERSION(1, 4)) {
|
|
allowAnyFilename = fgetc(fp);
|
|
}
|
|
captureAllKeys = fgetc(fp);
|
|
fgetc(fp); // updateDisplay (part of movie playing)
|
|
|
|
bool fontLoaded = fgetc(fp);
|
|
int fontNum;
|
|
char *charOrder;
|
|
if (fontLoaded) {
|
|
fontNum = fp->readUint16BE();
|
|
fontHeight = fp->readUint16BE();
|
|
|
|
if (ssgVersion < VERSION(2, 2)) {
|
|
int x;
|
|
charOrder = new char[257];
|
|
if (! checkNew(charOrder)) return false;
|
|
|
|
for (int a = 0; a < 256; a++) {
|
|
x = fgetc(fp);
|
|
charOrder[x] = a;
|
|
}
|
|
charOrder[256] = 0;
|
|
} else {
|
|
charOrder = readString(fp);
|
|
}
|
|
}
|
|
loadFont(fontNum, charOrder, fontHeight);
|
|
delete [] charOrder;
|
|
|
|
fontSpace = getSigned(fp);
|
|
|
|
killAllPeople();
|
|
killAllRegions();
|
|
|
|
int camerX = fp->readUint16BE();
|
|
int camerY = fp->readUint16BE();
|
|
float camerZ;
|
|
if (ssgVersion >= VERSION(2, 0)) {
|
|
camerZ = getFloat(fp);
|
|
} else {
|
|
camerZ = 1.0;
|
|
}
|
|
|
|
brightnessLevel = fgetc(fp);
|
|
|
|
loadHSI(fp, 0, 0, true);
|
|
loadHandlers(fp);
|
|
loadRegions(fp);
|
|
|
|
mouseCursorAnim = new personaAnimation;
|
|
if (! checkNew(mouseCursorAnim)) return false;
|
|
if (! loadAnim(mouseCursorAnim, fp)) return false;
|
|
mouseCursorFrameNum = fp->readUint16BE();
|
|
|
|
loadedFunction *rFunc;
|
|
loadedFunction * * buildList = &allRunningFunctions;
|
|
|
|
int countFunctions = fp->readUint16BE();
|
|
while (countFunctions --) {
|
|
rFunc = loadFunction(fp);
|
|
rFunc->next = NULL;
|
|
(* buildList) = rFunc;
|
|
buildList = &(rFunc->next);
|
|
}
|
|
|
|
for (a = 0; a < numGlobals; a++) {
|
|
unlinkVar(globalVars[a]);
|
|
loadVariable(&globalVars[a], fp);
|
|
}
|
|
|
|
loadPeople(fp);
|
|
|
|
if (fgetc(fp)) {
|
|
if (! setFloor(fp->readUint16BE())) return false;
|
|
} else setFloorNull();
|
|
|
|
if (fgetc(fp)) {
|
|
if (! setZBuffer(fp->readUint16BE())) return false;
|
|
}
|
|
|
|
if (fgetc(fp)) {
|
|
if (! loadLightMap(fp->readUint16BE())) return false;
|
|
}
|
|
|
|
if (ssgVersion >= VERSION(1, 4)) {
|
|
lightMapMode = fgetc(fp) % 3;
|
|
}
|
|
|
|
speechMode = fgetc(fp);
|
|
fadeMode = fgetc(fp);
|
|
loadSpeech(speech, fp);
|
|
loadStatusBars(fp);
|
|
loadSounds(fp);
|
|
|
|
saveEncoding = fp->readUint16BE();
|
|
|
|
if (ssgVersion >= VERSION(1, 6)) {
|
|
if (ssgVersion < VERSION(2, 0)) {
|
|
// aaLoad
|
|
fgetc(fp);
|
|
getFloat(fp);
|
|
getFloat(fp);
|
|
}
|
|
|
|
blur_loadSettings(fp);
|
|
}
|
|
|
|
if (ssgVersion >= VERSION(1, 3)) {
|
|
currentBlankColour = fp->readUint16BE();
|
|
currentBurnR = fgetc(fp);
|
|
currentBurnG = fgetc(fp);
|
|
currentBurnB = fgetc(fp);
|
|
|
|
// Read parallax layers
|
|
while (fgetc(fp)) {
|
|
int im = fp->readUint16BE();
|
|
int fx = fp->readUint16BE();
|
|
int fy = fp->readUint16BE();
|
|
|
|
if (! loadParallax(im, fx, fy)) return false;
|
|
}
|
|
|
|
int selectedLanguage = fgetc(fp);
|
|
if (selectedLanguage != languageNum) {
|
|
// Load the saved language!
|
|
languageNum = selectedLanguage;
|
|
setFileIndices(NULL, gameSettings.numLanguages, languageNum);
|
|
}
|
|
}
|
|
|
|
nosnapshot();
|
|
if (ssgVersion >= VERSION(1, 4)) {
|
|
if (fgetc(fp)) {
|
|
if (! restoreSnapshot(fp)) return false;
|
|
}
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
cameraX = camerX;
|
|
cameraY = camerY;
|
|
cameraZoom = camerZ;
|
|
#endif
|
|
|
|
clearStackLib();
|
|
return true;
|
|
}
|
|
|
|
} // End of namespace Sludge
|