libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-02-02 17:03:13 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

SLUDGE: code formatting

Browse Source
This commit is contained in:
yinsimei 2017-05-29 08:02:59 +02:00 committed by Eugene Sandulenko
parent 2dddb900c9
commit ca2ee02496
52 changed files with 2157 additions and 1718 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
engines/sludge/CommonCode/functionlist.h
View File

@ -1,10 +1,10 @@
/*
This is the list of the built in functions
This is the list of the built in functions
true or false states if it's a used function
in the current version of the engine,
but that value currently isn't used anywhere
*/
true or false states if it's a used function
in the current version of the engine,
but that value currently isn't used anywhere
*/
FUNC(true, say)
FUNC(true, skipSpeech)
@ -135,10 +135,10 @@ FUNC(true, captureAllKeys)
FUNC(true, cacheSound)
FUNC(true, setCharacterSpinSpeed)
FUNC(true, transitionMode)
FUNC(false, _rem_movieStart)
FUNC(false, _rem_movieAbort)
FUNC(false, _rem_moviePlaying)
FUNC(false, _rem_updateDisplay)
FUNC(false, _rem_movieStart)
FUNC(false, _rem_movieAbort)
FUNC(false, _rem_moviePlaying)
FUNC(false, _rem_updateDisplay)
FUNC(true, getSoundCache)
FUNC(true, saveCustomData)
FUNC(true, loadCustomData)
@ -160,7 +160,7 @@ FUNC(true, hasFlag)
FUNC(true, snapshotGrab)
FUNC(true, snapshotClear)
FUNC(true, bodgeFilenames)
FUNC(false, _rem_registryGetString)
FUNC(false, _rem_registryGetString)
FUNC(true, quitWithFatalError)
FUNC(true, _rem_setCharacterAA)
FUNC(true, _rem_setMaximumAA)

43
engines/sludge/backdrop.cpp
View File

@ -155,7 +155,7 @@ bool snapshot() {
viewSpeech();// ...and anything being said
drawStatusBar();
// Copy Our ViewPort To The Texture
// Copy Our ViewPort To The Texture
copyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, viewportOffsetX, viewportOffsetY, winWidth, winHeight, snapshotTextureName);
setPixelCoords(false);
@ -320,7 +320,9 @@ void loadBackDrop(int fileNum, int x, int y) {
if (!loadHSI(bigDataFile, x, y, false)) {
char mess[200];
sprintf(mess, "Can't paste overlay image outside scene dimensions\n\nX = %i\nY = %i\nWidth = %i\nHeight = %i", x, y, sceneWidth, sceneHeight);
sprintf(mess,
"Can't paste overlay image outside scene dimensions\n\nX = %i\nY = %i\nWidth = %i\nHeight = %i",
x, y, sceneWidth, sceneHeight);
fatal(mess);
}
@ -1006,11 +1008,14 @@ bool loadParallax(unsigned short v, unsigned short fracX,
extern int viewportOffsetX, viewportOffsetY;
bool loadPng(int &picWidth, int &picHeight, int &realPicWidth, int &realPicHeight, Common::SeekableReadStream *stream, bool reserve) {
debug("Loading back drop png.");
bool loadPng(int &picWidth, int &picHeight, int &realPicWidth,
int &realPicHeight, Common::SeekableReadStream *stream, bool reserve) {
debug(kSludgeDebugGraphics, "Loading back drop png.");
::Image::PNGDecoder png;
if (!png.loadStream(*stream))
if (!png.loadStream(*stream)) {
debug(kSludgeDebugGraphics, "Back drop is not a png");
return false;
}
backdropSurface.copyFrom(*(png.getSurface()));
picWidth = realPicWidth = backdropSurface.w;
picHeight = realPicHeight = backdropSurface.h;
@ -1049,7 +1054,7 @@ bool loadPng(int &picWidth, int &picHeight, int &realPicWidth, int &realPicHeigh
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return false;
}
png_init_io(png_ptr, stream); // Tell libpng which file to read
png_init_io(png_ptr, stream); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8);// 8 bytes already read
png_read_info(png_ptr, info_ptr);
@ -1086,7 +1091,8 @@ bool loadPng(int &picWidth, int &picHeight, int &realPicWidth, int &realPicHeigh
#endif
}
bool loadByteArray(int &picWidth, int &picHeight, int &realPicWidth, int &realPicHeight, Common::SeekableReadStream *stream, bool reserve) {
bool loadByteArray(int &picWidth, int &picHeight, int &realPicWidth,
int &realPicHeight, Common::SeekableReadStream *stream, bool reserve) {
#if 0
int32_t transCol = reserve ? -1 : 63519;
int t1, t2, n;
@ -1128,17 +1134,25 @@ bool loadByteArray(int &picWidth, int &picHeight, int &realPicWidth, int &realPi
#endif
}
bool loadImage(int &picWidth, int &picHeight, int &realPicWidth, int &realPicHeight, Common::SeekableReadStream *stream, int x, int y, bool reserve) {
bool loadImage(int &picWidth, int &picHeight, int &realPicWidth,
int &realPicHeight, Common::SeekableReadStream *stream, int x, int y,
bool reserve) {
debug(kSludgeDebugGraphics, "Loading back drop image.");
if (!loadPng(picWidth, picHeight, realPicWidth, realPicHeight, stream, reserve)) {
if (!loadByteArray(picWidth, picHeight, realPicWidth, realPicHeight, stream, reserve)) {
if (!loadPng(picWidth, picHeight, realPicWidth, realPicHeight, stream,
reserve)) {
if (!loadByteArray(picWidth, picHeight, realPicWidth, realPicHeight,
stream, reserve)) {
return false;
}
}
if (x == IN_THE_CENTRE) x = (sceneWidth - realPicWidth) >> 1;
if (y == IN_THE_CENTRE) y = (sceneHeight - realPicHeight) >> 1;
if (x < 0 || x + realPicWidth > sceneWidth || y < 0 || y + realPicHeight > sceneHeight) return false;
if (x == IN_THE_CENTRE)
x = (sceneWidth - realPicWidth) >> 1;
if (y == IN_THE_CENTRE)
y = (sceneHeight - realPicHeight) >> 1;
if (x < 0 || x + realPicWidth > sceneWidth || y < 0
|| y + realPicHeight > sceneHeight)
return false;
return true;
}
@ -1269,7 +1283,8 @@ bool loadHSI(Common::SeekableReadStream *stream, int x, int y, bool reserve) {
int picWidth, picHeight;
int realPicWidth, realPicHeight;
if (!loadImage(picWidth, picHeight, realPicWidth, realPicHeight, stream, x, y, reserve))
if (!loadImage(picWidth, picHeight, realPicWidth, realPicHeight, stream, x,
y, reserve))
return false;
#if 0
GLuint tmpTex;

3
engines/sludge/backdrop.h
View File

@ -37,7 +37,7 @@
namespace Sludge {
enum {
LIGHTMAPMODE_NONE = -1,
LIGHTMAPMODE_NONE = -1,
LIGHTMAPMODE_HOTSPOT,
LIGHTMAPMODE_PIXEL,
LIGHTMAPMODE_NUM
@ -46,7 +46,6 @@ enum {
extern unsigned int winWidth, winHeight, sceneWidth, sceneHeight;
extern int lightMapMode;
struct parallaxLayer {
#if 0
GLubyte *texture;

2
engines/sludge/builtin.cpp
View File

@ -2529,7 +2529,7 @@ builtReturn callBuiltIn(int whichFunc, int numParams, loadedFunction *fun) {
char buff[100];
sprintf(buff, "Built in function must have %i parameter%s",
paramNum[whichFunc],
(paramNum[whichFunc] == 1) ? "" : "s");
(paramNum[whichFunc] == 1) ? "" : "s");
fatal(copyString(buff));
return BR_ERROR;

9
engines/sludge/builtin.h
View File

@ -25,7 +25,14 @@
namespace Sludge {
enum builtReturn {BR_KEEP_AND_PAUSE, BR_ERROR, BR_CONTINUE, BR_PAUSE, BR_CALLAFUNC, BR_ALREADY_GONE};
enum builtReturn {
BR_KEEP_AND_PAUSE,
BR_ERROR,
BR_CONTINUE,
BR_PAUSE,
BR_CALLAFUNC,
BR_ALREADY_GONE
};
bool failSecurityCheck(char *fn);
builtReturn callBuiltIn(int whichFunc, int numParams, loadedFunction *fun);

3
engines/sludge/colours.h
View File

@ -42,7 +42,8 @@ inline unsigned short makeGrey(unsigned short int r) {
return ((r >> 3) << 11) | ((r >> 2) << 5) | (r >> 3);
}
inline unsigned short makeColour(unsigned short int r, unsigned short int g, unsigned short int b) {
inline unsigned short makeColour(unsigned short int r, unsigned short int g,
unsigned short int b) {
return ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
}

3
engines/sludge/console.cpp
View File

@ -24,7 +24,8 @@
namespace Sludge {
SludgeConsole::SludgeConsole(SludgeEngine *vm) : GUI::Debugger() {
SludgeConsole::SludgeConsole(SludgeEngine *vm) :
GUI::Debugger() {
_vm = vm;
}

4
engines/sludge/console.h
View File

@ -30,11 +30,11 @@ namespace Sludge {
class SludgeEngine;
// Example console class
class SludgeConsole : public GUI::Debugger {
class SludgeConsole: public GUI::Debugger {
public:
SludgeConsole(SludgeEngine *vm);
virtual ~SludgeConsole(void);
private:
SludgeEngine *_vm;
};

61
engines/sludge/csludge.h
View File

@ -25,22 +25,51 @@
namespace Sludge {
enum sludgeCommand {SLU_UNKNOWN,
SLU_RETURN, SLU_BRANCH, SLU_BR_ZERO, SLU_SET_GLOBAL,
SLU_SET_LOCAL, SLU_LOAD_GLOBAL, SLU_LOAD_LOCAL,
SLU_PLUS, SLU_MINUS, SLU_MULT, SLU_DIVIDE,
SLU_AND, SLU_OR, SLU_EQUALS, SLU_NOT_EQ, SLU_MODULUS,
SLU_LOAD_VALUE, SLU_LOAD_BUILT, SLU_LOAD_FUNC, SLU_CALLIT,
SLU_LOAD_STRING, SLU_LOAD_FILE, /*SLU_LOAD_SCENE,*/ SLU_LOAD_OBJTYPE,
SLU_NOT, SLU_LOAD_NULL, SLU_STACK_PUSH, SLU_LESSTHAN, SLU_MORETHAN, SLU_NEGATIVE,
SLU_UNREG, SLU_LESS_EQUAL, SLU_MORE_EQUAL,
SLU_INCREMENT_LOCAL,
SLU_DECREMENT_LOCAL,
SLU_INCREMENT_GLOBAL,
SLU_DECREMENT_GLOBAL, SLU_INDEXSET, SLU_INDEXGET,
SLU_INCREMENT_INDEX, SLU_DECREMENT_INDEX, SLU_QUICK_PUSH,
numSludgeCommands
};
enum sludgeCommand {
SLU_UNKNOWN,
SLU_RETURN,
SLU_BRANCH,
SLU_BR_ZERO,
SLU_SET_GLOBAL,
SLU_SET_LOCAL,
SLU_LOAD_GLOBAL,
SLU_LOAD_LOCAL,
SLU_PLUS,
SLU_MINUS,
SLU_MULT,
SLU_DIVIDE,
SLU_AND,
SLU_OR,
SLU_EQUALS,
SLU_NOT_EQ,
SLU_MODULUS,
SLU_LOAD_VALUE,
SLU_LOAD_BUILT,
SLU_LOAD_FUNC,
SLU_CALLIT,
SLU_LOAD_STRING,
SLU_LOAD_FILE, /*SLU_LOAD_SCENE,*/
SLU_LOAD_OBJTYPE,
SLU_NOT,
SLU_LOAD_NULL,
SLU_STACK_PUSH,
SLU_LESSTHAN,
SLU_MORETHAN,
SLU_NEGATIVE,
SLU_UNREG,
SLU_LESS_EQUAL,
SLU_MORE_EQUAL,
SLU_INCREMENT_LOCAL,
SLU_DECREMENT_LOCAL,
SLU_INCREMENT_GLOBAL,
SLU_DECREMENT_GLOBAL,
SLU_INDEXSET,
SLU_INDEXGET,
SLU_INCREMENT_INDEX,
SLU_DECREMENT_INDEX,
SLU_QUICK_PUSH,
numSludgeCommands
};
} // End of namespace Sludge

11
engines/sludge/cursors.cpp
View File

@ -68,8 +68,8 @@ void displayCursor() {
if (flipMe != 2) {
(flipMe ? flipFontSprite : fontSprite)(input.mouseX, input.mouseY,
mouseCursorAnim -> theSprites -> bank.sprites[spriteNum],
mouseCursorAnim -> theSprites -> bank.myPalette /* ( spritePalette&) NULL*/);
mouseCursorAnim -> theSprites -> bank.sprites[spriteNum],
mouseCursorAnim -> theSprites -> bank.myPalette /* ( spritePalette&) NULL*/);
}
if (++ mouseCursorCountUp >= mouseCursorAnim -> frames[mouseCursorFrameNum].howMany) {
@ -82,9 +82,10 @@ void displayCursor() {
}
void pasteCursor(int x, int y, personaAnimation *c) {
if (c -> numFrames) pasteSpriteToBackDrop(x, y,
c -> theSprites -> bank.sprites[c -> frames[0].frameNum],
c -> theSprites -> bank.myPalette);
if (c->numFrames)
pasteSpriteToBackDrop(x, y,
c->theSprites->bank.sprites[c->frames[0].frameNum],
c->theSprites->bank.myPalette);
}
} // End of namespace Sludge

33
engines/sludge/fileset.cpp
View File

@ -42,8 +42,8 @@ bool sliceBusy = true;
Common::File *bigDataFile = NULL;
uint32_t startOfDataIndex, startOfTextIndex,
startOfSubIndex, startOfObjectIndex;
uint32_t startOfDataIndex, startOfTextIndex, startOfSubIndex,
startOfObjectIndex;
bool openSubSlice(int num) {
// FILE * dbug = fopen ("debuggy.txt", "at");
@ -100,7 +100,6 @@ unsigned int openFileFromNum(int num) {
return get4bytes(bigDataFile);
}
// Converts a string from Windows CP-1252 to UTF-8.
// This is needed for old games.
char *convertString(char *s) {
@ -124,10 +123,10 @@ char *convertString(char *s) {
if (convert == (iconv_t) - 1) {
switch (errno) {
case EINVAL:
case EINVAL:
fprintf(stderr, "Error: Encoding not supported by iconv.\n");
break;
default:
default:
fprintf(stderr, "Error: Could not open iconv conversion descriptor.\n");
}
}
@ -136,35 +135,34 @@ char *convertString(char *s) {
size_t len2 = 65535;
size_t iconv_value =
#ifdef _WIN32
iconv(convert, (const char **) tmp1, &len1, tmp2, &len2);
iconv(convert, (const char **) tmp1, &len1, tmp2, &len2);
#else
iconv(convert, (char **) tmp1, &len1, tmp2, &len2);
iconv(convert, (char **) tmp1, &len1, tmp2, &len2);
#endif
if (iconv_value == (size_t) - 1) {
switch (errno) {
/* See "man 3 iconv" for an explanation. */
case EILSEQ:
/* See "man 3 iconv" for an explanation. */
case EILSEQ:
fprintf(stderr, "Invalid multibyte sequence.\n");
break;
case EINVAL:
case EINVAL:
fprintf(stderr, "Incomplete multibyte sequence.\n");
break;
case E2BIG:
case E2BIG:
fprintf(stderr, "No more room.\n");
break;
default:
default:
fprintf(stderr, "Error: %s.\n", strerror(errno));
}
fatal("Conversion to Unicode failed. This can be fixed by recompiling the game in a current version of the SLUDGE Development Kit, but this error should never happen. Congratulations, you've found a bug in the SLUDGE engine! Please let us know about it.");
}
iconv_close(convert);
delete [] sOrig;
return copyString(buf = bufOrig);
#endif
return s;//TODO: false value
return s; //TODO: false value
}
char *getNumberedString(int value) {
@ -199,7 +197,8 @@ void finishAccess() {
int32_t startIndex;
void setFileIndices(Common::File *fp, int numLanguages, unsigned int skipBefore) {
void setFileIndices(Common::File *fp, int numLanguages,
unsigned int skipBefore) {
if (fp) {
// Keep hold of the file handle, and let things get at it
bigDataFile = fp;
@ -220,7 +219,7 @@ void setFileIndices(Common::File *fp, int numLanguages, unsigned int skipBefore)
int skipAfter = numLanguages - skipBefore;
while (skipBefore) {
fp->seek(get4bytes(fp), SEEK_SET);
skipBefore --;
skipBefore--;
}
startOfTextIndex = fp->pos() + 4;
@ -228,7 +227,7 @@ void setFileIndices(Common::File *fp, int numLanguages, unsigned int skipBefore)
while (skipAfter) {
fp->seek(get4bytes(fp), SEEK_SET);
skipAfter --;
skipAfter--;
}
startOfSubIndex = fp->pos() + 4;

195
engines/sludge/floor.cpp
View File

@ -35,17 +35,15 @@ bool pointInFloorPolygon(floorPolygon &floorPoly, int x, int y) {
float xp_i, yp_i;
float xp_j, yp_j;
for (j = floorPoly.numVertices - 1; i < floorPoly.numVertices;
j = i ++) {
for (j = floorPoly.numVertices - 1; i < floorPoly.numVertices; j = i++) {
xp_i = currentFloor -> vertex[floorPoly.vertexID[i]].x;
yp_i = currentFloor -> vertex[floorPoly.vertexID[i]].y;
xp_j = currentFloor -> vertex[floorPoly.vertexID[j]].x;
yp_j = currentFloor -> vertex[floorPoly.vertexID[j]].y;
xp_i = currentFloor->vertex[floorPoly.vertexID[i]].x;
yp_i = currentFloor->vertex[floorPoly.vertexID[i]].y;
xp_j = currentFloor->vertex[floorPoly.vertexID[j]].x;
yp_j = currentFloor->vertex[floorPoly.vertexID[j]].y;
if ((((yp_i <= y) && (y < yp_j)) ||
((yp_j <= y) && (y < yp_i))) &&
(x < (xp_j - xp_i) * (y - yp_i) / (yp_j - yp_i) + xp_i)) {
if ((((yp_i <= y) && (y < yp_j)) || ((yp_j <= y) && (y < yp_i)))
&& (x < (xp_j - xp_i) * (y - yp_i) / (yp_j - yp_i) + xp_i)) {
c = !c;
}
@ -53,14 +51,15 @@ bool pointInFloorPolygon(floorPolygon &floorPoly, int x, int y) {
return c;
}
bool getMatchingCorners(floorPolygon &a, floorPolygon &b, int &cornerA, int &cornerB) {
bool getMatchingCorners(floorPolygon &a, floorPolygon &b, int &cornerA,
int &cornerB) {
int sharedVertices = 0;
int i, j;
for (i = 0; i < a.numVertices; i ++) {
for (j = 0; j < b.numVertices; j ++) {
for (i = 0; i < a.numVertices; i++) {
for (j = 0; j < b.numVertices; j++) {
if (a.vertexID[i] == b.vertexID[j]) {
if (sharedVertices ++) {
if (sharedVertices++) {
cornerB = a.vertexID[i];
return true;
} else {
@ -77,10 +76,11 @@ bool polysShareSide(floorPolygon &a, floorPolygon &b) {
int sharedVertices = 0;
int i, j;
for (i = 0; i < a.numVertices; i ++) {
for (j = 0; j < b.numVertices; j ++) {
for (i = 0; i < a.numVertices; i++) {
for (j = 0; j < b.numVertices; j++) {
if (a.vertexID[i] == b.vertexID[j]) {
if (sharedVertices ++) return true;
if (sharedVertices++)
return true;
}
}
}
@ -89,30 +89,31 @@ bool polysShareSide(floorPolygon &a, floorPolygon &b) {
}
void noFloor() {
currentFloor -> numPolygons = 0;
currentFloor -> polygon = NULL;
currentFloor -> vertex = NULL;
currentFloor -> matrix = NULL;
currentFloor->numPolygons = 0;
currentFloor->polygon = NULL;
currentFloor->vertex = NULL;
currentFloor->matrix = NULL;
}
bool initFloor() {
currentFloor = new flor;
if (! checkNew(currentFloor)) return false;
if (!checkNew(currentFloor))
return false;
noFloor();
return true;
}
void killFloor() {
for (int i = 0; i < currentFloor -> numPolygons; i ++) {
delete currentFloor -> polygon[i].vertexID;
delete currentFloor -> matrix[i];
for (int i = 0; i < currentFloor->numPolygons; i++) {
delete currentFloor->polygon[i].vertexID;
delete currentFloor->matrix[i];
}
delete currentFloor -> polygon;
currentFloor -> polygon = NULL;
delete currentFloor -> vertex;
currentFloor -> vertex = NULL;
delete currentFloor -> matrix;
currentFloor -> matrix = NULL;
delete currentFloor->polygon;
currentFloor->polygon = NULL;
delete currentFloor->vertex;
currentFloor->vertex = NULL;
delete currentFloor->matrix;
currentFloor->matrix = NULL;
}
void setFloorNull() {
@ -128,73 +129,81 @@ bool setFloor(int fileNum) {
setResourceForFatal(fileNum);
if (! openFileFromNum(fileNum)) return false;
if (!openFileFromNum(fileNum))
return false;
// Find out how many polygons there are and reserve memory
currentFloor -> originalNum = fileNum;
currentFloor -> numPolygons = getch(bigDataFile);
currentFloor -> polygon = new floorPolygon[currentFloor -> numPolygons];
if (! checkNew(currentFloor -> polygon)) return false;
currentFloor->originalNum = fileNum;
currentFloor->numPolygons = getch(bigDataFile);
currentFloor->polygon = new floorPolygon[currentFloor->numPolygons];
if (!checkNew(currentFloor->polygon))
return false;
// Read in each polygon
for (i = 0; i < currentFloor -> numPolygons; i ++) {
for (i = 0; i < currentFloor->numPolygons; i++) {
// Find out how many vertex IDs there are and reserve memory
currentFloor -> polygon[i].numVertices = getch(bigDataFile);
currentFloor -> polygon[i].vertexID = new int[currentFloor -> polygon[i].numVertices];
if (! checkNew(currentFloor -> polygon[i].vertexID)) return false;
currentFloor->polygon[i].numVertices = getch(bigDataFile);
currentFloor->polygon[i].vertexID =
new int[currentFloor->polygon[i].numVertices];
if (!checkNew(currentFloor->polygon[i].vertexID))
return false;
// Read in each vertex ID
for (j = 0; j < currentFloor -> polygon[i].numVertices; j ++) {
currentFloor -> polygon[i].vertexID[j] = get2bytes(bigDataFile);
for (j = 0; j < currentFloor->polygon[i].numVertices; j++) {
currentFloor->polygon[i].vertexID[j] = get2bytes(bigDataFile);
}
}
// Find out how many vertices there are and reserve memory
i = get2bytes(bigDataFile);
currentFloor -> vertex = new POINT[i];
if (! checkNew(currentFloor -> vertex)) return false;
currentFloor->vertex = new POINT[i];
if (!checkNew(currentFloor->vertex))
return false;
for (j = 0; j < i; j ++) {
for (j = 0; j < i; j++) {
currentFloor -> vertex[j].x = get2bytes(bigDataFile);
currentFloor -> vertex[j].y = get2bytes(bigDataFile);
currentFloor->vertex[j].x = get2bytes(bigDataFile);
currentFloor->vertex[j].y = get2bytes(bigDataFile);
}
finishAccess();
// Now build the movement martix
currentFloor -> matrix = new int *[currentFloor -> numPolygons];
int * * distanceMatrix = new int *[currentFloor -> numPolygons];
currentFloor->matrix = new int *[currentFloor->numPolygons];
int * * distanceMatrix = new int *[currentFloor->numPolygons];
if (! checkNew(currentFloor -> matrix)) return false;
if (!checkNew(currentFloor->matrix))
return false;
for (i = 0; i < currentFloor -> numPolygons; i ++) {
currentFloor -> matrix[i] = new int [currentFloor -> numPolygons];
distanceMatrix [i] = new int [currentFloor -> numPolygons];
if (! checkNew(currentFloor -> matrix[i])) return false;
for (j = 0; j < currentFloor -> numPolygons; j ++) {
currentFloor -> matrix[i][j] = -1;
distanceMatrix [i][j] = 10000;
for (i = 0; i < currentFloor->numPolygons; i++) {
currentFloor->matrix[i] = new int[currentFloor->numPolygons];
distanceMatrix[i] = new int[currentFloor->numPolygons];
if (!checkNew(currentFloor->matrix[i]))
return false;
for (j = 0; j < currentFloor->numPolygons; j++) {
currentFloor->matrix[i][j] = -1;
distanceMatrix[i][j] = 10000;
}
}
for (i = 0; i < currentFloor -> numPolygons; i ++) {
for (j = 0; j < currentFloor -> numPolygons; j ++) {
for (i = 0; i < currentFloor->numPolygons; i++) {
for (j = 0; j < currentFloor->numPolygons; j++) {
if (i != j) {
if (polysShareSide(currentFloor -> polygon[i], currentFloor -> polygon[j])) {
currentFloor -> matrix[i][j] = j;
distanceMatrix [i][j] = 1;
if (polysShareSide(currentFloor->polygon[i],
currentFloor->polygon[j])) {
currentFloor->matrix[i][j] = j;
distanceMatrix[i][j] = 1;
}
} else {
currentFloor -> matrix[i][j] = -2;
distanceMatrix [i][j] = 0;
currentFloor->matrix[i][j] = -2;
distanceMatrix[i][j] = 0;
}
}
}
@ -203,22 +212,23 @@ bool setFloor(int fileNum) {
int lookForDistance = 0;
do {
lookForDistance ++;
lookForDistance++;
// debugMatrix ();
madeChange = false;
for (i = 0; i < currentFloor -> numPolygons; i ++) {
for (j = 0; j < currentFloor -> numPolygons; j ++) {
if (currentFloor -> matrix[i][j] == -1) {
for (i = 0; i < currentFloor->numPolygons; i++) {
for (j = 0; j < currentFloor->numPolygons; j++) {
if (currentFloor->matrix[i][j] == -1) {
// OK, so we don't know how to get from i to j...
for (int d = 0; d < currentFloor -> numPolygons; d ++) {
for (int d = 0; d < currentFloor->numPolygons; d++) {
if (d != i && d != j) {
if (currentFloor -> matrix[i][d] == d &&
currentFloor -> matrix[d][j] >= 0 &&
distanceMatrix [d][j] <= lookForDistance) {
if (currentFloor->matrix[i][d] == d
&& currentFloor->matrix[d][j] >= 0
&& distanceMatrix[d][j]
<= lookForDistance) {
currentFloor -> matrix[i][j] = d;
distanceMatrix [i][j] = lookForDistance + 1;
currentFloor->matrix[i][j] = d;
distanceMatrix[i][j] = lookForDistance + 1;
madeChange = true;
}
}
@ -228,8 +238,8 @@ bool setFloor(int fileNum) {
}
} while (madeChange);
for (i = 0; i < currentFloor -> numPolygons; i ++) {
delete distanceMatrix [i];
for (i = 0; i < currentFloor->numPolygons; i++) {
delete distanceMatrix[i];
}
delete distanceMatrix;
@ -242,20 +252,26 @@ bool setFloor(int fileNum) {
void drawFloor() {
int i, j, nV;
for (i = 0; i < currentFloor -> numPolygons; i ++) {
for (i = 0; i < currentFloor->numPolygons; i++) {
// drawLine (i, 0, i + 5, 100);
nV = currentFloor -> polygon[i].numVertices;
nV = currentFloor->polygon[i].numVertices;
if (nV > 1) {
for (j = 1; j < nV; j ++) {
drawLine(currentFloor -> vertex[currentFloor -> polygon[i].vertexID[j - 1]].x,
currentFloor -> vertex[currentFloor -> polygon[i].vertexID[j - 1]].y,
currentFloor -> vertex[currentFloor -> polygon[i].vertexID[j]].x,
currentFloor -> vertex[currentFloor -> polygon[i].vertexID[j]].y);
for (j = 1; j < nV; j++) {
drawLine(
currentFloor->vertex[currentFloor->polygon[i].vertexID[j
- 1]].x,
currentFloor->vertex[currentFloor->polygon[i].vertexID[j
- 1]].y,
currentFloor->vertex[currentFloor->polygon[i].vertexID[j]].x,
currentFloor->vertex[currentFloor->polygon[i].vertexID[j]].y);
}
drawLine(currentFloor -> vertex[currentFloor -> polygon[i].vertexID[0]].x,
currentFloor -> vertex[currentFloor -> polygon[i].vertexID[0]].y,
currentFloor -> vertex[currentFloor -> polygon[i].vertexID[nV - 1]].x,
currentFloor -> vertex[currentFloor -> polygon[i].vertexID[nV - 1]].y);
drawLine(
currentFloor->vertex[currentFloor->polygon[i].vertexID[0]].x,
currentFloor->vertex[currentFloor->polygon[i].vertexID[0]].y,
currentFloor->vertex[currentFloor->polygon[i].vertexID[nV
- 1]].x,
currentFloor->vertex[currentFloor->polygon[i].vertexID[nV
- 1]].y);
}
}
}
@ -263,14 +279,15 @@ void drawFloor() {
int inFloor(int x, int y) {
int i, r = -1;
for (i = 0; i < currentFloor -> numPolygons; i ++)
if (pointInFloorPolygon(currentFloor -> polygon[i], x, y))
for (i = 0; i < currentFloor->numPolygons; i++)
if (pointInFloorPolygon(currentFloor->polygon[i], x, y))
r = i;
return r;
}
bool closestPointOnLine(int &closestX, int &closestY, int x1, int y1, int x2, int y2, int xP, int yP) {
bool closestPointOnLine(int &closestX, int &closestY, int x1, int y1, int x2,
int y2, int xP, int yP) {
int xDiff = x2 - x1;
int yDiff = y2 - y1;

3
engines/sludge/floor.h
View File

@ -54,7 +54,8 @@ bool setFloor(int fileNum);
void drawFloor();
int inFloor(int x, int y);
bool getMatchingCorners(floorPolygon &, floorPolygon &, int &, int &);
bool closestPointOnLine(int &closestX, int &closestY, int x1, int y1, int x2, int y2, int xP, int yP);
bool closestPointOnLine(int &closestX, int &closestY, int x1, int y1, int x2,
int y2, int xP, int yP);
} // End of namespace Sludge

64
engines/sludge/fonttext.cpp
View File

@ -51,11 +51,14 @@ unsigned int fontTableSize = 0;
extern float cameraZoom;
bool isInFont(char *theText) {
if (! fontTableSize) return 0;
if (! theText[0]) return 0;
if (!fontTableSize)
return 0;
if (!theText[0])
return 0;
// We don't want to compare strings. Only single characters allowed!
if (u8_strlen(theText) > 1) return false;
if (u8_strlen(theText) > 1)
return false;
int i = 0;
uint32_t c = u8_nextchar(theText, &i);
@ -72,7 +75,8 @@ int stringWidth(char *theText) {
uint32_t c;
int xOff = 0;
if (! fontTableSize) return 0;
if (!fontTableSize)
return 0;
while (theText[a]) {
c = u8_nextchar(theText, &a);
@ -87,46 +91,51 @@ void pasteString(char *theText, int xOff, int y, spritePalette &thePal) {
int a = 0;
uint32_t c;
if (! fontTableSize) return;
if (!fontTableSize)
return;
xOff += (int)((float)(fontSpace >> 1) / cameraZoom);
xOff += (int) ((float) (fontSpace >> 1) / cameraZoom);
while (theText[a]) {
c = u8_nextchar(theText, &a);
mySprite = & theFont.sprites[fontInTable(c)];
fontSprite(xOff, y, * mySprite, thePal);
xOff += (int)((double)(mySprite -> width + fontSpace) / cameraZoom);
mySprite = &theFont.sprites[fontInTable(c)];
fontSprite(xOff, y, *mySprite, thePal);
xOff += (int) ((double) (mySprite->width + fontSpace) / cameraZoom);
}
}
void pasteStringToBackdrop(char *theText, int xOff, int y, spritePalette &thePal) {
void pasteStringToBackdrop(char *theText, int xOff, int y,
spritePalette &thePal) {
sprite *mySprite;
int a = 0;
uint32_t c;
if (! fontTableSize) return;
if (!fontTableSize)
return;
xOff += fontSpace >> 1;
while (theText[a]) {
c = u8_nextchar(theText, &a);
mySprite = & theFont.sprites[fontInTable(c)];
pasteSpriteToBackDrop(xOff, y, * mySprite, thePal);
xOff += mySprite -> width + fontSpace;
mySprite = &theFont.sprites[fontInTable(c)];
pasteSpriteToBackDrop(xOff, y, *mySprite, thePal);
xOff += mySprite->width + fontSpace;
}
}
void burnStringToBackdrop(char *theText, int xOff, int y, spritePalette &thePal) {
void burnStringToBackdrop(char *theText, int xOff, int y,
spritePalette &thePal) {
sprite *mySprite;
int a = 0;
uint32_t c;
if (! fontTableSize) return;
if (!fontTableSize)
return;
xOff += fontSpace >> 1;
while (theText[a]) {
c = u8_nextchar(theText, &a);
mySprite = & theFont.sprites[fontInTable(c)];
burnSpriteToBackDrop(xOff, y, * mySprite, thePal);
xOff += mySprite -> width + fontSpace;
mySprite = &theFont.sprites[fontInTable(c)];
burnSpriteToBackDrop(xOff, y, *mySprite, thePal);
xOff += mySprite->width + fontSpace;
}
}
@ -167,26 +176,27 @@ bool loadFont(int filenum, const char *charOrder, int h) {
int a = 0;
uint32_t c;
delete [] fontOrderString;
delete[] fontOrderString;
fontOrderString = copyString(charOrder);
forgetSpriteBank(theFont);
loadedFontNum = filenum;
fontTableSize = 0;
while (charOrder[a]) {
c = u8_nextchar(charOrder, &a);
if (c > fontTableSize) fontTableSize = c;
if (c > fontTableSize)
fontTableSize = c;
}
fontTableSize++;
delete [] fontTable;
fontTable = new uint32_t [fontTableSize];
if (! checkNew(fontTable)) return false;
delete[] fontTable;
fontTable = new uint32_t[fontTableSize];
if (!checkNew(fontTable))
return false;
for (a = 0; a < fontTableSize; a ++) {
for (a = 0; a < fontTableSize; a++) {
fontTable[a] = 0;
}
a = 0;
@ -197,7 +207,7 @@ bool loadFont(int filenum, const char *charOrder, int h) {
i++;
}
if (! loadSpriteBank(filenum, theFont, true)) {
if (!loadSpriteBank(filenum, theFont, true)) {
fatal("Can't load font");
return false;
}

101
engines/sludge/freeze.cpp
View File

@ -72,7 +72,7 @@ void freezeGraphics() {
#endif
int w = winWidth;
int h = winHeight;
if (! NPOT_textures) {
if (!NPOT_textures) {
w = getNextPOT(winWidth);
h = getNextPOT(winHeight);
}
@ -89,7 +89,6 @@ void freezeGraphics() {
int antiAlias = gameSettings.antiAlias;
gameSettings.antiAlias = 0;
int x = 0;
while (x < winWidth) {
int y = 0;
@ -109,10 +108,10 @@ void freezeGraphics() {
}
#if 0
const GLfloat bPMVMatrix[] = {
2.0f / realWinWidth * cameraZoom, .0, .0, .0,
.0, 2.0f / realWinHeight * cameraZoom, .0, .0,
.0, .0, 1.0f, .0,
-2.0f * (x / realWinWidth) - 1.0f, -2.0f * (y / realWinHeight) - 1.0f, .0, 1.0f
2.0f / realWinWidth * cameraZoom, .0, .0, .0,
.0, 2.0f / realWinHeight * cameraZoom, .0, .0,
.0, .0, 1.0f, .0,
-2.0f * (x / realWinWidth) - 1.0f, -2.0f * (y / realWinHeight) - 1.0f, .0, 1.0f
};
for (int i = 0; i < 16; i++) {
@ -120,19 +119,18 @@ void freezeGraphics() {
}
// Render scene
glDepthMask(GL_TRUE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);// Clear The Screen
glDepthMask(GL_FALSE);
drawBackDrop(); // Draw the room
drawBackDrop();// Draw the room
drawZBuffer(cameraX, cameraY, false);
glEnable(GL_DEPTH_TEST);
drawPeople(); // Then add any moving characters...
drawPeople();// Then add any moving characters...
glDisable(GL_DEPTH_TEST);
// Copy Our ViewPort To The Texture
copyTexSubImage2D(GL_TEXTURE_2D, 0, x, y, 0, 0, w, h, freezeTextureName);
#endif
@ -152,7 +150,8 @@ void freezeGraphics() {
bool freeze() {
debugOut("calling freeze()\n");
frozenStuffStruct *newFreezer = new frozenStuffStruct;
if (! checkNew(newFreezer)) return false;
if (!checkNew(newFreezer))
return false;
// Grab a copy of the current scene
freezeGraphics();
@ -161,7 +160,7 @@ bool freeze() {
#endif
int picWidth = sceneWidth;
int picHeight = sceneHeight;
if (! NPOT_textures) {
if (!NPOT_textures) {
picWidth = getNextPOT(picWidth);
picHeight = getNextPOT(picHeight);
}
@ -173,11 +172,11 @@ bool freeze() {
backdropTextureName = 0;
#endif
newFreezer -> sceneWidth = sceneWidth;
newFreezer -> sceneHeight = sceneHeight;
newFreezer -> cameraX = cameraX;
newFreezer -> cameraY = cameraY;
newFreezer -> cameraZoom = cameraZoom;
newFreezer->sceneWidth = sceneWidth;
newFreezer->sceneHeight = sceneHeight;
newFreezer->cameraX = cameraX;
newFreezer->cameraY = cameraY;
newFreezer->cameraZoom = cameraZoom;
#if 0
newFreezer -> lightMapTexture = lightMap.data;
newFreezer -> lightMapTextureName = lightMap.name;
@ -192,9 +191,10 @@ bool freeze() {
zBuffer.tex = NULL;
#endif
// resizeBackdrop kills parallax stuff, light map, z-buffer...
if (! resizeBackdrop(winWidth, winHeight)) return fatal("Can't create new temporary backdrop buffer");
if (!resizeBackdrop(winWidth, winHeight))
return fatal("Can't create new temporary backdrop buffer");
if (! NPOT_textures) {
if (!NPOT_textures) {
picWidth = getNextPOT(sceneWidth);
picHeight = getNextPOT(sceneHeight);
#if 0
@ -225,31 +225,33 @@ bool freeze() {
deleteTextures(1, &newFreezer -> backdropTextureName);
}
#endif
newFreezer -> allPeople = allPeople;
newFreezer->allPeople = allPeople;
allPeople = NULL;
statusStuff *newStatusStuff = new statusStuff;
if (! checkNew(newStatusStuff)) return false;
newFreezer -> frozenStatus = copyStatusBarStuff(newStatusStuff);
if (!checkNew(newStatusStuff))
return false;
newFreezer->frozenStatus = copyStatusBarStuff(newStatusStuff);
newFreezer -> allScreenRegions = allScreenRegions;
newFreezer->allScreenRegions = allScreenRegions;
allScreenRegions = NULL;
overRegion = NULL;
newFreezer -> mouseCursorAnim = mouseCursorAnim;
newFreezer -> mouseCursorFrameNum = mouseCursorFrameNum;
newFreezer->mouseCursorAnim = mouseCursorAnim;
newFreezer->mouseCursorFrameNum = mouseCursorFrameNum;
mouseCursorAnim = makeNullAnim();
mouseCursorFrameNum = 0;
newFreezer -> speech = speech;
newFreezer->speech = speech;
initSpeech();
newFreezer -> currentEvents = currentEvents;
newFreezer->currentEvents = currentEvents;
currentEvents = new eventHandlers;
if (! checkNew(currentEvents)) return false;
if (!checkNew(currentEvents))
return false;
memset(currentEvents, 0, sizeof(eventHandlers));
newFreezer -> next = frozenStuff;
newFreezer->next = frozenStuff;
frozenStuff = newFreezer;
return true;
@ -259,8 +261,8 @@ int howFrozen() {
int a = 0;
frozenStuffStruct *f = frozenStuff;
while (f) {
a ++;
f = f -> next;
a++;
f = f->next;
}
return a;
}
@ -272,25 +274,26 @@ extern GLubyte *backdropTexture;
void unfreeze(bool killImage) {
frozenStuffStruct *killMe = frozenStuff;
if (! frozenStuff) return;
if (!frozenStuff)
return;
sceneWidth = frozenStuff -> sceneWidth;
sceneHeight = frozenStuff -> sceneHeight;
sceneWidth = frozenStuff->sceneWidth;
sceneHeight = frozenStuff->sceneHeight;
cameraX = frozenStuff -> cameraX;
cameraY = frozenStuff -> cameraY;
input.mouseX = (int)(input.mouseX * cameraZoom);
input.mouseY = (int)(input.mouseY * cameraZoom);
cameraZoom = frozenStuff -> cameraZoom;
input.mouseX = (int)(input.mouseX / cameraZoom);
input.mouseY = (int)(input.mouseY / cameraZoom);
cameraX = frozenStuff->cameraX;
cameraY = frozenStuff->cameraY;
input.mouseX = (int) (input.mouseX * cameraZoom);
input.mouseY = (int) (input.mouseY * cameraZoom);
cameraZoom = frozenStuff->cameraZoom;
input.mouseX = (int) (input.mouseX / cameraZoom);
input.mouseY = (int) (input.mouseY / cameraZoom);
setPixelCoords(false);
killAllPeople();
allPeople = frozenStuff -> allPeople;
allPeople = frozenStuff->allPeople;
killAllRegions();
allScreenRegions = frozenStuff -> allScreenRegions;
allScreenRegions = frozenStuff->allScreenRegions;
killLightMap();
#if 0
@ -346,18 +349,18 @@ void unfreeze(bool killImage) {
}
#endif
deleteAnim(mouseCursorAnim);
mouseCursorAnim = frozenStuff -> mouseCursorAnim;
mouseCursorFrameNum = frozenStuff -> mouseCursorFrameNum;
mouseCursorAnim = frozenStuff->mouseCursorAnim;
mouseCursorFrameNum = frozenStuff->mouseCursorFrameNum;
restoreBarStuff(frozenStuff -> frozenStatus);
restoreBarStuff(frozenStuff->frozenStatus);
delete currentEvents;
currentEvents = frozenStuff -> currentEvents;
currentEvents = frozenStuff->currentEvents;
killAllSpeech();
delete speech;
speech = frozenStuff -> speech;
frozenStuff = frozenStuff -> next;
speech = frozenStuff->speech;
frozenStuff = frozenStuff->next;
overRegion = NULL;
delete killMe;

1
engines/sludge/freeze.h
View File

@ -48,7 +48,6 @@ struct frozenStuffStruct {
frozenStuffStruct *next;
};
bool freeze();
void unfreeze(bool killImage = true);
int howFrozen();

72
engines/sludge/graphics.cpp
View File

@ -94,13 +94,13 @@ struct textureList *firstTexture = NULL;
textureList *addTexture() {
textureList *newTexture = new textureList;
newTexture -> next = firstTexture;
newTexture->next = firstTexture;
firstTexture = newTexture;
return newTexture;
}
#if 0
void deleteTextures(GLsizei n, const GLuint *textures) {
void deleteTextures(GLsizei n, const GLuint *textures) {
if (firstTexture == NULL) {
//debugOut("Deleting texture while list is already empty.\n");
} else {
@ -133,10 +133,10 @@ void deleteTextures(GLsizei n, const GLuint *textures) {
}
void getTextureDimensions(GLuint name, GLint *width, GLint *height) {
void getTextureDimensions(GLuint name, GLint *width, GLint *height) {
textureList *list = firstTexture;
while (list) {
if (list->name == name) {
if (list->name == name) {
*width = list->width;
*height = list->height;
#if !defined(HAVE_GLES2)
@ -156,7 +156,7 @@ void getTextureDimensions(GLuint name, GLint *width, GLint *height) {
fatal("Texture not found in list.\n");
}
void storeTextureDimensions(GLuint name, GLsizei width, GLsizei height, const char *file, int line) {
void storeTextureDimensions(GLuint name, GLsizei width, GLsizei height, const char *file, int line) {
if (! NPOT_textures && !(((height & (height - 1)) == 0) || ((width & (width - 1)) == 0))) {
debugOut("I was told to create a texture with dimensions %ix%i in %s @ line %d although NPOT textures are disabled.\n", width, height, file, line);
//height = getNextPOT(height);
@ -165,7 +165,7 @@ void storeTextureDimensions(GLuint name, GLsizei width, GLsizei height, const c
textureList *list = firstTexture;
while (list) {
if (list->name == name) {
if (list->name == name) {
//debugOut("Texture dimensions are overwritten.\n");
break;
}
@ -182,14 +182,14 @@ void storeTextureDimensions(GLuint name, GLsizei width, GLsizei height, const c
#endif
#ifdef HAVE_GLES2
void glesCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
void glesCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
// Work around for broken glCopy(Sub)TexImage2D...
void *tmp = malloc(width * height * 4);
glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
glTexSubImage2D(target, level, xoffset, yoffset, width, height, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
free(tmp);
}
void glesCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
void glesCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
// Work around for broken glCopy(Sub)TexImage2D...
void *tmp = malloc(width * height * 4);
glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
@ -199,7 +199,7 @@ void glesCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GL
#endif
#if 0
void dcopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border, GLuint name, const char *file, int line) {
void dcopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border, GLuint name, const char *file, int line) {
glBindTexture(GL_TEXTURE_2D, name);
#ifdef HAVE_GLES2_
@ -209,7 +209,7 @@ void dcopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint
#endif
}
void dcopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, GLuint name, const char *file, int line) {
void dcopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, GLuint name, const char *file, int line) {
glBindTexture(GL_TEXTURE_2D, name);
#ifdef HAVE_GLES2_
glesCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
@ -218,16 +218,16 @@ void dcopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoff
#endif
}
void dtexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type, const GLvoid *data, GLuint name, const char *file, int line) {
storeTextureDimensions(name, width, height, file, line);
void dtexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type, const GLvoid *data, GLuint name, const char *file, int line) {
storeTextureDimensions(name, width, height, file, line);
glBindTexture(GL_TEXTURE_2D, name);
glTexImage2D(target, level, internalformat, width, height, border, format, type, data);
glTexImage2D(target, level, internalformat, width, height, border, format, type, data);
}
void dtexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
GLenum format, GLenum type, const GLvoid *data, GLuint name, const char *file, int line) {
storeTextureDimensions(name, width, height, file, line);
void dtexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
GLenum format, GLenum type, const GLvoid *data, GLuint name, const char *file, int line) {
storeTextureDimensions(name, width, height, file, line);
glBindTexture(GL_TEXTURE_2D, name);
glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
}
@ -289,7 +289,6 @@ void drawQuad(GLint program, const GLfloat *vertices, int numTexCoords, ...) {
}
void setPMVMatrix(GLint program) {
glUniformMatrix4fv(glGetUniformLocation(program, "myPMVMatrix"), 1, GL_FALSE, aPMVMatrix);
}
@ -310,10 +309,10 @@ void setPixelCoords(bool pixels) {
glClear(GL_COLOR_BUFFER_BIT);
const GLfloat bPMVMatrix[] = {
2.0f / viewportWidth, .0, .0, .0,
.0, 2.0f / viewportHeight, .0, .0,
.0, .0, 1.0f, .0,
-1.0, -1.0f, .0, 1.0f
2.0f / viewportWidth, .0, .0, .0,
.0, 2.0f / viewportHeight, .0, .0,
.0, .0, 1.0f, .0,
-1.0, -1.0f, .0, 1.0f
};
for (int i = 0; i < 16; i++) {
@ -332,10 +331,10 @@ void setPixelCoords(bool pixels) {
GLfloat h = (GLfloat) winHeight / cameraZoom;
const GLfloat bPMVMatrix[] = {
2.0f / w, .0, .0, .0,
.0, -2.0f / h, .0, .0,
.0, .0, 1.0f, .0,
-1.0, 1.0f, .0, 1.0f
2.0f / w, .0, .0, .0,
.0, -2.0f / h, .0, .0,
.0, .0, 1.0f, .0,
-1.0, 1.0f, .0, 1.0f
};
for (int i = 0; i < 16; i++) {
@ -348,7 +347,6 @@ void setPixelCoords(bool pixels) {
int desktopW = 0, desktopH = 0;
bool runningFullscreen = false;
#if defined(HAVE_GLES2)
void saveTexture(GLuint tex, GLubyte *data) {
// use an FBO to easily grab the texture...
@ -412,7 +410,7 @@ void saveTexture(GLuint tex, GLubyte *data) {
drawQuad(shader.texture, vertices, 1, texCoords);
glUseProgram(0);
for (int i = 0; i < h; i++) {
for (int i = 0; i < h; i++) {
glReadPixels(viewportOffsetX, viewportOffsetY + i, w, 1, GL_RGBA, GL_UNSIGNED_BYTE, data + xoffset * 4 + (yoffset + i) * 4 * tw);
}
@ -607,13 +605,13 @@ void setGraphicsWindow(bool fullscreen, bool restoreGraphics, bool resize) {
Fragment = shaderFileRead("scale.frag");
#else
/* const GLubyte *str;
int glDerivativesAvailable;
str = glGetString (GL_EXTENSIONS);
glDerivativesAvailable = (strstr((const char *)str, "GL_OES_standard_derivatives") != NULL);
if (!glDerivativesAvailable) {
debugOut("Extension \"GL_OES_standard_derivatives\" not available. Advanced anti-aliasing is not possible. Using linear anti-aliasing instead.");
gameSettings.antiAlias = -1;
*/
int glDerivativesAvailable;
str = glGetString (GL_EXTENSIONS);
glDerivativesAvailable = (strstr((const char *)str, "GL_OES_standard_derivatives") != NULL);
if (!glDerivativesAvailable) {
debugOut("Extension \"GL_OES_standard_derivatives\" not available. Advanced anti-aliasing is not possible. Using linear anti-aliasing instead.");
gameSettings.antiAlias = -1;
*/
Fragment = shaderFileRead("scale_noaa.frag");
// }
@ -823,7 +821,6 @@ void setGraphicsWindow(bool fullscreen, bool restoreGraphics, bool resize) {
}
}
reloadSpriteTextures();
reloadParallaxTextures();
zBuffer.texName = 0;
@ -839,7 +836,7 @@ void setGraphicsWindow(bool fullscreen, bool restoreGraphics, bool resize) {
}
if (movieIsPlaying)
setMovieViewport();
setMovieViewport();
#endif
}
@ -923,7 +920,6 @@ void setupOpenGLStuff() {
}
// I found this function on a coding forum on the 'net.
// Looks a bit weird, but it should work.
int getNextPOT(int n) {

20
engines/sludge/graphics.h
View File

@ -87,7 +87,8 @@ void setPMVMatrix(GLint program);
#endif
void setPixelCoords(bool pixels);
void setGraphicsWindow(bool fullscreen, bool restoreGraphics = true, bool resize = false);
void setGraphicsWindow(bool fullscreen, bool restoreGraphics = true,
bool resize = false);
void setupOpenGLStuff();
@ -96,10 +97,10 @@ int getNextPOT(int n);
#if 0
void saveTexture(GLuint tex, GLubyte *data);
void dcopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border, GLuint name, const char *file, int line);
void dcopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, GLuint name, const char *file, int line);
void dtexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *data, GLuint name, const char *file, int line);
void dtexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data, GLuint name, const char *file, int line);
void dcopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border, GLuint name, const char *file, int line);
void dcopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, GLuint name, const char *file, int line);
void dtexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *data, GLuint name, const char *file, int line);
void dtexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data, GLuint name, const char *file, int line);
#define copyTexImage2D(target, level, internalformat, x, y, width, height, border, name) dcopyTexImage2D(target, level, internalformat, x, y, width,height, border, name, __FILE__, __LINE__)
@ -109,14 +110,15 @@ void dtexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
#define texSubImage2D( target, level, xoffset, yoffset, width, height, format, type, data,name) dtexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, data, name, __FILE__, __LINE__)
void deleteTextures(GLsizei n, const GLuint *textures);
void deleteTextures(GLsizei n, const GLuint *textures);
void getTextureDimensions(GLuint name, GLint *width, GLint *height);
void getTextureDimensions(GLuint name, GLint *width, GLint *height);
int printOglError(const char *file, int line);
int printOglError(const char *file, int line);
#define printOpenGLError() printOglError(__FILE__, __LINE__)
#endif
} // End of namespace Sludge
}
// End of namespace Sludge
#endif

33
engines/sludge/language.cpp
View File

@ -44,9 +44,9 @@ unsigned int stringToInt(char *s) {
if (*s >= '0' && *s <= '9') {
i *= 10;
i += *s - '0';
s ++;
s++;
} else if (*s == '-') {
negative = ! negative;
negative = !negative;
s++;
} else {
if (negative)
@ -56,7 +56,6 @@ unsigned int stringToInt(char *s) {
}
}
char *getPrefsFilename(char *filename) {
// Yes, this trashes the original string, but
// we also free it at the end (warning!)...
@ -92,7 +91,8 @@ void readIniFile(char *filename) {
Common::File fd;
if (!fd.open(langName)) {
debug(kSludgeDebugDataLoad, "Fail to open language file : %s", langName);
debug(kSludgeDebugDataLoad, "Fail to open language file : %s",
langName);
return;
}
@ -127,7 +127,7 @@ void readIniFile(char *filename) {
if (strcmp(lineSoFar, "LANGUAGE") == 0) {
gameSettings.languageID = stringToInt(secondSoFar);
} else if (strcmp(lineSoFar, "WINDOW") == 0) {
gameSettings.userFullScreen = ! stringToInt(secondSoFar);
gameSettings.userFullScreen = !stringToInt(secondSoFar);
} else if (strcmp(lineSoFar, "REFRESH") == 0) {
gameSettings.refreshRate = stringToInt(secondSoFar);
} else if (strcmp(lineSoFar, "ANTIALIAS") == 0) {
@ -153,10 +153,10 @@ void readIniFile(char *filename) {
default:
if (doingSecond) {
secondSoFar[here ++] = readChar;
secondSoFar[here++] = readChar;
secondSoFar[here] = 0;
} else {
lineSoFar[here ++] = readChar;
lineSoFar[here++] = readChar;
lineSoFar[here] = 0;
}
break;
@ -185,19 +185,23 @@ void saveIniFile(char *filename) {
void makeLanguageTable(Common::File *table) {
languageTable = new int[gameSettings.numLanguages + 1];
if (! checkNew(languageTable)) return;
if (!checkNew(languageTable))
return;
languageName = new char *[gameSettings.numLanguages + 1];
if (! checkNew(languageName)) return;
if (!checkNew(languageName))
return;
for (unsigned int i = 0; i <= gameSettings.numLanguages; i ++) {
for (unsigned int i = 0; i <= gameSettings.numLanguages; i++) {
languageTable[i] = i ? get2bytes(table) : 0;
debug(kSludgeDebugDataLoad, "languageTable %i: %i", i, languageTable[i]);
debug(kSludgeDebugDataLoad, "languageTable %i: %i", i,
languageTable[i]);
languageName[i] = 0;
if (gameVersion >= VERSION(2, 0)) {
if (gameSettings.numLanguages) {
languageName[i] = readString(table);
debug(kSludgeDebugDataLoad, "languageName %i: %s\n", i, languageName[i]);
debug(kSludgeDebugDataLoad, "languageName %i: %s\n", i,
languageName[i]);
}
}
}
@ -206,8 +210,9 @@ void makeLanguageTable(Common::File *table) {
int getLanguageForFileB() {
int indexNum = -1;
for (unsigned int i = 0; i <= gameSettings.numLanguages; i ++) {
if (languageTable[i] == gameSettings.languageID) indexNum = i;
for (unsigned int i = 0; i <= gameSettings.numLanguages; i++) {
if (languageTable[i] == gameSettings.languageID)
indexNum = i;
}
return indexNum;

12
engines/sludge/line.cpp
View File

@ -37,10 +37,10 @@ void drawLine(int x1, int y1, int x2, int y2) {
int x, y;
bool backwards = false;
#if 0
if (x1 < 0) x1 = 0;
if (y1 < 0) y1 = 0;
if (x2 < 0) x2 = 0;
if (y2 < 0) y2 = 0;
if (x1 < 0) x1 = 0;
if (y1 < 0) y1 = 0;
if (x2 < 0) x2 = 0;
if (y2 < 0) y2 = 0;
if (x1 > sceneWidth) x1 = sceneWidth - 1;
if (x2 > sceneWidth) x2 = sceneWidth - 1;
if (y1 > sceneHeight) y1 = sceneHeight - 1;
@ -69,10 +69,8 @@ void drawLine(int x1, int y1, int x2, int y2) {
}
setPixelCoords(true);
glLineWidth(2.0);
int xoffset = 0;
while (xoffset < diffX) {
int w = (diffX - xoffset < viewportWidth) ? diffX - xoffset : viewportWidth;
@ -98,7 +96,6 @@ void drawLine(int x1, int y1, int x2, int y2) {
backdropTexW, backdropTexH
};
glUseProgram(shader.texture);
setPMVMatrix(shader.texture);
@ -118,7 +115,6 @@ void drawLine(int x1, int y1, int x2, int y2) {
xo2, -yoffset + diffY, 0,
};
glUseProgram(shader.color);
setPMVMatrix(shader.color);

53
engines/sludge/loadsave.cpp
View File

@ -78,7 +78,6 @@ extern parallaxLayer *parallaxStuff; // "
extern int lightMapMode; // "
extern int languageNum;
//----------------------------------------------------------------------
// Globals (so we know what's saved already and what's a reference
//----------------------------------------------------------------------
@ -100,7 +99,7 @@ void saveStack(variableStack *vs, Common::WriteStream *stream) {
variableStack *search = vs;
while (search) {
elements ++;
elements++;
search = search->next;
}
@ -114,7 +113,8 @@ void saveStack(variableStack *vs, Common::WriteStream *stream) {
}
}
variableStack *loadStack(Common::SeekableReadStream *stream, variableStack **last) {
variableStack *loadStack(Common::SeekableReadStream *stream,
variableStack **last) {
int elements = get2bytes(stream);
int a;
variableStack *first = NULL;
@ -122,14 +122,15 @@ variableStack *loadStack(Common::SeekableReadStream *stream, variableStack **las
for (a = 0; a < elements; ++a) {
variableStack *nS = new variableStack;
if (!checkNew(nS)) return NULL;
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;
changeMe = &(nS->next);
}
@ -151,8 +152,9 @@ bool saveStackRef(stackHandler *vs, Common::WriteStream *stream) {
putch(0, stream);
saveStack(vs->first, stream);
s = new stackLibrary;
stackLibTotal ++;
if (! checkNew(s)) return false;
stackLibTotal++;
if (!checkNew(s))
return false;
s->next = stackLib;
s->stack = vs;
stackLib = s;
@ -173,7 +175,7 @@ stackHandler *getStackFromLibrary(int n) {
n = stackLibTotal - n;
while (n) {
stackLib = stackLib->next;
n --;
n--;
}
return stackLib->stack;
}
@ -185,14 +187,15 @@ stackHandler *loadStackRef(Common::SeekableReadStream *stream) {
stackDebug((stackfp, "loadStackRef (duplicate, get from library)\n"));
nsh = getStackFromLibrary(get2bytes(stream));
nsh->timesUsed ++;
nsh->timesUsed++;
} else {
stackDebug((stackfp, "loadStackRef (new one)\n"));
// Load the new stack
nsh = new stackHandler;
if (! checkNew(nsh)) return NULL;
if (!checkNew(nsh))
return NULL;
nsh->last = NULL;
nsh->first = loadStack(stream, &nsh->last);
nsh->timesUsed = 1;
@ -206,11 +209,12 @@ stackHandler *loadStackRef(Common::SeekableReadStream *stream) {
// Add it to the library of loaded stacks
stackLibrary *s = new stackLibrary;
if (! checkNew(s)) return NULL;
if (!checkNew(s))
return NULL;
s->stack = nsh;
s->next = stackLib;
stackLib = s;
stackLibTotal ++;
stackLibTotal++;
}
return nsh;
}
@ -257,15 +261,14 @@ bool saveVariable(variable *from, Common::WriteStream *stream) {
default:
fatal("Can't save variables of this type:",
(from->varType < SVT_NUM_TYPES) ?
typeName[from->varType] :
"bad ID");
(from->varType < SVT_NUM_TYPES) ?
typeName[from->varType] : "bad ID");
}
return true;
}
bool loadVariable(variable *to, Common::SeekableReadStream *stream) {
to->varType = (variableType)getch(stream);
to->varType = (variableType) getch(stream);
switch (to->varType) {
case SVT_INT:
case SVT_FUNC:
@ -292,13 +295,15 @@ bool loadVariable(variable *to, Common::SeekableReadStream *stream) {
case SVT_COSTUME:
to->varData.costumeHandler = new persona;
if (! checkNew(to->varData.costumeHandler)) return false;
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;
if (!checkNew(to->varData.animHandler))
return false;
loadAnim(to->varData.animHandler, stream);
return true;
@ -342,7 +347,8 @@ loadedFunction *loadFunction(Common::SeekableReadStream *stream) {
// Reserve memory...
loadedFunction *buildFunc = new loadedFunction;
if (! checkNew(buildFunc)) return NULL;
if (!checkNew(buildFunc))
return NULL;
// See what it was called by and load if we need to...
@ -350,7 +356,8 @@ loadedFunction *loadFunction(Common::SeekableReadStream *stream) {
buildFunc->calledBy = NULL;
if (getch(stream)) {
buildFunc->calledBy = loadFunction(stream);
if (! buildFunc->calledBy) return NULL;
if (!buildFunc->calledBy)
return NULL;
}
buildFunc->timeLeft = get4bytes(stream);
@ -396,7 +403,7 @@ bool saveGame(char *fname) {
fputc(allowAnyFilename, fp);
fputc(captureAllKeys, fp);
fputc(true, fp); // updateDisplay
fputc(true, fp);// updateDisplay
fputc(fontTableSize > 0, fp);
if (fontTableSize > 0) {
@ -515,7 +522,7 @@ bool loadGame(char *fname) {
}
if (savedGameTime.dwLowDateTime != fileTime.dwLowDateTime ||
savedGameTime.dwHighDateTime != fileTime.dwHighDateTime) {
savedGameTime.dwHighDateTime != fileTime.dwHighDateTime) {
return fatal(ERROR_GAME_LOAD_WRONG, fname);
}
@ -579,7 +586,6 @@ bool loadGame(char *fname) {
loadedFunction *rFunc;
loadedFunction * * buildList = &allRunningFunctions;
int countFunctions = get2bytes(fp);
while (countFunctions --) {
rFunc = loadFunction(fp);
@ -595,7 +601,6 @@ bool loadGame(char *fname) {
loadPeople(fp);
if (fgetc(fp)) {
if (! setFloor(get2bytes(fp))) return false;
} else setFloorNull();

99
engines/sludge/main_loop.cpp
View File

@ -36,7 +36,6 @@
#include <iostream>
#include <stdexcept>
#include <time.h>
@ -159,19 +158,19 @@ void checkInput() {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_VIDEORESIZE:
case SDL_VIDEORESIZE:
realWinWidth = event.resize.w;
realWinHeight = event.resize.h;
setGraphicsWindow(false, true, true);
break;
case SDL_MOUSEMOTION:
case SDL_MOUSEMOTION:
input.justMoved = true;
input.mouseX = event.motion.x * ((float)winWidth / cameraZoom) / realWinWidth;
input.mouseY = event.motion.y * ((float)winHeight / cameraZoom) / realWinHeight;
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_LEFT) {
if (SDL_GetModState() & KMOD_CTRL) {
input.rightClick = true;
@ -186,7 +185,7 @@ void checkInput() {
input.mouseY = event.motion.y * ((float)winHeight / cameraZoom) / realWinHeight;
break;
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEBUTTONUP:
if (event.button.button == SDL_BUTTON_LEFT) {
if (fakeRightclick) {
fakeRightclick = false;
@ -200,7 +199,7 @@ void checkInput() {
input.mouseY = event.motion.y * ((float)winHeight / cameraZoom) / realWinHeight;
break;
case SDL_KEYDOWN:
case SDL_KEYDOWN:
// A Windows key is pressed - let's leave fullscreen.
if (runningFullscreen) {
if (event.key.keysym.sym == SDLK_LSUPER || event.key.keysym.sym == SDLK_LSUPER) {
@ -224,7 +223,7 @@ void checkInput() {
break;
}
// Allow Alt+F4 to quit
if (SDLK_F4 == event.key.keysym.sym) {
if (SDLK_F4 == event.key.keysym.sym) {
SDL_Event event;
event.type = SDL_QUIT;
SDL_PushEvent(&event);
@ -233,86 +232,86 @@ void checkInput() {
break;
}
switch (event.key.keysym.sym) {
case SDLK_BACKSPACE:
case SDLK_DELETE: // Ok, mapping these to the same key is weird, I admit. But good?
case SDLK_BACKSPACE:
case SDLK_DELETE: // Ok, mapping these to the same key is weird, I admit. But good?
input.keyPressed = 127;
break;
case SDLK_TAB:
case SDLK_TAB:
input.keyPressed = 9;
break;
case SDLK_RETURN:
case SDLK_RETURN:
input.keyPressed = 13;
break;
case SDLK_ESCAPE:
case SDLK_ESCAPE:
input.keyPressed = 27;
break;
case SDLK_PAGEUP:
case SDLK_PAGEUP:
input.keyPressed = 63276;
break;
case SDLK_PAGEDOWN:
case SDLK_PAGEDOWN:
input.keyPressed = 63277;
break;
case SDLK_END:
case SDLK_END:
input.keyPressed = 63275;
break;
case SDLK_HOME:
case SDLK_HOME:
input.keyPressed = 63273;
break;
case SDLK_LEFT:
case SDLK_LEFT:
input.keyPressed = 63234;
break;
case SDLK_UP:
case SDLK_UP:
input.keyPressed = 63232;
break;
case SDLK_RIGHT:
case SDLK_RIGHT:
input.keyPressed = 63235;
break;
case SDLK_DOWN:
case SDLK_DOWN:
input.keyPressed = 63233;
break;
case SDLK_F1:
case SDLK_F1:
input.keyPressed = 63236;
break;
case SDLK_F2:
case SDLK_F2:
input.keyPressed = 63237;
break;
case SDLK_F3:
case SDLK_F3:
input.keyPressed = 63238;
break;
case SDLK_F4:
case SDLK_F4:
input.keyPressed = 63239;
break;
case SDLK_F5:
case SDLK_F5:
input.keyPressed = 63240;
break;
case SDLK_F6:
case SDLK_F6:
input.keyPressed = 63241;
break;
case SDLK_F7:
case SDLK_F7:
input.keyPressed = 63242;
break;
case SDLK_F8:
case SDLK_F8:
input.keyPressed = 63243;
break;
case SDLK_F9:
case SDLK_F9:
input.keyPressed = 63244;
break;
case SDLK_F10:
case SDLK_F10:
input.keyPressed = 63245;
break;
case SDLK_F11:
case SDLK_F11:
input.keyPressed = 63246;
break;
case SDLK_F12:
case SDLK_F12:
input.keyPressed = 63247;
break;
default:
default:
input.keyPressed = event.key.keysym.unicode;
break;
}
break;
case SDL_QUIT:
case SDL_QUIT:
if (reallyWantToQuit) {
// The game file has requested that we quit
weAreDoneSoQuit = 1;
@ -326,7 +325,7 @@ void checkInput() {
}
break;
default:
default:
break;
}
}
@ -335,9 +334,9 @@ void checkInput() {
int main_loop(char *filename)
#if 0
try
try
#endif
{
{
/* Dimensions of our window. */
winWidth = 640;
winHeight = 480;
@ -348,7 +347,6 @@ try
time_t t;
srand((unsigned) time(&t));
// bundleFolder is used to look for the game file
// and later to find the shader programs
#ifdef __APPLE__
@ -392,11 +390,13 @@ try
// The player pressed cancel in the file selection dialogue,
// so we should quit now.
if (!sludgeFile) return 0;
if (!sludgeFile)
return 0;
// OK, so we DO want to start up, then...
setGameFilePath(sludgeFile);
if (!initSludge(sludgeFile)) return 0;
if (!initSludge(sludgeFile))
return 0;
#if 0
/* Initialize the SDL library */
@ -430,12 +430,16 @@ try
registerWindowForFatal();
if (!resizeBackdrop(winWidth, winHeight)) return fatal("Couldn't allocate memory for backdrop");
if (!resizeBackdrop(winWidth, winHeight))
return fatal("Couldn't allocate memory for backdrop");
blankScreen(0, 0, winWidth, winHeight);
if (!initPeople()) return fatal("Couldn't initialise people stuff");
if (!initFloor()) return fatal("Couldn't initialise floor stuff");
if (!initObjectTypes()) return fatal("Couldn't initialise object type stuff");
if (!initPeople())
return fatal("Couldn't initialise people stuff");
if (!initFloor())
return fatal("Couldn't initialise floor stuff");
if (!initObjectTypes())
return fatal("Couldn't initialise object type stuff");
initSpeech();
initStatusBar();
resetRandW();
@ -473,7 +477,9 @@ try
walkAllPeople();
handleInput();
sludgeDisplay();
g_system->copyRectToScreen(backdropSurface.getPixels(), backdropSurface.pitch, 0, 0, backdropSurface.w, backdropSurface.h);
g_system->copyRectToScreen(backdropSurface.getPixels(),
backdropSurface.pitch, 0, 0, backdropSurface.w,
backdropSurface.h);
g_system->updateScreen();
#if 0
Wait_Frame();
@ -509,4 +515,5 @@ catch (std::exception &ex) { //NOTE by reference, not value
}
#endif
} // End of namespace Sludge
}
// End of namespace Sludge

6
engines/sludge/memwatch.cpp
View File

@ -43,7 +43,7 @@ void outputKnownMem() {
void adding(void *mem) {
allKnownMem[allKnownNum] = mem;
allKnownNum ++;
allKnownNum++;
outputKnownMem();
if (allKnownNum == 3000) {
@ -55,8 +55,8 @@ void adding(void *mem) {
}
void deleting(void *mem) {
allKnownNum --;
for (int i = 0; i <= allKnownNum; i ++) {
allKnownNum--;
for (int i = 0; i <= allKnownNum; i++) {
if (allKnownMem[i] == mem) {
allKnownMem[i] = allKnownMem[allKnownNum];
outputKnownMem();

61
engines/sludge/moreio.cpp
View File

@ -58,8 +58,8 @@ int get2bytes(Common::SeekableReadStream *stream) {
}
void put2bytes(int numtoput, Common::WriteStream *stream) {
putch((char)(numtoput / 256), stream);
putch((char)(numtoput % 256), stream);
putch((char) (numtoput / 256), stream);
putch((char) (numtoput % 256), stream);
}
void writeString(char *s, Common::WriteStream *stream) {
@ -70,7 +70,6 @@ void writeString(char *s, Common::WriteStream *stream) {
}
}
char *readString(Common::SeekableReadStream *stream) {
int a, len = get2bytes(stream);
char *s = new char[len + 1];
@ -78,7 +77,7 @@ char *readString(Common::SeekableReadStream *stream) {
return NULL;
}
for (a = 0; a < len; ++a) {
s[a] = (char)(getch(stream) - 1);
s[a] = (char) (getch(stream) - 1);
}
s[len] = 0;
debug(kSludgeDebugDataLoad, "Read string of length %i: %s", len, s);
@ -99,11 +98,10 @@ float floatSwap(float f) {
return dat2.f;
}
float getFloat(Common::SeekableReadStream *stream) {
float f;
size_t bytes_read = stream->read(&f, sizeof(float));
//fread(& f, sizeof(float), 1, fp);
//fread(& f, sizeof(float), 1, fp);
if (bytes_read != sizeof(float) && stream->err()) {
debug("Reading error in getFloat.\n");
}
@ -119,7 +117,7 @@ void putFloat(float f, Common::WriteStream *stream) {
#ifdef __BIG_ENDIAN__
f = floatSwap(f);
#endif
stream->write(&f,sizeof(float));
stream->write(&f, sizeof(float));
//fwrite(& f, sizeof(float), 1, fp);
}
@ -132,7 +130,6 @@ short shortSwap(short s) {
return (b1 << 8) + b2;
}
short getSigned(Common::SeekableReadStream *stream) {
short f;
size_t bytes_read = stream->read(&f, sizeof(short));
@ -152,7 +149,6 @@ void putSigned(short f, Common::WriteStream *stream) {
stream->write(&f, sizeof(short));
}
// The following two functions treat signed integers as unsigned.
// That's done on purpose.
@ -169,7 +165,6 @@ int32_t get4bytes(Common::SeekableReadStream *stream) {
return x;
}
void put4bytes(unsigned int i, Common::WriteStream *stream) {
unsigned char f1, f2, f3, f4;
@ -187,10 +182,12 @@ void put4bytes(unsigned int i, Common::WriteStream *stream) {
}
char *encodeFilename(char *nameIn) {
if (!nameIn) return NULL;
if (!nameIn)
return NULL;
if (allowAnyFilename) {
char *newName = new char[strlen(nameIn) * 2 + 1];
if (!checkNew(newName)) return NULL;
if (!checkNew(newName))
return NULL;
int i = 0;
while (*nameIn) {
@ -241,7 +238,7 @@ char *encodeFilename(char *nameIn) {
break;
}
newName[i] = 0;
nameIn ++;
nameIn++;
}
return newName;
} else {
@ -250,7 +247,8 @@ char *encodeFilename(char *nameIn) {
#ifdef _WIN32
if (nameIn[a] == '/') nameIn[a] = '\\';
#else
if (nameIn[a] == '\\') nameIn[a] = '/';
if (nameIn[a] == '\\')
nameIn[a] = '/';
#endif
}
@ -261,61 +259,62 @@ char *encodeFilename(char *nameIn) {
char *decodeFilename(char *nameIn) {
if (allowAnyFilename) {
char *newName = new char[strlen(nameIn) + 1];
if (!checkNew(newName)) return NULL;
if (!checkNew(newName))
return NULL;
int i = 0;
while (* nameIn) {
if (* nameIn == '_') {
nameIn ++;
switch (* nameIn) {
while (*nameIn) {
if (*nameIn == '_') {
nameIn++;
switch (*nameIn) {
case 'L':
newName[i] = '<';
nameIn ++;
nameIn++;
break;
case 'G':
newName[i] = '>';
nameIn ++;
nameIn++;
break;
case 'P':
newName[i] = '|';
nameIn ++;
nameIn++;
break;
case 'U':
newName[i] = '_';
nameIn ++;
nameIn++;
break;
case 'S':
newName[i] = '\"';
nameIn ++;
nameIn++;
break;
case 'B':
newName[i] = '\\';
nameIn ++;
nameIn++;
break;
case 'F':
newName[i] = '/';
nameIn ++;
nameIn++;
break;
case 'C':
newName[i] = ':';
nameIn ++;
nameIn++;
break;
case 'A':
newName[i] = '*';
nameIn ++;
nameIn++;
break;
case 'Q':
newName[i] = '?';
nameIn ++;
nameIn++;
break;
default:
newName[i] = '_';
}
} else {
newName[i] = *nameIn;
nameIn ++;
nameIn++;
}
i ++;
i++;
}
newName[i] = 0;

152
engines/sludge/movie.cpp
View File

@ -71,7 +71,7 @@ bool handleInput();
void playMovieStream(int a);
#if 0
int initMovieSound(int f, ALenum format, int audioChannels, ALuint samplerate,
ALuint(*callback)(void *userdata, ALubyte *data, ALuint bytes));
ALuint(*callback)(void *userdata, ALubyte *data, ALuint bytes));
#endif
movieStates movieIsPlaying = nothing;
@ -85,14 +85,14 @@ typedef struct audioBuffers {
unsigned int size;
audioBuffers *next;
Uint32 time_ms;
} audioBuffers;
}audioBuffers;
typedef struct audioQueue {
audioBuffers *first, *last;
int size;
SDL_mutex *mutex;
SDL_cond *cond;
} audioQueue;
}audioQueue;
audioQueue audioQ;
@ -115,18 +115,17 @@ typedef struct videoBuffers {
videoBuffers *next;
GLsizei w, h;
Uint32 time_ms;
} videoBuffers;
}videoBuffers;
typedef struct videoQueue {
videoBuffers *first, *last;
int size;
SDL_mutex *mutex;
SDL_cond *cond;
} videoQueue;
}videoQueue;
videoQueue videoQ;
void audio_queue_init(audioQueue *q) {
memset(q, 0, sizeof(audioQueue));
@ -138,7 +137,7 @@ int audio_queue_put(audioQueue *q, char *buffer, unsigned int size, long long ti
audioBuffers *audioBuf = new audioBuffers;
if (!audioBuf)
return -1;
return -1;
audioBuf->buffer = buffer;
audioBuf->next = NULL;
audioBuf->size = size;
@ -147,9 +146,9 @@ int audio_queue_put(audioQueue *q, char *buffer, unsigned int size, long long ti
SDL_LockMutex(q->mutex);
if (!q->last)
q->first = audioBuf;
q->first = audioBuf;
else
q->last->next = audioBuf;
q->last->next = audioBuf;
q->last = audioBuf;
q->size ++;
SDL_CondSignal(q->cond);
@ -161,7 +160,6 @@ int audio_queue_put(audioQueue *q, char *buffer, unsigned int size, long long ti
inline static int audio_queue_get(audioQueue *q, char **buffer) {
int ret = 0;
audioBuffers *audioBuf;
SDL_LockMutex(q->mutex);
@ -176,7 +174,7 @@ inline static int audio_queue_get(audioQueue *q, char **buffer) {
q->first = audioBuf->next;
if (!q->first)
q->last = NULL;
q->last = NULL;
q->size--;
*buffer = audioBuf->buffer;
ret = audioBuf->size;
@ -194,14 +192,14 @@ void video_queue_init(videoQueue *q) {
q->cond = SDL_CreateCond();
}
int video_queue_put(videoQueue *q, GLubyte *ytex,
GLubyte *utex,
GLubyte *vtex,
GLsizei w, GLsizei h,
long long time_ms) {
GLubyte *utex,
GLubyte *vtex,
GLsizei w, GLsizei h,
long long time_ms) {
videoBuffers *videoBuf = new videoBuffers;
if (!videoBuf)
return -1;
return -1;
videoBuf->ytex = ytex;
videoBuf->utex = utex;
videoBuf->vtex = vtex;
@ -213,9 +211,9 @@ int video_queue_put(videoQueue *q, GLubyte *ytex,
SDL_LockMutex(q->mutex);
if (!q->last)
q->first = videoBuf;
q->first = videoBuf;
else
q->last->next = videoBuf;
q->last->next = videoBuf;
q->last = videoBuf;
q->size ++;
SDL_CondSignal(q->cond);
@ -224,10 +222,10 @@ int video_queue_put(videoQueue *q, GLubyte *ytex,
return 0;
}
inline static int video_queue_get(videoQueue *q,
GLubyte **ytex,
GLubyte **utex,
GLubyte **vtex,
GLsizei *w, GLsizei *h) {
GLubyte **ytex,
GLubyte **utex,
GLubyte **vtex,
GLsizei *w, GLsizei *h) {
videoBuffers *videoBuf;
int ret = 0;
@ -237,7 +235,7 @@ inline static int video_queue_get(videoQueue *q,
if (videoBuf) {
q->first = videoBuf->next;
if (!q->first)
q->last = NULL;
q->last = NULL;
q->size--;
*ytex = videoBuf->ytex;
*utex = videoBuf->utex;
@ -279,10 +277,10 @@ void setMovieViewport() {
glViewport(vpOffsetX, vpOffsetY, vpWidth, vpHeight);
#endif
const GLfloat bPMVMatrix[] = {
2.0f / 640.f, .0, .0, .0,
.0, -2.0f / 400.f, .0, .0,
.0, .0, 1.0f, .0,
-1.0, 1.0f, .0, 1.0f
2.0f / 640.f, .0, .0, .0,
.0, -2.0f / 400.f, .0, .0,
.0, .0, 1.0f, .0,
-1.0, 1.0f, .0, 1.0f
};
for (int i = 0; i < 16; i++) {
@ -341,9 +339,9 @@ ALuint feedAudio(void *userdata, ALubyte *data, ALuint length) {
fakeAudio = false;
if (length > bufSize - bufOffset)
bufLen = bufSize - bufOffset;
bufLen = bufSize - bufOffset;
else
bufLen = length;
bufLen = length;
memcpy(data, buffer + bufOffset, bufLen);
@ -364,13 +362,13 @@ ALuint feedAudio(void *userdata, ALubyte *data, ALuint length) {
int playMovie(int fileNumber) {
#if 0
if (specialSettings & SPECIAL_SILENT)
return 0;
return 0;
if (movieIsPlaying) return 0;
movieSoundPlaying = false;
vpx_codec_ctx_t codec;
vpx_codec_ctx_t codec;
float pausefade = 1.0;
@ -396,7 +394,7 @@ int playMovie(int fileNumber) {
fatal("Movie error: Segment::CreateInstance() failed.\n");
}
ret = pSegment->Load();
ret = pSegment->Load();
if (ret < 0) {
fatal("Movie error: Segment::Load() failed.\n");
}
@ -413,7 +411,7 @@ int playMovie(int fileNumber) {
unsigned long i = 0;
const unsigned long j = pTracks->GetTracksCount();
enum { VIDEO_TRACK = 1, AUDIO_TRACK = 2 };
enum {VIDEO_TRACK = 1, AUDIO_TRACK = 2};
int videoTrack = -1;
int audioTrack = -1;
long long audioBitDepth;
@ -427,7 +425,7 @@ int playMovie(int fileNumber) {
const Track *const pTrack = pTracks->GetTrackByIndex(i++);
if (pTrack == NULL)
continue;
continue;
const long long trackType = pTrack->GetType();
//const unsigned long long trackUid = pTrack->GetUid();
@ -436,15 +434,15 @@ int playMovie(int fileNumber) {
if (trackType == VIDEO_TRACK && videoTrack < 0) {
videoTrack = pTrack->GetNumber();
const VideoTrack *const pVideoTrack =
static_cast<const VideoTrack *>(pTrack);
static_cast<const VideoTrack *>(pTrack);
const long long width = pVideoTrack->GetWidth();
const long long width = pVideoTrack->GetWidth();
const long long height = pVideoTrack->GetHeight();
const double rate = pVideoTrack->GetFrameRate();
if (rate > 0)
Init_Special_Timer(rate);
Init_Special_Timer(rate);
movieAspect = (float)width / height;
}
@ -452,9 +450,9 @@ int playMovie(int fileNumber) {
if (trackType == AUDIO_TRACK && audioTrack < 0) {
audioTrack = pTrack->GetNumber();
const AudioTrack *const pAudioTrack =
static_cast<const AudioTrack *>(pTrack);
static_cast<const AudioTrack *>(pTrack);
audioChannels = pAudioTrack->GetChannels();
audioChannels = pAudioTrack->GetChannels();
audioBitDepth = pAudioTrack->GetBitDepth();
audioSampleRate = pAudioTrack->GetSamplingRate();
@ -503,17 +501,17 @@ int playMovie(int fileNumber) {
oggPacket.b_o_s = oggPacket.packetno == 0;
r = vorbis_synthesis_headerin(&vorbisInfo, &vorbisComment, &oggPacket);
if (r)
fprintf(stderr, "vorbis_synthesis_headerin failed, error: %d", r);
fprintf(stderr, "vorbis_synthesis_headerin failed, error: %d", r);
oggPacket.packetno++;
p += sizes[i];
}
r = vorbis_synthesis_init(&vorbisDspState, &vorbisInfo);
if (r)
fprintf(stderr, "vorbis_synthesis_init failed, error: %d", r);
fprintf(stderr, "vorbis_synthesis_init failed, error: %d", r);
r = vorbis_block_init(&vorbisDspState, &vorbisBlock);
if (r)
fprintf(stderr, "vorbis_block_init failed, error: %d", r);
fprintf(stderr, "vorbis_block_init failed, error: %d", r);
ALenum audioFormat = alureGetSampleFormat(audioChannels, 16, 0);
movieAudioIndex = initMovieSound(fileNumber, audioFormat, audioChannels, (ALuint) audioSampleRate, feedAudio);
@ -527,10 +525,10 @@ int playMovie(int fileNumber) {
}
if (videoTrack < 0)
fatal("Movie error: No video in movie file.");
fatal("Movie error: No video in movie file.");
if (audioTrack < 0)
fatal("Movie error: No sound found.");
fatal("Movie error: No sound found.");
video_queue_init(&videoQ);
@ -540,11 +538,9 @@ int playMovie(int fileNumber) {
fatal("Movie error: Segment has no clusters.\n");
}
/* Initialize video codec */
if (vpx_codec_dec_init(&codec, interface, NULL, 0))
die_codec(&codec, "Failed to initialize decoder for movie.");
die_codec(&codec, "Failed to initialize decoder for movie.");
unsigned char *frame = new unsigned char[256 * 1024];
if (! checkNew(frame)) return false;
@ -571,7 +567,7 @@ int playMovie(int fileNumber) {
}
pBlockEntry = pCluster->GetFirst();
}
const Block *pBlock = pBlockEntry->GetBlock();
const Block *pBlock = pBlockEntry->GetBlock();
long long trackNum = pBlock->GetTrackNumber();
unsigned long tn = static_cast<unsigned long>(trackNum);
const Track *pTrack = pTracks->GetTrackByNumber(tn);
@ -634,7 +630,7 @@ int playMovie(int fileNumber) {
checkInput();
if (weAreDoneSoQuit)
break;
break;
handleInput();
if (movieIsPlaying && (! movieIsEnding) && (videoQ.size < 100 || audioQ.size < 100)) {
@ -652,7 +648,7 @@ int playMovie(int fileNumber) {
}
pBlockEntry = pCluster->GetFirst();
}
pBlock = pBlockEntry->GetBlock();
pBlock = pBlockEntry->GetBlock();
trackNum = pBlock->GetTrackNumber();
tn = static_cast<unsigned long>(trackNum);
pTrack = pTracks->GetTrackByNumber(tn);
@ -673,28 +669,27 @@ int playMovie(int fileNumber) {
if (! checkNew(frame)) return 0;
}
/*
fprintf (stderr, "Block :%s,%s,%15lld\n",
(trackType == VIDEO_TRACK) ? "V" : "A",
pBlock->IsKey() ? "I" : "P",
time_ns);
fprintf (stderr, "Block :%s,%s,%15lld\n",
(trackType == VIDEO_TRACK) ? "V" : "A",
pBlock->IsKey() ? "I" : "P",
time_ns);
*/
if (trackNum == videoTrack) {
theFrame.Read(&reader, frame);
/* Decode the frame */
if (vpx_codec_decode(&codec, frame, size, NULL, 0))
die_codec(&codec, "Failed to decode frame");
die_codec(&codec, "Failed to decode frame");
// Let's decode an image frame!
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
vpx_codec_iter_t iter = NULL;
vpx_image_t *img;
/* Get frame data */
while ((img = vpx_codec_get_frame(&codec, &iter))) {
if (img->fmt != VPX_IMG_FMT_I420)
fatal("Movie error. The movie is not in I420 colour format, which is the only one I can hanlde at the moment.");
fatal("Movie error. The movie is not in I420 colour format, which is the only one I can hanlde at the moment.");
unsigned int y;
@ -707,7 +702,7 @@ int playMovie(int fileNumber) {
utex = new GLubyte [(img->d_w >> 1) * (img->d_h >> 1)];
vtex = new GLubyte [(img->d_w >> 1) * (img->d_h >> 1)];
if (!ytex || !utex || !vtex)
fatal(ERROR_OUT_OF_MEMORY);
fatal(ERROR_OUT_OF_MEMORY);
}
@ -728,8 +723,7 @@ int playMovie(int fileNumber) {
}
video_queue_put(&videoQ, ytex, utex, vtex,
img->d_w, img->d_h, time_ns / 1000000);
img->d_w, img->d_h, time_ns / 1000000);
}
@ -744,7 +738,7 @@ int playMovie(int fileNumber) {
oggPacket.granulepos = -1;
if (! vorbis_synthesis(&vorbisBlock, &oggPacket)) {
if (vorbis_synthesis_blockin(&vorbisDspState, &vorbisBlock))
fprintf(stderr, "Vorbis Synthesis block in error.\n");
fprintf(stderr, "Vorbis Synthesis block in error.\n");
} else {
fprintf(stderr, "Vorbis Synthesis error.\n");
@ -771,12 +765,12 @@ int playMovie(int fileNumber) {
int off = (sgned ? 0 : 128);
vorbis_fpu_setround(&fpu);
for (j = 0; j < numSamples; j++)
for (i = 0; i < audioChannels; i++) {
val = vorbis_ftoi(pcm[i][j] * 128.f);
if (val > 127)val = 127;
else if (val < -128)val = -128;
*buffer++ = val + off;
}
for (i = 0; i < audioChannels; i++) {
val = vorbis_ftoi(pcm[i][j] * 128.f);
if (val > 127)val = 127;
else if (val < -128)val = -128;
*buffer++ = val + off;
}
vorbis_fpu_restore(fpu);
} else {
int off = (sgned ? 0 : 32768);
@ -835,7 +829,7 @@ int playMovie(int fileNumber) {
++frameCounter;
} else {
movieHasEnded:
movieHasEnded:
movieIsEnding = 1;
}
}
@ -865,30 +859,29 @@ movieHasEnded:
if (! vTextureName) glGenTextures(1, &vTextureName);
glBindTexture(GL_TEXTURE_2D, yTextureName);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0,
GL_ALPHA, GL_UNSIGNED_BYTE, ytex);
GL_ALPHA, GL_UNSIGNED_BYTE, ytex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, uTextureName);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w >> 1, h >> 1, 0,
GL_ALPHA, GL_UNSIGNED_BYTE, utex);
GL_ALPHA, GL_UNSIGNED_BYTE, utex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, vTextureName);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w >> 1, h >> 1, 0,
GL_ALPHA, GL_UNSIGNED_BYTE, vtex);
GL_ALPHA, GL_UNSIGNED_BYTE, vtex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, yTextureName);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h,
GL_ALPHA, GL_UNSIGNED_BYTE, ytex);
GL_ALPHA, GL_UNSIGNED_BYTE, ytex);
glBindTexture(GL_TEXTURE_2D, uTextureName);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w >> 1, h >> 1,
GL_ALPHA, GL_UNSIGNED_BYTE, utex);
GL_ALPHA, GL_UNSIGNED_BYTE, utex);
glBindTexture(GL_TEXTURE_2D, vTextureName);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w >> 1, h >> 1,
GL_ALPHA, GL_UNSIGNED_BYTE, vtex);
GL_ALPHA, GL_UNSIGNED_BYTE, vtex);
delete [] ytex;
delete [] utex;
@ -946,7 +939,6 @@ movieHasEnded:
glUseProgram(0);
glDisable(GL_BLEND);
Wait_Frame();
@ -971,10 +963,8 @@ movieHasEnded:
for (int i = 0; i < 10; i++) Wait_Frame();
huntKillFreeSound(fileNumber);
if (vpx_codec_destroy(&codec))
die_codec(&codec, "Failed to destroy codec");
die_codec(&codec, "Failed to destroy codec");
vorbis_dsp_clear(&vorbisDspState);
vorbis_block_clear(&vorbisBlock);

4
engines/sludge/movie.h
View File

@ -28,9 +28,7 @@ namespace Sludge {
movieIsPlaying tracks the state of movie playing
*/
enum movieStates {
nothing = 0,
playing,
paused
nothing = 0, playing, paused
};
extern movieStates movieIsPlaying;

43
engines/sludge/newfatal.cpp
View File

@ -41,7 +41,9 @@ namespace Sludge {
const char emergencyMemoryMessage[] = "Out of memory displaying error message!";
static char *fatalMessage = NULL;
static char *fatalInfo = joinStrings("Initialisation error! Something went wrong before we even got started!", "");
static char *fatalInfo =
joinStrings("Initialisation error! Something went wrong before we even got started!",
"");
extern int numResourceNames /* = 0*/;
extern char * *allResourceNames /*= NULL*/;
@ -49,14 +51,18 @@ extern char * *allResourceNames /*= NULL*/;
int resourceForFatal = -1;
const char *resourceNameFromNum(int i) {
if (i == -1) return NULL;
if (numResourceNames == 0) return "RESOURCE";
if (i < numResourceNames) return allResourceNames[i];
if (i == -1)
return NULL;
if (numResourceNames == 0)
return "RESOURCE";
if (i < numResourceNames)
return allResourceNames[i];
return "Unknown resource";
}
bool hasFatal() {
if (fatalMessage) return true;
if (fatalMessage)
return true;
return false;
}
@ -77,7 +83,10 @@ void warning(const char *l) {
void registerWindowForFatal() {
delete fatalInfo;
fatalInfo = joinStrings("There's an error with this SLUDGE game! If you're designing this game, please turn on verbose error messages in the project manager and recompile. If not, please contact the author saying where and how this problem occured.", "");
fatalInfo =
joinStrings(
"There's an error with this SLUDGE game! If you're designing this game, please turn on verbose error messages in the project manager and recompile. If not, please contact the author saying where and how this problem occured.",
"");
}
#if 0
@ -93,8 +102,8 @@ int inFatal(const char *str) {
}
#endif
fatalMessage = copyString(str);
if (fatalMessage == NULL) fatalMessage = copyString("Out of memory");
if (fatalMessage == NULL)
fatalMessage = copyString("Out of memory");
killSoundStuff();
@ -120,8 +129,10 @@ int checkNew(const void *mem) {
void setFatalInfo(const char *userFunc, const char *BIF) {
delete fatalInfo;
fatalInfo = new char [strlen(userFunc) + strlen(BIF) + 38];
if (fatalInfo) sprintf(fatalInfo, "Currently in this sub: %s\nCalling: %s", userFunc, BIF);
fatalInfo = new char[strlen(userFunc) + strlen(BIF) + 38];
if (fatalInfo)
sprintf(fatalInfo, "Currently in this sub: %s\nCalling: %s", userFunc,
BIF);
debug("%s", fatalInfo);
}
@ -132,17 +143,20 @@ void setResourceForFatal(int n) {
int fatal(const char *str1) {
if (numResourceNames && resourceForFatal != -1) {
const char *r = resourceNameFromNum(resourceForFatal);
char *newStr = new char[strlen(str1) + strlen(r) + strlen(fatalInfo) + 14];
char *newStr = new char[strlen(str1) + strlen(r) + strlen(fatalInfo)
+ 14];
if (checkNew(newStr)) {
sprintf(newStr, "%s\nResource: %s\n\n%s", fatalInfo, r, str1);
inFatal(newStr);
} else fatal(emergencyMemoryMessage);
} else
fatal(emergencyMemoryMessage);
} else {
char *newStr = new char[strlen(str1) + strlen(fatalInfo) + 3];
if (checkNew(newStr)) {
sprintf(newStr, "%s\n\n%s", fatalInfo, str1);
inFatal(newStr);
} else fatal(emergencyMemoryMessage);
} else
fatal(emergencyMemoryMessage);
}
return 0;
}
@ -152,7 +166,8 @@ int fatal(const char *str1, const char *str2) {
if (checkNew(newStr)) {
sprintf(newStr, "%s %s", str1, str2);
fatal(newStr);
} else fatal(emergencyMemoryMessage);
} else
fatal(emergencyMemoryMessage);
return 0;
}

68
engines/sludge/objtypes.cpp
View File

@ -42,8 +42,9 @@ objectType *findObjectType(int i) {
objectType *huntType = allObjectTypes;
while (huntType) {
if (huntType -> objectNum == i) return huntType;
huntType = huntType -> next;
if (huntType->objectNum == i)
return huntType;
huntType = huntType->next;
}
return loadObjectType(i);
@ -56,13 +57,13 @@ objectType *loadObjectType(int i) {
if (checkNew(newType)) {
if (openObjectSlice(i)) {
nameNum = get2bytes(bigDataFile);
newType -> r = (byte) getch(bigDataFile);
newType -> g = (byte) getch(bigDataFile);
newType -> b = (byte) getch(bigDataFile);
newType -> speechGap = getch(bigDataFile);
newType -> walkSpeed = getch(bigDataFile);
newType -> wrapSpeech = get4bytes(bigDataFile);
newType -> spinSpeed = get2bytes(bigDataFile);
newType->r = (byte) getch(bigDataFile);
newType->g = (byte) getch(bigDataFile);
newType->b = (byte) getch(bigDataFile);
newType->speechGap = getch(bigDataFile);
newType->walkSpeed = getch(bigDataFile);
newType->wrapSpeech = get4bytes(bigDataFile);
newType->spinSpeed = get2bytes(bigDataFile);
if (gameVersion >= VERSION(1, 6)) {
// aaLoad
@ -72,13 +73,14 @@ objectType *loadObjectType(int i) {
}
if (gameVersion >= VERSION(1, 4)) {
newType -> flags = get2bytes(bigDataFile);
newType->flags = get2bytes(bigDataFile);
} else {
newType -> flags = 0;
newType->flags = 0;
}
newType -> numCom = get2bytes(bigDataFile);
newType -> allCombis = (newType -> numCom) ? new combination[newType -> numCom] : NULL;
newType->numCom = get2bytes(bigDataFile);
newType->allCombis =
(newType->numCom) ? new combination[newType->numCom] : NULL;
#if DEBUG_COMBINATIONS
FILE *callEventLog = fopen("callEventLog.txt", "at");
@ -87,9 +89,9 @@ objectType *loadObjectType(int i) {
}
#endif
for (a = 0; a < newType -> numCom; a ++) {
newType -> allCombis[a].withObj = get2bytes(bigDataFile);
newType -> allCombis[a].funcNum = get2bytes(bigDataFile);
for (a = 0; a < newType->numCom; a++) {
newType->allCombis[a].withObj = get2bytes(bigDataFile);
newType->allCombis[a].funcNum = get2bytes(bigDataFile);
#if DEBUG_COMBINATIONS
if (callEventLog) {
fprintf(callEventLog, "%d(%d) ", newType -> allCombis[a].withObj, newType -> allCombis[a].funcNum);
@ -103,9 +105,9 @@ objectType *loadObjectType(int i) {
}
#endif
finishAccess();
newType -> screenName = getNumberedString(nameNum);
newType -> objectNum = i;
newType -> next = allObjectTypes;
newType->screenName = getNumberedString(nameNum);
newType->objectNum = i;
newType->next = allObjectTypes;
allObjectTypes = newType;
return newType;
}
@ -116,14 +118,14 @@ objectType *loadObjectType(int i) {
objectType *loadObjectRef(Common::SeekableReadStream *stream) {
objectType *r = loadObjectType(get2bytes(stream));
delete r -> screenName;
r -> screenName = readString(stream);
delete r->screenName;
r->screenName = readString(stream);
return r;
}
void saveObjectRef(objectType *r, Common::WriteStream *stream) {
put2bytes(r -> objectNum, stream);
writeString(r -> screenName, stream);
put2bytes(r->objectNum, stream);
writeString(r->screenName, stream);
}
int getCombinationFunction(int withThis, int thisObject) {
@ -137,9 +139,9 @@ int getCombinationFunction(int withThis, int thisObject) {
}
#endif
for (i = 0; i < obj -> numCom; i ++) {
if (obj -> allCombis[i].withObj == withThis) {
num = obj -> allCombis[i].funcNum;
for (i = 0; i < obj->numCom; i++) {
if (obj->allCombis[i].withObj == withThis) {
num = obj->allCombis[i].funcNum;
break;
}
}
@ -155,21 +157,21 @@ int getCombinationFunction(int withThis, int thisObject) {
}
void removeObjectType(objectType *oT) {
objectType * * huntRegion = & allObjectTypes;
objectType * * huntRegion = &allObjectTypes;
while (* huntRegion) {
if ((* huntRegion) == oT) {
while (*huntRegion) {
if ((*huntRegion) == oT) {
// FILE * debuggy2 = fopen ("debug.txt", "at");
// fprintf (debuggy2, "DELETING OBJECT TYPE: %p %s\n", oT, oT -> screenName);
// fclose (debuggy2);
* huntRegion = oT -> next;
delete oT -> allCombis;
delete oT -> screenName;
*huntRegion = oT->next;
delete oT->allCombis;
delete oT->screenName;
delete oT;
return;
} else {
huntRegion = & ((* huntRegion) -> next);
huntRegion = &((*huntRegion)->next);
}
}
fatal("Can't delete object type: bad pointer");

439
engines/sludge/people.cpp
View File

@ -71,7 +71,8 @@ inline int TF_abs(int a) {
}
void setFrames(onScreenPerson &m, int a) {
m.myAnim = m.myPersona->animation[(a * m.myPersona->numDirections) + m.direction];
m.myAnim = m.myPersona->animation[(a * m.myPersona->numDirections)
+ m.direction];
}
personaAnimation *createPersonaAnim(int num, variableStack *&stacky) {
@ -85,15 +86,17 @@ personaAnimation *createPersonaAnim(int num, variableStack *&stacky) {
int a = num, frameNum, howMany;
while (a) {
a --;
a--;
newP->frames[a].noise = 0;
if (stacky->thisVar.varType == SVT_FILE) {
newP->frames[a].noise = stacky->thisVar.varData.intValue;
} else if (stacky->thisVar.varType == SVT_FUNC) {
newP->frames[a].noise = - stacky->thisVar.varData.intValue;
newP->frames[a].noise = -stacky->thisVar.varData.intValue;
} else if (stacky->thisVar.varType == SVT_STACK) {
getValueType(frameNum, SVT_INT, stacky->thisVar.varData.theStack->first->thisVar);
getValueType(howMany, SVT_INT, stacky->thisVar.varData.theStack->first->next->thisVar);
getValueType(frameNum, SVT_INT,
stacky->thisVar.varData.theStack->first->thisVar);
getValueType(howMany, SVT_INT,
stacky->thisVar.varData.theStack->first->next->thisVar);
} else {
getValueType(frameNum, SVT_INT, stacky->thisVar);
howMany = 1;
@ -107,32 +110,34 @@ personaAnimation *createPersonaAnim(int num, variableStack *&stacky) {
}
personaAnimation *makeNullAnim() {
personaAnimation *newAnim = new personaAnimation;
if (!checkNew(newAnim)) return NULL;
personaAnimation *newAnim = new personaAnimation;
if (!checkNew(newAnim))
return NULL;
newAnim->theSprites = NULL;
newAnim->numFrames = 0;
newAnim->frames = NULL;
newAnim->theSprites = NULL;
newAnim->numFrames = 0;
newAnim->frames = NULL;
return newAnim;
}
personaAnimation *copyAnim(personaAnimation *orig) {
int num = orig->numFrames;
personaAnimation *newAnim = new personaAnimation;
if (!checkNew(newAnim)) return NULL;
personaAnimation *newAnim = new personaAnimation;
if (!checkNew(newAnim))
return NULL;
// Copy the easy bits...
newAnim->theSprites = orig->theSprites;
newAnim->numFrames = num;
newAnim->theSprites = orig->theSprites;
newAnim->numFrames = num;
if (num) {
// Argh!Frames!We need a whole NEW array of animFrame structures...
newAnim->frames = new animFrame[num];
if (!checkNew(newAnim->frames)) return NULL;
if (!checkNew(newAnim->frames))
return NULL;
for (int a = 0; a < num; ++a) {
newAnim->frames[a].frameNum = orig->frames[a].frameNum;
@ -161,7 +166,8 @@ void turnMeAngle(onScreenPerson *thisPerson, int direc) {
int d = thisPerson->myPersona->numDirections;
thisPerson->angle = direc;
direc += (180 / d) + 180 + thisPerson->angleOffset;
while (direc >= 360) direc -= 360;
while (direc >= 360)
direc -= 360;
thisPerson->direction = (direc * d) / 360;
}
@ -176,14 +182,17 @@ bool initPeople() {
void spinStep(onScreenPerson *thisPerson) {
int diff = (thisPerson->angle + 360) - thisPerson->wantAngle;
int eachSlice = thisPerson->spinSpeed ? thisPerson->spinSpeed : (360 / thisPerson->myPersona->numDirections);
int eachSlice =
thisPerson->spinSpeed ?
thisPerson->spinSpeed :
(360 / thisPerson->myPersona->numDirections);
while (diff > 180) {
diff -= 360;
}
if (diff >= eachSlice) {
turnMeAngle(thisPerson, thisPerson->angle - eachSlice);
} else if (diff <= - eachSlice) {
} else if (diff <= -eachSlice) {
turnMeAngle(thisPerson, thisPerson->angle + eachSlice);
} else {
turnMeAngle(thisPerson, thisPerson->wantAngle);
@ -194,19 +203,22 @@ void spinStep(onScreenPerson *thisPerson) {
void rethinkAngle(onScreenPerson *thisPerson) {
int d = thisPerson->myPersona->numDirections;
int direc = thisPerson->angle + (180 / d) + 180 + thisPerson->angleOffset;
while (direc >= 360) direc -= 360;
while (direc >= 360)
direc -= 360;
thisPerson->direction = (direc * d) / 360;
}
bool turnPersonToFace(int thisNum, int direc) {
onScreenPerson *thisPerson = findPerson(thisNum);
if (thisPerson) {
if (thisPerson->continueAfterWalking) abortFunction(thisPerson->continueAfterWalking);
if (thisPerson->continueAfterWalking)
abortFunction(thisPerson->continueAfterWalking);
thisPerson->continueAfterWalking = NULL;
thisPerson->walking = false;
thisPerson->spinning = false;
turnMeAngle(thisPerson, direc);
setFrames(* thisPerson, (thisPerson == speech->currentTalker) ? ANI_TALK : ANI_STAND);
setFrames(*thisPerson,
(thisPerson == speech->currentTalker) ? ANI_TALK : ANI_STAND);
return true;
}
return false;
@ -216,7 +228,8 @@ bool setPersonExtra(int thisNum, int extra) {
onScreenPerson *thisPerson = findPerson(thisNum);
if (thisPerson) {
thisPerson->extra = extra;
if (extra & EXTRA_NOSCALE) thisPerson->scale = 1;
if (extra & EXTRA_NOSCALE)
thisPerson->scale = 1;
return true;
}
return false;
@ -230,13 +243,15 @@ void setScale(short int h, short int d) {
void moveAndScale(onScreenPerson &me, float x, float y) {
me.x = x;
me.y = y;
if (!(me.extra & EXTRA_NOSCALE) && scaleDivide) me.scale = (me.y - scaleHorizon) / scaleDivide;
if (!(me.extra & EXTRA_NOSCALE) && scaleDivide)
me.scale = (me.y - scaleHorizon) / scaleDivide;
}
onScreenPerson *findPerson(int v) {
onScreenPerson *thisPerson = allPeople;
while (thisPerson) {
if (v == thisPerson->thisType->objectNum) break;
if (v == thisPerson->thisType->objectNum)
break;
thisPerson = thisPerson->next;
}
return thisPerson;
@ -244,12 +259,14 @@ onScreenPerson *findPerson(int v) {
void movePerson(int x, int y, int objNum) {
onScreenPerson *moveMe = findPerson(objNum);
if (moveMe) moveAndScale(* moveMe, x, y);
if (moveMe)
moveAndScale(*moveMe, x, y);
}
void setShown(bool h, int ob) {
onScreenPerson *moveMe = findPerson(ob);
if (moveMe) moveMe->show = h;
if (moveMe)
moveMe->show = h;
}
enum drawModes {
@ -318,57 +335,57 @@ void setMyDrawMode(onScreenPerson *moveMe, int h) {
moveMe->colourmix = 255;
moveMe->transparency = 0;
break;
case drawModeShadow1:
case drawModeShadow1:
moveMe->r = moveMe->g = moveMe->b = 0;
moveMe->colourmix = 255;
moveMe->transparency = 64;
break;
case drawModeShadow2:
case drawModeShadow2:
moveMe->r = moveMe->g = moveMe->b = 0;
moveMe->colourmix = 255;
moveMe->transparency = 128;
break;
case drawModeShadow3:
case drawModeShadow3:
moveMe->r = moveMe->g = moveMe->b = 0;
moveMe->colourmix = 255;
moveMe->transparency = 192;
break;
case drawModeFoggy3:
case drawModeFoggy3:
moveMe->r = moveMe->g = moveMe->b = 128;
moveMe->colourmix = 192;
moveMe->transparency = 0;
break;
case drawModeFoggy2:
case drawModeFoggy2:
moveMe->r = moveMe->g = moveMe->b = 128;
moveMe->colourmix = 128;
moveMe->transparency = 0;
break;
case drawModeFoggy1:
case drawModeFoggy1:
moveMe->r = moveMe->g = moveMe->b = 128;
moveMe->colourmix = 64;
moveMe->transparency = 0;
break;
case drawModeFoggy4:
case drawModeFoggy4:
moveMe->r = moveMe->g = moveMe->b = 128;
moveMe->colourmix = 255;
moveMe->transparency = 0;
break;
case drawModeGlow3:
case drawModeGlow3:
moveMe->r = moveMe->g = moveMe->b = 255;
moveMe->colourmix = 192;
moveMe->transparency = 0;
break;
case drawModeGlow2:
case drawModeGlow2:
moveMe->r = moveMe->g = moveMe->b = 255;
moveMe->colourmix = 128;
moveMe->transparency = 0;
break;
case drawModeGlow1:
case drawModeGlow1:
moveMe->r = moveMe->g = moveMe->b = 255;
moveMe->colourmix = 64;
moveMe->transparency = 0;
break;
case drawModeGlow4:
case drawModeGlow4:
moveMe->r = moveMe->g = moveMe->b = 255;
moveMe->colourmix = 255;
moveMe->transparency = 0;
@ -384,22 +401,27 @@ void setMyDrawMode(onScreenPerson *moveMe, int h) {
void setDrawMode(int h, int ob) {
onScreenPerson *moveMe = findPerson(ob);
if (!moveMe) return;
if (!moveMe)
return;
setMyDrawMode(moveMe, h);
}
void setPersonTransparency(int ob, unsigned char x) {
onScreenPerson *moveMe = findPerson(ob);
if (!moveMe) return;
if (!moveMe)
return;
if (x > 254) x = 254;
if (x > 254)
x = 254;
moveMe->transparency = x;
}
void setPersonColourise(int ob, unsigned char r, unsigned char g, unsigned char b, unsigned char colourmix) {
void setPersonColourise(int ob, unsigned char r, unsigned char g,
unsigned char b, unsigned char colourmix) {
onScreenPerson *moveMe = findPerson(ob);
if (!moveMe) return;
if (!moveMe)
return;
moveMe->r = r;
moveMe->g = g;
@ -407,37 +429,36 @@ void setPersonColourise(int ob, unsigned char r, unsigned char g, unsigned char
moveMe->colourmix = colourmix;
}
extern screenRegion *overRegion;
void shufflePeople() {
onScreenPerson * * thisReference = & allPeople;
onScreenPerson *A, * B;
onScreenPerson * * thisReference = &allPeople;
onScreenPerson *A, *B;
if (!allPeople) return;
if (!allPeople)
return;
while ((* thisReference)->next) {
float y1 = (* thisReference)->y;
if ((* thisReference)->extra & EXTRA_FRONT) y1 += 1000;
while ((*thisReference)->next) {
float y1 = (*thisReference)->y;
if ((*thisReference)->extra & EXTRA_FRONT)
y1 += 1000;
float y2 = (* thisReference)->next->y;
if ((* thisReference)->next->extra & EXTRA_FRONT) y2 += 1000;
float y2 = (*thisReference)->next->y;
if ((*thisReference)->next->extra & EXTRA_FRONT)
y2 += 1000;
if (y1 > y2) {
A = (* thisReference);
B = (* thisReference)->next;
A = (*thisReference);
B = (*thisReference)->next;
A->next = B->next;
B->next = A;
(* thisReference) = B;
(*thisReference) = B;
} else {
thisReference = & ((* thisReference)->next);
thisReference = &((*thisReference)->next);
}
}
}
void drawPeople() {
shufflePeople();
@ -453,15 +474,20 @@ void drawPeople() {
thisPerson->frameNum = 0;
thisPerson->frameTick = myAnim->frames[0].howMany;
if (myAnim->frames[thisPerson->frameNum].noise > 0) {
startSound(myAnim->frames[thisPerson->frameNum].noise, false);
thisPerson->frameNum ++;
startSound(myAnim->frames[thisPerson->frameNum].noise,
false);
thisPerson->frameNum++;
thisPerson->frameNum %= thisPerson->myAnim->numFrames;
thisPerson->frameTick = thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
thisPerson->frameTick =
thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
} else if (myAnim->frames[thisPerson->frameNum].noise) {
startNewFunctionNum(- myAnim->frames[thisPerson->frameNum].noise, 0, NULL, noStack);
thisPerson->frameNum ++;
startNewFunctionNum(
-myAnim->frames[thisPerson->frameNum].noise, 0,
NULL, noStack);
thisPerson->frameNum++;
thisPerson->frameNum %= thisPerson->myAnim->numFrames;
thisPerson->frameTick = thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
thisPerson->frameTick =
thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
}
}
int fNumSign = myAnim->frames[thisPerson->frameNum].frameNum;
@ -473,31 +499,39 @@ void drawPeople() {
}
if (m != 2) {
bool r = false;
r = scaleSprite(myAnim->theSprites->bank.sprites[fNum], myAnim->theSprites->bank.myPalette, thisPerson, m);
r = scaleSprite(myAnim->theSprites->bank.sprites[fNum],
myAnim->theSprites->bank.myPalette, thisPerson, m);
if (r) {
if (thisPerson->thisType->screenName[0]) {
if (personRegion.thisType != thisPerson->thisType) lastRegion = NULL;
if (personRegion.thisType != thisPerson->thisType)
lastRegion = NULL;
personRegion.thisType = thisPerson->thisType;
overRegion = & personRegion;
overRegion = &personRegion;
}
}
}
}
if (!-- thisPerson->frameTick) {
thisPerson->frameNum ++;
if (!--thisPerson->frameTick) {
thisPerson->frameNum++;
thisPerson->frameNum %= thisPerson->myAnim->numFrames;
thisPerson->frameTick = thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
thisPerson->frameTick =
thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
if (thisPerson->show && myAnim && myAnim->frames) {
if (myAnim->frames[thisPerson->frameNum].noise > 0) {
startSound(myAnim->frames[thisPerson->frameNum].noise, false);
thisPerson->frameNum ++;
startSound(myAnim->frames[thisPerson->frameNum].noise,
false);
thisPerson->frameNum++;
thisPerson->frameNum %= thisPerson->myAnim->numFrames;
thisPerson->frameTick = thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
thisPerson->frameTick =
thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
} else if (myAnim->frames[thisPerson->frameNum].noise) {
startNewFunctionNum(- myAnim->frames[thisPerson->frameNum].noise, 0, NULL, noStack);
thisPerson->frameNum ++;
startNewFunctionNum(
-myAnim->frames[thisPerson->frameNum].noise, 0,
NULL, noStack);
thisPerson->frameNum++;
thisPerson->frameNum %= thisPerson->myAnim->numFrames;
thisPerson->frameTick = thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
thisPerson->frameTick =
thisPerson->myAnim->frames[thisPerson->frameNum].howMany;
}
}
}
@ -514,22 +548,27 @@ void makeSilent(onScreenPerson &me) {
}
bool handleClosestPoint(int &setX, int &setY, int &setPoly) {
int gotX = 320, gotY = 200, gotPoly = -1, i, j, xTest1, yTest1,
xTest2, yTest2, closestX, closestY, oldJ, currentDistance = 0xFFFFF,
thisDistance;
int gotX = 320, gotY = 200, gotPoly = -1, i, j, xTest1, yTest1, xTest2,
yTest2, closestX, closestY, oldJ, currentDistance = 0xFFFFF,
thisDistance;
// FILE * dbug = fopen ("debug_closest.txt", "at");
// fprintf (dbug, "\nGetting closest point to %i, %i\n", setX, setY);
for (i = 0; i < currentFloor->numPolygons; i ++) {
for (i = 0; i < currentFloor->numPolygons; i++) {
oldJ = currentFloor->polygon[i].numVertices - 1;
for (j = 0; j < currentFloor->polygon[i].numVertices; j ++) {
for (j = 0; j < currentFloor->polygon[i].numVertices; j++) {
// fprintf (dbug, "Polygon %i, line %i... ", i, j);
xTest1 = currentFloor->vertex[currentFloor->polygon[i].vertexID[j]].x;
yTest1 = currentFloor->vertex[currentFloor->polygon[i].vertexID[j]].y;
xTest2 = currentFloor->vertex[currentFloor->polygon[i].vertexID[oldJ]].x;
yTest2 = currentFloor->vertex[currentFloor->polygon[i].vertexID[oldJ]].y;
closestPointOnLine(closestX, closestY, xTest1, yTest1, xTest2, yTest2, setX, setY);
xTest1 =
currentFloor->vertex[currentFloor->polygon[i].vertexID[j]].x;
yTest1 =
currentFloor->vertex[currentFloor->polygon[i].vertexID[j]].y;
xTest2 =
currentFloor->vertex[currentFloor->polygon[i].vertexID[oldJ]].x;
yTest2 =
currentFloor->vertex[currentFloor->polygon[i].vertexID[oldJ]].y;
closestPointOnLine(closestX, closestY, xTest1, yTest1, xTest2,
yTest2, setX, setY);
// fprintf (dbug, "closest point is %i, %i... ", closestX, closestY);
xTest1 = setX - closestX;
yTest1 = setY - closestY;
@ -549,7 +588,8 @@ bool handleClosestPoint(int &setX, int &setY, int &setPoly) {
}
// fclose (dbug);
if (gotPoly == -1) return false;
if (gotPoly == -1)
return false;
setX = gotX;
setY = gotY;
setPoly = gotPoly;
@ -565,11 +605,13 @@ bool doBorderStuff(onScreenPerson *moveMe) {
} else {
// The section in which we need to be next...
int newPoly = currentFloor->matrix[moveMe->inPoly][moveMe->walkToPoly];
if (newPoly == -1) return false;
if (newPoly == -1)
return false;
// Grab the index of the second matching corner...
int ID, ID2;
if (!getMatchingCorners(currentFloor->polygon[moveMe->inPoly], currentFloor->polygon[newPoly], ID, ID2))
if (!getMatchingCorners(currentFloor->polygon[moveMe->inPoly],
currentFloor->polygon[newPoly], ID, ID2))
return fatal("Not a valid floor plan!");
// Remember that we're walking to the new polygon...
@ -605,8 +647,8 @@ bool doBorderStuff(onScreenPerson *moveMe) {
dy23 *= dy23;
dy24 *= dy24;
if (sqrt((double) dx13 + dy13) + sqrt((double) dx23 + dy23) <
sqrt((double) dx14 + dy14) + sqrt((double) dx24 + dy24)) {
if (sqrt((double) dx13 + dy13) + sqrt((double) dx23 + dy23)
< sqrt((double) dx14 + dy14) + sqrt((double) dx24 + dy24)) {
moveMe->thisStepX = x3;
moveMe->thisStepY = y3;
} else {
@ -623,7 +665,7 @@ bool doBorderStuff(onScreenPerson *moveMe) {
moveMe->spinning = true;
}
setFrames(* moveMe, ANI_WALK);
setFrames(*moveMe, ANI_WALK);
return true;
}
@ -634,20 +676,22 @@ bool walkMe(onScreenPerson *thisPerson, bool move = true) {
xDiff = thisPerson->thisStepX - thisPerson->x;
yDiff = (thisPerson->thisStepY - thisPerson->y) * 2;
s = thisPerson->scale * thisPerson->walkSpeed;
if (s < 0.2) s = 0.2;
if (s < 0.2)
s = 0.2;
maxDiff = (TF_abs(xDiff) >= TF_abs(yDiff)) ? TF_abs(xDiff) : TF_abs(yDiff);
maxDiff =
(TF_abs(xDiff) >= TF_abs(yDiff)) ?
TF_abs(xDiff) : TF_abs(yDiff);
if (TF_abs(maxDiff) > s) {
if (thisPerson->spinning) {
spinStep(thisPerson);
setFrames(* thisPerson, ANI_WALK);
setFrames(*thisPerson, ANI_WALK);
}
s = maxDiff / s;
if (move)
moveAndScale(* thisPerson,
thisPerson->x + xDiff / s,
thisPerson->y + yDiff / (s * 2));
moveAndScale(*thisPerson, thisPerson->x + xDiff / s,
thisPerson->y + yDiff / (s * 2));
return true;
}
@ -659,24 +703,27 @@ bool walkMe(onScreenPerson *thisPerson, bool move = true) {
}
break;
}
if (!doBorderStuff(thisPerson)) break;
if (!doBorderStuff(thisPerson))
break;
}
thisPerson->walking = false;
setFrames(* thisPerson, ANI_STAND);
moveAndScale(* thisPerson,
thisPerson->walkToX,
thisPerson->walkToY);
setFrames(*thisPerson, ANI_STAND);
moveAndScale(*thisPerson, thisPerson->walkToX, thisPerson->walkToY);
return false;
}
bool makeWalkingPerson(int x, int y, int objNum, loadedFunction *func, int di) {
if (x == 0 && y == 0) return false;
if (currentFloor->numPolygons == 0) return false;
if (x == 0 && y == 0)
return false;
if (currentFloor->numPolygons == 0)
return false;
onScreenPerson *moveMe = findPerson(objNum);
if (!moveMe) return false;
if (!moveMe)
return false;
if (moveMe->continueAfterWalking) abortFunction(moveMe->continueAfterWalking);
if (moveMe->continueAfterWalking)
abortFunction(moveMe->continueAfterWalking);
moveMe->continueAfterWalking = NULL;
moveMe->walking = true;
moveMe->directionWhenDoneWalking = di;
@ -685,13 +732,16 @@ bool makeWalkingPerson(int x, int y, int objNum, loadedFunction *func, int di) {
moveMe->walkToY = y;
moveMe->walkToPoly = inFloor(x, y);
if (moveMe->walkToPoly == -1) {
if (!handleClosestPoint(moveMe->walkToX, moveMe->walkToY, moveMe->walkToPoly)) return false;
if (!handleClosestPoint(moveMe->walkToX, moveMe->walkToY,
moveMe->walkToPoly))
return false;
}
moveMe->inPoly = inFloor(moveMe->x, moveMe->y);
if (moveMe->inPoly == -1) {
int xxx = moveMe->x, yyy = moveMe->y;
if (!handleClosestPoint(xxx, yyy, moveMe->inPoly)) return false;
if (!handleClosestPoint(xxx, yyy, moveMe->inPoly))
return false;
}
doBorderStuff(moveMe);
@ -711,18 +761,22 @@ bool stopPerson(int o) {
moveMe->continueAfterWalking = NULL;
moveMe->walking = false;
moveMe->spinning = false;
setFrames(* moveMe, ANI_STAND);
setFrames(*moveMe, ANI_STAND);
return true;
}
return false;
}
bool forceWalkingPerson(int x, int y, int objNum, loadedFunction *func, int di) {
if (x == 0 && y == 0) return false;
bool forceWalkingPerson(int x, int y, int objNum, loadedFunction *func,
int di) {
if (x == 0 && y == 0)
return false;
onScreenPerson *moveMe = findPerson(objNum);
if (!moveMe) return false;
if (!moveMe)
return false;
if (moveMe->continueAfterWalking) abortFunction(moveMe->continueAfterWalking);
if (moveMe->continueAfterWalking)
abortFunction(moveMe->continueAfterWalking);
moveMe->walking = true;
moveMe->continueAfterWalking = NULL;
moveMe->directionWhenDoneWalking = di;
@ -745,27 +799,33 @@ bool forceWalkingPerson(int x, int y, int objNum, loadedFunction *func, int di)
}
void jumpPerson(int x, int y, int objNum) {
if (x == 0 && y == 0) return;
if (x == 0 && y == 0)
return;
onScreenPerson *moveMe = findPerson(objNum);
if (!moveMe) return;
if (moveMe->continueAfterWalking) abortFunction(moveMe->continueAfterWalking);
if (!moveMe)
return;
if (moveMe->continueAfterWalking)
abortFunction(moveMe->continueAfterWalking);
moveMe->continueAfterWalking = NULL;
moveMe->walking = false;
moveMe->spinning = false;
moveAndScale(* moveMe, x, y);
moveAndScale(*moveMe, x, y);
}
bool floatCharacter(int f, int objNum) {
onScreenPerson *moveMe = findPerson(objNum);
if (!moveMe) return false;
if (!moveMe)
return false;
moveMe->floaty = f;
return true;
}
bool setCharacterWalkSpeed(int f, int objNum) {
if (f <= 0) return false;
if (f <= 0)
return false;
onScreenPerson *moveMe = findPerson(objNum);
if (!moveMe) return false;
if (!moveMe)
return false;
moveMe->walkSpeed = f;
return true;
}
@ -778,9 +838,10 @@ void walkAllPeople() {
walkMe(thisPerson);
} else if (thisPerson->spinning) {
spinStep(thisPerson);
setFrames(* thisPerson, ANI_STAND);
setFrames(*thisPerson, ANI_STAND);
}
if ((!thisPerson->walking) && (!thisPerson->spinning) && thisPerson->continueAfterWalking) {
if ((!thisPerson->walking) && (!thisPerson->spinning)
&& thisPerson->continueAfterWalking) {
restartFunction(thisPerson->continueAfterWalking);
thisPerson->continueAfterWalking = NULL;
}
@ -790,14 +851,15 @@ void walkAllPeople() {
bool addPerson(int x, int y, int objNum, persona *p) {
onScreenPerson *newPerson = new onScreenPerson;
if (!checkNew(newPerson)) return false;
if (!checkNew(newPerson))
return false;
// EASY STUFF
newPerson->thisType = loadObjectType(objNum);
newPerson->scale = 1;
newPerson->extra = 0;
newPerson->continueAfterWalking = NULL;
moveAndScale(* newPerson, x, y);
moveAndScale(*newPerson, x, y);
newPerson->frameNum = 0;
newPerson->walkToX = x;
newPerson->walkToY = y;
@ -819,7 +881,7 @@ bool addPerson(int x, int y, int objNum, persona *p) {
newPerson->transparency = 0;
newPerson->myPersona = p;
setFrames(* newPerson, ANI_STAND);
setFrames(*newPerson, ANI_STAND);
// HEIGHT (BASED ON 1st FRAME OF 1st ANIMATION... INC. SPECIAL CASES)
int fNumSigned = p->animation[0]->frames[0].frameNum;
@ -828,22 +890,24 @@ bool addPerson(int x, int y, int objNum, persona *p) {
if (fNumSigned < 0) {
newPerson->height = 5;
} else {
newPerson->height = p->animation[0]->theSprites->bank.sprites[0].yhot + 5;
newPerson->height =
p->animation[0]->theSprites->bank.sprites[0].yhot + 5;
}
} else {
newPerson->height = p->animation[0]->theSprites->bank.sprites[fNum].yhot + 5;
newPerson->height = p->animation[0]->theSprites->bank.sprites[fNum].yhot
+ 5;
}
// NOW ADD IT IN THE RIGHT PLACE
onScreenPerson * * changethat = & allPeople;
onScreenPerson * * changethat = &allPeople;
while (((* changethat) != NULL) && ((* changethat)->y < y))
changethat = & ((* changethat)->next);
while (((*changethat) != NULL) && ((*changethat)->y < y))
changethat = &((*changethat)->next);
newPerson->next = (* changethat);
(* changethat) = newPerson;
newPerson->next = (*changethat);
(*changethat) = newPerson;
return (bool)(newPerson->thisType != NULL);
return (bool) (newPerson->thisType != NULL);
}
int timeForAnim(personaAnimation *fram) {
@ -854,10 +918,11 @@ int timeForAnim(personaAnimation *fram) {
return total;
}
void animatePerson(int obj, personaAnimation *fram) { // Set a new SINGLE animation
void animatePerson(int obj, personaAnimation *fram) { // Set a new SINGLE animation
onScreenPerson *moveMe = findPerson(obj);
if (moveMe) {
if (moveMe->continueAfterWalking) abortFunction(moveMe->continueAfterWalking);
if (moveMe->continueAfterWalking)
abortFunction(moveMe->continueAfterWalking);
moveMe->continueAfterWalking = NULL;
moveMe->walking = false;
moveMe->spinning = false;
@ -874,10 +939,10 @@ void animatePerson(int obj, persona *per) { // Set a new costume
moveMe->spinning = false;
moveMe->myPersona = per;
rethinkAngle(moveMe);
if (moveMe-> walking) {
setFrames(* moveMe, ANI_WALK);
if (moveMe->walking) {
setFrames(*moveMe, ANI_WALK);
} else {
setFrames(* moveMe, ANI_STAND);
setFrames(*moveMe, ANI_STAND);
}
}
}
@ -885,7 +950,8 @@ void animatePerson(int obj, persona *per) { // Set a new costume
void killAllPeople() {
onScreenPerson *killPeople;
while (allPeople) {
if (allPeople->continueAfterWalking) abortFunction(allPeople->continueAfterWalking);
if (allPeople->continueAfterWalking)
abortFunction(allPeople->continueAfterWalking);
allPeople->continueAfterWalking = NULL;
killPeople = allPeople;
allPeople = allPeople->next;
@ -896,19 +962,20 @@ void killAllPeople() {
void killMostPeople() {
onScreenPerson *killPeople;
onScreenPerson * * lookyHere = & allPeople;
onScreenPerson * * lookyHere = &allPeople;
while (* lookyHere) {
if ((* lookyHere)->extra & EXTRA_NOREMOVE) {
lookyHere = & (* lookyHere)->next;
while (*lookyHere) {
if ((*lookyHere)->extra & EXTRA_NOREMOVE) {
lookyHere = &(*lookyHere)->next;
} else {
killPeople = (* lookyHere);
killPeople = (*lookyHere);
// Change last pointer to NEXT in the list instead
(* lookyHere) = killPeople->next;
(*lookyHere) = killPeople->next;
// Gone from the list... now free some memory
if (killPeople->continueAfterWalking) abortFunction(killPeople->continueAfterWalking);
if (killPeople->continueAfterWalking)
abortFunction(killPeople->continueAfterWalking);
killPeople->continueAfterWalking = NULL;
removeObjectType(killPeople->thisType);
delete killPeople;
@ -920,21 +987,22 @@ void removeOneCharacter(int i) {
onScreenPerson *p = findPerson(i);
if (p) {
if (overRegion == &personRegion && overRegion->thisType == p->thisType) {
if (overRegion == &personRegion
&& overRegion->thisType == p->thisType) {
overRegion = NULL;
}
if (p->continueAfterWalking) abortFunction(p->continueAfterWalking);
if (p->continueAfterWalking)
abortFunction(p->continueAfterWalking);
p->continueAfterWalking = NULL;
onScreenPerson * * killPeople;
for (killPeople = & allPeople;
* killPeople != p;
killPeople = & ((* killPeople)->next)) {
for (killPeople = &allPeople; *killPeople != p; killPeople =
&((*killPeople)->next)) {
;
}
* killPeople = p->next;
*killPeople = p->next;
removeObjectType(p->thisType);
delete p;
}
@ -960,7 +1028,8 @@ bool loadAnim(personaAnimation *p, Common::SeekableReadStream *stream) {
if (p->numFrames) {
int a = get4bytes(stream);
p->frames = new animFrame[p->numFrames];
if (!checkNew(p->frames)) return false;
if (!checkNew(p->frames))
return false;
p->theSprites = loadBankForAnim(a);
for (a = 0; a < p->numFrames; ++a) {
@ -979,25 +1048,26 @@ bool loadAnim(personaAnimation *p, Common::SeekableReadStream *stream) {
return true;
}
/*
void debugCostume (char * message, persona * cossy) {
FILE * db = fopen ("debuTURN.txt", "at");
fprintf (db, " %s costume with %i directions...\n", message, cossy->numDirections);
for (int a = 0; a < cossy->numDirections * 3; ++a) {
fprintf (db, " %i frames:", cossy->animation[a]->numFrames);
for (int b = 0; b < cossy->animation[a]->numFrames; b ++) {
fprintf (db, " %i", cossy->animation[a]->frames[b]);
}
fprintf (db, "\n");
void debugCostume (char * message, persona * cossy) {
FILE * db = fopen ("debuTURN.txt", "at");
fprintf (db, " %s costume with %i directions...\n", message, cossy->numDirections);
for (int a = 0; a < cossy->numDirections * 3; ++a) {
fprintf (db, " %i frames:", cossy->animation[a]->numFrames);
for (int b = 0; b < cossy->animation[a]->numFrames; b ++) {
fprintf (db, " %i", cossy->animation[a]->frames[b]);
}
fprintf (db, "\n");
}
fclose (db);
}
*/
}
fclose (db);
}
*/
bool saveCostume(persona *cossy, Common::WriteStream *stream) {
int a;
put2bytes(cossy->numDirections, stream);
for (a = 0; a < cossy->numDirections * 3; ++a) {
if (!saveAnim(cossy->animation[a], stream)) return false;
if (!saveAnim(cossy->animation[a], stream))
return false;
}
// debugCostume ("Saved", cossy);
return true;
@ -1006,13 +1076,16 @@ bool saveCostume(persona *cossy, Common::WriteStream *stream) {
bool loadCostume(persona *cossy, Common::SeekableReadStream *stream) {
int a;
cossy->numDirections = get2bytes(stream);
cossy->animation = new personaAnimation * [cossy->numDirections * 3];
if (!checkNew(cossy->animation)) return false;
cossy->animation = new personaAnimation *[cossy->numDirections * 3];
if (!checkNew(cossy->animation))
return false;
for (a = 0; a < cossy->numDirections * 3; ++a) {
cossy->animation[a] = new personaAnimation;
if (!checkNew(cossy->animation[a])) return false;
if (!checkNew(cossy->animation[a]))
return false;
if (!loadAnim(cossy->animation[a], stream)) return false;
if (!loadAnim(cossy->animation[a], stream))
return false;
}
// debugCostume ("Loaded", cossy);
return true;
@ -1026,7 +1099,7 @@ bool savePeople(Common::WriteStream *stream) {
putSigned(scaleDivide, stream);
while (me) {
countPeople ++;
countPeople++;
me = me->next;
}
@ -1086,7 +1159,7 @@ bool savePeople(Common::WriteStream *stream) {
}
bool loadPeople(Common::SeekableReadStream *stream) {
onScreenPerson * * pointy = & allPeople;
onScreenPerson * * pointy = &allPeople;
onScreenPerson *me;
scaleHorizon = getSigned(stream);
@ -1098,13 +1171,16 @@ bool loadPeople(Common::SeekableReadStream *stream) {
allPeople = NULL;
for (a = 0; a < countPeople; ++a) {
me = new onScreenPerson;
if (!checkNew(me)) return false;
if (!checkNew(me))
return false;
me->myPersona = new persona;
if (!checkNew(me->myPersona)) return false;
if (!checkNew(me->myPersona))
return false;
me->myAnim = new personaAnimation;
if (!checkNew(me->myAnim)) return false;
if (!checkNew(me->myAnim))
return false;
me->x = getFloat(stream);
me->y = getFloat(stream);
@ -1132,7 +1208,8 @@ bool loadPeople(Common::SeekableReadStream *stream) {
me->spinning = getch(stream);
if (getch(stream)) {
me->continueAfterWalking = loadFunction(stream);
if (!me->continueAfterWalking) return false;
if (!me->continueAfterWalking)
return false;
} else {
me->continueAfterWalking = NULL;
}
@ -1169,8 +1246,8 @@ bool loadPeople(Common::SeekableReadStream *stream) {
}
me->next = NULL;
* pointy = me;
pointy = & (me->next);
*pointy = me;
pointy = &(me->next);
}
// db ("End of loadPeople");
return true;

11
engines/sludge/people.h
View File

@ -96,13 +96,16 @@ void makeSilent(onScreenPerson &me);
void setShown(bool h, int ob);
void setDrawMode(int h, int ob);
void setPersonTransparency(int ob, unsigned char x);
void setPersonColourise(int ob, unsigned char r, unsigned char g, unsigned char b, unsigned char colourmix);
void setPersonColourise(int ob, unsigned char r, unsigned char g,
unsigned char b, unsigned char colourmix);
// Moving 'em
void movePerson(int x, int y, int objNum);
bool makeWalkingPerson(int x, int y, int objNum, struct loadedFunction *func, int di);
bool forceWalkingPerson(int x, int y, int objNum, struct loadedFunction *func, int di);
bool makeWalkingPerson(int x, int y, int objNum, struct loadedFunction *func,
int di);
bool forceWalkingPerson(int x, int y, int objNum, struct loadedFunction *func,
int di);
void jumpPerson(int x, int y, int objNum);
void walkAllPeople();
bool turnPersonToFace(int thisNum, int direc);
@ -116,7 +119,7 @@ void animatePerson(int obj, personaAnimation *);
void animatePerson(int obj, persona *per);
personaAnimation *createPersonaAnim(int num, struct variableStack *&stacky);
inline void setBankFile(personaAnimation *newP, loadedSpriteBank *sB) {
newP -> theSprites = sB;
newP->theSprites = sB;
}
bool setPersonExtra(int f, int newSetting);
int timeForAnim(personaAnimation *fram);

41
engines/sludge/region.cpp
View File

@ -47,19 +47,20 @@ void showBoxes() {
}
void removeScreenRegion(int objectNum) {
screenRegion * * huntRegion = & allScreenRegions;
screenRegion * * huntRegion = &allScreenRegions;
screenRegion *killMe;
while (* huntRegion) {
if ((* huntRegion)->thisType->objectNum == objectNum) {
killMe = * huntRegion;
* huntRegion = killMe->next;
while (*huntRegion) {
if ((*huntRegion)->thisType->objectNum == objectNum) {
killMe = *huntRegion;
*huntRegion = killMe->next;
removeObjectType(killMe->thisType);
if (killMe == overRegion) overRegion = NULL;
if (killMe == overRegion)
overRegion = NULL;
delete killMe;
killMe = NULL;
} else {
huntRegion = & ((* huntRegion)->next);
huntRegion = &((*huntRegion)->next);
}
}
}
@ -69,7 +70,7 @@ void saveRegions(Common::WriteStream *stream) {
screenRegion *thisRegion = allScreenRegions;
while (thisRegion) {
thisRegion = thisRegion->next;
numRegions ++;
numRegions++;
}
put2bytes(numRegions, stream);
thisRegion = allScreenRegions;
@ -91,12 +92,12 @@ void loadRegions(Common::SeekableReadStream *stream) {
int numRegions = get2bytes(stream);
screenRegion *newRegion;
screenRegion * * pointy = & allScreenRegions;
screenRegion * * pointy = &allScreenRegions;
while (numRegions --) {
while (numRegions--) {
newRegion = new screenRegion;
* pointy = newRegion;
pointy = & (newRegion->next);
*pointy = newRegion;
pointy = &(newRegion->next);
newRegion->x1 = get2bytes(stream);
newRegion->y1 = get2bytes(stream);
@ -107,7 +108,7 @@ void loadRegions(Common::SeekableReadStream *stream) {
newRegion->di = get2bytes(stream);
newRegion->thisType = loadObjectRef(stream);
}
* pointy = NULL;
*pointy = NULL;
}
void killAllRegions() {
@ -121,9 +122,11 @@ void killAllRegions() {
overRegion = NULL;
}
bool addScreenRegion(int x1, int y1, int x2, int y2, int sX, int sY, int di, int objectNum) {
bool addScreenRegion(int x1, int y1, int x2, int y2, int sX, int sY, int di,
int objectNum) {
screenRegion *newRegion = new screenRegion;
if (!checkNew(newRegion)) return false;
if (!checkNew(newRegion))
return false;
newRegion->di = di;
newRegion->x1 = x1;
newRegion->y1 = y1;
@ -134,14 +137,16 @@ bool addScreenRegion(int x1, int y1, int x2, int y2, int sX, int sY, int di, int
newRegion->thisType = loadObjectType(objectNum);
newRegion->next = allScreenRegions;
allScreenRegions = newRegion;
return (bool)(newRegion->thisType != NULL);
return (bool) (newRegion->thisType != NULL);
}
void getOverRegion() {
screenRegion *thisRegion = allScreenRegions;
while (thisRegion) {
if ((input.mouseX >= thisRegion->x1 - cameraX) && (input.mouseY >= thisRegion->y1 - cameraY) &&
(input.mouseX <= thisRegion->x2 - cameraX) && (input.mouseY <= thisRegion->y2 - cameraY)) {
if ((input.mouseX >= thisRegion->x1 - cameraX)
&& (input.mouseY >= thisRegion->y1 - cameraY)
&& (input.mouseX <= thisRegion->x2 - cameraX)
&& (input.mouseY <= thisRegion->y2 - cameraY)) {
overRegion = thisRegion;
return;
}

92
engines/sludge/savedata.cpp
View File

@ -42,30 +42,30 @@ char encode2 = 0;
extern char *gamePath;
/*
void loadSaveDebug (char * com) {
FILE * ffpp = fopen ("debuggy.txt", "at");
fprintf (ffpp, "%s\n", com);
fclose (ffpp);
}
void loadSaveDebug (char * com) {
FILE * ffpp = fopen ("debuggy.txt", "at");
fprintf (ffpp, "%s\n", com);
fclose (ffpp);
}
void loadSaveDebug (char com) {
FILE * ffpp = fopen ("debuggy.txt", "at");
fprintf (ffpp, "%c\n", com);
fclose (ffpp);
}
void loadSaveDebug (char com) {
FILE * ffpp = fopen ("debuggy.txt", "at");
fprintf (ffpp, "%c\n", com);
fclose (ffpp);
}
void loadSaveDebug (int com) {
FILE * ffpp = fopen ("debuggy.txt", "at");
fprintf (ffpp, "%d\n", com);
fclose (ffpp);
}
*/
void loadSaveDebug (int com) {
FILE * ffpp = fopen ("debuggy.txt", "at");
fprintf (ffpp, "%d\n", com);
fclose (ffpp);
}
*/
void writeStringEncoded(const char *s, Common::WriteStream *stream) {
int a, len = strlen(s);
put2bytes(len, stream);
for (a = 0; a < len; a ++) {
for (a = 0; a < len; a++) {
putch(s[a] ^ encode1, stream);
encode1 += encode2;
}
@ -74,9 +74,10 @@ void writeStringEncoded(const char *s, Common::WriteStream *stream) {
char *readStringEncoded(Common::File *fp) {
int a, len = get2bytes(fp);
char *s = new char[len + 1];
if (!checkNew(s)) return NULL;
for (a = 0; a < len; a ++) {
s[a] = (char)(getch(fp) ^ encode1);
if (!checkNew(s))
return NULL;
for (a = 0; a < len; a++) {
s[a] = (char) (getch(fp) ^ encode1);
encode1 += encode2;
}
s[len] = 0;
@ -98,7 +99,7 @@ char *readTextPlain(Common::File *fp) {
if ((gotChar == '\n') || (fp->eos())) {
keepGoing = false;
} else {
stringSize ++;
stringSize++;
}
}
@ -107,7 +108,8 @@ char *readTextPlain(Common::File *fp) {
} else {
fp->seek(startPos, SEEK_SET);
reply = new char[stringSize + 1];
if (reply == NULL) return NULL;
if (reply == NULL)
return NULL;
size_t bytes_read = fp->read(reply, stringSize);
if (bytes_read != stringSize && fp->err()) {
debugOut("Reading error in readTextPlain.\n");
@ -123,7 +125,9 @@ bool fileToStack(char *filename, stackHandler *sH) {
variable stringVar;
stringVar.varType = SVT_NULL;
const char *checker = saveEncoding ? "[Custom data (encoded)]\r\n" : "[Custom data (ASCII)]\n";
const char *checker =
saveEncoding ?
"[Custom data (encoded)]\r\n" : "[Custom data (ASCII)]\n";
Common::File fd;
@ -150,39 +154,42 @@ bool fileToStack(char *filename, stackHandler *sH) {
}
encode1 = (unsigned char) saveEncoding & 255;
encode2 = (unsigned char)(saveEncoding >> 8);
encode2 = (unsigned char) (saveEncoding >> 8);
while (* checker) {
if (getch(&fd) != * checker) {
while (*checker) {
if (getch(&fd) != *checker) {
fd.close();
return fatal(LOAD_ERROR "This isn't a SLUDGE custom data file:", filename);
return fatal(LOAD_ERROR "This isn't a SLUDGE custom data file:",
filename);
}
checker ++;
checker++;
}
if (saveEncoding) {
char *checker = readStringEncoded(&fd);
if (strcmp(checker, "UN<EFBFBD>LO<EFBFBD>CKED")) {
fd.close();
return fatal(LOAD_ERROR "The current file encoding setting does not match the encoding setting used when this file was created:", filename);
return fatal(
LOAD_ERROR "The current file encoding setting does not match the encoding setting used when this file was created:",
filename);
}
delete checker;
checker = NULL;
}
for (;;) {
if (saveEncoding) {
char i = getch(&fd) ^ encode1;
if (fd.eos()) break;
if (fd.eos())
break;
switch (i) {
case 0: {
char *g = readStringEncoded(&fd);
makeTextVar(stringVar, g);
delete g;
}
break;
break;
case 1:
setVariable(stringVar, SVT_INT, get4bytes(&fd));
@ -199,18 +206,21 @@ bool fileToStack(char *filename, stackHandler *sH) {
}
} else {
char *line = readTextPlain(&fd);
if (!line) break;
if (!line)
break;
makeTextVar(stringVar, line);
}
if (sH -> first == NULL) {
if (sH->first == NULL) {
// Adds to the TOP of the array... oops!
if (!addVarToStackQuick(stringVar, sH -> first)) return false;
sH -> last = sH -> first;
if (!addVarToStackQuick(stringVar, sH->first))
return false;
sH->last = sH->first;
} else {
// Adds to the END of the array... much better
if (!addVarToStackQuick(stringVar, sH -> last -> next)) return false;
sH -> last = sH -> last -> next;
if (!addVarToStackQuick(stringVar, sH->last->next))
return false;
sH->last = sH->last->next;
}
}
fd.close();
@ -238,12 +248,12 @@ bool stackToFile(char *filename, const variable &from) {
while (hereWeAre) {
if (saveEncoding) {
switch (hereWeAre -> thisVar.varType) {
case SVT_STRING:
case SVT_STRING:
fputc(encode1, fp);
writeStringEncoded(hereWeAre -> thisVar.varData.theString, fp);
break;
case SVT_INT:
case SVT_INT:
// Small enough to be stored as a char
if (hereWeAre -> thisVar.varData.intValue >= 0 && hereWeAre -> thisVar.varData.intValue < 256) {
fputc(2 ^ encode1, fp);
@ -254,7 +264,7 @@ bool stackToFile(char *filename, const variable &from) {
}
break;
default:
default:
fatal("Can't create an encoded custom data file containing anything other than numbers and strings", filename);
fclose(fp);
return false;

14
engines/sludge/sludge.h
View File

@ -30,7 +30,7 @@
#include "sludge/console.h"
namespace Sludge {
class SludgeConsole;
struct SludgeGameDescription;
@ -43,8 +43,8 @@ enum {
kSludgeDebugBuiltin = 1 << 3,
kSludgeDebugGraphics = 1 << 4
};
class SludgeEngine : public Engine {
class SludgeEngine: public Engine {
protected:
// Engine APIs
virtual Common::Error run();
@ -52,19 +52,19 @@ protected:
public:
SludgeEngine(OSystem *syst, const SludgeGameDescription *gameDesc);
virtual ~SludgeEngine();
int getGameType() const;
const char *getGameId() const;
uint32 getFeatures() const;
Common::Language getLanguage() const;
const SludgeGameDescription *_gameDescription;
private:
SludgeConsole *_console;
Common::RandomSource *_rnd;
Common::RandomSource *_rnd;
};
} // End of namespace Sludge
#endif

543
engines/sludge/sludger.cpp
View File

File diff suppressed because it is too large Load Diff

29
engines/sludge/sludger.h
View File

@ -59,17 +59,17 @@ struct lineOfCode {
};
struct loadedFunction {
int originalNumber;
lineOfCode *compiledLines;
int numLocals, timeLeft, numArgs;
variable *localVars;
variableStack *stack;
variable reg;
unsigned int runThisLine;
loadedFunction *calledBy;
loadedFunction *next;
bool returnSomething, isSpeech, unfreezable, cancelMe;
unsigned char freezerLevel;
int originalNumber;
lineOfCode *compiledLines;
int numLocals, timeLeft, numArgs;
variable *localVars;
variableStack *stack;
variable reg;
unsigned int runThisLine;
loadedFunction *calledBy;
loadedFunction *next;
bool returnSomething, isSpeech, unfreezable, cancelMe;
unsigned char freezerLevel;
};
struct inputType {
@ -80,10 +80,10 @@ struct inputType {
extern unsigned char *gameIcon;
extern int iconW, iconH;
bool initSludge(char *);
void sludgeDisplay();
int startNewFunctionNum(unsigned int, unsigned int, loadedFunction *, variableStack*&, bool = true);
int startNewFunctionNum(unsigned int, unsigned int, loadedFunction *,
variableStack*&, bool = true);
bool handleInput();
void restartFunction(loadedFunction *fun);
bool loadFunctionCode(loadedFunction *newFunc);
@ -92,7 +92,8 @@ void saveHandlers(Common::WriteStream *stream);
void finishFunction(loadedFunction *fun);
void abortFunction(loadedFunction *fun);
Common::File *openAndVerify(char *filename, char extra1, char extra2, const char *er, int &fileVersion);
Common::File *openAndVerify(char *filename, char extra1, char extra2,
const char *er, int &fileVersion);
void freezeSubs();
void unfreezeSubs();

143
engines/sludge/sound_bass.cpp
View File

@ -49,9 +49,11 @@ soundThing soundCache[MAX_SAMPLES];
int defVol = 128;
int defSoundVol = 255;
char *loadEntireFileToMemory(Common::SeekableReadStream *inputFile, uint32_t size) {
char *loadEntireFileToMemory(Common::SeekableReadStream *inputFile,
uint32_t size) {
char *allData = new char[size];
if (!allData) return NULL;
if (!allData)
return NULL;
inputFile->read(allData, size);
finishAccess();
@ -68,15 +70,17 @@ void stopMOD(int i) {
int findInSoundCache(int a) {
int i;
for (i = 0; i < MAX_SAMPLES; i ++) {
if (soundCache[i].fileLoaded == a) return i;
for (i = 0; i < MAX_SAMPLES; i++) {
if (soundCache[i].fileLoaded == a)
return i;
}
return -1;
}
void huntKillSound(int filenum) {
int gotSlot = findInSoundCache(filenum);
if (gotSlot == -1) return;
if (gotSlot == -1)
return;
soundCache[gotSlot].looping = false;
BASS_SampleStop(soundCache[gotSlot].sample);
}
@ -90,7 +94,8 @@ void freeSound(int a) {
void huntKillFreeSound(int filenum) {
int gotSlot = findInSoundCache(filenum);
if (gotSlot != -1) freeSound(gotSlot);
if (gotSlot != -1)
freeSound(gotSlot);
}
bool initSoundStuff(HWND hwnd) {
@ -119,8 +124,10 @@ bool initSoundStuff(HWND hwnd) {
void killSoundStuff() {
if (soundOK) {
int a;
for (a = 0; a < MAX_MODS; a ++) stopMOD(a);
for (a = 0; a < MAX_SAMPLES; a ++) freeSound(a);
for (a = 0; a < MAX_MODS; a++)
stopMOD(a);
for (a = 0; a < MAX_SAMPLES; a++)
freeSound(a);
BASS_Free();
}
}
@ -132,13 +139,19 @@ bool playMOD(int f, int a, int fromTrack) {
setResourceForFatal(f);
uint32_t length = openFileFromNum(f);
if (length == 0) return NULL;
if (length == 0)
return NULL;
char *memImage;
memImage = loadEntireFileToMemory(bigDataFile, length);
if (!memImage) return fatal(ERROR_MUSIC_MEMORY_LOW);
if (!memImage)
return fatal(ERROR_MUSIC_MEMORY_LOW);
mod[a] = BASS_MusicLoad(true, memImage, 0, length, BASS_MUSIC_LOOP | BASS_MUSIC_RAMP/*|BASS_MUSIC_PRESCAN needed too if we're going to set the position in bytes*/, 0);
mod[a] =
BASS_MusicLoad(true, memImage, 0, length,
BASS_MUSIC_LOOP
| BASS_MUSIC_RAMP/*|BASS_MUSIC_PRESCAN needed too if we're going to set the position in bytes*/,
0);
delete memImage;
if (!mod[a]) {
@ -149,8 +162,10 @@ bool playMOD(int f, int a, int fromTrack) {
if (!BASS_ChannelPlay(mod[a], true))
debugOut("playMOD: Error %d!\n", BASS_ErrorGetCode());
BASS_ChannelSetPosition(mod[a], MAKELONG(fromTrack, 0), BASS_POS_MUSIC_ORDER);
BASS_ChannelFlags(mod[a], BASS_SAMPLE_LOOP | BASS_MUSIC_RAMP, BASS_SAMPLE_LOOP | BASS_MUSIC_RAMP);
BASS_ChannelSetPosition(mod[a], MAKELONG(fromTrack, 0),
BASS_POS_MUSIC_ORDER);
BASS_ChannelFlags(mod[a], BASS_SAMPLE_LOOP | BASS_MUSIC_RAMP,
BASS_SAMPLE_LOOP | BASS_MUSIC_RAMP);
}
setResourceForFatal(-1);
}
@ -160,7 +175,8 @@ bool playMOD(int f, int a, int fromTrack) {
void setMusicVolume(int a, int v) {
int ret;
if (soundOK && mod[a]) {
ret = BASS_ChannelSetAttribute(mod[a], BASS_ATTRIB_VOL, (float) v / 256);
ret = BASS_ChannelSetAttribute(mod[a], BASS_ATTRIB_VOL,
(float) v / 256);
if (!ret) {
debugOut("setMusicVolume: Error %d\n", BASS_ErrorGetCode());
}
@ -176,7 +192,8 @@ void setSoundVolume(int a, int v) {
int ch = findInSoundCache(a);
if (ch != -1) {
if (BASS_ChannelIsActive(soundCache[ch].mostRecentChannel)) {
BASS_ChannelSetAttribute(soundCache[ch].mostRecentChannel, BASS_ATTRIB_VOL, (float) v / 256);
BASS_ChannelSetAttribute(soundCache[ch].mostRecentChannel,
BASS_ATTRIB_VOL, (float) v / 256);
}
}
}
@ -186,7 +203,8 @@ bool stillPlayingSound(int ch) {
if (soundOK)
if (ch != -1)
if (soundCache[ch].fileLoaded != -1)
if (BASS_ChannelIsActive(soundCache[ch].mostRecentChannel) != BASS_ACTIVE_STOPPED)
if (BASS_ChannelIsActive(soundCache[ch].mostRecentChannel)
!= BASS_ACTIVE_STOPPED)
return true;
return false;
}
@ -212,8 +230,8 @@ int emptySoundSlot = 0;
int findEmptySoundSlot() {
int t;
for (t = 0; t < MAX_SAMPLES; t ++) {
emptySoundSlot ++;
for (t = 0; t < MAX_SAMPLES; t++) {
emptySoundSlot++;
emptySoundSlot %= MAX_SAMPLES;
if (!soundCache[emptySoundSlot].sample)
return emptySoundSlot;
@ -221,15 +239,16 @@ int findEmptySoundSlot() {
// Argh!They're all playing!Let's trash the oldest that's not looping...
for (t = 0; t < MAX_SAMPLES; t ++) {
emptySoundSlot ++;
for (t = 0; t < MAX_SAMPLES; t++) {
emptySoundSlot++;
emptySoundSlot %= MAX_SAMPLES;
if (!soundCache[emptySoundSlot].looping) return emptySoundSlot;
if (!soundCache[emptySoundSlot].looping)
return emptySoundSlot;
}
// Holy crap, they're all looping!What's this twat playing at?
emptySoundSlot ++;
emptySoundSlot++;
emptySoundSlot %= MAX_SAMPLES;
return emptySoundSlot;
}
@ -237,15 +256,15 @@ int findEmptySoundSlot() {
int guessSoundFree = 0;
/*
void soundWarning (char * t, int i) {
FILE * u = fopen ("soundlog.txt", "at");
fprintf (u, "%s: %i\n", t, i);
fclose (u);
}
*/
void soundWarning (char * t, int i) {
FILE * u = fopen ("soundlog.txt", "at");
fprintf (u, "%s: %i\n", t, i);
fclose (u);
}
*/
bool forceRemoveSound() {
for (int a = 0; a < 8; a ++) {
for (int a = 0; a < 8; a++) {
if (soundCache[a].fileLoaded != -1 && !stillPlayingSound(a)) {
// soundWarning ("Deleting silent sound", a);
freeSound(a);
@ -253,7 +272,7 @@ bool forceRemoveSound() {
}
}
for (int a = 0; a < 8; a ++) {
for (int a = 0; a < 8; a++) {
if (soundCache[a].fileLoaded != -1) {
// soundWarning ("Deleting playing sound", a);
freeSound(a);
@ -267,16 +286,20 @@ bool forceRemoveSound() {
int cacheSound(int f) {
setResourceForFatal(f);
if (!soundOK) return 0;
if (!soundOK)
return 0;
int a = findInSoundCache(f);
if (a != -1) return a;
if (f == -2) return -1;
if (a != -1)
return a;
if (f == -2)
return -1;
a = findEmptySoundSlot();
freeSound(a);
uint32_t length = openFileFromNum(f);
if (!length) return -1;
if (!length)
return -1;
char *memImage;
@ -295,7 +318,8 @@ int cacheSound(int f) {
for (;;) {
// soundWarning (" Trying to load sound into slot", a);
soundCache[a].sample = BASS_SampleLoad(true, memImage, 0, length, 65535, 0);
soundCache[a].sample = BASS_SampleLoad(true, memImage, 0, length, 65535,
0);
if (soundCache[a].sample) {
soundCache[a].fileLoaded = f;
@ -315,17 +339,21 @@ int cacheSound(int f) {
bool startSound(int f, bool loopy) {
if (soundOK) {
int a = cacheSound(f);
if (a == -1) return false;
if (a == -1)
return false;
soundCache[a].looping = loopy;
soundCache[a].vol = defSoundVol;
soundCache[a].mostRecentChannel = BASS_SampleGetChannel(soundCache[a].sample, false);
soundCache[a].mostRecentChannel = BASS_SampleGetChannel(
soundCache[a].sample, false);
if (soundCache[a].mostRecentChannel) {
BASS_ChannelPlay(soundCache[a].mostRecentChannel, true);
BASS_ChannelSetAttribute(soundCache[a].mostRecentChannel, BASS_ATTRIB_VOL, defSoundVol);
BASS_ChannelSetAttribute(soundCache[a].mostRecentChannel,
BASS_ATTRIB_VOL, defSoundVol);
if (loopy) {
BASS_ChannelFlags(soundCache[a].mostRecentChannel, BASS_SAMPLE_LOOP, BASS_SAMPLE_LOOP); // set LOOP flag
BASS_ChannelFlags(soundCache[a].mostRecentChannel,
BASS_SAMPLE_LOOP, BASS_SAMPLE_LOOP); // set LOOP flag
}
}
@ -334,22 +362,22 @@ bool startSound(int f, bool loopy) {
}
/*
void debugSounds () {
FILE * fp = fopen ("newdebug.txt", "at");
if (fp) {
for (int aa = 0; aa < 32; aa ++) {
if (aa == EFFECT_CHANNELS) fprintf (fp, "|");
fprintf (fp, FSOUND_IsPlaying (aa) ? "#" : ".");
}
fprintf (fp, "\n");
fclose (fp);
}
}
// */
void debugSounds () {
FILE * fp = fopen ("newdebug.txt", "at");
if (fp) {
for (int aa = 0; aa < 32; aa ++) {
if (aa == EFFECT_CHANNELS) fprintf (fp, "|");
fprintf (fp, FSOUND_IsPlaying (aa) ? "#" : ".");
}
fprintf (fp, "\n");
fclose (fp);
}
}
// */
void saveSounds(Common::WriteStream *stream) {
if (soundOK) {
for (int i = 0; i < MAX_SAMPLES; i ++) {
for (int i = 0; i < MAX_SAMPLES; i++) {
if (soundCache[i].looping) {
putch(1, stream);
put2bytes(soundCache[i].fileLoaded, stream);
@ -363,7 +391,8 @@ void saveSounds(Common::WriteStream *stream) {
}
void loadSounds(Common::SeekableReadStream *stream) {
for (int i = 0; i < MAX_SAMPLES; i ++) freeSound(i);
for (int i = 0; i < MAX_SAMPLES; i++)
freeSound(i);
while (getch(stream)) {
int fileLoaded = get2bytes(stream);
@ -379,11 +408,13 @@ bool getSoundCacheStack(stackHandler *sH) {
variable newFileHandle;
newFileHandle.varType = SVT_NULL;
for (int a = 0; a < MAX_SAMPLES; a ++) {
for (int a = 0; a < MAX_SAMPLES; a++) {
if (soundCache[a].fileLoaded != -1) {
setVariable(newFileHandle, SVT_FILE, soundCache[a].fileLoaded);
if (!addVarToStackQuick(newFileHandle, sH -> first)) return false;
if (sH -> last == NULL) sH -> last = sH -> first;
if (!addVarToStackQuick(newFileHandle, sH->first))
return false;
if (sH->last == NULL)
sH->last = sH->first;
}
}
return true;

134
engines/sludge/sound_openal.cpp
View File

@ -97,7 +97,8 @@ bool initSoundStuff(HWND hwnd) {
}
void killSoundStuff() {
if (! soundOK) return;
if (!soundOK)
return;
#if 0
SilenceIKillYou = true;
for (int i = 0; i < MAX_SAMPLES; i ++) {
@ -105,7 +106,7 @@ void killSoundStuff() {
if (! alureStopSource(soundCache[i].playingOnSource, AL_TRUE)) {
debugOut("Failed to stop source: %s\n",
alureGetErrorString());
alureGetErrorString());
}
}
@ -114,7 +115,7 @@ void killSoundStuff() {
if (! alureDestroyStream(soundCache[i].stream, 0, NULL)) {
debugOut("Failed to destroy stream: %s\n",
alureGetErrorString());
alureGetErrorString());
}
}
@ -125,7 +126,7 @@ void killSoundStuff() {
if (! alureStopSource(modCache[i].playingOnSource, AL_TRUE)) {
debugOut("Failed to stop source: %s\n",
alureGetErrorString());
alureGetErrorString());
}
}
@ -134,7 +135,7 @@ void killSoundStuff() {
if (! alureDestroyStream(modCache[i].stream, 0, NULL)) {
debugOut("Failed to destroy stream: %s\n",
alureGetErrorString());
alureGetErrorString());
}
}
@ -151,7 +152,8 @@ void killSoundStuff() {
*/
void setMusicVolume(int a, int v) {
if (! soundOK) return;
if (!soundOK)
return;
if (modCache[a].playing) {
#if 0
@ -165,7 +167,8 @@ void setDefaultMusicVolume(int v) {
}
void setSoundVolume(int a, int v) {
if (! soundOK) return;
if (!soundOK)
return;
int ch = findInSoundCache(a);
if (ch != -1) {
if (soundCache[ch].playing) {
@ -218,7 +221,7 @@ static void mod_eos_callback(void *cacheIndex, ALuint source) {
if (! alureDestroyStream(modCache[*a].stream, 0, NULL)) {
debugOut("Failed to destroy stream: %s\n",
alureGetErrorString());
alureGetErrorString());
}
modCache[*a].stream = NULL;
@ -232,7 +235,7 @@ static void mod_eos_callback(void *cacheIndex, ALuint source) {
int findInSoundCache(int a) {
int i;
for (i = 0; i < MAX_SAMPLES; i ++) {
for (i = 0; i < MAX_SAMPLES; i++) {
if (soundCache[i].fileLoaded == a) {
return i;
}
@ -241,7 +244,8 @@ int findInSoundCache(int a) {
}
void stopMOD(int i) {
if (! soundOK) return;
if (!soundOK)
return;
#if 0
alGetError();
if (modCache[i].playing) {
@ -253,7 +257,8 @@ void stopMOD(int i) {
}
void huntKillSound(int filenum) {
if (! soundOK) return;
if (!soundOK)
return;
#if 0
// Clear OpenAL errors to make sure they don't block anything:
alGetError();
@ -273,7 +278,8 @@ void huntKillSound(int filenum) {
}
void freeSound(int a) {
if (! soundOK) return;
if (!soundOK)
return;
#if 0
// Clear OpenAL errors to make sure they don't block anything:
alGetError();
@ -283,12 +289,12 @@ void freeSound(int a) {
if (soundCache[a].playing) {
if (! alureStopSource(soundCache[a].playingOnSource, AL_TRUE)) {
debugOut("Failed to stop source: %s\n",
alureGetErrorString());
alureGetErrorString());
}
}
if (! alureDestroyStream(soundCache[a].stream, 0, NULL)) {
debugOut("Failed to destroy stream: %s\n",
alureGetErrorString());
alureGetErrorString());
}
soundCache[a].stream = NULL;
@ -297,11 +303,12 @@ void freeSound(int a) {
SilenceIKillYou = false;
}
void huntKillFreeSound(int filenum) {
if (! soundOK) return;
if (!soundOK)
return;
int gotSlot = findInSoundCache(filenum);
if (gotSlot == -1) return;
if (gotSlot == -1)
return;
freeSound(gotSlot);
}
@ -339,10 +346,10 @@ void playStream(int a, bool isMOD, bool loopy) {
if (loopy) {
ok = alurePlaySourceStream(src, (*st).stream,
NUM_BUFS, -1, eos_callback, &intpointers[a]);
NUM_BUFS, -1, eos_callback, &intpointers[a]);
} else {
ok = alurePlaySourceStream(src, (*st).stream,
NUM_BUFS, 0, eos_callback, &intpointers[a]);
NUM_BUFS, 0, eos_callback, &intpointers[a]);
}
if (!ok) {
@ -361,9 +368,11 @@ void playStream(int a, bool isMOD, bool loopy) {
#endif
}
char *loadEntireFileToMemory(Common::SeekableReadStream *inputFile, uint32_t size) {
char *loadEntireFileToMemory(Common::SeekableReadStream *inputFile,
uint32_t size) {
char *allData = new char[size];
if (! allData) return NULL;
if (!allData)
return NULL;
size_t bytes_read = inputFile->read(allData, size);
if (bytes_read != size && inputFile->err()) {
@ -376,7 +385,8 @@ char *loadEntireFileToMemory(Common::SeekableReadStream *inputFile, uint32_t siz
}
bool playMOD(int f, int a, int fromTrack) {
if (! soundOK) return true;
if (!soundOK)
return true;
stopMOD(a);
setResourceForFatal(f);
@ -400,7 +410,7 @@ bool playMOD(int f, int a, int fromTrack) {
if (! alureSetStreamOrder(modCache[a].stream, fromTrack)) {
debugOut("Failed to set stream order: %s\n",
alureGetErrorString());
alureGetErrorString());
}
playStream(a, true, true);
@ -408,7 +418,7 @@ bool playMOD(int f, int a, int fromTrack) {
} else {
debugOut("Failed to create stream from MOD: %s\n",
alureGetErrorString());
alureGetErrorString());
warning(ERROR_MUSIC_ODDNESS);
soundCache[a].stream = NULL;
@ -431,15 +441,15 @@ bool stillPlayingSound(int ch) {
}
bool forceRemoveSound() {
for (int a = 0; a < MAX_SAMPLES; a ++) {
if (soundCache[a].fileLoaded != -1 && ! stillPlayingSound(a)) {
for (int a = 0; a < MAX_SAMPLES; a++) {
if (soundCache[a].fileLoaded != -1 && !stillPlayingSound(a)) {
// soundWarning ("Deleting silent sound", a);
freeSound(a);
return 1;
}
}
for (int a = 0; a < MAX_SAMPLES; a ++) {
for (int a = 0; a < MAX_SAMPLES; a++) {
if (soundCache[a].fileLoaded != -1) {
// soundWarning ("Deleting playing sound", a);
freeSound(a);
@ -454,17 +464,17 @@ int emptySoundSlot = 0;
int findEmptySoundSlot() {
int t;
for (t = 0; t < MAX_SAMPLES; t ++) {
emptySoundSlot ++;
for (t = 0; t < MAX_SAMPLES; t++) {
emptySoundSlot++;
emptySoundSlot %= MAX_SAMPLES;
#if 0
if (soundCache[emptySoundSlot].stream == NULL)
return emptySoundSlot;
return emptySoundSlot;
#endif
}
for (t = 0; t < MAX_SAMPLES; t ++) {
emptySoundSlot ++;
for (t = 0; t < MAX_SAMPLES; t++) {
emptySoundSlot++;
emptySoundSlot %= MAX_SAMPLES;
if (!soundCache[emptySoundSlot].playing)
return emptySoundSlot;
@ -472,22 +482,24 @@ int findEmptySoundSlot() {
// Argh! They're all playing! Let's trash the oldest that's not looping...
for (t = 0; t < MAX_SAMPLES; t ++) {
emptySoundSlot ++;
for (t = 0; t < MAX_SAMPLES; t++) {
emptySoundSlot++;
emptySoundSlot %= MAX_SAMPLES;
if (! soundCache[emptySoundSlot].looping) return emptySoundSlot;
if (!soundCache[emptySoundSlot].looping)
return emptySoundSlot;
}
// Holy crap, they're all looping! What's this twat playing at?
emptySoundSlot ++;
emptySoundSlot++;
emptySoundSlot %= MAX_SAMPLES;
return emptySoundSlot;
}
int cacheSound(int f) {
if (! soundOK) return -1;
if (!soundOK)
return -1;
unsigned int chunkLength;
int retval;
@ -506,12 +518,12 @@ int cacheSound(int f) {
if (soundCache[a].playing) {
if (! alureStopSource(soundCache[a].playingOnSource, AL_TRUE)) {
debugOut("Failed to stop source: %s\n",
alureGetErrorString());
alureGetErrorString());
}
}
if (! alureRewindStream(soundCache[a].stream)) {
debugOut("Failed to rewind stream: %s\n",
alureGetErrorString());
alureGetErrorString());
}
return a;
@ -560,7 +572,7 @@ int cacheSound(int f) {
} else {
debugOut("Failed to create stream from sound: %s\n",
alureGetErrorString());
alureGetErrorString());
warning(ERROR_SOUND_ODDNESS);
soundCache[a].stream = NULL;
@ -592,7 +604,7 @@ bool startSound(int f, bool loopy) {
void saveSounds(Common::WriteStream *stream) {
if (soundOK) {
for (int i = 0; i < MAX_SAMPLES; i ++) {
for (int i = 0; i < MAX_SAMPLES; i++) {
if (soundCache[i].looping) {
putch(1, stream);
put2bytes(soundCache[i].fileLoaded, stream);
@ -606,7 +618,8 @@ void saveSounds(Common::WriteStream *stream) {
}
void loadSounds(Common::SeekableReadStream *stream) {
for (int i = 0; i < MAX_SAMPLES; i ++) freeSound(i);
for (int i = 0; i < MAX_SAMPLES; i++)
freeSound(i);
while (getch(stream)) {
int fileLoaded = get2bytes(stream);
@ -622,11 +635,13 @@ bool getSoundCacheStack(stackHandler *sH) {
variable newFileHandle;
newFileHandle.varType = SVT_NULL;
for (int a = 0; a < MAX_SAMPLES; a ++) {
for (int a = 0; a < MAX_SAMPLES; a++) {
if (soundCache[a].fileLoaded != -1) {
setVariable(newFileHandle, SVT_FILE, soundCache[a].fileLoaded);
if (! addVarToStackQuick(newFileHandle, sH -> first)) return false;
if (sH -> last == NULL) sH -> last = sH -> first;
if (!addVarToStackQuick(newFileHandle, sH->first))
return false;
if (sH->last == NULL)
sH->last = sH->first;
}
}
return true;
@ -634,19 +649,22 @@ bool getSoundCacheStack(stackHandler *sH) {
soundList *deleteSoundFromList(soundList *s) {
// Don't delete a playing sound.
if (s->cacheIndex) return NULL;
if (s->cacheIndex)
return NULL;
soundList *o = NULL;
if (! s->next) {
if (!s->next) {
o = s->prev;
if (o) o-> next = NULL;
if (o)
o->next = NULL;
delete s;
return o;
}
if (s != s->next) {
o = s->next;
o->prev = s->prev;
if (o->prev) o->prev->next = o;
if (o->prev)
o->prev->next = o;
}
delete s;
return o;
@ -699,9 +717,9 @@ void playSoundList(soundList *s) {
}
soundCache[a].looping = false;
if (s->vol < 0)
soundCache[a].vol = defSoundVol;
soundCache[a].vol = defSoundVol;
else
soundCache[a].vol = s->vol;
soundCache[a].vol = s->vol;
s-> cacheIndex = a;
ALboolean ok;
@ -719,7 +737,7 @@ void playSoundList(soundList *s) {
alSourcef(src, AL_GAIN, (float) soundCache[a].vol / 256);
ok = alurePlaySourceStream(src, (*st).stream,
NUM_BUFS, 0, list_eos_callback, s);
NUM_BUFS, 0, list_eos_callback, s);
if (!ok) {
@ -753,7 +771,7 @@ void playMovieStream(int a) {
alSourcef(src, AL_GAIN, (float) soundCache[a].vol / 256);
ok = alurePlaySourceStream(src, soundCache[a].stream,
10, 0, sound_eos_callback, &intpointers[a]);
10, 0, sound_eos_callback, &intpointers[a]);
if (!ok) {
debugOut("Failed to play stream: %s\n", alureGetErrorString());
alDeleteSources(1, &src);
@ -771,7 +789,7 @@ void playMovieStream(int a) {
#if 0
int initMovieSound(int f, ALenum format, int audioChannels, ALuint samplerate,
ALuint(*callback)(void *userdata, ALubyte *data, ALuint bytes)) {
ALuint(*callback)(void *userdata, ALubyte *data, ALuint bytes)) {
if (! soundOK) return 0;
int retval;
@ -782,9 +800,9 @@ int initMovieSound(int f, ALenum format, int audioChannels, ALuint samplerate,
#if 0
// audioChannel * sampleRate gives us a buffer of half a second. Not much, but it should be enough.
soundCache[a].stream = alureCreateStreamFromCallback(
callback,
&intpointers[a], format, samplerate,
audioChannels * samplerate, 0, NULL);
callback,
&intpointers[a], format, samplerate,
audioChannels * samplerate, 0, NULL);
#endif
if (soundCache[a].stream != NULL) {
soundCache[a].fileLoaded = f;
@ -793,7 +811,7 @@ int initMovieSound(int f, ALenum format, int audioChannels, ALuint samplerate,
} else {
#if 0
debugOut("Failed to create stream from sound: %s\n",
alureGetErrorString());
alureGetErrorString());
#endif
warning(ERROR_SOUND_ODDNESS);
soundCache[a].stream = NULL;

25
engines/sludge/sprbanks.cpp
View File

@ -31,42 +31,43 @@ loadedSpriteBank *allLoadedBanks = NULL;
extern spriteBank theFont;
extern int loadedFontNum, fontTableSize;
loadedSpriteBank *loadBankForAnim(int ID) {
//debugOut ("loadBankForAnim: Looking for sprite bank with ID %d\n", ID);
loadedSpriteBank *returnMe = allLoadedBanks;
while (returnMe) {
if (returnMe -> ID == ID) {
if (returnMe->ID == ID) {
//debugOut ("loadBankForAnim: Found existing sprite bank with ID %d\n", returnMe -> ID);
return returnMe;
}
returnMe = returnMe -> next;
returnMe = returnMe->next;
}
returnMe = new loadedSpriteBank;
//debugOut ("loadBankForAnim: No existing sprite bank with ID %d\n", ID);
if (checkNew(returnMe)) {
returnMe -> ID = ID;
if (loadSpriteBank(ID, returnMe -> bank, false)) {
returnMe -> timesUsed = 0;
returnMe -> next = allLoadedBanks;
returnMe->ID = ID;
if (loadSpriteBank(ID, returnMe->bank, false)) {
returnMe->timesUsed = 0;
returnMe->next = allLoadedBanks;
allLoadedBanks = returnMe;
debugOut("loadBankForAnim: New sprite bank created OK\n");
return returnMe;
} else {
debugOut("loadBankForAnim: I guess I couldn't load the sprites...\n");
debugOut(
"loadBankForAnim: I guess I couldn't load the sprites...\n");
return NULL;
}
} else return NULL;
} else
return NULL;
}
void reloadSpriteTextures() {
loadedSpriteBank *spriteBank = allLoadedBanks;
while (spriteBank) {
//fprintf (stderr, "Reloading bank %d: %s.\n", spriteBank->ID, resourceNameFromNum (spriteBank->ID));
delete spriteBank-> bank.sprites;
spriteBank-> bank.sprites = NULL;
delete spriteBank->bank.sprites;
spriteBank->bank.sprites = NULL;
loadSpriteBank(spriteBank->ID, spriteBank->bank, false);
spriteBank = spriteBank -> next;
spriteBank = spriteBank->next;
}
if (fontTableSize) {
delete theFont.sprites;

212
engines/sludge/sprites.cpp
View File

@ -57,7 +57,6 @@ extern float cameraZoom;
unsigned char currentBurnR = 0, currentBurnG = 0, currentBurnB = 0;
void forgetSpriteBank(spriteBank &forgetme) {
#if 0
deleteTextures(forgetme.myPalette.numTextures, forgetme.myPalette.tex_names);
@ -70,49 +69,53 @@ void forgetSpriteBank(spriteBank &forgetme) {
delete [] forgetme.myPalette.tex_names;
forgetme.myPalette.tex_names = NULL;
#endif
delete [] forgetme.myPalette.tex_w;
delete[] forgetme.myPalette.tex_w;
forgetme.myPalette.tex_w = NULL;
delete [] forgetme.myPalette.tex_h;
delete[] forgetme.myPalette.tex_h;
forgetme.myPalette.tex_h = NULL;
if (forgetme.myPalette.pal) {
delete [] forgetme.myPalette.pal;
delete[] forgetme.myPalette.pal;
forgetme.myPalette.pal = NULL;
delete [] forgetme.myPalette.r;
delete[] forgetme.myPalette.r;
forgetme.myPalette.r = NULL;
delete [] forgetme.myPalette.g;
delete[] forgetme.myPalette.g;
forgetme.myPalette.g = NULL;
delete [] forgetme.myPalette.b;
delete[] forgetme.myPalette.b;
forgetme.myPalette.b = NULL;
}
delete forgetme.sprites;
forgetme.sprites = NULL;
// TODO: also remove sprite bank from allLoadedBanks
// And add a function call for this function to the scripting language
}
bool reserveSpritePal(spritePalette &sP, int n) {
if (sP.pal) {
delete [] sP.pal;
delete [] sP.r;
delete [] sP.g;
delete [] sP.b;
delete[] sP.pal;
delete[] sP.r;
delete[] sP.g;
delete[] sP.b;
}
sP.pal = new unsigned short int [n];
if (! checkNew(sP.pal)) return false;
sP.pal = new unsigned short int[n];
if (!checkNew(sP.pal))
return false;
sP.r = new unsigned char [n];
if (! checkNew(sP.r)) return false;
sP.g = new unsigned char [n];
if (! checkNew(sP.g)) return false;
sP.b = new unsigned char [n];
if (! checkNew(sP.b)) return false;
sP.r = new unsigned char[n];
if (!checkNew(sP.r))
return false;
sP.g = new unsigned char[n];
if (!checkNew(sP.g))
return false;
sP.b = new unsigned char[n];
if (!checkNew(sP.b))
return false;
sP.total = n;
return (bool)(sP.pal != NULL) && (sP.r != NULL) && (sP.g != NULL) && (sP.b != NULL);
return (bool) (sP.pal != NULL) && (sP.r != NULL) && (sP.g != NULL)
&& (sP.b != NULL);
}
bool loadSpriteBank(int fileNum, spriteBank &loadhere, bool isFont) {
@ -173,60 +176,60 @@ bool loadSpriteBank(int fileNum, spriteBank &loadhere, bool isFont) {
for (i = 0; i < total; i ++) {
switch (spriteBankVersion) {
case 3: {
loadhere.sprites[i].xhot = getSigned(bigDataFile);
loadhere.sprites[i].yhot = getSigned(bigDataFile);
case 3: {
loadhere.sprites[i].xhot = getSigned(bigDataFile);
loadhere.sprites[i].yhot = getSigned(bigDataFile);
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return fatal("Can't open sprite bank / font.");
}
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return fatal("Can't open sprite bank / font.");
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
return fatal("Can't open sprite bank / font.");
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
return fatal("Can't open sprite bank / font.");
}
png_infop end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return fatal("Can't open sprite bank / font.");
}
png_init_io(png_ptr, bigDataFile); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8); // No sig
png_infop end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return fatal("Can't open sprite bank / font.");
}
png_init_io(png_ptr, bigDataFile); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8);// No sig
png_read_info(png_ptr, info_ptr);
png_read_info(png_ptr, info_ptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
unsigned char *row_pointers[height];
spriteData[i] = new unsigned char [rowbytes * height];
if (! checkNew(spriteData[i])) return false;
unsigned char *row_pointers[height];
spriteData[i] = new unsigned char [rowbytes * height];
if (! checkNew(spriteData[i])) return false;
for (unsigned int row = 0; row < height; row++)
for (unsigned int row = 0; row < height; row++)
row_pointers[row] = spriteData[i] + row * rowbytes;
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
picwidth = loadhere.sprites[i].width = width;
picheight = loadhere.sprites[i].height = height;
break;
}
case 2:
picwidth = loadhere.sprites[i].width = width;
picheight = loadhere.sprites[i].height = height;
break;
}
case 2:
picwidth = get2bytes(bigDataFile);
picheight = get2bytes(bigDataFile);
loadhere.sprites[i].xhot = getSigned(bigDataFile);
loadhere.sprites[i].yhot = getSigned(bigDataFile);
break;
default:
default:
picwidth = (byte) fgetc(bigDataFile);
picheight = (byte) fgetc(bigDataFile);
loadhere.sprites[i].xhot = fgetc(bigDataFile);
@ -256,27 +259,27 @@ bool loadSpriteBank(int fileNum, spriteBank &loadhere, bool isFont) {
}
spriteData[i] = data;
switch (spriteBankVersion) {
case 2: { // RUN LENGTH COMPRESSED DATA
unsigned size = picwidth * picheight;
unsigned pip = 0;
case 2: { // RUN LENGTH COMPRESSED DATA
unsigned size = picwidth * picheight;
unsigned pip = 0;
while (pip < size) {
byte col = fgetc(bigDataFile);
int looper;
while (pip < size) {
byte col = fgetc(bigDataFile);
int looper;
if (col > howmany) {
col -= howmany + 1;
looper = fgetc(bigDataFile) + 1;
} else looper = 1;
if (col > howmany) {
col -= howmany + 1;
looper = fgetc(bigDataFile) + 1;
} else looper = 1;
while (looper --) {
data[pip ++] = col;
while (looper --) {
data[pip ++] = col;
}
}
}
}
break;
break;
default: // RAW DATA
default: // RAW DATA
size_t bytes_read = fread(data, picwidth, picheight, bigDataFile);
if (bytes_read != picwidth * picheight && ferror(bigDataFile)) {
debugOut("Reading error in loadSpriteBank.\n");
@ -287,7 +290,6 @@ bool loadSpriteBank(int fileNum, spriteBank &loadhere, bool isFont) {
}
numTextures++;
if (! spriteBankVersion) {
howmany = fgetc(bigDataFile);
startIndex = fgetc(bigDataFile);
@ -368,9 +370,9 @@ bool loadSpriteBank(int fileNum, spriteBank &loadhere, bool isFont) {
target[1] = (GLubyte) 255;
target[2] = (GLubyte) 255;
if (s)
target[3] = (GLubyte) loadhere.myPalette.r[s];
target[3] = (GLubyte) loadhere.myPalette.r[s];
/*else
target[3] = (GLubyte) 0;*/
target[3] = (GLubyte) 0;*/
}
} else {
target[0] = (GLubyte) spriteData[i][fromhere++];
@ -390,7 +392,7 @@ bool loadSpriteBank(int fileNum, spriteBank &loadhere, bool isFont) {
glGenTextures(numTextures, loadhere.myPalette.tex_names);
if (isFont)
glGenTextures(numTextures, loadhere.myPalette.burnTex_names);
glGenTextures(numTextures, loadhere.myPalette.burnTex_names);
#endif
@ -436,7 +438,8 @@ bool loadSpriteBank(int fileNum, spriteBank &loadhere, bool isFont) {
return true;
}
void pasteSpriteToBackDrop(int x1, int y1, sprite &single, const spritePalette &fontPal) {
void pasteSpriteToBackDrop(int x1, int y1, sprite &single,
const spritePalette &fontPal) {
#if 0
float tx1 = (float)(single.tex_x) / fontPal.tex_w[single.texNum];
float ty1 = 0.0;
@ -490,7 +493,6 @@ void pasteSpriteToBackDrop(int x1, int y1, sprite &single, const spritePalette &
while (yoffset < diffY) {
int h = (diffY - yoffset < viewportHeight) ? diffY - yoffset : viewportHeight;
// Render the sprite to the backdrop
// (using mulitexturing, so the backdrop is seen where alpha < 1.0)
glActiveTexture(GL_TEXTURE2);
@ -499,7 +501,7 @@ void pasteSpriteToBackDrop(int x1, int y1, sprite &single, const spritePalette &
glUseProgram(shader.paste);
GLint uniform = glGetUniformLocation(shader.paste, "useLightTexture");
if (uniform >= 0) glUniform1i(uniform, 0); // No lighting
if (uniform >= 0) glUniform1i(uniform, 0);// No lighting
setPMVMatrix(shader.paste);
@ -536,7 +538,8 @@ void pasteSpriteToBackDrop(int x1, int y1, sprite &single, const spritePalette &
setPixelCoords(false);
}
void burnSpriteToBackDrop(int x1, int y1, sprite &single, const spritePalette &fontPal) {
void burnSpriteToBackDrop(int x1, int y1, sprite &single,
const spritePalette &fontPal) {
#if 0
float tx1 = (float)(single.tex_x - 0.5) / fontPal.tex_w[single.texNum];
float ty1 = 0.0;
@ -626,7 +629,7 @@ void burnSpriteToBackDrop(int x1, int y1, sprite &single, const spritePalette &f
glBindTexture(GL_TEXTURE_2D, fontPal.burnTex_names[single.texNum]);
//FIXME: Test this some more. Also pasting the backdrop again is not strictly necessary but allows using the paste shader.
drawQuad(shader.paste, spriteVertices, 3, spriteTexCoords, NULL, backdropTexCoords);
drawQuad(shader.paste, spriteVertices, 3, spriteTexCoords, NULL, backdropTexCoords);
glUseProgram(0);
// Copy Our ViewPort To The Texture
@ -644,17 +647,19 @@ void burnSpriteToBackDrop(int x1, int y1, sprite &single, const spritePalette &f
extern GLuint backdropTextureName;
#endif
void fontSprite(bool flip, int x, int y, sprite &single, const spritePalette &fontPal) {
void fontSprite(bool flip, int x, int y, sprite &single,
const spritePalette &fontPal) {
float tx1 = (float)(single.tex_x - 0.5) / fontPal.tex_w[single.texNum];
float tx1 = (float) (single.tex_x - 0.5) / fontPal.tex_w[single.texNum];
float ty1 = 0.0;
float tx2 = (float)(single.tex_x + single.width + (flip ? 1.0 : 0.5)) / fontPal.tex_w[single.texNum];
float ty2 = (float)(single.height + 2) / fontPal.tex_h[single.texNum];
float tx2 = (float) (single.tex_x + single.width + (flip ? 1.0 : 0.5))
/ fontPal.tex_w[single.texNum];
float ty2 = (float) (single.height + 2) / fontPal.tex_h[single.texNum];
float x1 = (float)x - (float)single.xhot / cameraZoom;
float y1 = (float)y - (float)single.yhot / cameraZoom;
float x2 = x1 + (float)single.width / cameraZoom;
float y2 = y1 + (float)single.height / cameraZoom;
float x1 = (float) x - (float) single.xhot / cameraZoom;
float y1 = (float) y - (float) single.yhot / cameraZoom;
float x2 = x1 + (float) single.width / cameraZoom;
float y2 = y1 + (float) single.height / cameraZoom;
#if 0
GLfloat vertices[] = {
@ -707,13 +712,11 @@ void fontSprite(int x, int y, sprite &single, const spritePalette &fontPal) {
fontSprite(false, x, y, single, fontPal);
}
void flipFontSprite(int x, int y, sprite &single, const spritePalette &fontPal) {
void flipFontSprite(int x, int y, sprite &single,
const spritePalette &fontPal) {
fontSprite(true, x, y, single, fontPal);
}
unsigned char curLight[3];
void setDrawMode(onScreenPerson *thisPerson) {
@ -734,7 +737,8 @@ extern GLuint backdropTextureName;
bool checkColourChange(bool reset);
bool scaleSprite(sprite &single, const spritePalette &fontPal, onScreenPerson *thisPerson, bool mirror) {
bool scaleSprite(sprite &single, const spritePalette &fontPal,
onScreenPerson *thisPerson, bool mirror) {
#if 0
float x = thisPerson->x;
float y = thisPerson->y;
@ -758,9 +762,9 @@ bool scaleSprite(sprite &single, const spritePalette &fontPal, onScreenPerson *t
x = x / cameraZoom;
y = y / cameraZoom;
if (single.xhot < 0)
x1 = x - (int)((mirror ? (float)(single.width - single.xhot) : (float)(single.xhot + 1)) * scale / cameraZoom);
x1 = x - (int)((mirror ? (float)(single.width - single.xhot) : (float)(single.xhot + 1)) * scale / cameraZoom);
else
x1 = x - (int)((mirror ? (float)(single.width - (single.xhot + 1)) : (float)single.xhot) * scale / cameraZoom);
x1 = x - (int)((mirror ? (float)(single.width - (single.xhot + 1)) : (float)single.xhot) * scale / cameraZoom);
y1 = y - (int)((single.yhot - thisPerson->floaty) * scale / cameraZoom);
x2 = x1 + (int)(diffX / cameraZoom);
y2 = y1 + (int)(diffY / cameraZoom);
@ -768,9 +772,9 @@ bool scaleSprite(sprite &single, const spritePalette &fontPal, onScreenPerson *t
x -= cameraX;
y -= cameraY;
if (single.xhot < 0)
x1 = x - (int)((mirror ? (float)(single.width - single.xhot) : (float)(single.xhot + 1)) * scale);
x1 = x - (int)((mirror ? (float)(single.width - single.xhot) : (float)(single.xhot + 1)) * scale);
else
x1 = x - (int)((mirror ? (float)(single.width - (single.xhot + 1)) : (float)single.xhot) * scale);
x1 = x - (int)((mirror ? (float)(single.width - (single.xhot + 1)) : (float)single.xhot) * scale);
y1 = y - (int)((single.yhot - thisPerson->floaty) * scale);
x2 = x1 + diffX;
y2 = y1 + diffY;
@ -843,7 +847,7 @@ bool scaleSprite(sprite &single, const spritePalette &fontPal, onScreenPerson *t
}
#ifndef HAVE_GLES2
if (!(thisPerson->extra & EXTRA_RECTANGULAR))
checkColourChange(true);
checkColourChange(true);
#endif
setDrawMode(thisPerson);
@ -909,7 +913,8 @@ bool scaleSprite(sprite &single, const spritePalette &fontPal, onScreenPerson *t
}
// Paste a scaled sprite onto the backdrop
void fixScaleSprite(int x, int y, sprite &single, const spritePalette &fontPal, onScreenPerson *thisPerson, int camX, int camY, bool mirror) {
void fixScaleSprite(int x, int y, sprite &single, const spritePalette &fontPal,
onScreenPerson *thisPerson, int camX, int camY, bool mirror) {
#if 0
float scale = thisPerson-> scale;
bool useZB = !(thisPerson->extra & EXTRA_NOZB);
@ -926,9 +931,9 @@ void fixScaleSprite(int x, int y, sprite &single, const spritePalette &fontPal,
int diffY = (int)(((float)single.height) * scale);
int x1;
if (single.xhot < 0)
x1 = x - (int)((mirror ? (float)(single.width - single.xhot) : (float)(single.xhot + 1)) * scale);
x1 = x - (int)((mirror ? (float)(single.width - single.xhot) : (float)(single.xhot + 1)) * scale);
else
x1 = x - (int)((mirror ? (float)(single.width - (single.xhot + 1)) : (float)single.xhot) * scale);
x1 = x - (int)((mirror ? (float)(single.width - (single.xhot + 1)) : (float)single.xhot) * scale);
int y1 = y - (int)((single.yhot - thisPerson->floaty) * scale);
float spriteWidth = diffX;
@ -942,7 +947,6 @@ void fixScaleSprite(int x, int y, sprite &single, const spritePalette &fontPal,
GLfloat z;
if (useZB && zBuffer.numPanels) {
int i;
for (i = 1; i < zBuffer.numPanels; i++) {

37
engines/sludge/sprites.h
View File

@ -51,23 +51,24 @@ public:
GLuint *tex_names;
GLuint *burnTex_names;
#endif
int *tex_w, * tex_h;
int *tex_w, *tex_h;
int numTextures;
unsigned char originalRed, originalGreen, originalBlue, total;
spritePalette(): pal(0), r(0), g(0), b(0)/*, tex_names(0), burnTex_names(0)*/
, tex_w(0), tex_h(0), numTextures(0)
, total(0) {}
spritePalette() :
pal(0), r(0), g(0), b(0)/*, tex_names(0), burnTex_names(0)*/
, tex_w(0), tex_h(0), numTextures(0), total(0) {
}
~spritePalette() {
delete [] pal;
delete [] r;
delete [] g;
delete [] b;
delete[] pal;
delete[] r;
delete[] g;
delete[] b;
// delete [] tex_names;
// delete [] burnTex_names;
delete [] tex_w;
delete [] tex_h;
delete[] tex_w;
delete[] tex_h;
}
};
@ -84,13 +85,19 @@ bool loadSpriteBank(char *filename, spriteBank &loadhere);
bool loadSpriteBank(int fileNum, spriteBank &loadhere, bool isFont);
void fontSprite(int x1, int y1, sprite &single, const spritePalette &fontPal);
void flipFontSprite(int x1, int y1, sprite &single, const spritePalette &fontPal);
void flipFontSprite(int x1, int y1, sprite &single,
const spritePalette &fontPal);
bool scaleSprite(sprite &single, const spritePalette &fontPal, onScreenPerson *thisPerson, bool mirror);
void pasteSpriteToBackDrop(int x1, int y1, sprite &single, const spritePalette &fontPal);
bool scaleSprite(sprite &single, const spritePalette &fontPal,
onScreenPerson *thisPerson, bool mirror);
void pasteSpriteToBackDrop(int x1, int y1, sprite &single,
const spritePalette &fontPal);
bool reserveSpritePal(spritePalette &sP, int n);
void fixScaleSprite(int x1, int y1, sprite &single, const spritePalette &fontPal, onScreenPerson *thisPerson, const int camX, const int camY, bool);
void burnSpriteToBackDrop(int x1, int y1, sprite &single, const spritePalette &fontPal);
void fixScaleSprite(int x1, int y1, sprite &single,
const spritePalette &fontPal, onScreenPerson *thisPerson,
const int camX, const int camY, bool);
void burnSpriteToBackDrop(int x1, int y1, sprite &single,
const spritePalette &fontPal);
} // End of namespace Sludge

10
engines/sludge/stringy.cpp
View File

@ -28,15 +28,17 @@
namespace Sludge {
char *copyString(const char *copyMe) {
char *newString = new char [strlen(copyMe) + 1];
if (! checkNew(newString)) return NULL;
char *newString = new char[strlen(copyMe) + 1];
if (!checkNew(newString))
return NULL;
strcpy(newString, copyMe);
return newString;
}
char *joinStrings(const char *s1, const char *s2) {
char *newString = new char [strlen(s1) + strlen(s2) + 1];
if (! checkNew(newString)) return NULL;
char *newString = new char[strlen(s1) + strlen(s2) + 1];
if (!checkNew(newString))
return NULL;
sprintf(newString, "%s%s", s1, s2);
return newString;
}

39
engines/sludge/talk.cpp
View File

@ -60,7 +60,7 @@ void killAllSpeech() {
}
if (speech->currentTalker) {
makeSilent(* (speech->currentTalker));
makeSilent(*(speech->currentTalker));
speech->currentTalker = NULL;
}
@ -96,8 +96,9 @@ void addSpeechLine(char *theLine, int x, int &offset) {
speech->allSpeech = newLine;
if ((xx1 < 5) && (offset < (5 - xx1))) {
offset = 5 - xx1;
} else if ((xx2 >= ((float)winWidth / cameraZoom) - 5) && (offset > (((float)winWidth / cameraZoom) - 5 - xx2))) {
offset = ((float)winWidth / cameraZoom) - 5 - xx2;
} else if ((xx2 >= ((float) winWidth / cameraZoom) - 5)
&& (offset > (((float) winWidth / cameraZoom) - 5 - xx2))) {
offset = ((float) winWidth / cameraZoom) - 5 - xx2;
}
}
@ -111,7 +112,8 @@ int wrapSpeechXY(char *theText, int x, int y, int wrap, int sampleFile) {
killAllSpeech();
int speechTime = (strlen(theText) + 20) * speechSpeed;
if (speechTime < 1) speechTime = 1;
if (speechTime < 1)
speechTime = 1;
if (sampleFile != -1) {
if (speechMode >= 1) {
#if 0
@ -128,7 +130,7 @@ int wrapSpeechXY(char *theText, int x, int y, int wrap, int sampleFile) {
while (strlen(theText) > wrap) {
a = wrap;
while (theText[a] != ' ') {
a --;
a--;
if (a == 0) {
a = wrap;
break;
@ -143,8 +145,12 @@ int wrapSpeechXY(char *theText, int x, int y, int wrap, int sampleFile) {
addSpeechLine(theText, x, offset);
y -= fontHeight / cameraZoom;
if (y < 0) speech->speechY -= y;
else if (speech->speechY > cameraY + (float)(winHeight - fontHeight / 3) / cameraZoom) speech->speechY = cameraY + (float)(winHeight - fontHeight / 3) / cameraZoom;
if (y < 0)
speech->speechY -= y;
else if (speech->speechY
> cameraY + (float) (winHeight - fontHeight / 3) / cameraZoom)
speech->speechY = cameraY
+ (float) (winHeight - fontHeight / 3) / cameraZoom;
if (offset) {
speechLine *viewLine = speech->allSpeech;
@ -156,8 +162,13 @@ int wrapSpeechXY(char *theText, int x, int y, int wrap, int sampleFile) {
return speechTime;
}
int wrapSpeechPerson(char *theText, onScreenPerson &thePerson, int sampleFile, bool animPerson) {
int i = wrapSpeechXY(theText, thePerson.x - cameraX, thePerson.y - cameraY - (thePerson.scale * (thePerson.height - thePerson.floaty)) - thePerson.thisType->speechGap, thePerson.thisType->wrapSpeech, sampleFile);
int wrapSpeechPerson(char *theText, onScreenPerson &thePerson, int sampleFile,
bool animPerson) {
int i = wrapSpeechXY(theText, thePerson.x - cameraX,
thePerson.y - cameraY
- (thePerson.scale * (thePerson.height - thePerson.floaty))
- thePerson.thisType->speechGap,
thePerson.thisType->wrapSpeech, sampleFile);
if (animPerson) {
makeTalker(thePerson);
speech->currentTalker = &thePerson;
@ -172,16 +183,20 @@ int wrapSpeech(char *theText, int objT, int sampleFile, bool animPerson) {
onScreenPerson *thisPerson = findPerson(objT);
if (thisPerson) {
setObjFontColour(thisPerson->thisType);
i = wrapSpeechPerson(theText, * thisPerson, sampleFile, animPerson);
i = wrapSpeechPerson(theText, *thisPerson, sampleFile, animPerson);
} else {
screenRegion *thisRegion = getRegionForObject(objT);
if (thisRegion) {
setObjFontColour(thisRegion->thisType);
i = wrapSpeechXY(theText, ((thisRegion->x1 + thisRegion->x2) >> 1) - cameraX, thisRegion->y1 - thisRegion->thisType->speechGap - cameraY, thisRegion->thisType->wrapSpeech, sampleFile);
i = wrapSpeechXY(theText,
((thisRegion->x1 + thisRegion->x2) >> 1) - cameraX,
thisRegion->y1 - thisRegion->thisType->speechGap - cameraY,
thisRegion->thisType->wrapSpeech, sampleFile);
} else {
objectType *temp = findObjectType(objT);
setObjFontColour(temp);
i = wrapSpeechXY(theText, winWidth >> 1, 10, temp->wrapSpeech, sampleFile);
i = wrapSpeechXY(theText, winWidth >> 1, 10, temp->wrapSpeech,
sampleFile);
}
}
return i;

1
engines/sludge/talk.h
View File

@ -32,7 +32,6 @@ struct speechLine {
int x;
};
struct speechStruct {
onScreenPerson *currentTalker;
speechLine *allSpeech;

4
engines/sludge/thumbnail.cpp
View File

@ -40,7 +40,6 @@ int thumbWidth = 0, thumbHeight = 0;
extern GLuint backdropTextureName;
#endif
bool saveThumbnail(Common::WriteStream *stream) {
#if 0
GLuint thumbnailTextureName = 0;
@ -72,7 +71,6 @@ bool saveThumbnail(Common::WriteStream *stream) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
const GLfloat vertices[] = {
0., 0., 0.,
thumbWidth - 1.f, 0., 0.,
@ -120,8 +118,6 @@ bool saveThumbnail(Common::WriteStream *stream) {
glReadPixels(viewportOffsetX, viewportOffsetY, thumbWidth, thumbHeight, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, image);
#endif
glUseProgram(0);
#endif
setPixelCoords(false);

3
engines/sludge/timing.cpp
View File

@ -59,4 +59,5 @@ void Wait_Frame(void) {
}
#endif
} // End of namespace Sludge
}
// End of namespace Sludge

7
engines/sludge/transition.cpp
View File

@ -113,7 +113,7 @@ void transitionSnapshotBox() {
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBindTexture(GL_TEXTURE_2D, snapshotTextureName);
float xScale = (float) brightnessLevel * winWidth / 510.f; // 510 = 255*2
float xScale = (float) brightnessLevel * winWidth / 510.f;// 510 = 255*2
float yScale = (float) brightnessLevel * winHeight / 510.f;
const GLfloat vertices[] = {
@ -187,7 +187,6 @@ bool reserveTransitionTexture() {
return true;
}
void transitionDisolve() {
#if 0
@ -224,7 +223,7 @@ void transitionDisolve() {
toScreen[0] = toScreen[1] = toScreen[2] = toScreen[3] = 0;
}
toScreen += 4;
} while (toScreen < end);
}while (toScreen < end);
texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, transitionTexture, transitionTextureName);
@ -292,7 +291,7 @@ void transitionTV() {
toScreen[0] = toScreen[1] = toScreen[2] = toScreen[3] = 0;
}
toScreen += 4;
} while (toScreen < end);
}while (toScreen < end);
texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, transitionTexture, transitionTextureName);

331
engines/sludge/variable.cpp
View File

@ -41,10 +41,9 @@
namespace Sludge {
const char *typeName[] = {"undefined", "number", "user function", "string",
"built-in function", "file", "stack",
"object type", "animation", "costume"
};
const char *typeName[] = { "undefined", "number", "user function", "string",
"built-in function", "file", "stack", "object type", "animation",
"costume" };
extern char *outputDir;
@ -56,18 +55,19 @@ void unlinkVar(variable &thisVar) {
break;
case SVT_STACK:
thisVar.varData.theStack -> timesUsed --;
if (thisVar.varData.theStack -> timesUsed <= 0) {
while (thisVar.varData.theStack -> first) trimStack(thisVar.varData.theStack -> first);
thisVar.varData.theStack->timesUsed--;
if (thisVar.varData.theStack->timesUsed <= 0) {
while (thisVar.varData.theStack->first)
trimStack(thisVar.varData.theStack->first);
delete thisVar.varData.theStack;
thisVar.varData.theStack = NULL;
}
break;
case SVT_FASTARRAY:
thisVar.varData.fastArray -> timesUsed --;
if (thisVar.varData.theStack -> timesUsed <= 0) {
delete thisVar.varData.fastArray -> fastVariables;
thisVar.varData.fastArray->timesUsed--;
if (thisVar.varData.theStack->timesUsed <= 0) {
delete thisVar.varData.fastArray->fastVariables;
delete[] thisVar.varData.fastArray;
thisVar.varData.fastArray = NULL;
}
@ -101,7 +101,8 @@ personaAnimation *getAnimationFromVar(variable &thisVar) {
if (thisVar.varType == SVT_INT && thisVar.varData.intValue == 0)
return makeNullAnim();
fatal("Expecting an animation variable; found variable of type", typeName[thisVar.varType]);
fatal("Expecting an animation variable; found variable of type",
typeName[thisVar.varType]);
return NULL;
}
@ -117,13 +118,15 @@ persona *getCostumeFromVar(variable &thisVar) {
switch (thisVar.varType) {
case SVT_ANIM:
p = new persona;
if (! checkNew(p)) return NULL;
p -> numDirections = 1;
p -> animation = new personaAnimation * [3];
if (! checkNew(p -> animation)) return NULL;
if (!checkNew(p))
return NULL;
p->numDirections = 1;
p->animation = new personaAnimation *[3];
if (!checkNew(p->animation))
return NULL;
for (int iii = 0; iii < 3; iii ++)
p -> animation[iii] = copyAnim(thisVar.varData.animHandler);
for (int iii = 0; iii < 3; iii++)
p->animation[iii] = copyAnim(thisVar.varData.animHandler);
break;
@ -132,7 +135,8 @@ persona *getCostumeFromVar(variable &thisVar) {
break;
default:
fatal("Expecting an animation variable; found variable of type", typeName[thisVar.varType]);
fatal("Expecting an animation variable; found variable of type",
typeName[thisVar.varType]);
}
return p;
@ -140,10 +144,10 @@ persona *getCostumeFromVar(variable &thisVar) {
int stackSize(const stackHandler *me) {
int r = 0;
variableStack *a = me -> first;
variableStack *a = me->first;
while (a) {
r ++;
a = a -> next;
r++;
a = a->next;
}
return r;
}
@ -156,7 +160,8 @@ char *ConvertFromUTF16(const WCHAR *input);
bool getSavedGamesStack(stackHandler *sH, char *ext) {
char *pattern = joinStrings("*", ext);
if (! pattern) return false;
if (!pattern)
return false;
variable newName;
newName.varType = SVT_NULL;
@ -182,30 +187,32 @@ bool getSavedGamesStack(stackHandler *sH, char *ext) {
if (! addVarToStack(newName, sH -> first)) return false;
if (sH -> last == NULL) sH -> last = sH -> first;
keepGoing = FindNextFile(handle, & theData);
} while (keepGoing);
}while (keepGoing);
FindClose(handle);
}
#else
DIR *dir = opendir(".");
if (! dir) return false;
if (!dir)
return false;
struct dirent *d = readdir(dir);
while (d != NULL) {
if (! strcmp(d->d_name + strlen(d->d_name) - strlen(ext), ext)) {
if (!strcmp(d->d_name + strlen(d->d_name) - strlen(ext), ext)) {
d->d_name[strlen(d->d_name) - strlen(ext)] = 0;
char *decoded = decodeFilename(d->d_name);
makeTextVar(newName, decoded);
delete[] decoded;
if (! addVarToStack(newName, sH -> first)) return false;
if (sH -> last == NULL) sH -> last = sH -> first;
if (!addVarToStack(newName, sH->first))
return false;
if (sH->last == NULL)
sH->last = sH->first;
}
d = readdir(dir);
}
closedir(dir);
#endif
@ -218,11 +225,12 @@ bool getSavedGamesStack(stackHandler *sH, char *ext) {
bool copyStack(const variable &from, variable &to) {
to.varType = SVT_STACK;
to.varData.theStack = new stackHandler;
if (! checkNew(to.varData.theStack)) return false;
to.varData.theStack -> first = NULL;
to.varData.theStack -> last = NULL;
to.varData.theStack -> timesUsed = 1;
variableStack *a = from.varData.theStack -> first;
if (!checkNew(to.varData.theStack))
return false;
to.varData.theStack->first = NULL;
to.varData.theStack->last = NULL;
to.varData.theStack->timesUsed = 1;
variableStack *a = from.varData.theStack->first;
#if DEBUG_STACKINESS
{
@ -233,12 +241,12 @@ bool copyStack(const variable &from, variable &to) {
#endif
while (a) {
addVarToStack(a -> thisVar, to.varData.theStack -> first);
if (to.varData.theStack -> last == NULL) {
addVarToStack(a->thisVar, to.varData.theStack->first);
if (to.varData.theStack->last == NULL) {
#if DEBUG_STACKINESS
stackDebug((stackfp, "LAST"));
#endif
to.varData.theStack -> last = to.varData.theStack -> first;
to.varData.theStack->last = to.varData.theStack->first;
}
#if DEBUG_STACKINESS
@ -249,7 +257,7 @@ bool copyStack(const variable &from, variable &to) {
}
#endif
a = a -> next;
a = a->next;
}
#if DEBUG_STACKINESS
@ -265,10 +273,10 @@ bool copyStack(const variable &from, variable &to) {
}
/*void newStackVar (variable & thisVar) {
unlinkVar (thisVar);
thisVar.varType = VT_STACK;
thisVar.varData.theStack = NULL;
} */
unlinkVar (thisVar);
thisVar.varType = VT_STACK;
thisVar.varData.theStack = NULL;
} */
void addVariablesInSecond(variable &var1, variable &var2) {
if (var1.varType == SVT_INT && var2.varType == SVT_INT) {
@ -330,7 +338,7 @@ void makeTextVar(variable &thisVar, const char *txt) {
bool loadStringToVar(variable &thisVar, int value) {
makeTextVar(thisVar, getNumberedString(value));
return (bool)(thisVar.varData.theString != NULL);
return (bool) (thisVar.varData.theString != NULL);
}
char *getTextFromAnyVar(const variable &from) {
@ -343,13 +351,16 @@ char *getTextFromAnyVar(const variable &from) {
char *builder2;
char *grabText;
for (int i = 0; i < from.varData.fastArray -> size; i ++) {
for (int i = 0; i < from.varData.fastArray->size; i++) {
builder2 = joinStrings(builder, " ");
if (! builder2) return NULL;
if (!builder2)
return NULL;
delete builder;
grabText = getTextFromAnyVar(from.varData.fastArray -> fastVariables[i]);
grabText = getTextFromAnyVar(
from.varData.fastArray->fastVariables[i]);
builder = joinStrings(builder2, grabText);
if (! builder) return NULL;
if (!builder)
return NULL;
delete grabText;
grabText = NULL;
delete builder2;
@ -363,27 +374,30 @@ char *getTextFromAnyVar(const variable &from) {
char *builder2;
char *grabText;
variableStack *stacky = from.varData.theStack -> first;
variableStack *stacky = from.varData.theStack->first;
while (stacky) {
builder2 = joinStrings(builder, " ");
if (! builder2) return NULL;
if (!builder2)
return NULL;
delete builder;
grabText = getTextFromAnyVar(stacky -> thisVar);
grabText = getTextFromAnyVar(stacky->thisVar);
builder = joinStrings(builder2, grabText);
if (! builder) return NULL;
if (!builder)
return NULL;
delete grabText;
grabText = NULL;
delete builder2;
builder2 = NULL;
stacky = stacky -> next;
stacky = stacky->next;
}
return builder;
}
case SVT_INT: {
char *buff = new char[10];
if (! checkNew(buff)) return NULL;
if (!checkNew(buff))
return NULL;
sprintf(buff, "%i", from.varData.intValue);
return buff;
}
@ -395,17 +409,18 @@ char *getTextFromAnyVar(const variable &from) {
return joinStrings("", resourceNameFromNum(from.varData.intValue));
}
/* case SVT_ANIM:
{
char * buff = new char[20];
if (! checkNew (buff)) return NULL;
sprintf (buff, "%p", from.varData.animHandler);
return buff;
}*/
/* case SVT_ANIM:
{
char * buff = new char[20];
if (! checkNew (buff)) return NULL;
sprintf (buff, "%p", from.varData.animHandler);
return buff;
}*/
case SVT_OBJTYPE: {
objectType *thisType = findObjectType(from.varData.intValue);
if (thisType) return copyString(thisType -> screenName);
if (thisType)
return copyString(thisType->screenName);
}
default:
@ -421,16 +436,16 @@ bool getBoolean(const variable &from) {
return false;
case SVT_INT:
return (bool)(from.varData.intValue != 0);
return (bool) (from.varData.intValue != 0);
case SVT_STACK:
return (bool)(from.varData.theStack -> first != NULL);
return (bool) (from.varData.theStack->first != NULL);
case SVT_STRING:
return (bool)(from.varData.theString[0] != 0);
return (bool) (from.varData.theString[0] != 0);
case SVT_FASTARRAY:
return (bool)(from.varData.fastArray -> size != 0);
return (bool) (from.varData.fastArray->size != 0);
default:
break;
@ -451,7 +466,7 @@ bool copyMain(const variable &from, variable &to) {
case SVT_FASTARRAY:
to.varData.fastArray = from.varData.fastArray;
to.varData.fastArray -> timesUsed ++;
to.varData.fastArray->timesUsed++;
return true;
case SVT_STRING:
@ -460,7 +475,7 @@ bool copyMain(const variable &from, variable &to) {
case SVT_STACK:
to.varData.theStack = from.varData.theStack;
to.varData.theStack -> timesUsed ++;
to.varData.theStack->timesUsed++;
return true;
case SVT_COSTUME:
@ -487,109 +502,124 @@ bool copyVariable(const variable &from, variable &to) {
}
variable *fastArrayGetByIndex(fastArrayHandler *vS, unsigned int theIndex) {
if (theIndex < 0 || theIndex >= vS -> size) return NULL;
return & vS -> fastVariables[theIndex];
if (theIndex < 0 || theIndex >= vS->size)
return NULL;
return &vS->fastVariables[theIndex];
}
bool makeFastArraySize(variable &to, int size) {
if (size < 0) return fatal("Can't create a fast array with a negative number of elements!");
if (size < 0)
return fatal(
"Can't create a fast array with a negative number of elements!");
unlinkVar(to);
to.varType = SVT_FASTARRAY;
to.varData.fastArray = new fastArrayHandler;
if (! checkNew(to.varData.fastArray)) return false;
to.varData.fastArray -> fastVariables = new variable[size];
if (! checkNew(to.varData.fastArray -> fastVariables)) return false;
for (int i = 0; i < size; i ++) {
initVarNew(to.varData.fastArray -> fastVariables[i]);
if (!checkNew(to.varData.fastArray))
return false;
to.varData.fastArray->fastVariables = new variable[size];
if (!checkNew(to.varData.fastArray->fastVariables))
return false;
for (int i = 0; i < size; i++) {
initVarNew(to.varData.fastArray->fastVariables[i]);
}
to.varData.fastArray -> size = size;
to.varData.fastArray -> timesUsed = 1;
to.varData.fastArray->size = size;
to.varData.fastArray->timesUsed = 1;
return true;
}
bool makeFastArrayFromStack(variable &to, const stackHandler *stacky) {
int size = stackSize(stacky);
if (! makeFastArraySize(to, size)) return false;
if (!makeFastArraySize(to, size))
return false;
// Now let's fill up the new array
variableStack *allV = stacky -> first;
variableStack *allV = stacky->first;
size = 0;
while (allV) {
copyMain(allV -> thisVar, to.varData.fastArray -> fastVariables[size]);
size ++;
allV = allV -> next;
copyMain(allV->thisVar, to.varData.fastArray->fastVariables[size]);
size++;
allV = allV->next;
}
return true;
}
/*
bool moveVariable (variable & from, variable & to) {
unlinkVar (to);
memcpy (& to, & from, sizeof (variable));
from.varType = SVT_NULL;
}
*/
bool moveVariable (variable & from, variable & to) {
unlinkVar (to);
memcpy (& to, & from, sizeof (variable));
from.varType = SVT_NULL;
}
*/
bool addVarToStack(const variable &va, variableStack *&thisStack) {
variableStack *newStack = new variableStack;
if (! checkNew(newStack)) return false;
if (!checkNew(newStack))
return false;
if (! copyMain(va, newStack -> thisVar)) return false;
newStack -> next = thisStack;
if (!copyMain(va, newStack->thisVar))
return false;
newStack->next = thisStack;
thisStack = newStack;
debug(kSludgeDebugStackMachine, "Variable %s was added to stack", getTextFromAnyVar(va));
debug(kSludgeDebugStackMachine, "Variable %s was added to stack",
getTextFromAnyVar(va));
return true;
}
bool addVarToStackQuick(variable &va, variableStack *&thisStack) {
variableStack *newStack = new variableStack;
if (! checkNew(newStack)) return false;
if (!checkNew(newStack))
return false;
// if (! copyMain (va, newStack -> thisVar)) return false;
memcpy(& (newStack -> thisVar), & va, sizeof(variable));
memcpy(&(newStack->thisVar), &va, sizeof(variable));
va.varType = SVT_NULL;
newStack -> next = thisStack;
newStack->next = thisStack;
thisStack = newStack;
debug(kSludgeDebugStackMachine, "Variable %s was added to stack quick", getTextFromAnyVar(va));
debug(kSludgeDebugStackMachine, "Variable %s was added to stack quick",
getTextFromAnyVar(va));
return true;
}
bool stackSetByIndex(variableStack *vS, unsigned int theIndex, const variable &va) {
while (theIndex --) {
vS = vS -> next;
if (! vS) return fatal("Index past end of stack.");
bool stackSetByIndex(variableStack *vS, unsigned int theIndex,
const variable &va) {
while (theIndex--) {
vS = vS->next;
if (!vS)
return fatal("Index past end of stack.");
}
return copyVariable(va, vS -> thisVar);
return copyVariable(va, vS->thisVar);
}
variable *stackGetByIndex(variableStack *vS, unsigned int theIndex) {
while (theIndex --) {
vS = vS -> next;
if (! vS) {
while (theIndex--) {
vS = vS->next;
if (!vS) {
return NULL;
}
}
return & (vS -> thisVar);
return &(vS->thisVar);
}
int deleteVarFromStack(const variable &va, variableStack *&thisStack, bool allOfEm) {
variableStack * * huntVar = & thisStack;
int deleteVarFromStack(const variable &va, variableStack *&thisStack,
bool allOfEm) {
variableStack * * huntVar = &thisStack;
variableStack *killMe;
int reply = 0;
while (* huntVar) {
if (compareVars((* huntVar) -> thisVar, va)) {
killMe = * huntVar;
* huntVar = killMe -> next;
unlinkVar(killMe -> thisVar);
while (*huntVar) {
if (compareVars((*huntVar)->thisVar, va)) {
killMe = *huntVar;
*huntVar = killMe->next;
unlinkVar(killMe->thisVar);
delete killMe;
if (! allOfEm) return 1;
reply ++;
if (!allOfEm)
return 1;
reply++;
} else {
huntVar = & ((* huntVar) -> next);
huntVar = &((*huntVar)->next);
}
}
@ -610,8 +640,12 @@ variableStack *stackFindLast(variableStack *hunt) {
bool getValueType(int &toHere, variableType vT, const variable &v) {
//if (! v) return false;
if (v.varType != vT) {
char *e1 = joinStrings("Can only perform specified operation on a value which is of type ", typeName[vT]);
char *e2 = joinStrings("... value supplied was of type ", typeName[v.varType]);
char *e1 =
joinStrings(
"Can only perform specified operation on a value which is of type ",
typeName[vT]);
char *e2 = joinStrings("... value supplied was of type ",
typeName[v.varType]);
fatal(e1, e2);
return false;
@ -622,50 +656,51 @@ bool getValueType(int &toHere, variableType vT, const variable &v) {
void trimStack(variableStack *&stack) {
variableStack *killMe = stack;
stack = stack -> next;
stack = stack->next;
debug(kSludgeDebugStackMachine, "Variable %s was removed from stack", getTextFromAnyVar(killMe -> thisVar));
debug(kSludgeDebugStackMachine, "Variable %s was removed from stack",
getTextFromAnyVar(killMe->thisVar));
// When calling this, we've ALWAYS checked that stack != NULL
unlinkVar(killMe -> thisVar);
unlinkVar(killMe->thisVar);
delete killMe;
}
/*
void debugVar (FILE * fp, const variable & thisVar) {
switch (thisVar.varType) {
case SVT_INT:
fprintf (fp, "integer value %i", thisVar.varData.intValue);
break;
void debugVar (FILE * fp, const variable & thisVar) {
switch (thisVar.varType) {
case SVT_INT:
fprintf (fp, "integer value %i", thisVar.varData.intValue);
break;
case SVT_FUNC:
fprintf (fp, "pointer to function %i", thisVar.varData.intValue);
break;
case SVT_FUNC:
fprintf (fp, "pointer to function %i", thisVar.varData.intValue);
break;
case SVT_BUILT:
fprintf (fp, "pointer to bif %i", thisVar.varData.intValue);
break;
case SVT_BUILT:
fprintf (fp, "pointer to bif %i", thisVar.varData.intValue);
break;
case SVT_OBJTYPE:
fprintf (fp, "object type %i", thisVar.varData.intValue);
break;
case SVT_OBJTYPE:
fprintf (fp, "object type %i", thisVar.varData.intValue);
break;
case SVT_STRING:
fprintf (fp, "\"%s\"", thisVar.varData.theString);
break;
case SVT_STRING:
fprintf (fp, "\"%s\"", thisVar.varData.theString);
break;
case SVT_FILE:
fprintf (fp, "file handle %i", thisVar.varData.intValue);
break;
case SVT_FILE:
fprintf (fp, "file handle %i", thisVar.varData.intValue);
break;
case SVT_NULL:
fprintf (fp, "null");
break;
case SVT_NULL:
fprintf (fp, "null");
break;
default:
fprintf (fp, "unknown variable type");
break;
}
}
*/
default:
fprintf (fp, "unknown variable type");
break;
}
}
*/
} // End of namespace Sludge

55
engines/sludge/variable.h
View File

@ -27,41 +27,50 @@ namespace Sludge {
struct variable;
struct variableStack;
enum variableType {SVT_NULL, SVT_INT, SVT_FUNC, SVT_STRING,
SVT_BUILT, SVT_FILE, SVT_STACK,
SVT_OBJTYPE, SVT_ANIM, SVT_COSTUME,
SVT_FASTARRAY, SVT_NUM_TYPES
};
enum variableType {
SVT_NULL,
SVT_INT,
SVT_FUNC,
SVT_STRING,
SVT_BUILT,
SVT_FILE,
SVT_STACK,
SVT_OBJTYPE,
SVT_ANIM,
SVT_COSTUME,
SVT_FASTARRAY,
SVT_NUM_TYPES
};
struct fastArrayHandler {
struct variable *fastVariables;
int size;
int timesUsed;
struct variable *fastVariables;
int size;
int timesUsed;
};
struct stackHandler {
struct variableStack *first;
struct variableStack *last;
int timesUsed;
struct variableStack *first;
struct variableStack *last;
int timesUsed;
};
union variableData {
signed int intValue;
char *theString;
stackHandler *theStack;
struct personaAnimation *animHandler;
struct persona *costumeHandler;
fastArrayHandler *fastArray;
signed int intValue;
char *theString;
stackHandler *theStack;
struct personaAnimation *animHandler;
struct persona *costumeHandler;
fastArrayHandler *fastArray;
};
struct variable {
variableType varType;
variableData varData;
variableType varType;
variableData varData;
};
struct variableStack {
variable thisVar;
variableStack *next;
variable thisVar;
variableStack *next;
};
// Initialisation
@ -94,7 +103,8 @@ bool getValueType(int &toHere, variableType vT, const variable &v);
bool addVarToStack(const variable &va, variableStack *&thisStack);
bool addVarToStackQuick(variable &va, variableStack *&thisStack);
void trimStack(variableStack *&stack);
int deleteVarFromStack(const variable &va, variableStack *&thisStack, bool allOfEm = false);
int deleteVarFromStack(const variable &va, variableStack *&thisStack,
bool allOfEm = false);
variableStack *stackFindLast(variableStack *hunt);
bool copyStack(const variable &from, variable &to);
int stackSize(const stackHandler *me);
@ -106,7 +116,6 @@ bool makeFastArrayFromStack(variable &to, const stackHandler *stacky);
bool makeFastArraySize(variable &to, int size);
variable *fastArrayGetByIndex(fastArrayHandler *vS, unsigned int theIndex);
#define DEBUG_STACKINESS 0
#if DEBUG_STACKINESS

219
engines/sludge/vid.cpp
View File

@ -40,10 +40,10 @@
namespace Sludge {
struct timStream {
PAVISTREAM got;
AVISTREAMINFO info;
LONG chunkSize;
LPBYTE chunk;
PAVISTREAM got;
AVISTREAMINFO info;
LONG chunkSize;
LPBYTE chunk;
};
static PAVIFILE pAviFile = NULL;
@ -64,27 +64,32 @@ extern HWND hMainWindow;
void initialiseMovieStuff() {
char buffer[500];
if (ExpandEnvironmentStrings("%temp%", buffer, 499) == 0) buffer[0] = NULL;
if (ExpandEnvironmentStrings("%temp%", buffer, 499) == 0)
buffer[0] = NULL;
videoFile = joinStrings(buffer, "\\test.avi");
// warning (videoFile);
}
bool getStream(DWORD type, timStream &intoHere) {
if (AVIFileGetStream(pAviFile, & intoHere.got, type, 0)) {
if (AVIFileGetStream(pAviFile, &intoHere.got, type, 0)) {
intoHere.got = NULL;
return true;
} else if (AVIStreamInfo(intoHere.got, & intoHere.info, sizeof(AVISTREAMINFO))) {
} else if (AVIStreamInfo(intoHere.got, &intoHere.info,
sizeof(AVISTREAMINFO))) {
return fatal("Can't get stream info");
} else if (AVIStreamReadFormat(intoHere.got, AVIStreamStart(intoHere.got), NULL, & intoHere.chunkSize)) {
} else if (AVIStreamReadFormat(intoHere.got, AVIStreamStart(intoHere.got),
NULL, &intoHere.chunkSize)) {
return fatal("Can't get stream chunk size");
} else {
// So far so good! Let's read a chunk of data (huh?)
intoHere.chunk = new BYTE[intoHere.chunkSize];
if (! intoHere.chunk) {
if (!intoHere.chunk) {
return fatal("Out of memory");
} else if (AVIStreamReadFormat(intoHere.got, AVIStreamStart(intoHere.got), intoHere.chunk, & intoHere.chunkSize)) {
} else if (AVIStreamReadFormat(intoHere.got,
AVIStreamStart(intoHere.got), intoHere.chunk,
&intoHere.chunkSize)) {
return fatal("Couldn't read stream format");
}
}
@ -97,46 +102,48 @@ void killStream(timStream &intoHere) {
}
/*
#define WAVHEADERSIZE 20
char wavHeader[WAVHEADERSIZE] = {'R', 'I', 'F', 'F', 0, 0, 0, 0,
'W', 'A', 'V', 'E', 'f', 'm', 't',
0x20, 0x10, 0, 0, 0};
#define WAVHEADERSIZE 20
char wavHeader[WAVHEADERSIZE] = {'R', 'I', 'F', 'F', 0, 0, 0, 0,
'W', 'A', 'V', 'E', 'f', 'm', 't',
0x20, 0x10, 0, 0, 0};
void handleAudio () {
LONG aSize;
void handleAudio () {
LONG aSize;
if(AVIStreamRead(audio.got, 0, AVISTREAMREAD_CONVENIENT, NULL, 0, & aSize, NULL)) return;
if(AVIStreamRead(audio.got, 0, AVISTREAMREAD_CONVENIENT, NULL, 0, & aSize, NULL)) return;
int totalSize = aSize + audio.chunkSize + WAVHEADERSIZE + 4;
int totalSize = aSize + audio.chunkSize + WAVHEADERSIZE + 4;
LPBYTE pBuffer = new BYTE[totalSize];
if (!pBuffer) return;
LPBYTE pBuffer = new BYTE[totalSize];
if (!pBuffer) return;
memcpy (pBuffer, wavHeader, WAVHEADERSIZE);
pBuffer[4] = (char) (aSize);
pBuffer[5] = (char) (aSize >> 8);
memcpy (pBuffer + WAVHEADERSIZE, audio.chunk, audio.chunkSize);
memcpy (pBuffer + WAVHEADERSIZE + audio.chunkSize, "data", 4);
memcpy (pBuffer, wavHeader, WAVHEADERSIZE);
pBuffer[4] = (char) (aSize);
pBuffer[5] = (char) (aSize >> 8);
memcpy (pBuffer + WAVHEADERSIZE, audio.chunk, audio.chunkSize);
memcpy (pBuffer + WAVHEADERSIZE + audio.chunkSize, "data", 4);
if(! AVIStreamRead (audio.got, 0, AVISTREAMREAD_CONVENIENT, pBuffer + audio.chunkSize + WAVHEADERSIZE + 4, aSize, NULL, NULL)) {
FILE * fp = fopen ("test.wav", "wb");
if (fp) {
fwrite (pBuffer, 1, totalSize, fp);
fclose (fp);
}
int i = fakeCacheSoundForVideo ((char *) pBuffer, totalSize);
if (i != -1) startSound (i, false);
}
if(! AVIStreamRead (audio.got, 0, AVISTREAMREAD_CONVENIENT, pBuffer + audio.chunkSize + WAVHEADERSIZE + 4, aSize, NULL, NULL)) {
FILE * fp = fopen ("test.wav", "wb");
if (fp) {
fwrite (pBuffer, 1, totalSize, fp);
fclose (fp);
}
int i = fakeCacheSoundForVideo ((char *) pBuffer, totalSize);
if (i != -1) startSound (i, false);
}
delete pBuffer;
}
*/
delete pBuffer;
}
*/
void finishVideo() {
videoPlaying = false;
AVIStreamGetFrameClose(pgf);
if (audio.got) AVIStreamRelease(audio.got);
if (video.got) AVIStreamRelease(video.got);
if (audio.got)
AVIStreamRelease(audio.got);
if (video.got)
AVIStreamRelease(video.got);
killStream(audio);
killStream(video);
AVIFileRelease(pAviFile);
@ -144,17 +151,19 @@ void finishVideo() {
#ifdef _MSC_VER
_unlink(videoFile);
#else
unlink(videoFile);
unlink(videoFile)
;
#endif
}
#define COPYSIZE 256
bool extractSlice(int fileNum, char *toName) {
unsigned char buff[COPYSIZE];
unsigned char buff[COPYSIZE];
unsigned long fileLength = openFileFromNum(fileNum);
if (! fileLength) return false; // Error already displayed
unsigned long fileLength = openFileFromNum(fileNum);
if (!fileLength)
return false; // Error already displayed
#if 0
FILE *copyVid = fopen(toName, "wb");
if (! copyVid) return fatal("Can't extract resource");
@ -171,94 +180,100 @@ bool extractSlice(int fileNum, char *toName) {
fclose(copyVid);
#endif
finishAccess();
finishAccess();
return true;
return true;
}
bool startVideo(int fileNum) {
setResourceForFatal(fileNum);
setResourceForFatal(fileNum);
AVIFILEINFO info;
AVIFILEINFO info;
if (videoPlaying) finishVideo();
AVIFileInit();
if (videoPlaying)
finishVideo();
AVIFileInit();
if (! extractSlice(fileNum, videoFile)) return false;
if (AVIFileOpen(& pAviFile, videoFile, OF_READ, NULL))
return fatal(ERROR_AVI_FILE_ERROR);
if (!extractSlice(fileNum, videoFile))
return false;
if (AVIFileOpen(&pAviFile, videoFile, OF_READ, NULL))
return fatal(ERROR_AVI_FILE_ERROR);
AVIFileInfo(pAviFile, &info, sizeof(info));
AVIFileInfo(pAviFile, &info, sizeof(info));
if (! getStream(streamtypeAUDIO, audio)) return false;
if (! getStream(streamtypeVIDEO, video)) return false;
if (!getStream(streamtypeAUDIO, audio))
return false;
if (!getStream(streamtypeVIDEO, video))
return false;
if (! video.got) return fatal(ERROR_AVI_NO_STREAM);
if (!video.got)
return fatal(ERROR_AVI_NO_STREAM);
// if (audio.got) handleAudio ();
pgf = AVIStreamGetFrameOpen(video.got, NULL);
if (!pgf) return fatal(ERROR_AVI_ARGH);
pgf = AVIStreamGetFrameOpen(video.got, NULL);
if (!pgf)
return fatal(ERROR_AVI_ARGH);
LPBITMAPINFO pInfo = (LPBITMAPINFO)(video.chunk);
vidBytesPerPixel = pInfo -> bmiHeader.biBitCount / 8;
biSize = pInfo -> bmiHeader.biSize;
vidWidth = pInfo -> bmiHeader.biWidth;
vidHeight = pInfo -> bmiHeader.biHeight;
LPBITMAPINFO pInfo = (LPBITMAPINFO)(video.chunk);
vidBytesPerPixel = pInfo->bmiHeader.biBitCount / 8;
biSize = pInfo->bmiHeader.biSize;
vidWidth = pInfo->bmiHeader.biWidth;
vidHeight = pInfo->bmiHeader.biHeight;
videoFrameNum = 0;
videoPlaying = true;
videoFrameNum = 0;
videoPlaying = true;
setResourceForFatal(-1);
setResourceForFatal(-1);
return true;
return true;
}
bool nextVideoFrame() {
LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER) AVIStreamGetFrame(pgf, videoFrameNum);
if (! lpbi) {
finishVideo();
return false;
}
LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER) AVIStreamGetFrame(pgf,
videoFrameNum);
if (!lpbi) {
finishVideo();
return false;
}
BYTE *pData = (((BYTE *) lpbi) + lpbi->biSize);
BYTE *pData = (((BYTE *) lpbi) + lpbi->biSize);
int xOff = (winWidth - vidWidth) >> 1;
int yOff = (winHeight + vidHeight) >> 1;
unsigned short int *startingPoint = screen + xOff + (yOff * winWidth);
int xOff = (winWidth - vidWidth) >> 1;
int yOff = (winHeight + vidHeight) >> 1;
unsigned short int *startingPoint = screen + xOff + (yOff * winWidth);
for (int y = 0; y < vidHeight; y ++) {
startingPoint -= winWidth;
unsigned short int *toHere = startingPoint;
for (int x = 0; x < vidWidth; x ++) {
switch (vidBytesPerPixel) {
case 1:
(* toHere) = makeGrey(*pData);
break;
case 3:
case 4:
(* toHere) = makeColour(*(pData + 2), *(pData + 1), *pData);
break;
default: {
WORD Pixel16 = * ((WORD *) pData);
(* toHere) = makeColour(
(((UINT)(Pixel16) >> 10) & 0x1F) << 3,
(((UINT)(Pixel16) >> 5) & 0x1F) << 3,
(((UINT)(Pixel16) >> 0) & 0x1F) << 3);
}
for (int y = 0; y < vidHeight; y++) {
startingPoint -= winWidth;
unsigned short int *toHere = startingPoint;
for (int x = 0; x < vidWidth; x++) {
switch (vidBytesPerPixel) {
case 1:
(*toHere) = makeGrey(*pData);
break;
}
pData += vidBytesPerPixel;
toHere ++;
case 3:
case 4:
(*toHere) = makeColour(*(pData + 2), *(pData + 1), *pData);
break;
default: {
WORD Pixel16 = *((WORD *) pData);
(*toHere) = makeColour((((UINT)(Pixel16) >> 10) & 0x1F) << 3,
(((UINT)(Pixel16) >> 5) & 0x1F) << 3,
(((UINT)(Pixel16) >> 0) & 0x1F) << 3);
}
break;
}
pData += vidBytesPerPixel;
toHere++;
}
}
videoFrameNum ++;
videoFrameNum++;
return true;
return true;
}
} // End of namespace Sludge

293
engines/sludge/winstuff.cpp
View File

@ -53,179 +53,178 @@
namespace Sludge {
HINSTANCE hInst; // Handle of the main instance
extern HWND hMainWindow;
HINSTANCE hInst; // Handle of the main instance
extern HWND hMainWindow;
extern variableStack *noStack;
extern variableStack *noStack;
// The platform-specific functions - Windows edition.
WCHAR *ConvertToUTF16(const char *input) {
int s = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input, -1, NULL, 0);
WCHAR *ret = new WCHAR [s];
checkNew(ret);
/*int a = */MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input, -1, ret, s);
return ret;
}
char *ConvertFromUTF16(const WCHAR *input) {
int s = WideCharToMultiByte(CP_UTF8, 0, input, -1, NULL, 0, NULL, NULL);
char *ret = new char [s];
checkNew(ret);
/*int a = */WideCharToMultiByte(CP_UTF8, 0, input, -1, ret, s, NULL, NULL);
return ret;
}
char *grabFileName() {
OPENFILENAME ofn;
WCHAR path[MAX_PATH];
WCHAR file[MAX_PATH] = TEXT("");
hInst = GetModuleHandle(NULL);
memset(& ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.hInstance = hInst;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrInitialDir = path;
ofn.Flags = OFN_HIDEREADONLY | OFN_EXPLORER;
ofn.lpstrFilter = TEXT("SLUDGE games (*.SLG)\0*.slg\0\0");
ofn.lpstrFile = file;
if (GetOpenFileName(& ofn)) {
return ConvertFromUTF16(file);
} else {
return NULL;
WCHAR *ConvertToUTF16(const char *input) {
int s = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input, -1, NULL, 0);
WCHAR *ret = new WCHAR [s];
checkNew(ret);
/*int a = */MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input, -1, ret, s);
return ret;
}
}
extern char **languageName;
extern int *languageTable;
char *ConvertFromUTF16(const WCHAR *input) {
int s = WideCharToMultiByte(CP_UTF8, 0, input, -1, NULL, 0, NULL, NULL);
char *ret = new char [s];
checkNew(ret);
/*int a = */WideCharToMultiByte(CP_UTF8, 0, input, -1, ret, s, NULL, NULL);
return ret;
}
HBITMAP hLogo = NULL;
extern unsigned char *gameLogo;
char *grabFileName() {
OPENFILENAME ofn;
WCHAR path[MAX_PATH];
WCHAR file[MAX_PATH] = TEXT("");
BOOL CALLBACK setupDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
switch (message) {
case WM_INITDIALOG:
if (gameLogo) {
hLogo = CreateBitmap(310, 88, 1, 32, gameLogo);
SendDlgItemMessage(hDlg, 1003, STM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hLogo);
hInst = GetModuleHandle(NULL);
memset(& ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.hInstance = hInst;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrInitialDir = path;
ofn.Flags = OFN_HIDEREADONLY | OFN_EXPLORER;
ofn.lpstrFilter = TEXT("SLUDGE games (*.SLG)\0*.slg\0\0");
ofn.lpstrFile = file;
if (GetOpenFileName(& ofn)) {
return ConvertFromUTF16(file);
} else {
return NULL;
}
}
if (gameSettings.userFullScreen)
extern char **languageName;
extern int *languageTable;
HBITMAP hLogo = NULL;
extern unsigned char *gameLogo;
BOOL CALLBACK setupDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
switch (message) {
case WM_INITDIALOG:
if (gameLogo) {
hLogo = CreateBitmap(310, 88, 1, 32, gameLogo);
SendDlgItemMessage(hDlg, 1003, STM_SETIMAGE, (WPARAM)IMAGE_BITMAP, (LPARAM)hLogo);
}
if (gameSettings.userFullScreen)
CheckDlgButton(hDlg, 1000, BST_CHECKED);
else
else
CheckDlgButton(hDlg, 1000, BST_UNCHECKED);
SendDlgItemMessage(hDlg, 1002, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)TEXT("Default (best looking)")));
SendDlgItemMessage(hDlg, 1002, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)TEXT("Linear (faster but blurry)")));
SendDlgItemMessage(hDlg, 1002, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)TEXT("Off (blocky graphics)")));
SendDlgItemMessage(hDlg, 1002, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)TEXT("Default (best looking)")));
SendDlgItemMessage(hDlg, 1002, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)TEXT("Linear (faster but blurry)")));
SendDlgItemMessage(hDlg, 1002, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)TEXT("Off (blocky graphics)")));
if (gameSettings.antiAlias < 0)
if (gameSettings.antiAlias < 0)
SendDlgItemMessage(hDlg, 1002, CB_SETCURSEL, 1, 0);
else if (gameSettings.antiAlias)
else if (gameSettings.antiAlias)
SendDlgItemMessage(hDlg, 1002, CB_SETCURSEL, 0, 0);
else
else
SendDlgItemMessage(hDlg, 1002, CB_SETCURSEL, 2, 0);
if (gameSettings.numLanguages) {
WCHAR text[20];
for (unsigned int i = 0; i <= gameSettings.numLanguages; i++) {
if (languageName[i]) {
WCHAR *w_lang = ConvertToUTF16(languageName[i]);
SendDlgItemMessage(hDlg, 1001, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)w_lang));
delete w_lang;
} else {
swprintf(text, TEXT("Language %d"), i);
SendDlgItemMessage(hDlg, 1001, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)text));
}
}
SendDlgItemMessage(hDlg, 1001, CB_SETCURSEL, getLanguageForFileB(), 0);
} else {
const WCHAR *text = TEXT("No translations available");
SendDlgItemMessage(hDlg, 1001, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)text));
SendDlgItemMessage(hDlg, 1001, CB_SETCURSEL, 0, 0);
EnableWindow(GetDlgItem(hDlg, 1001), false);
}
return true;
case WM_COMMAND:
if (hLogo) DeleteObject(hLogo);
switch (LOWORD(wParam)) {
case IDOK:
gameSettings.userFullScreen = (IsDlgButtonChecked(hDlg, 1000) == BST_CHECKED);
gameSettings.antiAlias = SendDlgItemMessage(hDlg, 1002, CB_GETCURSEL, 0, 0);
if (gameSettings.antiAlias == 0) gameSettings.antiAlias = 1;
else if (gameSettings.antiAlias == 1) gameSettings.antiAlias = -1;
else if (gameSettings.antiAlias == 2) gameSettings.antiAlias = 0;
if (gameSettings.numLanguages) {
gameSettings.languageID = SendDlgItemMessage(hDlg, 1001, CB_GETCURSEL, 0, 0);
if (gameSettings.languageID < 0) gameSettings.languageID = 0;
gameSettings.languageID = languageTable[gameSettings.languageID];
WCHAR text[20];
for (unsigned int i = 0; i <= gameSettings.numLanguages; i++) {
if (languageName[i]) {
WCHAR *w_lang = ConvertToUTF16(languageName[i]);
SendDlgItemMessage(hDlg, 1001, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)w_lang));
delete w_lang;
} else {
swprintf(text, TEXT("Language %d"), i);
SendDlgItemMessage(hDlg, 1001, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)text));
}
}
SendDlgItemMessage(hDlg, 1001, CB_SETCURSEL, getLanguageForFileB(), 0);
} else {
const WCHAR *text = TEXT("No translations available");
SendDlgItemMessage(hDlg, 1001, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>((LPCTSTR)text));
SendDlgItemMessage(hDlg, 1001, CB_SETCURSEL, 0, 0);
EnableWindow(GetDlgItem(hDlg, 1001), false);
}
EndDialog(hDlg, true);
return TRUE;
return true;
case IDCANCEL:
EndDialog(hDlg, false);
return TRUE;
case WM_COMMAND:
if (hLogo) DeleteObject(hLogo);
switch (LOWORD(wParam)) {
case IDOK:
gameSettings.userFullScreen = (IsDlgButtonChecked(hDlg, 1000) == BST_CHECKED);
gameSettings.antiAlias = SendDlgItemMessage(hDlg, 1002, CB_GETCURSEL, 0, 0);
if (gameSettings.antiAlias == 0) gameSettings.antiAlias = 1;
else if (gameSettings.antiAlias == 1) gameSettings.antiAlias = -1;
else if (gameSettings.antiAlias == 2) gameSettings.antiAlias = 0;
if (gameSettings.numLanguages) {
gameSettings.languageID = SendDlgItemMessage(hDlg, 1001, CB_GETCURSEL, 0, 0);
if (gameSettings.languageID < 0) gameSettings.languageID = 0;
gameSettings.languageID = languageTable[gameSettings.languageID];
}
EndDialog(hDlg, true);
return TRUE;
case IDCANCEL:
EndDialog(hDlg, false);
return TRUE;
}
break;
}
break;
}
return false;
}
int showSetupWindow() {
hInst = GetModuleHandle(NULL);
if (! hInst) debugOut("ERROR: No hInst!\n");
if (DialogBox(hInst, TEXT("SETUPWINDOW"), NULL, setupDlgProc)) return true;
return false;
}
void msgBox(const char *head, const char *msg) {
WCHAR *w_head = ConvertToUTF16(head);
WCHAR *w_msg = ConvertToUTF16(msg);
MessageBox(NULL, w_msg, w_head, MB_OK | MB_ICONSTOP | MB_SYSTEMMODAL | MB_SETFOREGROUND);
delete w_head;
delete w_msg;
}
int msgBoxQuestion(const char *head, const char *msg) {
WCHAR *w_head = ConvertToUTF16(head);
WCHAR *w_msg = ConvertToUTF16(msg);
int val = MessageBox(NULL, w_msg, w_head, MB_YESNO | MB_SETFOREGROUND | MB_APPLMODAL | MB_ICONQUESTION) == IDNO;
delete w_head;
delete w_msg;
if (val)
return false;
return true;
}
}
void changeToUserDir() {
TCHAR szAppData[MAX_PATH];
/*hr = */SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, szAppData);
_wchdir(szAppData);
}
int showSetupWindow() {
uint32_t launch(char *f) {
WCHAR *w_f = ConvertToUTF16(f);
uint32_t r = (uint32_t) ShellExecute(hMainWindow, TEXT("open"), w_f, NULL, TEXT("C:\\"), SW_SHOWNORMAL);
delete w_f;
return r;
}
hInst = GetModuleHandle(NULL);
bool defaultUserFullScreen() {
return true;
}
if (! hInst) debugOut("ERROR: No hInst!\n");
if (DialogBox(hInst, TEXT("SETUPWINDOW"), NULL, setupDlgProc)) return true;
return false;
}
void msgBox(const char *head, const char *msg) {
WCHAR *w_head = ConvertToUTF16(head);
WCHAR *w_msg = ConvertToUTF16(msg);
MessageBox(NULL, w_msg, w_head, MB_OK | MB_ICONSTOP | MB_SYSTEMMODAL | MB_SETFOREGROUND);
delete w_head;
delete w_msg;
}
int msgBoxQuestion(const char *head, const char *msg) {
WCHAR *w_head = ConvertToUTF16(head);
WCHAR *w_msg = ConvertToUTF16(msg);
int val = MessageBox(NULL, w_msg, w_head, MB_YESNO | MB_SETFOREGROUND | MB_APPLMODAL | MB_ICONQUESTION) == IDNO;
delete w_head;
delete w_msg;
if (val)
return false;
return true;
}
void changeToUserDir() {
TCHAR szAppData[MAX_PATH];
/*hr = */SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, szAppData);
_wchdir(szAppData);
}
uint32_t launch(char *f) {
WCHAR *w_f = ConvertToUTF16(f);
uint32_t r = (uint32_t) ShellExecute(hMainWindow, TEXT("open"), w_f, NULL, TEXT("C:\\"), SW_SHOWNORMAL);
delete w_f;
return r;
}
bool defaultUserFullScreen() {
return true;
}
} // End of namespace Sludge

13
engines/sludge/zbuffer.cpp
View File

@ -47,13 +47,14 @@ void killZBuffer() {
void sortZPal(int *oldpal, int *newpal, int size) {
int i, tmp;
for (i = 0; i < size; i ++) {
for (i = 0; i < size; i++) {
newpal[i] = i;
}
if (size < 2) return;
if (size < 2)
return;
for (i = 1; i < size; i ++) {
for (i = 1; i < size; i++) {
if (oldpal[newpal[i]] < oldpal[newpal[i - 1]]) {
tmp = newpal[i];
newpal[i] = newpal[i - 1];
@ -80,17 +81,17 @@ bool setZBuffer(int y) {
if (fgetc(bigDataFile) != 'b') return fatal("Not a Z-buffer file");
switch (fgetc(bigDataFile)) {
case 0:
case 0:
zBuffer.width = 640;
zBuffer.height = 480;
break;
case 1:
case 1:
zBuffer.width = get2bytes(bigDataFile);
zBuffer.height = get2bytes(bigDataFile);
break;
default:
default:
return fatal("Extended Z-buffer format not supported in this version of the SLUDGE engine");
}
if (zBuffer.width != sceneWidth || zBuffer.height != sceneHeight) {

1
engines/sludge/zbuffer.h
View File

@ -44,7 +44,6 @@ struct zBufferData {
#endif
};
bool setZBuffer(int y);
void killZBuffer();
void drawZBuffer(int x, int y, bool upsidedown);