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

Whitespace: "(type *)something" instead of "(type *) something", because

Browse Source 
that's how we write it in most other places.

svn-id: r18069
This commit is contained in:
Torbjörn Andersson 2005-05-12 13:12:15 +00:00
parent d6a20a231b
commit d34e5fc605
29 changed files with 269 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
sword2/anims.cpp
View File

@ -64,7 +64,7 @@ int Router::doAnimate(ObjectLogic *ob_logic, ObjectGraphic *ob_graphic, int32 an
return IR_STOP;
}
head = (StandardHeader *) _vm->_resman->openResource(animRes);
head = (StandardHeader *)_vm->_resman->openResource(animRes);
// if it's not an animation file
if (head->fileType != ANIMATION_FILE) {
@ -88,7 +88,7 @@ int Router::doAnimate(ObjectLogic *ob_logic, ObjectGraphic *ob_graphic, int32 an
// open anim file
anim_file = _vm->_resman->openResource(animRes);
head = (StandardHeader *) anim_file;
head = (StandardHeader *)anim_file;
assert(head->fileType == ANIMATION_FILE);
// point to anim header
@ -251,7 +251,7 @@ void Logic::createSequenceSpeech(MovieTextObject *sequenceText[]) {
// now fill out the SpriteInfo structure in the
// MovieTextObjectStructure
frame = (FrameHeader *) _sequenceTextList[line].text_mem;
frame = (FrameHeader *)_sequenceTextList[line].text_mem;
sequenceText[line]->textSprite = new SpriteInfo;

22
sword2/build_display.cpp
View File

@ -52,11 +52,11 @@ Screen::Screen(Sword2Engine *vm, int16 width, int16 height) {
if ((width % CELLWIDE) || (height % CELLDEEP))
error("Bad cell size");
_dirtyGrid = (byte *) calloc(_gridWide, _gridDeep);
_dirtyGrid = (byte *)calloc(_gridWide, _gridDeep);
if (!_dirtyGrid)
error("Could not initialise dirty grid");
_buffer = (byte *) malloc(width * height);
_buffer = (byte *)malloc(width * height);
if (!_buffer)
error("Could not initialise display");
@ -116,7 +116,7 @@ void Screen::buildDisplay() {
startRenderCycle();
byte *file = _vm->_resman->openResource(_thisScreen.background_layer_id);
MultiScreenHeader *screenLayerTable = (MultiScreenHeader *) (file + sizeof(StandardHeader));
MultiScreenHeader *screenLayerTable = (MultiScreenHeader *)(file + sizeof(StandardHeader));
// Render at least one frame, but if the screen is scrolling, and if
// there is time left, we will render extra frames to smooth out the
@ -199,7 +199,7 @@ void Screen::displayMsg(byte *text, int time) {
clearScene();
byte *text_spr = _vm->_fontRenderer->makeTextSprite(text, 640, 187, _vm->_speechFontId);
FrameHeader *frame = (FrameHeader *) text_spr;
FrameHeader *frame = (FrameHeader *)text_spr;
SpriteInfo spriteInfo;
@ -404,7 +404,7 @@ void Screen::processImage(BuildUnit *build_unit) {
spriteType |= RDSPR_RLE16;
// points to just after last cdt_entry, ie.
// start of colour table
colTablePtr = (byte *) (anim_head + 1) + anim_head->noAnimFrames * sizeof(CdtEntry);
colTablePtr = (byte *)(anim_head + 1) + anim_head->noAnimFrames * sizeof(CdtEntry);
break;
}
}
@ -426,7 +426,7 @@ void Screen::processImage(BuildUnit *build_unit) {
spriteInfo.type = spriteType;
spriteInfo.blend = anim_head->blend;
// points to just after frame header, ie. start of sprite data
spriteInfo.data = (byte *) (frame_head + 1);
spriteInfo.data = (byte *)(frame_head + 1);
spriteInfo.colourTable = colTablePtr;
// check for largest layer for debug info
@ -719,7 +719,7 @@ void Screen::rollCredits() {
palette[i * 4 + 3] = 0;
}
logoData = (byte *) malloc(logoWidth * logoHeight);
logoData = (byte *)malloc(logoWidth * logoHeight);
f.read(logoData, logoWidth * logoHeight);
f.close();
@ -890,10 +890,10 @@ void Screen::rollCredits() {
if (!creditsLines[i].sprite) {
debug(2, "Creating sprite '%s'", creditsLines[i].str);
creditsLines[i].sprite = _vm->_fontRenderer->makeTextSprite((byte *) creditsLines[i].str, 600, 14, _vm->_speechFontId, 0);
creditsLines[i].sprite = _vm->_fontRenderer->makeTextSprite((byte *)creditsLines[i].str, 600, 14, _vm->_speechFontId, 0);
}
FrameHeader *frame = (FrameHeader *) creditsLines[i].sprite;
FrameHeader *frame = (FrameHeader *)creditsLines[i].sprite;
spriteInfo.y = creditsLines[i].top - scrollPos;
spriteInfo.w = frame->width;
@ -1020,7 +1020,7 @@ void Screen::splashScreen() {
barSprite.type = RDSPR_RLE256FAST | RDSPR_TRANS;
barSprite.blend = 0;
barSprite.colourTable = 0;
barSprite.data = (byte *) (frame + 1);
barSprite.data = (byte *)(frame + 1);
drawSprite(&barSprite);
@ -1029,7 +1029,7 @@ void Screen::splashScreen() {
for (int i = 0; i < animHead->noAnimFrames; i++) {
frame = _vm->fetchFrameHeader(loadingBar, i);
barSprite.data = (byte *) (frame + 1);
barSprite.data = (byte *)(frame + 1);
drawSprite(&barSprite);
updateDisplay();
_vm->_system->delayMillis(30);

16
sword2/console.cpp
View File

@ -180,8 +180,8 @@ bool Debugger::Cmd_Help(int argc, const char **argv) {
}
static int compare_blocks(const void *p1, const void *p2) {
const MemBlock *m1 = *(const MemBlock * const *) p1;
const MemBlock *m2 = *(const MemBlock * const *) p2;
const MemBlock *m1 = *(const MemBlock * const *)p1;
const MemBlock *m2 = *(const MemBlock * const *)p2;
if (m1->size < m2->size)
return 1;
@ -194,7 +194,7 @@ bool Debugger::Cmd_Mem(int argc, const char **argv) {
int16 numBlocks = _vm->_memory->getNumBlocks();
MemBlock *memBlocks = _vm->_memory->getMemBlocks();
MemBlock **blocks = (MemBlock **) malloc(numBlocks * sizeof(MemBlock));
MemBlock **blocks = (MemBlock **)malloc(numBlocks * sizeof(MemBlock));
int i, j;
@ -209,7 +209,7 @@ bool Debugger::Cmd_Mem(int argc, const char **argv) {
DebugPrintf("---------------------------------------------------------------------------\n");
for (i = 0; i < numBlocks; i++) {
StandardHeader *head = (StandardHeader *) blocks[i]->ptr;
StandardHeader *head = (StandardHeader *)blocks[i]->ptr;
const char *type;
switch (head->fileType) {
@ -320,7 +320,7 @@ bool Debugger::Cmd_ResList(int argc, const char **argv) {
for (uint i = 0; i < numResFiles; i++) {
if (resList[i].ptr && resList[i].refCount >= minCount) {
StandardHeader *head = (StandardHeader *) resList[i].ptr;
StandardHeader *head = (StandardHeader *)resList[i].ptr;
DebugPrintf("%-4d: %-35s refCount: %-3d\n", i, head->name, resList[i].refCount);
}
}
@ -445,7 +445,7 @@ bool Debugger::Cmd_ResLook(int argc, const char **argv) {
}
// Open up the resource and take a look inside!
StandardHeader *file_header = (StandardHeader *) _vm->_resman->openResource(res);
StandardHeader *file_header = (StandardHeader *)_vm->_resman->openResource(res);
switch (file_header->fileType) {
case ANIMATION_FILE:
@ -512,12 +512,12 @@ bool Debugger::Cmd_RunList(int argc, const char **argv) {
uint32 runList = _vm->_logic->getRunList();
if (runList) {
game_object_list = (uint32 *) (_vm->_resman->openResource(runList) + sizeof(StandardHeader));
game_object_list = (uint32 *)(_vm->_resman->openResource(runList) + sizeof(StandardHeader));
DebugPrintf("Runlist number %d\n", runList);
for (int i = 0; game_object_list[i]; i++) {
file_header = (StandardHeader *) _vm->_resman->openResource(game_object_list[i]);
file_header = (StandardHeader *)_vm->_resman->openResource(game_object_list[i]);
DebugPrintf("%d %s\n", game_object_list[i], file_header->name);
_vm->_resman->closeResource(game_object_list[i]);
}

24
sword2/controls.cpp
View File

@ -145,8 +145,8 @@ FontRendererGui::FontRendererGui(Sword2Engine *vm, int fontId)
sprite.type = RDSPR_NOCOMPRESSION | RDSPR_TRANS;
for (int i = 0; i < SIZE_OF_CHAR_SET; i++) {
head = (FrameHeader *) _vm->fetchFrameHeader(font, i);
sprite.data = (byte *) (head + 1);
head = (FrameHeader *)_vm->fetchFrameHeader(font, i);
sprite.data = (byte *)(head + 1);
sprite.w = head->width;
sprite.h = head->height;
_vm->_screen->createSurface(&sprite, &_glyph[i]._data);
@ -399,8 +399,8 @@ int Dialog::runModal() {
Widget::Widget(Dialog *parent, int states)
: _vm(parent->_vm), _parent(parent), _numStates(states), _state(0) {
_sprites = (SpriteInfo *) calloc(states, sizeof(SpriteInfo));
_surfaces = (WidgetSurface *) calloc(states, sizeof(WidgetSurface));
_sprites = (SpriteInfo *)calloc(states, sizeof(SpriteInfo));
_surfaces = (WidgetSurface *)calloc(states, sizeof(WidgetSurface));
_hitRect.left = _hitRect.right = _hitRect.top = _hitRect.bottom = -1;
}
@ -447,7 +447,7 @@ void Widget::createSurfaceImage(int state, uint32 res, int x, int y, uint32 pc)
spriteType |= RDSPR_RLE256;
// Points to just after last cdt_entry, i.e. start of colour
// table
colTablePtr = (byte *) (anim_head + 1) +
colTablePtr = (byte *)(anim_head + 1) +
anim_head->noAnimFrames * sizeof(CdtEntry);
break;
}
@ -461,7 +461,7 @@ void Widget::createSurfaceImage(int state, uint32 res, int x, int y, uint32 pc)
_sprites[state].blend = anim_head->blend;
// Points to just after frame header, ie. start of sprite data
_sprites[state].data = (byte *) (frame_head + 1);
_sprites[state].data = (byte *)(frame_head + 1);
_vm->_screen->createSurface(&_sprites[state], &_surfaces[state]._surface);
_surfaces[state]._original = true;
@ -1074,9 +1074,9 @@ public:
void setText(FontRendererGui *fr, int slot, byte *text) {
_fr = fr;
if (text)
sprintf((char *) _text, "%d. %s", slot, text);
sprintf((char *)_text, "%d. %s", slot, text);
else
sprintf((char *) _text, "%d. ", slot);
sprintf((char *)_text, "%d. ", slot);
}
byte *getText() {
@ -1285,7 +1285,7 @@ void SaveRestoreDialog::onAction(Widget *widget, int result) {
} else if (widget == _cancelButton) {
setResult(0);
} else {
Slot *slot = (Slot *) widget;
Slot *slot = (Slot *)widget;
int textWidth;
byte tmp;
int i;
@ -1322,8 +1322,8 @@ void SaveRestoreDialog::onAction(Widget *widget, int result) {
else
_firstPos = 4;
strcpy((char *) _editBuffer, (char *) slot->getText());
_editPos = strlen((char *) _editBuffer);
strcpy((char *)_editBuffer, (char *)slot->getText());
_editPos = strlen((char *)_editBuffer);
_cursorTick = 0;
_editBuffer[_editPos] = '_';
_editBuffer[_editPos + 1] = 0;
@ -1400,7 +1400,7 @@ int SaveRestoreDialog::runModal() {
if (result) {
switch (_mode) {
case kSaveDialog:
if (_vm->saveGame(_selectedSlot, (byte *) &_editBuffer[_firstPos]) != SR_OK)
if (_vm->saveGame(_selectedSlot, (byte *)&_editBuffer[_firstPos]) != SR_OK)
result = 0;
break;
case kRestoreDialog:

2
sword2/debug.cpp
View File

@ -53,7 +53,7 @@ void Debugger::makeDebugTextBlock(char *text, int16 x, int16 y) {
assert(blockNo < MAX_DEBUG_TEXTS);
_debugTextBlocks[blockNo] = _vm->_fontRenderer->buildNewBloc((byte *) text, x, y, 640 - x, 0, RDSPR_DISPLAYALIGN, CONSOLE_FONT_ID, NO_JUSTIFICATION);
_debugTextBlocks[blockNo] = _vm->_fontRenderer->buildNewBloc((byte *)text, x, y, 640 - x, 0, RDSPR_DISPLAYALIGN, CONSOLE_FONT_ID, NO_JUSTIFICATION);
}
void Debugger::buildDebugText() {

16
sword2/driver/_mouse.cpp
View File

@ -122,7 +122,7 @@ void Mouse::drawMouse() {
memset(mouseData, 0, mouse_width * mouse_height);
if (_luggageAnim)
decompressMouse(mouseData, (byte *) _luggageAnim + READ_LE_UINT32(_luggageOffset), _luggageAnim->mousew,
decompressMouse(mouseData, (byte *)_luggageAnim + READ_LE_UINT32(_luggageOffset), _luggageAnim->mousew,
_luggageAnim->mouseh, mouse_width, deltaX, deltaY);
if (_mouseAnim)
@ -144,7 +144,7 @@ int32 Mouse::animateMouse() {
if (++_mouseFrame == _mouseAnim->noAnimFrames)
_mouseFrame = MOUSEFLASHFRAME;
_mouseSprite = (byte *) _mouseAnim + READ_LE_UINT32(_mouseOffsets + _mouseFrame);
_mouseSprite = (byte *)_mouseAnim + READ_LE_UINT32(_mouseOffsets + _mouseFrame);
if (_mouseFrame != prevMouseFrame)
drawMouse();
@ -172,12 +172,12 @@ int32 Mouse::setMouseAnim(byte *ma, int32 size, int32 mouseFlash) {
else
_mouseFrame = MOUSEFLASHFRAME;
_mouseAnim = (MouseAnim *) malloc(size);
_mouseAnim = (MouseAnim *)malloc(size);
if (!_mouseAnim)
return RDERR_OUTOFMEMORY;
memcpy((byte *) _mouseAnim, ma, size);
_mouseOffsets = (int32 *) ((byte *) _mouseAnim + sizeof(MouseAnim));
memcpy((byte *)_mouseAnim, ma, size);
_mouseOffsets = (int32 *)((byte *)_mouseAnim + sizeof(MouseAnim));
animateMouse();
drawMouse();
@ -207,12 +207,12 @@ int32 Mouse::setLuggageAnim(byte *ma, int32 size) {
}
if (ma) {
_luggageAnim = (MouseAnim *) malloc(size);
_luggageAnim = (MouseAnim *)malloc(size);
if (!_luggageAnim)
return RDERR_OUTOFMEMORY;
memcpy((byte *) _luggageAnim, ma, size);
_luggageOffset = (int32 *) ((byte *) _luggageAnim + sizeof(MouseAnim));
memcpy((byte *)_luggageAnim, ma, size);
_luggageOffset = (int32 *)((byte *)_luggageAnim + sizeof(MouseAnim));
animateMouse();
drawMouse();

6
sword2/driver/animation.cpp
View File

@ -177,7 +177,7 @@ int32 MoviePlayer::play(const char *filename, MovieTextObject *text[], int32 lea
if (leadInRes) {
byte *leadIn = _vm->_resman->openResource(leadInRes);
uint32 leadInLen = _vm->_resman->fetchLen(leadInRes) - sizeof(StandardHeader);
StandardHeader *header = (StandardHeader *) leadIn;
StandardHeader *header = (StandardHeader *)leadIn;
assert(header->fileType == WAV_FILE);
@ -192,7 +192,7 @@ int32 MoviePlayer::play(const char *filename, MovieTextObject *text[], int32 lea
if (leadOutRes) {
leadOut = _vm->_resman->openResource(leadOutRes);
leadOutLen = _vm->_resman->fetchLen(leadOutRes) - sizeof(StandardHeader);
StandardHeader *header = (StandardHeader *) leadOut;
StandardHeader *header = (StandardHeader *)leadOut;
assert(header->fileType == WAV_FILE);
@ -420,7 +420,7 @@ void MoviePlayer::playDummy(const char *filename, MovieTextObject *text[], byte
data = _vm->_fontRenderer->makeTextSprite(msg, RENDERWIDE, 255, _vm->_speechFontId);
}
FrameHeader *frame = (FrameHeader *) data;
FrameHeader *frame = (FrameHeader *)data;
SpriteInfo msgSprite;
byte *msgSurface;

8
sword2/driver/d_sound.cpp
View File

@ -423,9 +423,9 @@ int Sound::readBuffer(int16 *buffer, const int numSamples) {
if (!_mixBuffer || numSamples > _mixBufferLen) {
if (_mixBuffer)
_mixBuffer = (int16 *) realloc(_mixBuffer, 2 * numSamples);
_mixBuffer = (int16 *)realloc(_mixBuffer, 2 * numSamples);
else
_mixBuffer = (int16 *) malloc(2 * numSamples);
_mixBuffer = (int16 *)malloc(2 * numSamples);
_mixBufferLen = numSamples;
}
@ -724,14 +724,14 @@ uint32 Sound::preFetchCompSpeech(uint32 speechId, uint16 **buf) {
uint32 bufferSize = 2 * numSamples;
*buf = (uint16 *) malloc(bufferSize);
*buf = (uint16 *)malloc(bufferSize);
if (!*buf) {
delete input;
fh->file->close();
return 0;
}
uint32 readSamples = input->readBuffer((int16 *) *buf, numSamples);
uint32 readSamples = input->readBuffer((int16 *)*buf, numSamples);
fh->file->close();
delete input;

2
sword2/driver/menu.cpp
View File

@ -278,7 +278,7 @@ int32 Mouse::setMenuIcon(uint8 menu, uint8 pocket, byte *icon) {
// Only put the icon in the pocket if it is not NULL
if (icon != NULL) {
_iconCount++;
_icons[menu][pocket] = (byte *) malloc(RDMENU_ICONWIDE * RDMENU_ICONDEEP);
_icons[menu][pocket] = (byte *)malloc(RDMENU_ICONWIDE * RDMENU_ICONDEEP);
if (_icons[menu][pocket] == NULL)
return RDERR_OUTOFMEMORY;
memcpy(_icons[menu][pocket], icon, RDMENU_ICONWIDE * RDMENU_ICONDEEP);

2
sword2/driver/palette.cpp
View File

@ -88,7 +88,7 @@ void Screen::setFullPalette(int32 palRes) {
if (palRes) {
byte *pal = _vm->_resman->openResource(palRes);
StandardHeader *head = (StandardHeader *) pal;
StandardHeader *head = (StandardHeader *)pal;
assert(head->fileType == PALETTE_FILE);
pal += sizeof(StandardHeader);

10
sword2/driver/render.cpp
View File

@ -213,7 +213,7 @@ void Screen::plotPoint(int x, int y, uint8 colour) {
}
static void plot(int x, int y, int colour, void *data) {
Screen *screen = (Screen *) data;
Screen *screen = (Screen *)data;
screen->plotPoint(x, y, (uint8) colour);
}
@ -427,13 +427,13 @@ int32 Screen::initialiseBackgroundLayer(Parallax *p) {
_xBlocks[_layer] = (p->w + BLOCKWIDTH - 1) / BLOCKWIDTH;
_yBlocks[_layer] = (p->h + BLOCKHEIGHT - 1) / BLOCKHEIGHT;
_blockSurfaces[_layer] = (BlockSurface **) calloc(_xBlocks[_layer] * _yBlocks[_layer], sizeof(BlockSurface *));
_blockSurfaces[_layer] = (BlockSurface **)calloc(_xBlocks[_layer] * _yBlocks[_layer], sizeof(BlockSurface *));
if (!_blockSurfaces[_layer])
return RDERR_OUTOFMEMORY;
// Decode the parallax layer into a large chunk of memory
byte *memchunk = (byte *) calloc(_xBlocks[_layer] * _yBlocks[_layer], BLOCKWIDTH * BLOCKHEIGHT);
byte *memchunk = (byte *)calloc(_xBlocks[_layer] * _yBlocks[_layer], BLOCKWIDTH * BLOCKHEIGHT);
if (!memchunk)
return RDERR_OUTOFMEMORY;
@ -441,7 +441,7 @@ int32 Screen::initialiseBackgroundLayer(Parallax *p) {
if (!p->offset[i])
continue;
byte *pLine = (byte *) p + FROM_LE_32(p->offset[i]);
byte *pLine = (byte *)p + FROM_LE_32(p->offset[i]);
uint16 packets = READ_LE_UINT16(pLine);
uint16 offset = READ_LE_UINT16(pLine + 2);
@ -503,7 +503,7 @@ int32 Screen::initialiseBackgroundLayer(Parallax *p) {
// Only assign a surface to the block if it contains data.
if (block_has_data) {
_blockSurfaces[_layer][i] = (BlockSurface *) malloc(sizeof(BlockSurface));
_blockSurfaces[_layer][i] = (BlockSurface *)malloc(sizeof(BlockSurface));
// Copy the data into the surfaces.
dst = _blockSurfaces[_layer][i]->data;

12
sword2/driver/sprite.cpp
View File

@ -247,7 +247,7 @@ int32 Screen::decompressRLE16(byte *dst, byte *src, int32 decompSize, byte *colT
*/
int32 Screen::createSurface(SpriteInfo *s, byte **sprite) {
*sprite = (byte *) malloc(s->w * s->h);
*sprite = (byte *)malloc(s->w * s->h);
if (!*sprite)
return RDERR_OUTOFMEMORY;
@ -371,7 +371,7 @@ int32 Screen::drawSprite(SpriteInfo *s) {
if (s->type & RDSPR_NOCOMPRESSION)
sprite = s->data;
else {
sprite = (byte *) malloc(s->w * s->h);
sprite = (byte *)malloc(s->w * s->h);
freeSprite = true;
if (!sprite)
return RDERR_OUTOFMEMORY;
@ -389,7 +389,7 @@ int32 Screen::drawSprite(SpriteInfo *s) {
}
if (s->type & RDSPR_FLIP) {
newSprite = (byte *) malloc(s->w * s->h);
newSprite = (byte *)malloc(s->w * s->h);
if (newSprite == NULL) {
if (freeSprite)
free(sprite);
@ -482,7 +482,7 @@ int32 Screen::drawSprite(SpriteInfo *s) {
return RDERR_NOTIMPLEMENTED;
}
newSprite = (byte *) malloc(s->scaledWidth * s->scaledHeight);
newSprite = (byte *)malloc(s->scaledWidth * s->scaledHeight);
if (newSprite == NULL) {
if (freeSprite)
free(sprite);
@ -516,7 +516,7 @@ int32 Screen::drawSprite(SpriteInfo *s) {
// RDSPR_NOCOMPRESSION case.
if (!freeSprite) {
newSprite = (byte *) malloc(s->w * s->h);
newSprite = (byte *)malloc(s->w * s->h);
memcpy(newSprite, sprite, s->w * s->h);
sprite = newSprite;
freeSprite = true;
@ -624,7 +624,7 @@ int32 Screen::openLightMask(SpriteInfo *s) {
if (_lightMask)
return RDERR_NOTCLOSED;
_lightMask = (byte *) malloc(s->w * s->h);
_lightMask = (byte *)malloc(s->w * s->h);
if (!_lightMask)
return RDERR_OUTOFMEMORY;

186
sword2/function.cpp
View File

@ -52,7 +52,7 @@ int32 Logic::fnRegisterStartPoint(int32 *params) {
// 1 pointer to ascii message
int32 key = params[0];
char *name = (char *) decodePtr(params[1]);
char *name = (char *)decodePtr(params[1]);
_vm->registerStartPoint(key, name);
return IR_CONT;
@ -81,19 +81,19 @@ int32 Logic::fnSetSession(int32 *params) {
int32 Logic::fnBackSprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteStatus((ObjectGraphic *) decodePtr(params[0]), BACK_SPRITE);
_router->setSpriteStatus((ObjectGraphic *)decodePtr(params[0]), BACK_SPRITE);
return IR_CONT;
}
int32 Logic::fnSortSprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteStatus((ObjectGraphic *) decodePtr(params[0]), SORT_SPRITE);
_router->setSpriteStatus((ObjectGraphic *)decodePtr(params[0]), SORT_SPRITE);
return IR_CONT;
}
int32 Logic::fnForeSprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteStatus((ObjectGraphic *) decodePtr(params[0]), FORE_SPRITE);
_router->setSpriteStatus((ObjectGraphic *)decodePtr(params[0]), FORE_SPRITE);
return IR_CONT;
}
@ -106,7 +106,7 @@ int32 Logic::fnRegisterMouse(int32 *params) {
// params: 0 pointer to ObjectMouse or 0 for no write to mouse
// list
_vm->_mouse->registerMouse((ObjectMouse *) decodePtr(params[0]), NULL);
_vm->_mouse->registerMouse((ObjectMouse *)decodePtr(params[0]), NULL);
return IR_CONT;
}
@ -117,8 +117,8 @@ int32 Logic::fnAnim(int32 *params) {
// Normal forward animation
return _router->doAnimate(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
params[2], false);
}
@ -198,10 +198,10 @@ int32 Logic::fnWalk(int32 *params) {
// 6 target direction (8 means end walk on ANY direction)
return _router->doWalk(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectMega *) decodePtr(params[2]),
(ObjectWalkdata *) decodePtr(params[3]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
(ObjectMega *)decodePtr(params[2]),
(ObjectWalkdata *)decodePtr(params[3]),
params[4], params[5], params[6]);
}
@ -217,10 +217,10 @@ int32 Logic::fnWalkToAnim(int32 *params) {
// 4 anim resource id
return _router->walkToAnim(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectMega *) decodePtr(params[2]),
(ObjectWalkdata *) decodePtr(params[3]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
(ObjectMega *)decodePtr(params[2]),
(ObjectWalkdata *)decodePtr(params[3]),
params[4]);
}
@ -236,10 +236,10 @@ int32 Logic::fnTurn(int32 *params) {
// 4 target direction
return _router->doFace(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectMega *) decodePtr(params[2]),
(ObjectWalkdata *) decodePtr(params[3]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
(ObjectMega *)decodePtr(params[2]),
(ObjectWalkdata *)decodePtr(params[3]),
params[4]);
}
@ -257,8 +257,8 @@ int32 Logic::fnStandAt(int32 *params) {
// 4 target direction
_router->standAt(
(ObjectGraphic *) decodePtr(params[0]),
(ObjectMega *) decodePtr(params[1]),
(ObjectGraphic *)decodePtr(params[0]),
(ObjectMega *)decodePtr(params[1]),
params[2], params[3], params[4]);
return IR_CONT;
}
@ -272,10 +272,10 @@ int32 Logic::fnStand(int32 *params) {
// params: 0 pointer to object's graphic structure
// 1 pointer to object's mega structure
// 2 target direction
ObjectMega *ob_mega = (ObjectMega *) decodePtr(params[1]);
ObjectMega *ob_mega = (ObjectMega *)decodePtr(params[1]);
_router->standAt(
(ObjectGraphic *) decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[0]),
ob_mega, ob_mega->feet_x, ob_mega->feet_y, params[2]);
return IR_CONT;
}
@ -290,8 +290,8 @@ int32 Logic::fnStandAfterAnim(int32 *params) {
// 2 anim resource id
_router->standAfterAnim(
(ObjectGraphic *) decodePtr(params[0]),
(ObjectMega *) decodePtr(params[1]),
(ObjectGraphic *)decodePtr(params[0]),
(ObjectMega *)decodePtr(params[1]),
params[2]);
return IR_CONT;
}
@ -303,7 +303,7 @@ int32 Logic::fnPause(int32 *params) {
// NB. Pause-value of 0 causes script to continue, 1 causes a 1-cycle
// quit, 2 gives 2 cycles, etc.
ObjectLogic *ob_logic = (ObjectLogic *) decodePtr(params[0]);
ObjectLogic *ob_logic = (ObjectLogic *)decodePtr(params[0]);
if (ob_logic->looping == 0) {
ob_logic->looping = 1;
@ -327,17 +327,17 @@ int32 Logic::fnMegaTableAnim(int32 *params) {
// Normal forward anim
return _router->megaTableAnimate(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectMega *) decodePtr(params[2]),
(uint32 *) decodePtr(params[3]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
(ObjectMega *)decodePtr(params[2]),
(uint32 *)decodePtr(params[3]),
false);
}
int32 Logic::fnAddMenuObject(int32 *params) {
// params: 0 pointer to a MenuObject structure to copy down
_vm->_mouse->addMenuObject((MenuObject *) decodePtr(params[0]));
_vm->_mouse->addMenuObject((MenuObject *)decodePtr(params[0]));
return IR_CONT;
}
@ -379,14 +379,14 @@ int32 Logic::fnSetFrame(int32 *params) {
// open the resource (& check it's valid)
byte *anim_file = _vm->_resman->openResource(res);
StandardHeader *head = (StandardHeader *) anim_file;
StandardHeader *head = (StandardHeader *)anim_file;
assert(head->fileType == ANIMATION_FILE);
// set up pointer to the animation header
AnimHeader *anim_head = _vm->fetchAnimHeader(anim_file);
// set up anim resource in graphic object
ObjectGraphic *ob_graphic = (ObjectGraphic *) decodePtr(params[0]);
ObjectGraphic *ob_graphic = (ObjectGraphic *)decodePtr(params[0]);
ob_graphic->anim_resource = res;
ob_graphic->anim_pc = params[2] ? anim_head->noAnimFrames - 1 : 0;
@ -401,7 +401,7 @@ int32 Logic::fnRandomPause(int32 *params) {
// 1 minimum number of game-cycles to pause
// 2 maximum number of game-cycles to pause
ObjectLogic *ob_logic = (ObjectLogic *) decodePtr(params[0]);
ObjectLogic *ob_logic = (ObjectLogic *)decodePtr(params[0]);
int32 pars[2];
if (ob_logic->looping == 0) {
@ -424,9 +424,9 @@ int32 Logic::fnRegisterFrame(int32 *params) {
// 1 pointer to graphic structure
// 2 pointer to mega structure or NULL if not a mega
ObjectMouse *ob_mouse = (ObjectMouse *) decodePtr(params[0]);
ObjectGraphic *ob_graph = (ObjectGraphic *) decodePtr(params[1]);
ObjectMega *ob_mega = (ObjectMega *) decodePtr(params[2]);
ObjectMouse *ob_mouse = (ObjectMouse *)decodePtr(params[0]);
ObjectGraphic *ob_graph = (ObjectGraphic *)decodePtr(params[1]);
ObjectMega *ob_mega = (ObjectMega *)decodePtr(params[2]);
_vm->_screen->registerFrame(ob_mouse, ob_graph, ob_mega);
return IR_CONT;
@ -434,7 +434,7 @@ int32 Logic::fnRegisterFrame(int32 *params) {
int32 Logic::fnNoSprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteStatus((ObjectGraphic *) decodePtr(params[0]), NO_SPRITE);
_router->setSpriteStatus((ObjectGraphic *)decodePtr(params[0]), NO_SPRITE);
return IR_CONT;
}
@ -463,7 +463,7 @@ int32 Logic::fnUpdatePlayerStats(int32 *params) {
// params: 0 pointer to mega structure
ObjectMega *ob_mega = (ObjectMega *) decodePtr(params[0]);
ObjectMega *ob_mega = (ObjectMega *)decodePtr(params[0]);
ScreenInfo *screenInfo = _vm->_screen->getScreenInfo();
screenInfo->player_feet_x = ob_mega->feet_x;
@ -496,7 +496,7 @@ int32 Logic::fnPassGraph(int32 *params) {
int32 Logic::fnInitFloorMouse(int32 *params) {
// params: 0 pointer to object's mouse structure
ObjectMouse *ob_mouse = (ObjectMouse *) decodePtr(params[0]);
ObjectMouse *ob_mouse = (ObjectMouse *)decodePtr(params[0]);
ScreenInfo *screenInfo = _vm->_screen->getScreenInfo();
// floor is always lowest priority
@ -537,10 +537,10 @@ int32 Logic::fnFaceXY(int32 *params) {
// 5 target y-coord
return _router->faceXY(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectMega *) decodePtr(params[2]),
(ObjectWalkdata *) decodePtr(params[3]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
(ObjectMega *)decodePtr(params[2]),
(ObjectWalkdata *)decodePtr(params[3]),
params[4], params[5]);
}
@ -582,13 +582,13 @@ int32 Logic::fnAddHuman(int32 *params) {
int32 Logic::fnWeWait(int32 *params) {
// params: 0 target
StandardHeader *head = (StandardHeader *) _vm->_resman->openResource(params[0]);
StandardHeader *head = (StandardHeader *)_vm->_resman->openResource(params[0]);
assert(head->fileType == GAME_OBJECT);
// Run the target's get-speech-state script
int32 target = params[0];
char *raw_script_ad = (char *) head;
char *raw_script_ad = (char *)head;
uint32 null_pc = 5;
runScript(raw_script_ad, raw_script_ad, &null_pc);
@ -622,20 +622,20 @@ int32 Logic::fnTheyDoWeWait(int32 *params) {
// 6 ins4
// 7 ins5
StandardHeader *head = (StandardHeader *) _vm->_resman->openResource(params[1]);
StandardHeader *head = (StandardHeader *)_vm->_resman->openResource(params[1]);
assert(head->fileType == GAME_OBJECT);
// Run the target's get-speech-state script
int32 target = params[1];
char *raw_script_ad = (char *) head;
char *raw_script_ad = (char *)head;
uint32 null_pc = 5;
runScript(raw_script_ad, raw_script_ad, &null_pc);
_vm->_resman->closeResource(target);
ObjectLogic *ob_logic = (ObjectLogic *) decodePtr(params[0]);
ObjectLogic *ob_logic = (ObjectLogic *)decodePtr(params[0]);
if (_scriptVars[RESULT] == 1 && !_scriptVars[INS_COMMAND] && ob_logic->looping == 0) {
// The target is waiting, i.e. not busy, and there is no other
@ -694,13 +694,13 @@ int32 Logic::fnTheyDo(int32 *params) {
// 5 ins4
// 6 ins5
StandardHeader *head = (StandardHeader *) _vm->_resman->openResource(params[0]);
StandardHeader *head = (StandardHeader *)_vm->_resman->openResource(params[0]);
assert (head->fileType == GAME_OBJECT);
// Run the target's get-speech-state script
int32 target = params[0];
char *raw_script_ad = (char *) head;
char *raw_script_ad = (char *)head;
uint32 null_pc = 5;
runScript(raw_script_ad, raw_script_ad, &null_pc);
@ -745,10 +745,10 @@ int32 Logic::fnWalkToTalkToMega(int32 *params) {
// 5 separation
return _router->walkToTalkToMega(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectMega *) decodePtr(params[2]),
(ObjectWalkdata *) decodePtr(params[3]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
(ObjectMega *)decodePtr(params[2]),
(ObjectWalkdata *)decodePtr(params[3]),
params[4], params[5]);
}
@ -801,8 +801,8 @@ int32 Logic::fnISpeak(int32 *params) {
// Set up the pointers which we know we'll always need
ObjectLogic *ob_logic = (ObjectLogic *) decodePtr(params[S_OB_LOGIC]);
ObjectGraphic *ob_graphic = (ObjectGraphic *) decodePtr(params[S_OB_GRAPHIC]);
ObjectLogic *ob_logic = (ObjectLogic *)decodePtr(params[S_OB_LOGIC]);
ObjectGraphic *ob_graphic = (ObjectGraphic *)decodePtr(params[S_OB_GRAPHIC]);
// FIRST TIME ONLY: create the text, load the wav, set up the anim,
// etc.
@ -858,7 +858,7 @@ int32 Logic::fnISpeak(int32 *params) {
return IR_CONT;
}
StandardHeader *head = (StandardHeader *) _vm->_resman->openResource(text_res);
StandardHeader *head = (StandardHeader *)_vm->_resman->openResource(text_res);
if (head->fileType != TEXT_FILE) {
// Invalid - not a text resource
@ -867,7 +867,7 @@ int32 Logic::fnISpeak(int32 *params) {
return IR_CONT;
}
if (!_vm->checkTextLine((byte *) head, local_text)) {
if (!_vm->checkTextLine((byte *)head, local_text)) {
// Line number out of range
_vm->_resman->closeResource(text_res);
_scriptVars[RESULT] = 2;
@ -919,8 +919,8 @@ int32 Logic::fnISpeak(int32 *params) {
// Use this direction table to derive the anim
// NB. ASSUMES WE HAVE A MEGA OBJECT!!
ObjectMega *ob_mega = (ObjectMega *) decodePtr(params[S_OB_MEGA]);
int32 *anim_table = (int32 *) decodePtr(params[S_DIR_TABLE]);
ObjectMega *ob_mega = (ObjectMega *)decodePtr(params[S_OB_MEGA]);
int32 *anim_table = (int32 *)decodePtr(params[S_DIR_TABLE]);
_animId = anim_table[ob_mega->current_dir];
} else {
@ -1194,7 +1194,7 @@ int32 Logic::fnSpeechProcess(int32 *params) {
// 3 pointer to ob_mega
// 4 pointer to ob_walkdata
ObjectSpeech *ob_speech = (ObjectSpeech *) decodePtr(params[1]);
ObjectSpeech *ob_speech = (ObjectSpeech *)decodePtr(params[1]);
while (1) {
int32 pars[9];
@ -1423,7 +1423,7 @@ int32 Logic::fnSetScaling(int32 *params) {
// Where s is system scale, which itself is (256 * actual_scale) ie.
// s == 128 is half size
ObjectMega *ob_mega = (ObjectMega *) decodePtr(params[0]);
ObjectMega *ob_mega = (ObjectMega *)decodePtr(params[0]);
ob_mega->scale_a = params[1];
ob_mega->scale_b = params[2];
@ -1480,10 +1480,10 @@ int32 Logic::fnTimedWait(int32 *params) {
// 1 target
// 2 number of cycles before give up
StandardHeader *head = (StandardHeader *) _vm->_resman->openResource(params[1]);
StandardHeader *head = (StandardHeader *)_vm->_resman->openResource(params[1]);
assert(head->fileType == GAME_OBJECT);
ObjectLogic *ob_logic = (ObjectLogic *) decodePtr(params[0]);
ObjectLogic *ob_logic = (ObjectLogic *)decodePtr(params[0]);
if (!ob_logic->looping) {
// This is the first time, so set up the time-out.
@ -1493,7 +1493,7 @@ int32 Logic::fnTimedWait(int32 *params) {
// Run the target's get-speech-state script
int32 target = params[1];
char *raw_script_ad = (char *) head;
char *raw_script_ad = (char *)head;
uint32 null_pc = 5;
runScript(raw_script_ad, raw_script_ad, &null_pc);
@ -1605,7 +1605,7 @@ int32 Logic::fnSetValue(int32 *params) {
// params: 0 pointer to object's mega structure
// 1 value to set it to
ObjectMega *ob_mega = (ObjectMega *) decodePtr(params[0]);
ObjectMega *ob_mega = (ObjectMega *)decodePtr(params[0]);
ob_mega->megaset_res = params[1];
return IR_CONT;
@ -1671,10 +1671,10 @@ int32 Logic::fnReverseMegaTableAnim(int32 *params) {
// Reverse anim
return _router->megaTableAnimate(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectMega *) decodePtr(params[2]),
(uint32 *) decodePtr(params[3]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
(ObjectMega *)decodePtr(params[2]),
(uint32 *)decodePtr(params[3]),
true);
}
@ -1685,8 +1685,8 @@ int32 Logic::fnReverseAnim(int32 *params) {
// Reverse anim
return _router->doAnimate(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
params[2], true);
}
@ -1745,25 +1745,25 @@ int32 Logic::fnSetStandbyCoords(int32 *params) {
int32 Logic::fnBackPar0Sprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteStatus((ObjectGraphic *) decodePtr(params[0]), BGP0_SPRITE);
_router->setSpriteStatus((ObjectGraphic *)decodePtr(params[0]), BGP0_SPRITE);
return IR_CONT;
}
int32 Logic::fnBackPar1Sprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteStatus((ObjectGraphic *) decodePtr(params[0]), BGP1_SPRITE);
_router->setSpriteStatus((ObjectGraphic *)decodePtr(params[0]), BGP1_SPRITE);
return IR_CONT;
}
int32 Logic::fnForePar0Sprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteStatus((ObjectGraphic *) decodePtr(params[0]), FGP0_SPRITE);
_router->setSpriteStatus((ObjectGraphic *)decodePtr(params[0]), FGP0_SPRITE);
return IR_CONT;
}
int32 Logic::fnForePar1Sprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteStatus((ObjectGraphic *) decodePtr(params[0]), FGP1_SPRITE);
_router->setSpriteStatus((ObjectGraphic *)decodePtr(params[0]), FGP1_SPRITE);
return IR_CONT;
}
@ -1816,8 +1816,8 @@ int32 Logic::fnStandAtAnim(int32 *params) {
// 2 anim resource id
_router->standAtAnim(
(ObjectGraphic *) decodePtr(params[0]),
(ObjectMega *) decodePtr(params[1]),
(ObjectGraphic *)decodePtr(params[0]),
(ObjectMega *)decodePtr(params[1]),
params[2]);
return IR_CONT;
}
@ -1827,7 +1827,7 @@ int32 Logic::fnStandAtAnim(int32 *params) {
int32 Logic::fnSetScrollLeftMouse(int32 *params) {
// params: 0 pointer to object's mouse structure
ObjectMouse *ob_mouse = (ObjectMouse *) decodePtr(params[0]);
ObjectMouse *ob_mouse = (ObjectMouse *)decodePtr(params[0]);
ScreenInfo *screenInfo = _vm->_screen->getScreenInfo();
// Highest priority
@ -1852,7 +1852,7 @@ int32 Logic::fnSetScrollLeftMouse(int32 *params) {
int32 Logic::fnSetScrollRightMouse(int32 *params) {
// params: 0 pointer to object's mouse structure
ObjectMouse *ob_mouse = (ObjectMouse *) decodePtr(params[0]);
ObjectMouse *ob_mouse = (ObjectMouse *)decodePtr(params[0]);
ScreenInfo *screenInfo = _vm->_screen->getScreenInfo();
// Highest priority
@ -1984,7 +1984,7 @@ int32 Logic::fnGetPlayerSaveData(int32 *params) {
// Any walk-data must be cleared - the player will be set to stand if
// he was walking when saved.
ObjectMega *ob_mega = (ObjectMega *) mega_ptr;
ObjectMega *ob_mega = (ObjectMega *)mega_ptr;
if (ob_mega->currently_walking) {
ob_mega->currently_walking = 0;
@ -1998,7 +1998,7 @@ int32 Logic::fnGetPlayerSaveData(int32 *params) {
fnStand(pars);
// Reset looping flag (which would have been 1 during fnWalk)
ObjectLogic *ob_logic = (ObjectLogic *) logic_ptr;
ObjectLogic *ob_logic = (ObjectLogic *)logic_ptr;
ob_logic->looping = 0;
}
@ -2095,7 +2095,7 @@ int32 Logic::fnPauseForEvent(int32 *params) {
// params: 0 pointer to object's logic structure
// 1 number of game-cycles to pause
ObjectLogic *ob_logic = (ObjectLogic *) decodePtr(params[0]);
ObjectLogic *ob_logic = (ObjectLogic *)decodePtr(params[0]);
if (checkEventWaiting()) {
ob_logic->looping = 0;
@ -2121,10 +2121,10 @@ int32 Logic::fnFaceMega(int32 *params) {
// 4 id of target mega to face
return _router->faceMega(
(ObjectLogic *) decodePtr(params[0]),
(ObjectGraphic *) decodePtr(params[1]),
(ObjectMega *) decodePtr(params[2]),
(ObjectWalkdata *) decodePtr(params[3]),
(ObjectLogic *)decodePtr(params[0]),
(ObjectGraphic *)decodePtr(params[1]),
(ObjectMega *)decodePtr(params[2]),
(ObjectWalkdata *)decodePtr(params[3]),
params[4]);
}
@ -2140,11 +2140,11 @@ int32 Logic::fnPlaySequence(int32 *params) {
// of computer games" - but at the very least we want to show the
// cutscene subtitles, so I removed them.
debug(5, "fnPlaySequence(\"%s\");", (const char *) decodePtr(params[0]));
debug(5, "fnPlaySequence(\"%s\");", (const char *)decodePtr(params[0]));
// add the appropriate file extension & play it
strcpy(filename, (const char *) decodePtr(params[0]));
strcpy(filename, (const char *)decodePtr(params[0]));
// Write to walkthrough file (zebug0.txt)
debug(5, "PLAYING SEQUENCE \"%s\"", filename);
@ -2201,13 +2201,13 @@ int32 Logic::fnPlaySequence(int32 *params) {
int32 Logic::fnShadedSprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteShading((ObjectGraphic *) decodePtr(params[0]), SHADED_SPRITE);
_router->setSpriteShading((ObjectGraphic *)decodePtr(params[0]), SHADED_SPRITE);
return IR_CONT;
}
int32 Logic::fnUnshadedSprite(int32 *params) {
// params: 0 pointer to object's graphic structure
_router->setSpriteShading((ObjectGraphic *) decodePtr(params[0]), UNSHADED_SPRITE);
_router->setSpriteShading((ObjectGraphic *)decodePtr(params[0]), UNSHADED_SPRITE);
return IR_CONT;
}
@ -2279,7 +2279,7 @@ int32 Logic::fnResetGlobals(int32 *params) {
debug(5, "globals size: %d", size);
globals = (uint32 *) ((byte *) _vm->_resman->openResource(1) + sizeof(StandardHeader));
globals = (uint32 *)((byte *)_vm->_resman->openResource(1) + sizeof(StandardHeader));
// blank each global variable
memset(globals, 0, size);

2
sword2/icons.cpp
View File

@ -73,7 +73,7 @@ void Mouse::buildMenu() {
// register all carried menu objects.
uint32 null_pc = 0;
char *menuScript = (char *) _vm->_resman->openResource(MENU_MASTER_OBJECT);
char *menuScript = (char *)_vm->_resman->openResource(MENU_MASTER_OBJECT);
_vm->_logic->runScript(menuScript, menuScript, &null_pc);
_vm->_resman->closeResource(MENU_MASTER_OBJECT);

14
sword2/interpreter.cpp
View File

@ -214,7 +214,7 @@ int Logic::runScript(char *scriptData, char *objectData, uint32 *offset) {
int32 stack[STACK_SIZE];
int32 stackPtr = 0;
StandardHeader *header = (StandardHeader *) scriptData;
StandardHeader *header = (StandardHeader *)scriptData;
scriptData += sizeof(StandardHeader) + sizeof(ObjectHub);
// The script data format:
@ -230,13 +230,13 @@ int Logic::runScript(char *scriptData, char *objectData, uint32 *offset) {
// Get the start of variables and start of code
uint32 *localVars = (uint32 *) (scriptData + sizeof(int32));
uint32 *localVars = (uint32 *)(scriptData + sizeof(int32));
char *code = scriptData + READ_LE_UINT32(scriptData) + sizeof(int32);
uint32 noScripts = READ_LE_UINT32(code);
code += sizeof(int32);
const uint32 *offsetTable = (const uint32 *) code;
const uint32 *offsetTable = (const uint32 *)code;
if (*offset < noScripts) {
ip = FROM_LE_32(offsetTable[*offset]);
@ -271,7 +271,7 @@ int Logic::runScript(char *scriptData, char *objectData, uint32 *offset) {
// So if his click hander (action script number 2) finishes, and
// variable 913 is 1, we set it back to 0 manually.
bool checkPyramidBug = scriptNumber == 2 && strcmp((char *) header->name, "titipoco_81") == 0;
bool checkPyramidBug = scriptNumber == 2 && strcmp((char *)header->name, "titipoco_81") == 0;
code += noScripts * sizeof(int32);
@ -382,7 +382,7 @@ int Logic::runScript(char *scriptData, char *objectData, uint32 *offset) {
Read16ip(parameter);
parameter /= 4;
ptr = (byte *) &localVars[parameter];
ptr = (byte *)&localVars[parameter];
push_ptr(ptr);
debug(9, "CP_PUSH_LOCAL_ADDR: &localVars[%d] => %p", parameter, ptr);
break;
@ -392,7 +392,7 @@ int Logic::runScript(char *scriptData, char *objectData, uint32 *offset) {
Read8ip(parameter);
// ip now points to the string
ptr = (byte *) (code + ip);
ptr = (byte *)(code + ip);
push_ptr(ptr);
debug(9, "CP_PUSH_STRING: \"%s\"", ptr);
ip += (parameter + 1);
@ -400,7 +400,7 @@ int Logic::runScript(char *scriptData, char *objectData, uint32 *offset) {
case CP_PUSH_DEREFERENCED_STRUCTURE:
// Push the address of a dereferenced structure
Read32ip(parameter);
ptr = (byte *) (objectData + sizeof(int32) + sizeof(StandardHeader) + sizeof(ObjectHub) + parameter);
ptr = (byte *)(objectData + sizeof(int32) + sizeof(StandardHeader) + sizeof(ObjectHub) + parameter);
push_ptr(ptr);
debug(9, "CP_PUSH_DEREFERENCED_STRUCTURE: %d => %p", parameter, ptr);
break;

2
sword2/interpreter.h
View File

@ -36,7 +36,7 @@ enum {
// Get parameter fix so that the playstation version can handle words not on
// word boundaries
#define Read8ip(var) { var = *((const int8 *) (code + ip)); ip++; }
#define Read8ip(var) { var = *((const int8 *)(code + ip)); ip++; }
#define Read16ip(var) { var = (int16) READ_LE_UINT16(code + ip); ip += sizeof(int16); }
#define Read32ip(var) { var = (int32) READ_LE_UINT32(code + ip); ip += sizeof(int32); }
#define Read32ipLeaveip(var) { var = (int32) READ_LE_UINT32(code + ip); }

2
sword2/layers.cpp
View File

@ -129,7 +129,7 @@ void Screen::initBackground(int32 res, int32 new_palette) {
// shading mask
MultiScreenHeader *screenLayerTable = (MultiScreenHeader *) (file + sizeof(StandardHeader));
MultiScreenHeader *screenLayerTable = (MultiScreenHeader *)(file + sizeof(StandardHeader));
if (screenLayerTable->maskOffset) {
SpriteInfo spriteInfo;

16
sword2/logic.cpp
View File

@ -63,10 +63,10 @@ int Logic::processSession() {
uint32 ret, script;
char *raw_script_ad;
StandardHeader *head = (StandardHeader *) _vm->_resman->openResource(run_list);
StandardHeader *head = (StandardHeader *)_vm->_resman->openResource(run_list);
assert(head->fileType == RUN_LIST);
uint32 *game_object_list = (uint32 *) (head + 1);
uint32 *game_object_list = (uint32 *)(head + 1);
// read the next id
uint id = game_object_list[_pc++];
@ -79,10 +79,10 @@ int Logic::processSession() {
return 0;
}
head = (StandardHeader *) _vm->_resman->openResource(_scriptVars[ID]);
head = (StandardHeader *)_vm->_resman->openResource(_scriptVars[ID]);
assert(head->fileType == GAME_OBJECT);
_curObjectHub = (ObjectHub *) (head + 1);
_curObjectHub = (ObjectHub *)(head + 1);
debug(5, "Level %d id(%d) pc(%d)",
LEVEL,
@ -109,18 +109,18 @@ int Logic::processSession() {
// This is the script data. Script and data
// object are the same.
raw_script_ad = (char *) head;
raw_script_ad = (char *)head;
ret = runScript(raw_script_ad, raw_script_ad, &_curObjectHub->script_pc[LEVEL]);
} else {
// We're running the script of another game
// object - get our data object address.
StandardHeader *far_head = (StandardHeader *) _vm->_resman->openResource(script / SIZE);
StandardHeader *far_head = (StandardHeader *)_vm->_resman->openResource(script / SIZE);
assert(far_head->fileType == GAME_OBJECT || far_head->fileType == SCREEN_MANAGER);
raw_script_ad = (char *) far_head;
char *raw_data_ad = (char *) head;
raw_script_ad = (char *)far_head;
char *raw_data_ad = (char *)head;
ret = runScript(raw_script_ad, raw_data_ad, &_curObjectHub->script_pc[LEVEL]);

22
sword2/maketext.cpp
View File

@ -93,17 +93,17 @@ byte *FontRenderer::makeTextSprite(byte *sentence, uint16 maxWidth, uint8 pen, u
// Allocate memory for array of lineInfo structures
byte *line = (byte *) malloc(MAX_LINES * sizeof(LineInfo));
byte *line = (byte *)malloc(MAX_LINES * sizeof(LineInfo));
// Get details of sentence breakdown into array of LineInfo structures
// and get the number of lines involved
uint16 noOfLines = analyseSentence(sentence, maxWidth, fontRes, (LineInfo *) line);
uint16 noOfLines = analyseSentence(sentence, maxWidth, fontRes, (LineInfo *)line);
// Construct the sprite based on the info gathered - returns floating
// mem block
byte *textSprite = buildTextSprite(sentence, fontRes, pen, (LineInfo *) line, noOfLines);
byte *textSprite = buildTextSprite(sentence, fontRes, pen, (LineInfo *)line, noOfLines);
free(line);
return textSprite;
@ -213,12 +213,12 @@ byte *FontRenderer::buildTextSprite(byte *sentence, uint32 fontRes, uint8 pen, L
// Allocate memory for the text sprite
uint32 sizeOfSprite = spriteWidth * spriteHeight;
byte *textSprite = (byte *) malloc(sizeof(FrameHeader) + sizeOfSprite);
byte *textSprite = (byte *)malloc(sizeof(FrameHeader) + sizeOfSprite);
// At this stage, textSprite points to an unmovable memory block. Set
// up the frame header.
FrameHeader *frameHeadPtr = (FrameHeader *) textSprite;
FrameHeader *frameHeadPtr = (FrameHeader *)textSprite;
frameHeadPtr->compSize = 0;
frameHeadPtr->width = spriteWidth;
@ -324,7 +324,7 @@ FrameHeader* FontRenderer::findChar(byte ch, byte *charSet) {
*/
void FontRenderer::copyChar(FrameHeader *charPtr, byte *spritePtr, uint16 spriteWidth, uint8 pen) {
byte *source = (byte *) charPtr + sizeof(FrameHeader);
byte *source = (byte *)charPtr + sizeof(FrameHeader);
byte *rowPtr = spritePtr;
for (uint i = 0; i < charPtr->height; i++) {
@ -387,7 +387,7 @@ uint32 FontRenderer::buildNewBloc(byte *ascii, int16 x, int16 y, uint16 width, u
// without margin checking - used for debug text
if (justification != NO_JUSTIFICATION) {
FrameHeader *frame_head = (FrameHeader *) _blocList[i].text_mem;
FrameHeader *frame_head = (FrameHeader *)_blocList[i].text_mem;
switch (justification) {
case POSITION_AT_CENTRE_OF_BASE:
@ -460,7 +460,7 @@ uint32 FontRenderer::buildNewBloc(byte *ascii, int16 x, int16 y, uint16 width, u
void FontRenderer::printTextBlocs() {
for (uint i = 0; i < MAX_text_blocs; i++) {
if (_blocList[i].text_mem) {
FrameHeader *frame = (FrameHeader *) _blocList[i].text_mem;
FrameHeader *frame = (FrameHeader *)_blocList[i].text_mem;
SpriteInfo spriteInfo;
spriteInfo.x = _blocList[i].x;
@ -507,7 +507,7 @@ void Sword2Engine::initialiseFontResourceFlags() {
// "zapisz" Polish for "save"
// Get the text line (& skip the 2 chars containing the wavId)
char *textLine = (char *) fetchTextLine(textFile, SAVE_LINE_NO) + 2;
char *textLine = (char *)fetchTextLine(textFile, SAVE_LINE_NO) + 2;
if (strcmp(textLine, "tallenna") == 0)
initialiseFontResourceFlags(FINNISH_TEXT);
@ -529,9 +529,9 @@ void Sword2Engine::initialiseFontResourceFlags() {
// But we get it from the text resource instead.
if (Logic::_scriptVars[DEMO])
textLine = (char *) fetchTextLine(textFile, 451) + 2;
textLine = (char *)fetchTextLine(textFile, 451) + 2;
else
textLine = (char *) fetchTextLine(textFile, 54) + 2;
textLine = (char *)fetchTextLine(textFile, 54) + 2;
_system->setWindowCaption(textLine);
_resman->closeResource(TEXT_RES);

8
sword2/memory.cpp
View File

@ -66,9 +66,9 @@ MemoryManager::MemoryManager(Sword2Engine *vm) : _vm(vm) {
// encoding or decoding pointers any faster, and these are by far the
// most common operations.
_idStack = (int16 *) malloc(MAX_MEMORY_BLOCKS * sizeof(int16));
_memBlocks = (MemBlock *) malloc(MAX_MEMORY_BLOCKS * sizeof(MemBlock));
_memBlockIndex = (MemBlock **) malloc(MAX_MEMORY_BLOCKS * sizeof(MemBlock *));
_idStack = (int16 *)malloc(MAX_MEMORY_BLOCKS * sizeof(int16));
_memBlocks = (MemBlock *)malloc(MAX_MEMORY_BLOCKS * sizeof(MemBlock));
_memBlockIndex = (MemBlock **)malloc(MAX_MEMORY_BLOCKS * sizeof(MemBlock *));
_totAlloc = 0;
_numBlocks = 0;
@ -192,7 +192,7 @@ byte *MemoryManager::memAlloc(uint32 size, int16 uid) {
int16 id = _idStack[--_idStackPtr];
// Allocate the new memory block
byte *ptr = (byte *) malloc(size);
byte *ptr = (byte *)malloc(size);
assert(ptr);

52
sword2/protocol.cpp
View File

@ -30,9 +30,9 @@ namespace Sword2 {
*/
byte *Sword2Engine::fetchPalette(byte *screenFile) {
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *) (screenFile + sizeof(StandardHeader));
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *)(screenFile + sizeof(StandardHeader));
byte *palette = (byte *) mscreenHeader + mscreenHeader->palette;
byte *palette = (byte *)mscreenHeader + mscreenHeader->palette;
// Always set colour 0 to black, because while most background screen
// palettes have a bright colour 0 it should come out as black in the
@ -52,9 +52,9 @@ byte *Sword2Engine::fetchPalette(byte *screenFile) {
*/
byte *Sword2Engine::fetchPaletteMatchTable(byte *screenFile) {
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *) (screenFile + sizeof(StandardHeader));
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *)(screenFile + sizeof(StandardHeader));
return (byte *) mscreenHeader + mscreenHeader->paletteTable;
return (byte *)mscreenHeader + mscreenHeader->paletteTable;
}
/**
@ -63,8 +63,8 @@ byte *Sword2Engine::fetchPaletteMatchTable(byte *screenFile) {
*/
ScreenHeader *Sword2Engine::fetchScreenHeader(byte *screenFile) {
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *) (screenFile + sizeof(StandardHeader));
ScreenHeader *screenHeader = (ScreenHeader *) ((byte *) mscreenHeader + mscreenHeader->screen);
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *)(screenFile + sizeof(StandardHeader));
ScreenHeader *screenHeader = (ScreenHeader *)((byte *)mscreenHeader + mscreenHeader->screen);
return screenHeader;
}
@ -83,9 +83,9 @@ LayerHeader *Sword2Engine::fetchLayerHeader(byte *screenFile, uint16 layerNo) {
error("fetchLayerHeader(%d) invalid layer number!", layerNo);
#endif
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *) (screenFile + sizeof(StandardHeader));
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *)(screenFile + sizeof(StandardHeader));
LayerHeader *layerHeader = (LayerHeader *) ((byte *) mscreenHeader + mscreenHeader->layers + (layerNo * sizeof(LayerHeader)));
LayerHeader *layerHeader = (LayerHeader *)((byte *)mscreenHeader + mscreenHeader->layers + (layerNo * sizeof(LayerHeader)));
return layerHeader;
}
@ -96,9 +96,9 @@ LayerHeader *Sword2Engine::fetchLayerHeader(byte *screenFile, uint16 layerNo) {
*/
byte *Sword2Engine::fetchShadingMask(byte *screenFile) {
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *) (screenFile + sizeof(StandardHeader));
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *)(screenFile + sizeof(StandardHeader));
return (byte *) mscreenHeader + mscreenHeader->maskOffset;
return (byte *)mscreenHeader + mscreenHeader->maskOffset;
}
/**
@ -107,7 +107,7 @@ byte *Sword2Engine::fetchShadingMask(byte *screenFile) {
*/
AnimHeader *Sword2Engine::fetchAnimHeader(byte *animFile) {
return (AnimHeader *) (animFile + sizeof(StandardHeader));
return (AnimHeader *)(animFile + sizeof(StandardHeader));
}
/**
@ -124,7 +124,7 @@ CdtEntry *Sword2Engine::fetchCdtEntry(byte *animFile, uint16 frameNo) {
error("fetchCdtEntry(animFile,%d) - anim only %d frames", frameNo, animHead->noAnimFrames);
#endif
return (CdtEntry *) ((byte *) animHead + sizeof(AnimHeader) + frameNo * sizeof(CdtEntry));
return (CdtEntry *)((byte *)animHead + sizeof(AnimHeader) + frameNo * sizeof(CdtEntry));
}
/**
@ -135,7 +135,7 @@ CdtEntry *Sword2Engine::fetchCdtEntry(byte *animFile, uint16 frameNo) {
FrameHeader *Sword2Engine::fetchFrameHeader(byte *animFile, uint16 frameNo) {
// required address = (address of the start of the anim header) + frameOffset
return (FrameHeader *) (animFile + sizeof(StandardHeader) + fetchCdtEntry(animFile, frameNo)->frameOffset);
return (FrameHeader *)(animFile + sizeof(StandardHeader) + fetchCdtEntry(animFile, frameNo)->frameOffset);
}
/**
@ -143,36 +143,36 @@ FrameHeader *Sword2Engine::fetchFrameHeader(byte *animFile, uint16 frameNo) {
*/
Parallax *Sword2Engine::fetchBackgroundParallaxLayer(byte *screenFile, int layer) {
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *) (screenFile + sizeof(StandardHeader));
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *)(screenFile + sizeof(StandardHeader));
#ifdef SWORD2_DEBUG
if (mscreenHeader->bg_parallax[layer] == 0)
error("fetchBackgroundParallaxLayer(%d) - No parallax layer exists", layer);
#endif
return (Parallax *) ((byte *) mscreenHeader + mscreenHeader->bg_parallax[layer]);
return (Parallax *)((byte *)mscreenHeader + mscreenHeader->bg_parallax[layer]);
}
Parallax *Sword2Engine::fetchBackgroundLayer(byte *screenFile) {
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *) (screenFile + sizeof(StandardHeader));
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *)(screenFile + sizeof(StandardHeader));
#ifdef SWORD2_DEBUG
if (mscreenHeader->screen == 0)
error("fetchBackgroundLayer (%d) - No background layer exists");
#endif
return (Parallax *) ((byte *) mscreenHeader + mscreenHeader->screen + sizeof(ScreenHeader));
return (Parallax *)((byte *)mscreenHeader + mscreenHeader->screen + sizeof(ScreenHeader));
}
Parallax *Sword2Engine::fetchForegroundParallaxLayer(byte *screenFile, int layer) {
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *) (screenFile + sizeof(StandardHeader));
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *)(screenFile + sizeof(StandardHeader));
#ifdef SWORD2_DEBUG
if (mscreenHeader->fg_parallax[layer] == 0)
error("fetchForegroundParallaxLayer(%d) - No parallax layer exists", layer);
#endif
return (Parallax *) ((byte *) mscreenHeader + mscreenHeader->fg_parallax[layer]);
return (Parallax *)((byte *)mscreenHeader + mscreenHeader->fg_parallax[layer]);
}
static byte errorLine[128];
@ -181,11 +181,11 @@ byte *Sword2Engine::fetchTextLine(byte *file, uint32 text_line) {
StandardHeader *fileHeader;
uint32 *point;
TextHeader *text_header = (TextHeader *) (file + sizeof(StandardHeader));
TextHeader *text_header = (TextHeader *)(file + sizeof(StandardHeader));
if (text_line >= text_header->noOfLines) {
fileHeader = (StandardHeader *) file;
sprintf((char *) errorLine, "xxMissing line %d of %s (only 0..%d)", text_line, fileHeader->name, text_header->noOfLines - 1);
fileHeader = (StandardHeader *)file;
sprintf((char *)errorLine, "xxMissing line %d of %s (only 0..%d)", text_line, fileHeader->name, text_header->noOfLines - 1);
// first 2 chars are NULL so that actor-number comes out as '0'
@ -195,22 +195,22 @@ byte *Sword2Engine::fetchTextLine(byte *file, uint32 text_line) {
}
// point to the lookup table
point = (uint32 *) text_header + 1;
point = (uint32 *)text_header + 1;
return (byte *) (file + READ_LE_UINT32(point + text_line));
return (byte *)(file + READ_LE_UINT32(point + text_line));
}
// Used for testing text & speech (see fnISpeak in speech.cpp)
bool Sword2Engine::checkTextLine(byte *file, uint32 text_line) {
TextHeader *text_header = (TextHeader *) (file + sizeof(StandardHeader));
TextHeader *text_header = (TextHeader *)(file + sizeof(StandardHeader));
return text_line < text_header->noOfLines;
}
byte *Sword2Engine::fetchObjectName(int32 resourceId, byte *buf) {
StandardHeader *header = (StandardHeader *) _resman->openResource(resourceId);
StandardHeader *header = (StandardHeader *)_resman->openResource(resourceId);
memcpy(buf, header->name, NAME_LEN);
_resman->closeResource(resourceId);

50
sword2/resman.cpp
View File

@ -81,7 +81,7 @@ ResourceManager::ResourceManager(Sword2Engine *vm) {
size = file.size();
// Get some space for the incoming resource file - soon to be trashed
temp = (byte *) malloc(size);
temp = (byte *)malloc(size);
if (file.read(temp, size) != size) {
file.close();
@ -134,7 +134,7 @@ ResourceManager::ResourceManager(Sword2Engine *vm) {
_totalResFiles = size / 4;
// Table seems ok so malloc some space
_resConvTable = (uint16 *) malloc(size);
_resConvTable = (uint16 *)malloc(size);
for (i = 0; i < size / 2; i++)
_resConvTable[i] = file.readUint16LE();
@ -163,7 +163,7 @@ ResourceManager::ResourceManager(Sword2Engine *vm) {
for (i = 0; i < _totalClusters; i++) {
for (j = 0; j < _totalClusters; j++) {
if (scumm_stricmp((char *) cdInf[j].clusterName, _resFiles[i].fileName) == 0)
if (scumm_stricmp((char *)cdInf[j].clusterName, _resFiles[i].fileName) == 0)
break;
}
@ -179,7 +179,7 @@ ResourceManager::ResourceManager(Sword2Engine *vm) {
for (i = 0; i < _totalClusters; i++)
debug(2, "filename of cluster %d: -%s", i, _resFiles[i].fileName);
_resList = (Resource *) malloc(_totalResFiles * sizeof(Resource));
_resList = (Resource *)malloc(_totalResFiles * sizeof(Resource));
for (i = 0; i < _totalResFiles; i++) {
_resList[i].ptr = NULL;
@ -208,7 +208,7 @@ ResourceManager::~ResourceManager() {
void convertEndian(byte *file, uint32 len) {
int i;
StandardHeader *hdr = (StandardHeader *) file;
StandardHeader *hdr = (StandardHeader *)file;
file += sizeof(StandardHeader);
@ -217,7 +217,7 @@ void convertEndian(byte *file, uint32 len) {
switch (hdr->fileType) {
case ANIMATION_FILE: {
AnimHeader *animHead = (AnimHeader *) file;
AnimHeader *animHead = (AnimHeader *)file;
SWAP16(animHead->noAnimFrames);
SWAP16(animHead->feetStartX);
@ -226,13 +226,13 @@ void convertEndian(byte *file, uint32 len) {
SWAP16(animHead->feetEndY);
SWAP16(animHead->blend);
CdtEntry *cdtEntry = (CdtEntry *) (file + sizeof(AnimHeader));
CdtEntry *cdtEntry = (CdtEntry *)(file + sizeof(AnimHeader));
for (i = 0; i < animHead->noAnimFrames; i++, cdtEntry++) {
SWAP16(cdtEntry->x);
SWAP16(cdtEntry->y);
SWAP32(cdtEntry->frameOffset);
FrameHeader *frameHeader = (FrameHeader *) (file + cdtEntry->frameOffset);
FrameHeader *frameHeader = (FrameHeader *)(file + cdtEntry->frameOffset);
// Quick trick to prevent us from incorrectly applying the endian
// fixes multiple times. This assumes that frames are less than 1 MB
// and have height/width less than 4096.
@ -247,7 +247,7 @@ void convertEndian(byte *file, uint32 len) {
break;
}
case SCREEN_FILE: {
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *) file;
MultiScreenHeader *mscreenHeader = (MultiScreenHeader *)file;
SWAP32(mscreenHeader->palette);
SWAP32(mscreenHeader->bg_parallax[0]);
@ -260,14 +260,14 @@ void convertEndian(byte *file, uint32 len) {
SWAP32(mscreenHeader->maskOffset);
// screenHeader
ScreenHeader *screenHeader = (ScreenHeader *) (file + mscreenHeader->screen);
ScreenHeader *screenHeader = (ScreenHeader *)(file + mscreenHeader->screen);
SWAP16(screenHeader->width);
SWAP16(screenHeader->height);
SWAP16(screenHeader->noLayers);
// layerHeader
LayerHeader *layerHeader = (LayerHeader *) (file + mscreenHeader->layers);
LayerHeader *layerHeader = (LayerHeader *)(file + mscreenHeader->layers);
for (i = 0; i < screenHeader->noLayers; i++, layerHeader++) {
SWAP16(layerHeader->x);
SWAP16(layerHeader->y);
@ -282,14 +282,14 @@ void convertEndian(byte *file, uint32 len) {
int offset;
offset = mscreenHeader->bg_parallax[0];
if (offset > 0) {
parallax = (Parallax *) (file + offset);
parallax = (Parallax *)(file + offset);
SWAP16(parallax->w);
SWAP16(parallax->h);
}
offset = mscreenHeader->bg_parallax[1];
if (offset > 0) {
parallax = (Parallax *) (file + offset);
parallax = (Parallax *)(file + offset);
SWAP16(parallax->w);
SWAP16(parallax->h);
}
@ -297,7 +297,7 @@ void convertEndian(byte *file, uint32 len) {
// backgroundLayer
offset = mscreenHeader->screen + sizeof(ScreenHeader);
if (offset > 0) {
parallax = (Parallax *) (file + offset);
parallax = (Parallax *)(file + offset);
SWAP16(parallax->w);
SWAP16(parallax->h);
}
@ -305,21 +305,21 @@ void convertEndian(byte *file, uint32 len) {
// foregroundParallaxLayer
offset = mscreenHeader->fg_parallax[0];
if (offset > 0) {
parallax = (Parallax *) (file + offset);
parallax = (Parallax *)(file + offset);
SWAP16(parallax->w);
SWAP16(parallax->h);
}
offset = mscreenHeader->fg_parallax[1];
if (offset > 0) {
parallax = (Parallax *) (file + offset);
parallax = (Parallax *)(file + offset);
SWAP16(parallax->w);
SWAP16(parallax->h);
}
break;
}
case GAME_OBJECT: {
ObjectHub *objectHub = (ObjectHub *) file;
ObjectHub *objectHub = (ObjectHub *)file;
objectHub->type = (int) SWAP_BYTES_32(objectHub->type);
SWAP32(objectHub->logic_level);
@ -332,12 +332,12 @@ void convertEndian(byte *file, uint32 len) {
break;
}
case WALK_GRID_FILE: {
WalkGridHeader *walkGridHeader = (WalkGridHeader *) file;
WalkGridHeader *walkGridHeader = (WalkGridHeader *)file;
SWAP32(walkGridHeader->numBars);
SWAP32(walkGridHeader->numNodes);
BarData *barData = (BarData *) (file + sizeof(WalkGridHeader));
BarData *barData = (BarData *)(file + sizeof(WalkGridHeader));
for (i = 0; i < walkGridHeader->numBars; i++) {
SWAP16(barData->x1);
SWAP16(barData->y1);
@ -353,7 +353,7 @@ void convertEndian(byte *file, uint32 len) {
barData++;
}
uint16 *node = (uint16 *) (file + sizeof(WalkGridHeader) + walkGridHeader->numBars * sizeof(BarData));
uint16 *node = (uint16 *)(file + sizeof(WalkGridHeader) + walkGridHeader->numBars * sizeof(BarData));
for (i = 0; i < walkGridHeader->numNodes * 2; i++) {
SWAP16(*node);
node++;
@ -366,7 +366,7 @@ void convertEndian(byte *file, uint32 len) {
case PARALLAX_FILE_null:
break;
case RUN_LIST: {
uint32 *list = (uint32 *) file;
uint32 *list = (uint32 *)file;
while (*list) {
SWAP32(*list);
list++;
@ -374,7 +374,7 @@ void convertEndian(byte *file, uint32 len) {
break;
}
case TEXT_FILE: {
TextHeader *textHeader = (TextHeader *) file;
TextHeader *textHeader = (TextHeader *)file;
SWAP32(textHeader->noOfLines);
break;
}
@ -440,7 +440,7 @@ byte *ResourceManager::openResource(uint32 res, bool dump) {
file->read(_resList[res].ptr, len);
if (dump) {
StandardHeader *header = (StandardHeader *) _resList[res].ptr;
StandardHeader *header = (StandardHeader *)_resList[res].ptr;
char buf[256];
const char *tag;
Common::File out;
@ -725,7 +725,7 @@ void ResourceManager::killAll(bool wantInfo) {
continue;
if (_resList[i].ptr) {
StandardHeader *header = (StandardHeader *) _resList[i].ptr;
StandardHeader *header = (StandardHeader *)_resList[i].ptr;
if (wantInfo)
Debug_Printf("Nuked %5d: %s\n", i, header->name);
@ -757,7 +757,7 @@ void ResourceManager::killAllObjects(bool wantInfo) {
continue;
if (_resList[i].ptr) {
StandardHeader *header = (StandardHeader *) _resList[i].ptr;
StandardHeader *header = (StandardHeader *)_resList[i].ptr;
if (header->fileType == GAME_OBJECT) {
if (wantInfo)

10
sword2/router.cpp
View File

@ -109,7 +109,7 @@ void Router::allocateRouteMem() {
if (_routeSlots[slotNo])
freeRouteMem();
_routeSlots[slotNo] = (WalkData *) malloc(sizeof(WalkData) * O_WALKANIM_SIZE);
_routeSlots[slotNo] = (WalkData *)malloc(sizeof(WalkData) * O_WALKANIM_SIZE);
// 12000 bytes were used for this in Sword1 mega compacts, based on
// 20 bytes per 'WalkData' frame
@ -127,7 +127,7 @@ void Router::allocateRouteMem() {
WalkData *Router::getRouteMem() {
uint8 slotNo = returnSlotNo(Logic::_scriptVars[ID]);
return (WalkData *) _routeSlots[slotNo];
return (WalkData *)_routeSlots[slotNo];
}
void Router::freeRouteMem() {
@ -2397,7 +2397,7 @@ void Router::loadWalkGrid() {
// open walk grid file
fPolygrid = _vm->_resman->openResource(_walkGridList[i]);
fPolygrid += sizeof(StandardHeader);
memcpy((byte *) &floorHeader, fPolygrid, sizeof(WalkGridHeader));
memcpy((byte *)&floorHeader, fPolygrid, sizeof(WalkGridHeader));
fPolygrid += sizeof(WalkGridHeader);
// how many bars & nodes are we getting from this
@ -2414,7 +2414,7 @@ void Router::loadWalkGrid() {
// lines
memcpy((byte *) &_bars[_nBars], fPolygrid, theseBars * sizeof(BarData));
memcpy((byte *)&_bars[_nBars], fPolygrid, theseBars * sizeof(BarData));
// move pointer to start of node data
fPolygrid += theseBars * sizeof(BarData);
@ -2423,7 +2423,7 @@ void Router::loadWalkGrid() {
// leave node 0 for start node
for (uint j = 0; j < theseNodes; j++) {
memcpy((byte *) &_node[_nNodes + j].x, fPolygrid, 2 * sizeof(int16));
memcpy((byte *)&_node[_nNodes + j].x, fPolygrid, 2 * sizeof(int16));
fPolygrid += 2 * sizeof(int16);
}

20
sword2/save_rest.cpp
View File

@ -93,7 +93,7 @@ static void convertHeaderEndian(Sword2Engine::SaveGameHeader &header) {
uint32 Sword2Engine::saveGame(uint16 slotNo, byte *desc) {
uint32 bufferSize = findBufferSize();
byte *saveBufferMem = (byte *) malloc(bufferSize);
byte *saveBufferMem = (byte *)malloc(bufferSize);
fillSaveBuffer(saveBufferMem, bufferSize, desc);
@ -132,7 +132,7 @@ void Sword2Engine::fillSaveBuffer(byte *buffer, uint32 size, byte *desc) {
// Set up the _saveGameHeader. Checksum gets filled in last of all.
ScreenInfo *screenInfo = _screen->getScreenInfo();
strcpy(_saveGameHeader.description, (char *) desc);
strcpy(_saveGameHeader.description, (char *)desc);
_saveGameHeader.varLength = _resman->fetchLen(1);
_saveGameHeader.screenId = screenInfo->background_layer_id;
_saveGameHeader.runListId = _logic->getRunList();
@ -160,7 +160,7 @@ void Sword2Engine::fillSaveBuffer(byte *buffer, uint32 size, byte *desc) {
memcpy(buffer + sizeof(_saveGameHeader), varsRes, FROM_LE_32(_saveGameHeader.varLength));
#ifdef SCUMM_BIG_ENDIAN
uint32 *globalVars = (uint32 *) (buffer + sizeof(_saveGameHeader) + sizeof(StandardHeader));
uint32 *globalVars = (uint32 *)(buffer + sizeof(_saveGameHeader) + sizeof(StandardHeader));
const uint numVars = (FROM_LE_32(_saveGameHeader.varLength) - sizeof(StandardHeader)) / 4;
for (uint i = 0; i < numVars; i++)
@ -205,7 +205,7 @@ uint32 Sword2Engine::saveData(uint16 slotNo, byte *buffer, uint32 bufferSize) {
uint32 Sword2Engine::restoreGame(uint16 slotNo) {
uint32 bufferSize = findBufferSize();
byte *saveBufferMem = (byte *) malloc(bufferSize);
byte *saveBufferMem = (byte *)malloc(bufferSize);
uint32 errorCode = restoreData(slotNo, saveBufferMem, bufferSize);
@ -332,7 +332,7 @@ uint32 Sword2Engine::restoreFromBuffer(byte *buffer, uint32 size) {
memcpy(varsRes, buffer + sizeof(_saveGameHeader), _saveGameHeader.varLength);
#ifdef SCUMM_BIG_ENDIAN
uint32 *globalVars = (uint32 *) (varsRes + sizeof(StandardHeader));
uint32 *globalVars = (uint32 *)(varsRes + sizeof(StandardHeader));
const uint numVars = (_saveGameHeader.varLength - sizeof(StandardHeader)) / 4;
for (uint i = 0; i < numVars; i++)
@ -416,7 +416,7 @@ uint32 Sword2Engine::getSaveDescription(uint16 slotNo, byte *description) {
in->read(&dummy, sizeof(dummy));
delete in;
strcpy((char *) description, dummy.description);
strcpy((char *)description, dummy.description);
return SR_OK;
}
@ -447,11 +447,11 @@ bool Sword2Engine::saveExists(uint16 slotNo) {
*/
void Sword2Engine::getPlayerStructures() {
StandardHeader *head = (StandardHeader *) _resman->openResource(CUR_PLAYER_ID);
StandardHeader *head = (StandardHeader *)_resman->openResource(CUR_PLAYER_ID);
assert(head->fileType == GAME_OBJECT);
char *raw_script_ad = (char *) head;
char *raw_script_ad = (char *)head;
// Script no. 7 - 'george_savedata_request' calls fnPassPlayerSaveData
uint32 null_pc = 7;
@ -467,11 +467,11 @@ void Sword2Engine::getPlayerStructures() {
*/
void Sword2Engine::putPlayerStructures() {
StandardHeader *head = (StandardHeader *) _resman->openResource(CUR_PLAYER_ID);
StandardHeader *head = (StandardHeader *)_resman->openResource(CUR_PLAYER_ID);
assert(head->fileType == GAME_OBJECT);
char *raw_script_ad = (char *) head;
char *raw_script_ad = (char *)head;
// Script no. 8 - 'george_savedata_return' calls fnGetPlayerSaveData

2
sword2/sound.cpp
View File

@ -205,7 +205,7 @@ void Sound::queueFx(int32 res, int32 type, int32 delay, int32 volume, int32 pan)
for (int i = 0; i < FXQ_LENGTH; i++) {
if (!_fxQueue[i].resource) {
byte *data = _vm->_resman->openResource(res);
StandardHeader *header = (StandardHeader *) data;
StandardHeader *header = (StandardHeader *)data;
assert(header->fileType == WAV_FILE);

6
sword2/speech.cpp
View File

@ -87,7 +87,7 @@ void Logic::locateTalker(int32 *params) {
if (cdt_entry->frameType & FRAME_OFFSET) {
// The frame has offsets, i.e. it's a scalable mega frame
ObjectMega *ob_mega = (ObjectMega *) decodePtr(params[S_OB_MEGA]);
ObjectMega *ob_mega = (ObjectMega *)decodePtr(params[S_OB_MEGA]);
// Calculate scale at which to print the sprite, based on feet
// y-coord and scaling constants (NB. 'scale' is actually
@ -158,7 +158,7 @@ void Logic::formText(int32 *params) {
return;
}
ObjectSpeech *ob_speech = (ObjectSpeech *) decodePtr(params[S_OB_SPEECH]);
ObjectSpeech *ob_speech = (ObjectSpeech *)decodePtr(params[S_OB_SPEECH]);
// Establish the max width allowed for this text sprite.
uint32 textWidth = ob_speech->width ? ob_speech->width : 400;
@ -181,7 +181,7 @@ void Logic::formText(int32 *params) {
_vm->_resman->closeResource(text_res);
// Set speech duration, in case not using a wav.
_speechTime = strlen((char *) text) + 30;
_speechTime = strlen((char *)text) + 30;
}
/**

6
sword2/startup.cpp
View File

@ -117,7 +117,7 @@ bool Sword2Engine::initStartMenu() {
// start list
if (_resman->checkValid(_startRes)) {
char *raw_script = (char *) _resman->openResource(_startRes);
char *raw_script = (char *)_resman->openResource(_startRes);
uint32 null_pc = 0;
_logic->runScript(raw_script, raw_script, &null_pc);
@ -167,8 +167,8 @@ void Sword2Engine::runStart(int start) {
}
// Open George
char *raw_data_ad = (char *) _resman->openResource(CUR_PLAYER_ID);
char *raw_script = (char *) _resman->openResource(_startList[start].start_res_id);
char *raw_data_ad = (char *)_resman->openResource(CUR_PLAYER_ID);
char *raw_script = (char *)_resman->openResource(_startList[start].start_res_id);
// Denotes script to run
uint32 null_pc = _startList[start].key & 0xffff;

6
sword2/sword2.cpp
View File

@ -221,7 +221,7 @@ void Sword2Engine::writeSettings() {
*/
void Sword2Engine::setupPersistentResources() {
Logic::_scriptVars = (uint32 *) (_resman->openResource(1) + sizeof(StandardHeader));
Logic::_scriptVars = (uint32 *)(_resman->openResource(1) + sizeof(StandardHeader));
_resman->openResource(CUR_PLAYER_ID);
}
@ -592,8 +592,8 @@ void Sword2Engine::startGame() {
uint32 null_pc = 1;
char *raw_data_ad = (char *) _resman->openResource(CUR_PLAYER_ID);
char *raw_script = (char *) _resman->openResource(screen_manager_id);
char *raw_data_ad = (char *)_resman->openResource(CUR_PLAYER_ID);
char *raw_script = (char *)_resman->openResource(screen_manager_id);
_logic->runScript(raw_script, raw_data_ad, &null_pc);

8
sword2/walker.cpp
View File

@ -250,7 +250,7 @@ int Router::walkToTalkToMega(ObjectLogic *ob_logic, ObjectGraphic *ob_graph, Obj
// If this is the start of the walk, calculate the route.
if (!ob_logic->looping) {
StandardHeader *head = (StandardHeader *) _vm->_resman->openResource(megaId);
StandardHeader *head = (StandardHeader *)_vm->_resman->openResource(megaId);
assert(head->fileType == GAME_OBJECT);
@ -258,7 +258,7 @@ int Router::walkToTalkToMega(ObjectLogic *ob_logic, ObjectGraphic *ob_graph, Obj
// call, and will set _engineMega to the ObjectMega of mega we
// want to route to.
char *raw_script_ad = (char *) head;
char *raw_script_ad = (char *)head;
uint32 null_pc = 3;
_vm->_logic->runScript(raw_script_ad, raw_script_ad, &null_pc);
@ -344,7 +344,7 @@ int Router::faceMega(ObjectLogic *ob_logic, ObjectGraphic *ob_graph, ObjectMega
// If this is the start of the walk, decide where to walk to.
if (!ob_logic->looping) {
StandardHeader *head = (StandardHeader *) _vm->_resman->openResource(megaId);
StandardHeader *head = (StandardHeader *)_vm->_resman->openResource(megaId);
assert(head->fileType == GAME_OBJECT);
@ -352,7 +352,7 @@ int Router::faceMega(ObjectLogic *ob_logic, ObjectGraphic *ob_graph, ObjectMega
// call, and will set _engineMega to the ObjectMega of mega we
// want to turn to face.
char *raw_script_ad = (char *) head;
char *raw_script_ad = (char *)head;
uint32 null_pc = 3;
_vm->_logic->runScript(raw_script_ad, raw_script_ad, &null_pc);