diff options
author | Vincent Hamm | 2007-04-27 12:58:35 +0000 |
---|---|---|
committer | Vincent Hamm | 2007-04-27 12:58:35 +0000 |
commit | c01aa37caaadb2e65667b1156a907e92e859fee8 (patch) | |
tree | 5c55328c78f6f1664f4f46baadee583fcff977ef /engines/cruise/mainDraw.cpp | |
parent | edd9b31a483c07066537663a01c265d99d69ada7 (diff) | |
download | scummvm-rg350-c01aa37caaadb2e65667b1156a907e92e859fee8.tar.gz scummvm-rg350-c01aa37caaadb2e65667b1156a907e92e859fee8.tar.bz2 scummvm-rg350-c01aa37caaadb2e65667b1156a907e92e859fee8.zip |
Add cruise source code for scummvm
svn-id: r26605
Diffstat (limited to 'engines/cruise/mainDraw.cpp')
-rw-r--r-- | engines/cruise/mainDraw.cpp | 1142 |
1 files changed, 1142 insertions, 0 deletions
diff --git a/engines/cruise/mainDraw.cpp b/engines/cruise/mainDraw.cpp new file mode 100644 index 0000000000..7e938bdb96 --- /dev/null +++ b/engines/cruise/mainDraw.cpp @@ -0,0 +1,1142 @@ +/* ScummVM - Scumm Interpreter + * Copyright (C) 2006 The ScummVM project + * + * cinE Engine is (C) 2004-2005 by CinE Team + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + * + */ + +#include "cruise/cruise_main.h" +#include "polys.h" + +namespace Cruise { + +int currentTransparent; + +struct drawVar1Struct +{ + struct drawVar1Struct* next; + short int field_2; + short int field_4; + short int field_6; + short int field_8; + objectStruct* field_A; +}; + +typedef struct drawVar1Struct drawVar1Struct; + +drawVar1Struct drawVar1; + + +void mainDraw6(void) +{ + drawVar1Struct* pCurrent = drawVar1.next; + + while(pCurrent) + { + drawVar1Struct* next = pCurrent->next; + + if(pCurrent->field_6 == 5) + { + Op_7Sub(pCurrent->field_2, pCurrent->field_4, pCurrent->field_8); + } + else + { + setObjectPosition(pCurrent->field_2, pCurrent->field_4, pCurrent->field_6, pCurrent->field_8); + } + + if(pCurrent->field_A->nextAnimDelay < 0) + { + objectParamsQuery params; + + getMultipleObjectParam(pCurrent->field_2, pCurrent->field_4, ¶ms); + + pCurrent->field_A->currentAnimDelay = params.var6-1; + } + + free(pCurrent); + + pCurrent = next; + } +} + +void flipScreen(void) +{ + uint8* swapPtr; + + swapPtr = gfxModuleData.pPage00; + gfxModuleData.pPage00 = gfxModuleData.pPage10; + gfxModuleData.pPage10 = swapPtr; + + gfxModuleData_flipScreen(); + + /*memcpy(globalAtariScreen, gfxModuleData.pPage00, 16000); + convertAtariToRaw(gfxModuleData.pPage00,globalScreen,200,320);*/ +} + +int spriteX1; +int spriteX2; +int spriteY1; +int spriteY2; + +char* polyOutputBuffer; + +void pixel(int x, int y, char color) +{ + if(x >= 0 && x < 320 && y >= 0 && y < 200) + polyOutputBuffer[320*y+x] = color; +} + +// this function checks if the dataPtr is not 0, else it retrives the data for X, Y, scale and DataPtr again (OLD: mainDrawSub1Sub1) +void getPolyData(int fileIndex, int X, int Y, int *outScale, int *outY, int *outX, char **outDataPtr, int scale, char* dataPtr) +{ + if(*(uint16*) dataPtr == 0) + { + uint16 newFileIndex; + uint16 newX; + char* newDataPtr; // this one is quite useless + uint16 newY; + + dataPtr += 2; + newFileIndex = *(uint16*) dataPtr; + flipShort(&newFileIndex); + + dataPtr += 2; + newX = *(uint16*) dataPtr; + flipShort(&newX); + + newDataPtr = dataPtr; // useless + + newY = *(uint16*) (newDataPtr + 2); + flipShort(&newY); + + newFileIndex += fileIndex; + + if(newFileIndex >= 0) + { + if(filesDatabase[newFileIndex].resType == 0 && filesDatabase[newFileIndex].subData.ptr) + { + dataPtr = (char*)filesDatabase[newFileIndex].subData.ptr; + } + } + + scale = -scale; + X -= newX; + Y -= newY; + } + + *outDataPtr = dataPtr; + *outX = X; + *outY = Y; + *outScale = scale; +} + +int upscaleValue(int value, int scale) +{ + return (((value * scale) << 8) / 2); +} + +int m_flipLeftRight; +int m_useSmallScale; +int m_lowerX; +int m_lowerY; +int m_coordCount; +int m_first_X; +int m_first_Y; +int m_scaleValue; +int m_current_X; +int m_current_Y; +int m_color; + +int16 polyBuffer[512]; +int16 polyBuffer2[512]; +int16 polyBuffer3[404]; +int16 polyBuffer4[512]; + +// this function fills the sizeTable for the poly (OLD: mainDrawSub1Sub2) +void getPolySize(int positionX, int positionY, int scale, int sizeTable[4], unsigned char* dataPtr) +{ + int upperBorder; + int lowerBorder; + m_flipLeftRight = 0; + + if(scale < 0) // flip left right + { + m_flipLeftRight = 1; + scale = -scale; + } + + // X1 + + upperBorder = *(dataPtr + 3); + + if(m_flipLeftRight) + { + upperBorder = -upperBorder; + } + + upperBorder = (upscaleValue(upperBorder, scale) + 0x8000) >> 16; + upperBorder = -upperBorder; + lowerBorder = upperBorder; + + // X2 + + upperBorder = *(dataPtr + 1); + upperBorder -= *(dataPtr + 3); + + if(m_flipLeftRight) + { + upperBorder = -upperBorder; + } + + upperBorder = (upscaleValue(upperBorder, scale) + 0x8000) >> 16; + + if(upperBorder < lowerBorder) // exchange borders if lower > upper + { + int temp = upperBorder; + upperBorder = lowerBorder; + lowerBorder = temp; + } + + sizeTable[0] = lowerBorder; // left + sizeTable[1] = upperBorder; // right + + // Y1 + + upperBorder = *(dataPtr + 4); + upperBorder = (upscaleValue(upperBorder, scale) + 0x8000) >> 16; + upperBorder = -upperBorder; + lowerBorder = upperBorder; + + // Y2 + + upperBorder = *(dataPtr + 2); + upperBorder -= *(dataPtr + 4); + upperBorder = (upscaleValue(upperBorder, scale) + 0x8000) >> 16; + + if(upperBorder < lowerBorder) // exchange borders if lower > upper + { + int temp = upperBorder; + upperBorder = lowerBorder; + lowerBorder = temp; + } + + sizeTable[2] = lowerBorder; // bottom + sizeTable[3] = upperBorder; // top +} + +void blitPolyMode1(char* dest, char* ptr, int16* buffer, char color) +{ +} + +void blitPolyMode2(char* dest, int16* buffer, char color) +{ +} + +int polySize1; +int polySize2; +int polySize3; +int polySize4; + +int polyVar1; +int16* polyVar2; + +void drawPolySub(void) +{ + int i; + + for(i = 0; i < polyVar1; i++) + { + line(polyBuffer4[i * 2], polyBuffer4[i * 2 + 1], polyBuffer4[(i + 1) * 2], polyBuffer4[(i + 1) * 2 + 1], m_color & 0xF); + } + + fillpoly(polyBuffer4, polyVar1, m_color & 0xF); +} + +char* drawPolyMode1(char* dataPointer, int linesToDraw) +{ + int index; + int16* pBufferDest; + + polyVar1 = linesToDraw; + pBufferDest = &polyBuffer4[polyVar1 * 2]; + index = *(dataPointer++); + + polySize1 = polySize2 = pBufferDest[-2] = pBufferDest[-2 + linesToDraw * 2] = polyBuffer2[index * 2]; + polySize1 = polySize2 = pBufferDest[-1] = pBufferDest[-1 + linesToDraw * 2] = polyBuffer2[(index * 2) + 1]; + + linesToDraw--; + + pBufferDest -= 2; + + polyVar2 = pBufferDest; + + do + { + int value; + + index = *(dataPointer++); + value = pBufferDest[-2] = pBufferDest[-2 + polyVar1 * 2] = polyBuffer2[index * 2]; + + if(value < polySize1) + { + polySize1 = value; + } + if(value > polySize2) + { + polySize2 = value; + } + + value = pBufferDest[-1] = pBufferDest[-1 + polyVar1 * 2] = polyBuffer2[(index * 2) + 1]; + + if(value > polySize4) + { + polySize4 = value; + } + if(value < polySize3) + { + polySize3 = value; + polyVar2 = pBufferDest - 4; + } + pBufferDest -= 2; + + } while(--linesToDraw); + + drawPolySub(); + + return dataPointer; +} + +char* drawPolyMode2(char* dataPointer, int linesToDraw) +{ + int index; + int16* pBufferDest; + + pBufferDest = polyBuffer4; + polyVar1 = linesToDraw; + polyVar2 = polyBuffer4; + index = *(dataPointer++); + + polySize1 = polySize2 = pBufferDest[0] = pBufferDest[linesToDraw * 2] = polyBuffer2[index * 2]; + polySize1 = polySize2 = pBufferDest[1] = pBufferDest[linesToDraw * 2 + 1] = polyBuffer2[(index * 2) + 1]; + + linesToDraw--; + + pBufferDest += 2; + + do + { + int value; + + index = *(dataPointer++); + value = pBufferDest[0] = pBufferDest[polyVar1 * 2] = polyBuffer2[index * 2]; + + if(value < polySize1) + { + polySize1 = value; + } + if(value > polySize2) + { + polySize2 = value; + } + + value = pBufferDest[1] = pBufferDest[polyVar1 * 2 + 1] = polyBuffer2[(index * 2) + 1]; + + if(value > polySize4) + { + polySize4 = value; + } + if(value < polySize3) + { + polySize3 = value; + polyVar2 = pBufferDest; + } + + pBufferDest += 2; + + } while(--linesToDraw); + + drawPolySub(); + + return dataPointer; +} + +// this function builds the poly model and then calls the draw functions (OLD: mainDrawSub1Sub5) +void buildPolyModel(int positionX, int positionY, int scale, char* ptr2, char* destBuffer, char* dataPtr) +{ + int counter = 0; // numbers of coordinates to process + int startX = 0; // first X in model + int startY = 0; // first Y in model + int x = 0; // current X + int y = 0; // current Y + int offsetXinModel = 0; // offset of the X value in the model + int offsetYinModel = 0; // offset of the Y value in the model + unsigned char* dataPointer = (unsigned char*)dataPtr; + int16* ptrPoly_1_Buf = polyBuffer; + int16* ptrPoly_2_Buf; + polyOutputBuffer = destBuffer; // global + + m_flipLeftRight = 0; + m_useSmallScale = 0; + m_lowerX = *(dataPointer + 3); + m_lowerY = *(dataPointer + 4); + + if(scale < 0) + { + scale = -scale; // flip left right + m_flipLeftRight = 1; + } + + if(scale < 0x180) // If scale is smaller than 384 + { + m_useSmallScale = 1; + m_scaleValue = scale << 1; // double scale + } + else + { + m_scaleValue = scale; + } + + dataPointer += 5; + + m_coordCount = (*(dataPointer++)) + 1; // original uses +1 here but its later substracted again, we could skip it + m_first_X = *(dataPointer++); + m_first_Y = *(dataPointer++); + startX = m_lowerX - m_first_X; + startY = m_lowerY - m_first_Y; + + if(m_useSmallScale) + { + startX >>= 1; + startY >>= 1; + } + + if(m_flipLeftRight) + { + startX = -startX; + } + + /* + NOTE: + + The original code continues here with using X, Y instead of startX and StartY. + + Original code: + positionX -= (upscaleValue(startX, m_scaleValue) + 0x8000) >> 16; + positionY -= (upscaleValue(startX, m_scaleValue) + 0x8000) >> 16; + */ + + // get coordinates from data + + startX = positionX - ((upscaleValue(startX, m_scaleValue) + 0x8000) >> 16); + startY = positionY - ((upscaleValue(startY, m_scaleValue) + 0x8000) >> 16); + + ptrPoly_1_Buf[0] = 0; + ptrPoly_1_Buf[1] = 0; + ptrPoly_1_Buf += 2; + counter = m_coordCount - 1 - 1; // skip the first pair, we already have the values + + do + { + x = *(dataPointer++) - m_first_X; + y = *(dataPointer++) - m_first_Y; + + if(m_useSmallScale) // shrink all coordinates by factor 2 if a scale smaller than 384 is used + { + x >>= 1; + y >>= 1; + } + + ptrPoly_1_Buf[0] = offsetXinModel - x; + ptrPoly_1_Buf++; + offsetXinModel = x; + + ptrPoly_1_Buf[0] = -(offsetYinModel - y); + ptrPoly_1_Buf++; + offsetYinModel = y; + + } while(--counter); + + // scale and adjust coordinates with offset (using two polybuffers by doing that) + + /* + NOTE: Is there a need for having two, a scaled and unscaled polybuffer? + */ + + ptrPoly_2_Buf = polyBuffer; + ptrPoly_1_Buf = polyBuffer2; + counter = m_coordCount - 1; // reset counter // process first pair two + m_current_X = 0; + m_current_Y = 0; + + do + { + x = ptrPoly_2_Buf[0]; + + if(m_flipLeftRight == 0) + { + x = -x; + } + + ////////////////// + + m_current_X += upscaleValue(x, m_scaleValue); + ptrPoly_1_Buf[0] = ((m_current_X + 0x8000) >> 16) + startX; // adjust X value with start offset + + m_current_Y += upscaleValue(ptrPoly_2_Buf[1], m_scaleValue); + ptrPoly_1_Buf[1] = ((m_current_Y + 0x8000) >> 16) + startY; // adjust Y value with start offset + + ///////////////// + + ptrPoly_1_Buf += 2; + ptrPoly_2_Buf += 2; + + } while(--counter); + + // position of the dataPointer is m_coordCount * 2 + + do + { + int linesToDraw = *dataPointer++; + + if(linesToDraw > 1) // if value not zero + { + uint16 minimumScale; + + m_color = *dataPointer; // color + dataPointer += 2; + + minimumScale = *(uint16*) (dataPointer); + dataPointer += 2; + + flipShort(&minimumScale); + + if(minimumScale > scale) // if the scale is too small, for the model to be drawn ... + { + dataPointer += linesToDraw; // ... skip ahead + } + else + { + if(m_flipLeftRight) + { + dataPointer = (unsigned char*)drawPolyMode1((char*)dataPointer, linesToDraw); + } + else + { + dataPointer = (unsigned char*)drawPolyMode2((char*)dataPointer, linesToDraw); + } + + if(destBuffer) + { + if(ptr2) + { + blitPolyMode1(destBuffer, ptr2, polyBuffer3, m_color & 0xF); + } + else + { + blitPolyMode2(destBuffer, polyBuffer3, m_color & 0xF); + } + } + } + } + else + { + dataPointer += 4; + } + } while(*dataPointer != 0xFF); +} + +// draw poly sprite (OLD: mainDrawSub1) +void mainDrawPolygons(int fileIndex, objectStruct* pObject, int X, int scale, int Y, char* destBuffer, char* dataPtr) +{ + int newX; + int newY; + int newScale; + char* newDataPtr; + char* ptr2; // unused + int var_8; // unused + + int sizeTable[4]; // 0 = left, 1 = right, 2 = bottom, 3 = top + + // this function checks if the dataPtr is not 0, else it retrives the data for X, Y, scale and DataPtr again (OLD: mainDrawSub1Sub1) + getPolyData(fileIndex, X, Y, &newScale, &newY, &newX, &newDataPtr, scale, dataPtr); + + // this function fills the sizeTable for the poly (OLD: mainDrawSub1Sub2) + getPolySize(newX, newY, newScale, sizeTable, (unsigned char*)newDataPtr); + + spriteX2 = sizeTable[0] - 2; // left border + spriteX1 = sizeTable[1] + 18; // right border + spriteY2 = sizeTable[2] - 2; // bottom border + spriteY1 = sizeTable[3] + 2; // top border + +/* if (X == 28 && Y == 80 && scale == 1024) { + printf("0--> x1: %i, y1: %i, x2: %i, y2: %i\n", sizeTable[1], sizeTable[3], sizeTable[0], sizeTable[2]); + printf("1--> x1: %i, y1: %i, x2: %i, y2: %i\n", spriteX1, spriteY1, spriteX2, spriteY2); + } */ + if(spriteX2 >= 320) + return; + if(spriteX1 < 0) + return; + if(spriteY2 >= 200) + return; + if(spriteY1 < 0) + return; + + if(spriteX2 < 0) + { + spriteX2 = 0; + } + if(spriteX1 > 320) + { + spriteX1 = 320; + } + if(spriteY2 < 0) + { + spriteY2 = 0; + } + if(spriteY1 > 200) + { + spriteY1 = 200; + } + + if(spriteX1 == spriteX2) + return; + if(spriteY1 == spriteY2) + return; + + ptr2 = NULL; + var_8 = 0; + + if(pObject) + { + objectStruct* pCurrentObject = pObject; + + do + { + if(pCurrentObject->type == 2) + { + // ASSERT(0); + } + + pCurrentObject = pCurrentObject->next; + } while(pCurrentObject); + } + + // this function builds the poly model and then calls the draw functions (OLD: mainDrawSub1Sub5) + buildPolyModel(newX, newY, newScale, ptr2, destBuffer, newDataPtr); +} + +void mainSprite(int globalX, int globalY, gfxEntryStruct* pGfxPtr, uint8* ouputPtr, int newColor, int idx) +{ + // this is used for font only + + if(pGfxPtr) + { + uint8* initialOuput; + uint8* output; + int i; + int j; + int x; + int y; + uint8* ptr = pGfxPtr->imagePtr; + int height = pGfxPtr->height; + int width = pGfxPtr->width; + + if(globalY < 0) + { + globalY = 0; + } + + if(globalY + pGfxPtr->height >= 198) + { + globalY = 198 - pGfxPtr->height; + } + + initialOuput = ouputPtr + (globalY*320) + globalX; + + y = globalY; + x = globalX; + + for(i = 0; i < height; i++) + { + output = initialOuput + 320 * i; + + for(j = 0; j < width; j++) + { + uint8 color = *(ptr++); + + if(color) + { + if((x >= 0) && (x < 320) && (y >= 0) && (y < 200)) + { + if(color == 1) + { + *output = (uint8) 0; + } + else + { + *output = (uint8) newColor; + } + } + } + output++; + } + } + } +} + +void mainDrawSub4(int objX1, int var_6, objectStruct* currentObjPtr, char* data1, int objY2, int objX2, char* output, char* data2) +{ + int x = 0; + int y = 0; + + for(y = 0; y < var_6; y++) + { + for(x = 0; x < (objX1 * 8); x++) + { + uint8 color = (data1[0]); + data1++; + + if((x + objX2) >= 0 && (x + objX2) < 320 && (y + objY2) >= 0 && (y + objY2) < 200) + { + if(color != currentTransparent) + { + output[320 * (y + objY2) + x + objX2] = color; + } + } + } + } +} + +void mainDraw5(int overlayIdx, int idx, int field_28, objectStruct* pObject, int newVal) +{ + drawVar1Struct* pNewEntry; + + pNewEntry = (drawVar1Struct*)malloc(sizeof(drawVar1Struct)); + + pNewEntry->next = drawVar1.next; + drawVar1.next = pNewEntry; + + pNewEntry->field_2 = overlayIdx; + pNewEntry->field_4 = idx; + pNewEntry->field_6 = field_28; + pNewEntry->field_8 = newVal; + pNewEntry->field_A = pObject; +} + +#ifdef _DEBUG +void drawCtp(void) +{ + int i; + + if(ctp_walkboxTable) + { + for(i = 0; i < 15; i++) + { + uint16* dataPtr = &ctp_walkboxTable[i * 40]; + int type = walkboxType[i]; // show different types in different colors + + if(*dataPtr) + { + int j; + fillpoly((short*)dataPtr+1, *dataPtr, type); + + for(j = 0; j < (*dataPtr - 1); j++) + { + line(dataPtr[1 + j * 2], dataPtr[1 + j * 2 + 1], dataPtr[1 + (j + 1) * 2], dataPtr[1 + ( j + 1) * 2 + 1], 0); + } + + line(dataPtr[1 + j * 2], dataPtr[1 + j * 2 + 1], dataPtr[1], dataPtr[2], 0); + } + } + } +} +#endif + +void drawMenu(menuStruct* pMenu) +{ + if(pMenu && pMenu->numElements) + { + int height; + int x; + int y; + int var_10; + int bx; + int newX; + int var_6; + int currentY; + int var_8; + int di; + menuElementStruct* si; + + height = pMenu->gfx->height; + x = pMenu->x; + y = pMenu->y; + + var_10 = pMenu->gfx->width / (199 - (pMenu->gfx->width * 2)); + + bx = var_10 / (pMenu->numElements + 1); // rustine... + + if(!bx) + { + bx++; + + if((pMenu->numElements * height) + y > 199 - height) + { + y = ((-1 - pMenu->numElements) * height) + 200; + } + } + else + { + if(var_10 % pMenu->numElements) + { + bx++; + } + + y = height; + } + + newX = 320 * (2 - bx); + + if(newX < x) + { + x = newX; + } + + if(x < 0) + { + x = 0; + } + + var_6 = (80 * (bx-1)) + x; + + if(var_6 <= 320) + { + mainSprite(var_6, y - height, pMenu->gfx, gfxModuleData.pPage10, video4, 320); + } + + currentY = y; + var_8 = 0; + di = x; + + si = pMenu->ptrNextElement; + + if(si) + { + do + { + int color; + + gfxEntryStruct* var_2 = si->gfx; + + si->x = di; + si->y = currentY; + si->varA = 320; + + if(si->varC) + { + color = video3; + } + else + { + if(si->color != 255) + { + color = si->color; + } + else + { + color = video2; + } + } + + if(di < 320) + { + mainSprite(di, currentY, var_2, gfxModuleData.pPage10, color, 320); + } + + currentY += height; + var_8++; + + if(var_8 == var_10) + { + var_8 = 0; + di += 320; + currentY = y; + } + + si = si->next; + } while(si); + } + } +} + +int getValueFromObjectQuerry(objectParamsQuery* params, int idx) +{ + switch(idx) + { + case 0: + return params->X; + case 1: + return params->Y; + case 2: + return params->baseFileIdx; + case 3: + return params->fileIdx; + case 4: + return params->scale; + case 5: + return params->var5; + case 6: + return params->var6; + case 7: + return params->var7; + } + + assert(0); + + return 0; +} + +void mainDraw(int16 param) +{ + uint8* bgPtr; + objectStruct* currentObjPtr; + int16 currentObjIdx; + int16 objX1 = 0; + int16 objY1 = 0; + int16 objZ1 = 0; + int16 objX2; + int16 objY2; + int16 spriteHeight; + + + if(fadeVar) + { + return; + } + + bgPtr = backgroundPtrtable[currentActiveBackgroundPlane]; + + if(bgPtr) + { + gfxModuleData_gfxCopyScreen((char*)bgPtr,(char*)gfxModuleData.pPage10); + } + + drawVar1.next = NULL; + + currentObjPtr = objectHead.next; + +#ifdef _DEBUG + polyOutputBuffer = (char*)bgPtr; + drawCtp(); +#endif + + //-------------------------------------------------- DRAW OBJECTS TYPE 4 -----------------------------------------// + + while(currentObjPtr) + { + if((currentActiveBackgroundPlane == currentObjPtr->backgroundPlane) && (currentObjPtr->hide == 0) && (currentObjPtr->type == 4)) + { + int16 fileIdx; + objectParamsQuery params; + + currentObjIdx = currentObjPtr->idx; + + if((currentObjPtr->followObjectOverlayIdx == currentObjPtr->overlay) && (currentObjPtr->followObjectIdx == currentObjPtr->idx)) + { + objX1 = 0; + objY1 = 0; + objZ1 = 0; + } + else + { + // Declaring this twice ? + // objectParamsQuery params; + + getMultipleObjectParam(currentObjPtr->followObjectOverlayIdx, currentObjPtr->followObjectIdx, ¶ms); + + objX1 = params.X; + objY1 = params.Y; + objZ1 = params.fileIdx; + } + + getMultipleObjectParam(currentObjPtr->overlay, currentObjIdx, ¶ms); + + objX2 = objX1 + params.X; + objY2 = objY1 + params.Y; + + fileIdx = params.fileIdx; + + if(fileIdx >= 0) + { + fileIdx += objZ1; + } + + if((params.var5 >= 0) && (fileIdx >= 0) && filesDatabase[fileIdx].subData.ptr) + { + if(filesDatabase[fileIdx].subData.resourceType == 8) + { + mainDrawPolygons(fileIdx, currentObjPtr, objX2, params.scale, objY2, (char*)gfxModuleData.pPage10, (char*)filesDatabase[fileIdx].subData.ptr); // poly + } + else if(filesDatabase[fileIdx].subData.resourceType == 6) + { + } + else if(filesDatabase[fileIdx].resType == 1) + { + } + else if(filesDatabase[fileIdx].subData.resourceType == 4) + { + objX1 = filesDatabase[fileIdx].width; // width + spriteHeight = filesDatabase[fileIdx].height; // height + + if(filesDatabase[fileIdx].subData.ptr) + { + currentTransparent = filesDatabase[fileIdx].subData.transparency; + + mainDrawSub4(objX1, spriteHeight, currentObjPtr, (char*)filesDatabase[fileIdx].subData.ptr, objY2, objX2, (char*)gfxModuleData.pPage10, (char*)filesDatabase[fileIdx].subData.ptr); + } + } + } + + if((currentObjPtr->field_26 != 0) && (param == 0)) + { + if(currentObjPtr->currentAnimDelay <= 0) + { + int newVal; + objX1 = 1; + + newVal = getValueFromObjectQuerry(¶ms,currentObjPtr->field_28) + currentObjPtr->field_26; + + if(currentObjPtr->field_26 > 0) + { + if(currentObjPtr->field_22 < newVal) + { + if(currentObjPtr->field_30 >= 0) + { + int16 data2; + + newVal = currentObjPtr->field_20; + + if(currentObjPtr->field_30 > 0) + { + currentObjPtr->field_30--; + } + + data2 = currentObjPtr->field_20; + + objX1 = 0; + currentObjPtr->field_26 = 0; + + if(currentObjPtr->field_2A) // should we resume the script ? + { + if(currentObjPtr->field_1A == 20) + { + changeScriptParamInList(currentObjPtr->field_18, currentObjPtr->field_16, &scriptHandle2, 0, -1); + } + else + if(currentObjPtr->field_1A == 30) + { + changeScriptParamInList(currentObjPtr->field_18, currentObjPtr->field_16, &scriptHandle1, 0, -1); + } + } + newVal = data2; + } + } + } + else + { + ASSERT(0); + /* if(currentObjPtr->field_22>newVal) + { + } */ + } + + if(currentObjPtr->nextAnimDelay >= 0) + { + currentObjPtr->currentAnimDelay = currentObjPtr->nextAnimDelay; + } + + if(currentObjPtr->field_2C >= 0 && (currentObjPtr->field_2C == newVal) && currentObjPtr->field_2A != 0) + { + if(currentObjPtr->field_1A == 20) + { + changeScriptParamInList(currentObjPtr->field_18, currentObjPtr->field_16, &scriptHandle2, 0, -1); + } + else + if(currentObjPtr->field_1A == 30) + { + changeScriptParamInList(currentObjPtr->field_18, currentObjPtr->field_16, &scriptHandle1, 0, -1); + } + + currentObjPtr->field_2A = 0; + } + + if(objX1) + { + mainDraw5(currentObjPtr->overlay, currentObjPtr->idx, currentObjPtr->field_28, currentObjPtr, newVal); + } + } + else + { + currentObjPtr->currentAnimDelay--; + } + } + } + + currentObjPtr = currentObjPtr->next; + } + + //----------------------------------------------------------------------------------------------------------------// + + mainDraw6(); + var20 = 0; + + //-------------------------------------------------- DRAW OBJECTS TYPE 5 -----------------------------------------// + + currentObjPtr = objectHead.next; + + while(currentObjPtr) + { + if(currentObjPtr->type == 5 && currentObjPtr->hide == 0) + { + mainSprite(currentObjPtr->field_A, currentObjPtr->field_C, currentObjPtr->gfxPtr, gfxModuleData.pPage10, currentObjPtr->field_10, currentObjPtr->spriteIdx); + var20 = 1; + } + currentObjPtr = currentObjPtr->next; + } + + //----------------------------------------------------------------------------------------------------------------// + + if(currentActiveMenu != -1) + { + if(menuTable[currentActiveMenu]) + { + drawMenu(menuTable[currentActiveMenu]); + return; + } + } + + if(mouseVar1) + { + ASSERT(0); + // TODO: draw mouse here + } +} + +} // End of namespace Cruise |