Ticket #8997: Cruise_Cell.patch

File Cruise_Cell.patch, 20.0 KB (added by SF/remoun, 15 years ago)

Changes to Cruise::cellStruct (now Cruise::Cell), as of SVN trunk rev. 39900

  • engines/cruise/cell.cpp

     
    2929
    3030namespace Cruise {
    3131
    32 cellStruct cellHead;
     32Cell g_cellHead;
    3333
    34 void resetPtr(cellStruct *ptr) {
    35         ptr->next = NULL;
    36         ptr->prev = NULL;
     34void Cell::reset() {
     35        this->next = NULL;
     36        this->prev = NULL;
    3737}
    3838
    39 void freeMessageList(cellStruct *objPtr) {
     39// TODO: Delete.
     40void freeMessageList(Cell *objPtr) {
    4041        /*      if (objPtr) {
    4142                         if (objPtr->next)
    4243                         free(objPtr->next);
    … …  
    4546                } */
    4647}
    4748
    48 cellStruct *addCell(cellStruct *pHead, int16 overlayIdx, int16 objIdx, int16 type, int16 backgroundPlane, int16 scriptOverlay, int16 scriptNumber, int16 scriptType) {
     49void Cell::addCellAfter(Cell* pNext) {
     50        if(!pNext)
     51                return;
     52        pNext->prev = this;
     53        pNext->next = next;
     54        if(next)
     55                next->prev = pNext;
     56        next = pNext;
     57}
     58
     59Cell *Cell::addCell(int16 overlayIdx, int16 objIdx, int16 type, int16 backgroundPlane, int16 scriptOverlay, int16 scriptNumber, int16 scriptType) {
     60        Cell *pHead = this;
    4961        int16 var;
    5062
    51         cellStruct *newElement;
    52         cellStruct *currentHead = pHead;
    53         cellStruct *currentHead2;
    54         cellStruct *currentHead3;
     63        Cell *newElement;
     64        Cell *currentHead = pHead;
     65        Cell *currentHead2;
     66        Cell *currentHead3;
    5567
    5668        if (getSingleObjectParam(overlayIdx, objIdx, 2, &var) < 0) {
    5769                return 0;
    … …  
    8698
    8799        currentHead = currentHead2;
    88100
    89         newElement = (cellStruct *) mallocAndZero(sizeof(cellStruct));
     101        newElement = (Cell *) mallocAndZero(sizeof(Cell));
    90102
    91103        if (!newElement)
    92104                return 0;
    93105
    94         newElement->next = currentHead3->next;
    95         currentHead3->next = newElement;
     106        currentHead3->addCellAfter(newElement);
    96107
    97108        newElement->idx = objIdx;
    98109        newElement->type = type;
    … …  
    126137        return newElement;
    127138}
    128139
    129 void createTextObject(cellStruct *pObject, int overlayIdx, int messageIdx, int x, int y, int width, int16 color, int backgroundPlane, int parentOvl, int parentIdx) {
    130 
     140void Cell::createTextObject(int overlayIdx, int messageIdx, int x, int y, int width, int16 color, int backgroundPlane, int parentOvl, int parentIdx) {
     141        Cell *pObject = this;
    131142        const char *ax;
    132         cellStruct *savePObject = pObject;
    133         cellStruct *cx;
     143        Cell *savePObject = pObject;
     144        Cell *cx;
    134145
    135         cellStruct *pNewElement;
    136         cellStruct *si = pObject->next;
    137         cellStruct *var_2;
     146        Cell *pNewElement;
     147        Cell *si = pObject->next;
     148        Cell *var_2;
    138149
    139150        while (si) {
    140151                pObject = si;
    … …  
    143154
    144155        var_2 = si;
    145156
    146         pNewElement = (cellStruct *) malloc(sizeof(cellStruct));
    147         memset(pNewElement, 0, sizeof(cellStruct));
     157        pNewElement = (Cell *) mallocAndZero(sizeof(Cell));
    148158
    149         pNewElement->next = pObject->next;
    150         pObject->next = pNewElement;
     159        pObject->addCellAfter(pNewElement);
    151160
    152161        pNewElement->idx = messageIdx;
    153162        pNewElement->type = OBJ_TYPE_MESSAGE;
    … …  
    178187        }
    179188}
    180189
    181 void removeCell(cellStruct *objPtr, int ovlNumber, int objectIdx, int objType, int backgroundPlane) {
    182         cellStruct *currentObj = objPtr->next;
    183         cellStruct *previous;
     190void Cell::removeCell(int ovlNumber, int objectIdx, int objType, int backgroundPlane) {
     191        Cell *objPtr = this;
     192        Cell *currentObj = objPtr->next;
     193        Cell *previous;
    184194
    185195        while (currentObj) {
    186196                if (((currentObj->overlay == ovlNumber) || (ovlNumber == -1)) &&
    … …  
    197207        currentObj = objPtr->next;
    198208
    199209        while (currentObj) {
    200                 cellStruct *si;
     210                Cell *si;
    201211
    202212                si = currentObj;
    203213
    204214                if (si->type == -1) {
    205                         cellStruct *dx;
     215                        Cell *dx;
    206216                        previous->next = si->next;
    207217
    208218                        dx = si->next;
    … …  
    226236        }
    227237}
    228238
    229 void linkCell(cellStruct *pHead, int ovl, int obj, int type, int ovl2, int obj2) {
     239void Cell::linkCell(int ovl, int obj, int type, int ovl2, int obj2) {
     240        Cell *pHead = this;
    230241        while (pHead) {
    231242                if ((pHead->overlay == ovl) || (ovl == -1)) {
    232243                        if ((pHead->idx == obj) || (obj == -1)) {
    … …  
    241252        }
    242253}
    243254
    244 void freezeCell(cellStruct * pObject, int overlayIdx, int objIdx, int objType, int backgroundPlane, int oldFreeze, int newFreeze) {
     255void Cell::freezeCell(int overlayIdx, int objIdx, int objType, int backgroundPlane, int oldFreeze, int newFreeze) {
     256        Cell * pObject = this;
    245257        while (pObject) {
    246258                if ((pObject->overlay == overlayIdx) || (overlayIdx == -1)) {
    247259                        if ((pObject->idx == objIdx) || (objIdx == -1)) {
    … …  
    259271        }
    260272}
    261273
    262 void sortCells(int16 ovlIdx, int16 ovjIdx, cellStruct *objPtr) {
    263         cellStruct *pl, *pl2, *pl3, *pl4, *plz, *pllast;
    264         cellStruct prov;
     274void Cell::sortCells(int16 ovlIdx, int16 ovjIdx) {
     275        Cell *objPtr = this;
     276        Cell *pl, *pl2, *pl3, *pl4, *plz, *pllast;
     277        Cell prov;
    265278        int16 newz, objz, sobjz;
    266279
    267280        pl4 = NULL;
    … …  
    334347        }
    335348}
    336349
     350void Cell::freeObjectList() {
     351        Cell *pListHead = this;
     352        int var_2 = 0;
     353        Cell *pCurrent = pListHead->next;
     354
     355        while (pCurrent) {
     356                Cell *pNext = pCurrent->next;
     357
     358                if (pCurrent->freeze == 0) {
     359                        free(pCurrent->gfxPtr);
     360                        free(pCurrent);
     361                }
     362
     363                var_2 = 1;
     364
     365                pCurrent = pNext;
     366        }
     367
     368        if (var_2) {
     369                pListHead->reset();
     370        }
     371}
     372
    337373} // End of namespace Cruise

  • engines/cruise/cell.h

     
    3333
    3434struct gfxEntryStruct;
    3535
    36 struct cellStruct {
    37         struct cellStruct *next;
    38         struct cellStruct *prev;
     36class Cell {
     37public:
     38        Cell *next;
     39        Cell *prev;
    3940        int16 idx;
    4041        int16 type;
    4142        int16 overlay;
    … …  
    6061        int16 animCounter;
    6162        int16 animLoop;
    6263        gfxEntryStruct *gfxPtr;
     64
     65        void reset();
     66        Cell *addCell(int16 overlayIdx, int16 objIdx, int16 type, int16 backgroundPlane, int16 scriptOverlay, int16 scriptNumber, int16 scriptType);
     67        void createTextObject(int overlayIdx, int messageIdx, int x, int y, int width, int16 color, int backgroundPlane, int parentOvl, int parentIdx);
     68        void removeCell(int ovlNumber, int objectIdx, int objType, int backgroundPlane);
     69        void freezeCell(int overlayIdx, int objIdx, int objType, int backgroundPlane, int oldFreeze, int newFreeze);
     70        void sortCells(int16 param1, int16 param2);
     71        void linkCell(int ovl, int obj, int type, int ovl2, int obj2);
     72        void freeObjectList();
     73        /**
     74         * Add a new cell immediately after the current cell. Does nothing if pNext is NULL.
     75         * @param pNext the cell to add
     76         */
     77        void addCellAfter(Cell* pNext);
    6378};
    6479
    65 extern cellStruct cellHead;
     80extern Cell g_cellHead;
    6681
    67 void resetPtr(cellStruct * ptr);
    68 cellStruct *addCell(cellStruct *pHead, int16 overlayIdx, int16 objIdx, int16 type, int16 backgroundPlane, int16 scriptOverlay, int16 scriptNumber, int16 scriptType);
    69 void createTextObject(cellStruct *pObject, int overlayIdx, int messageIdx, int x, int y, int width, int16 color, int backgroundPlane, int parentOvl, int parentIdx);
    70 void removeCell(cellStruct *objPtr, int ovlNumber, int objectIdx, int objType, int backgroundPlane);
    71 void freezeCell(cellStruct * pObject, int overlayIdx, int objIdx, int objType, int backgroundPlane, int oldFreeze, int newFreeze);
    72 void sortCells(int16 param1, int16 param2, cellStruct *objPtr);
    73 void linkCell(cellStruct *pHead, int ovl, int obj, int type, int ovl2, int obj2);
    74 
    75 
    7682} // End of namespace Cruise
    7783
    7884#endif

  • engines/cruise/cruise_main.cpp

     
    425425        resetPtr2(&procHead);
    426426        resetPtr2(&relHead);
    427427
    428         resetPtr(&cellHead);
     428        g_cellHead.reset();
    429429
    430430        resetActorPtr(&actorHead);
    431431        resetBackgroundIncrustList(&backgroundIncrustHead);
    … …  
    574574int findObject(int mouseX, int mouseY, int *outObjOvl, int *outObjIdx) {
    575575        char objectName[80];
    576576
    577         cellStruct *currentObject = cellHead.prev;
     577        Cell *currentObject = g_cellHead.prev;
    578578
    579579        while (currentObject) {
    580580                if (currentObject->overlay > 0 && overlayTable[currentObject->overlay].alreadyLoaded &&
    … …  
    11951195                                }
    11961196
    11971197                                if (currentScriptPtr) {
    1198                                         createTextObject(&cellHead, ovlIdx, pHeader->id, x, y, 200, findHighColor(), masterScreen, currentScriptPtr->overlayNumber, currentScriptPtr->scriptNumber);
     1198                                        g_cellHead.createTextObject(ovlIdx, pHeader->id, x, y, 200, findHighColor(), masterScreen, currentScriptPtr->overlayNumber, currentScriptPtr->scriptNumber);
    11991199                                } else {
    1200                                         createTextObject(&cellHead, ovlIdx, pHeader->id, x, y, 200, findHighColor(), masterScreen, 0, 0);
     1200                                        g_cellHead.createTextObject(ovlIdx, pHeader->id, x, y, 200, findHighColor(), masterScreen, 0, 0);
    12011201                                }
    12021202
    12031203                                userWait = 1;
    … …  
    12331233                                                autoTrack = true;
    12341234                                                userWait = 0;
    12351235                                                userEnabled = 0;
    1236                                                 freezeCell(&cellHead, ovlIdx, pHeader->id, 5, -1, 0, 9998);
     1236                                                g_cellHead.freezeCell(ovlIdx, pHeader->id, 5, -1, 0, 9998);
    12371237                                        }
    12381238                                }
    12391239                        }
    … …  
    18711871                        if (autoTrack) {
    18721872                                if (isAnimFinished(narratorOvl, narratorIdx, &actorHead, ATP_MOUSE)) {
    18731873                                        if (autoMsg != -1) {
    1874                                                 freezeCell(&cellHead, autoOvl, autoMsg, 5, -1, 9998, 0);
     1874                                                g_cellHead.freezeCell(autoOvl, autoMsg, 5, -1, 9998, 0);
    18751875
    18761876                                                char* pText = getText(autoMsg, autoOvl);
    18771877
    … …  
    18861886                                        userEnabled = false;
    18871887                                }
    18881888                        } else if (autoMsg != -1) {
    1889                                 removeCell(&cellHead, autoOvl, autoMsg, 5, masterScreen);
     1889                                g_cellHead.removeCell(autoOvl, autoMsg, 5, masterScreen);
    18901890                                autoMsg = -1;
    18911891                        }
    18921892                }

  • engines/cruise/debugger.cpp

     
    4444        const char *pObjType;
    4545        objectParamsQuery params;
    4646
    47         cellStruct *currentObject = cellHead.prev;
     47        Cell *currentObject = g_cellHead.prev;
    4848
    4949        while (currentObject) {
    5050                if (currentObject->overlay > 0 && overlayTable[currentObject->overlay].alreadyLoaded &&

  • engines/cruise/function.cpp

     
    266266        return (0);
    267267}
    268268
    269 void freeObjectList(cellStruct *pListHead) {
    270         int var_2 = 0;
    271         cellStruct *pCurrent = pListHead->next;
    272269
    273         while (pCurrent) {
    274                 cellStruct *pNext = pCurrent->next;
    275 
    276                 if (pCurrent->freeze == 0) {
    277                         free(pCurrent->gfxPtr);
    278                         free(pCurrent);
    279                 }
    280 
    281                 var_2 = 1;
    282 
    283                 pCurrent = pNext;
    284         }
    285 
    286         if (var_2) {
    287                 resetPtr(pListHead);
    288         }
    289 }
    290 
    291270int16 Op_FreeCell(void) {
    292         freeObjectList(&cellHead);
     271        g_cellHead.freeObjectList();
    293272        return (0);
    294273}
    295274
    … …  
    329308                overlay = currentScriptPtr->overlayNumber;
    330309        }
    331310
    332         removeCell(&cellHead, overlay, idx, 5, masterScreen);
     311        g_cellHead.removeCell(overlay, idx, 5, masterScreen);
    333312
    334313        return (0);
    335314}
    … …  
    724703        if (!overlayIdx)
    725704                overlayIdx = currentScriptPtr->overlayNumber;
    726705
    727         addCell(&cellHead, overlayIdx, objIdx, objType, masterScreen, currentScriptPtr->overlayNumber, currentScriptPtr->scriptNumber, currentScriptPtr->type);
     706        g_cellHead.addCell(overlayIdx, objIdx, objType, masterScreen, currentScriptPtr->overlayNumber, currentScriptPtr->scriptNumber, currentScriptPtr->type);
    728707
    729708        return 0;
    730709}
    … …  
    752731                ovlNumber = currentScriptPtr->overlayNumber;
    753732        }
    754733
    755         removeCell(&cellHead, ovlNumber, objectIdx, objType, masterScreen);
     734        g_cellHead.removeCell(ovlNumber, objectIdx, objType, masterScreen);
    756735
    757736        return 0;
    758737}
    … …  
    819798                }
    820799        }
    821800
    822         createTextObject(&cellHead, overlayIdx, var_8, var_6, var_4, var_2, color, masterScreen, currentScriptPtr->overlayNumber, currentScriptPtr->scriptNumber);
     801        g_cellHead.createTextObject(overlayIdx, var_8, var_6, var_4, var_2, color, masterScreen, currentScriptPtr->overlayNumber, currentScriptPtr->scriptNumber);
    823802
    824803        return 0;
    825804}
    … …  
    854833}
    855834
    856835int16 Op_AutoCell(void) {
    857         cellStruct *pObject;
     836        Cell *pObject;
    858837
    859838        int signal = popVar();
    860839        int loop = popVar();
    … …  
    870849        if (!overlay)
    871850                overlay = currentScriptPtr->overlayNumber;
    872851
    873         pObject = addCell(&cellHead, overlay, obj, 4, masterScreen, currentScriptPtr->overlayNumber, currentScriptPtr->scriptNumber, currentScriptPtr->type);
     852        pObject = g_cellHead.addCell(overlay, obj, 4, masterScreen, currentScriptPtr->overlayNumber, currentScriptPtr->scriptNumber, currentScriptPtr->type);
    874853
    875854        if (!pObject)
    876855                return 0;
    … …  
    14771456                overlayIdx = currentScriptPtr->overlayNumber;
    14781457        }
    14791458
    1480         freezeCell(&cellHead, overlayIdx, objIdx, objType, backgroundPlante, oldFreeze, newFreezz);
     1459        g_cellHead.freezeCell(overlayIdx, objIdx, objType, backgroundPlante, oldFreeze, newFreezz);
    14811460
    14821461        return 0;
    14831462}
    … …  
    17231702        if (!ovl2)
    17241703                ovl2 = currentScriptPtr->overlayNumber;
    17251704
    1726         linkCell(&cellHead, ovl, obj, type, ovl2, obj2);
     1705        g_cellHead.linkCell(ovl, obj, type, ovl2, obj2);
    17271706
    17281707        return 0;
    17291708}

  • engines/cruise/function.h

     
    3333int32 opcodeType8(void);
    3434int16 computeZoom(int param);
    3535int16 subOp23(int param1, int param2);
    36 void freeObjectList(cellStruct *pListHead);
    3736int removeAnimation(actorStruct * pHead, int overlay, int objIdx, int objType);
    3837
    3938} // End of namespace Cruise

  • engines/cruise/mainDraw.cpp

     
    3535        short int objIdx;
    3636        short int type;
    3737        short int newValue;
    38         cellStruct *pCell;
     38        Cell *pCell;
    3939};
    4040
    4141autoCellStruct autoCellHead;
    4242
    43 void addAutoCell(int overlayIdx, int idx, int type, int newVal, cellStruct *pObject) {
     43void addAutoCell(int overlayIdx, int idx, int type, int newVal, Cell *pObject) {
    4444        autoCellStruct *pNewEntry;
    4545
    4646        pNewEntry = new autoCellStruct;
    … …  
    10521052unsigned char polygonMask[(320*200)/8];
    10531053
    10541054// draw poly sprite (OLD: mainDrawSub1)
    1055 void mainDrawPolygons(int fileIndex, cellStruct *plWork, int X, int scale, int Y, char *destBuffer, char *dataPtr) {
     1055void mainDrawPolygons(int fileIndex, Cell *plWork, int X, int scale, int Y, char *destBuffer, char *dataPtr) {
    10561056        int newX;
    10571057        int newY;
    10581058        int newScale;
    … …  
    11811181        }
    11821182}
    11831183
    1184 void drawSprite(int width, int height, cellStruct *currentObjPtr, const uint8 *dataIn, int ys, int xs, uint8 *output, const uint8 *dataBuf) {
     1184void drawSprite(int width, int height, Cell *currentObjPtr, const uint8 *dataIn, int ys, int xs, uint8 *output, const uint8 *dataBuf) {
    11851185        int x = 0;
    11861186        int y = 0;
    11871187
    1188         cellStruct* plWork = currentObjPtr;
     1188        Cell* plWork = currentObjPtr;
    11891189        int workBufferSize = height * (width / 8);
    11901190
    11911191        unsigned char* workBuf = (unsigned char*)malloc(workBufferSize);
    … …  
    13671367
    13681368void mainDraw(int16 param) {
    13691369        uint8 *bgPtr;
    1370         cellStruct *currentObjPtr;
     1370        Cell *currentObjPtr;
    13711371        int16 currentObjIdx;
    13721372        int16 objX1 = 0;
    13731373        int16 objY1 = 0;
    … …  
    13891389
    13901390        autoCellHead.next = NULL;
    13911391
    1392         currentObjPtr = cellHead.next;
     1392        currentObjPtr = g_cellHead.next;
    13931393
    13941394#ifdef _DEBUG
    13951395        /*      polyOutputBuffer = (char*)bgPtr;
    … …  
    15311531
    15321532        //-------------------------------------------------- DRAW OBJECTS TYPE 5 (MSG)-----------------------------------------//
    15331533
    1534         currentObjPtr = cellHead.next;
     1534        currentObjPtr = g_cellHead.next;
    15351535
    15361536        while (currentObjPtr) {
    15371537                if (currentObjPtr->type == OBJ_TYPE_MESSAGE && currentObjPtr->freeze == 0) {

  • engines/cruise/mainDraw.h

     
    3939void mainDraw(int16 param);
    4040void flipScreen(void);
    4141void buildPolyModel(int X, int Y, int scale, char *ptr2, char *destBuffer, char *dataPtr);
    42 void drawSprite(int width, int height, cellStruct *currentObjPtr, const uint8 *dataIn, int ys, int xs, uint8 *output, const uint8 *dataBuf);
     42void drawSprite(int width, int height, Cell *currentObjPtr, const uint8 *dataIn, int ys, int xs, uint8 *output, const uint8 *dataBuf);
    4343void flipPoly(int fileId, int16 *dataPtr, int scale, char** newFrame, int X, int Y, int *outX, int *outY, int *outScale);
    4444void getPolySize(int positionX, int positionY, int scale, int sizeTable[4], unsigned char *dataPtr);
    4545bool findPoly(char* dataPtr, int x, int y, int zoom, int mouseX, int mouseY);

  • engines/cruise/object.cpp

     
    129129                if (param3 != 5)
    130130                        return;
    131131                globalVars[overlayTable[ovlIdx].state + ptr->_stateTableIdx] = param4;
    132                 sortCells(ovlIdx, objIdx, &cellHead);
     132                g_cellHead.sortCells(ovlIdx, objIdx);
    133133                break;
    134134        }
    135135        case UNIQUE:
    … …  
    148148                }
    149149                case 2: {       // z
    150150                        ptr2->Z = param4;
    151                         sortCells(ovlIdx, objIdx, &cellHead);
     151                        g_cellHead.sortCells(ovlIdx, objIdx);
    152152                        break;
    153153                }
    154154                case 3: {
    … …  
    192192        case THEME:
    193193        case MULTIPLE: {
    194194                globalVars[overlayTable[ovlIdx].state + ptr->_stateTableIdx] = newState;
    195                 sortCells(ovlIdx, objIdx, &cellHead);
     195                g_cellHead.sortCells(ovlIdx, objIdx);
    196196                break;
    197197        }
    198198        case UNIQUE:
    … …  
    212212
    213213                destEntry->state = newState;
    214214
    215                 sortCells(ovlIdx, objIdx, &cellHead);
     215                g_cellHead.sortCells(ovlIdx, objIdx);
    216216                break;
    217217        }
    218218        default: {

  • engines/cruise/saveload.cpp

     
    313313
    314314static void syncCell(Common::Serializer &s) {
    315315        int chunkCount = 0;
    316         cellStruct *t, *p;
     316        Cell *t, *p;
    317317        uint16 dummyWord = 0;
    318318
    319319        if (s.isSaving()) {
    320320                // Figure out the number of chunks to save
    321                 t = cellHead.next;
     321                t = g_cellHead.next;
    322322                while (t) {
    323323                        ++chunkCount;
    324324                        t = t->next;
    325325                }
    326326        } else {
    327                 cellHead.next = NULL; // Not in ASM code, but I guess the variable is defaulted in the EXE
     327                g_cellHead.next = NULL; // Not in ASM code, but I guess the variable is defaulted in the EXE
    328328        }
    329329        s.syncAsSint16LE(chunkCount);
    330330
    331         t = s.isSaving() ? cellHead.next : &cellHead;
     331        t = s.isSaving() ? g_cellHead.next : &g_cellHead;
    332332        for (int i = 0; i < chunkCount; ++i) {
    333                 p = s.isSaving() ? t : (cellStruct *)mallocAndZero(sizeof(cellStruct));
     333                p = s.isSaving() ? t : (Cell *)mallocAndZero(sizeof(Cell));
    334334
    335335                s.syncAsUint16LE(dummyWord);
    336336                s.syncAsUint16LE(dummyWord);
    … …  
    365365                else {
    366366                        p->next = NULL;
    367367                        t->next = p;
    368                         p->prev = cellHead.prev;
    369                         cellHead.prev = p;
     368                        p->prev = g_cellHead.prev;
     369                        g_cellHead.prev = p;
    370370                        t = p;
    371371                }
    372372        }
    … …  
    610610        resetPreload();
    611611        freeCTP();
    612612
    613         freezeCell(&cellHead, -1, -1, -1, -1, -1, 0);
     613        g_cellHead.freezeCell(-1, -1, -1, -1, -1, 0);
    614614        // TODO: unfreeze anims
    615615
    616         freeObjectList(&cellHead);
     616        g_cellHead.freeObjectList();
    617617        removeAnimation(&actorHead, -1, -1, -1);
    618618
    619619        changeScriptParamInList(-1, -1, &procHead, -1, 0);
    … …  
    669669        resetPtr2(&procHead);
    670670        resetPtr2(&relHead);
    671671
    672         resetPtr(&cellHead);
     672        g_cellHead.reset();
    673673
    674674        resetActorPtr(&actorHead);
    675675        resetBackgroundIncrustList(&backgroundIncrustHead);
    … …  
    755755        char buffer[256];
    756756        char saveIdentBuffer[6];
    757757        int lowMemorySave;
    758         cellStruct *currentcellHead;
     758        Cell *currentCellHead;
    759759
    760760        sprintf(buffer, "CR.%d", saveGameIdx);
    761761
    … …  
    859859
    860860        lastAni[0] = 0;
    861861
    862         currentcellHead = cellHead.next;
     862        currentCellHead = g_cellHead.next;
    863863
    864         while (currentcellHead) {
    865                 if (currentcellHead->type == 5) {
    866                         uint8 *ptr = mainProc14(currentcellHead->overlay, currentcellHead->idx);
     864        while (currentCellHead) {
     865                if (currentCellHead->type == 5) {
     866                        uint8 *ptr = mainProc14(currentCellHead->overlay, currentCellHead->idx);
    867867
    868868                        ASSERT(0);
    869869
    870870                        if (ptr) {
    871871                                ASSERT(0);
    872                                 //*(int16*)(currentcellHead->datas+0x2E) = getSprite(ptr,*(int16*)(currentcellHead->datas+0xE));
     872                                //*(int16*)(currentCellHead->datas+0x2E) = getSprite(ptr,*(int16*)(currentCellHead->datas+0xE));
    873873                        } else {
    874874                                ASSERT(0);
    875                                 //*(int16*)(currentcellHead->datas+0x2E) = 0;
     875                                //*(int16*)(currentCellHead->datas+0x2E) = 0;
    876876                        }
    877877                }
    878878
    879                 currentcellHead = currentcellHead->next;
     879                currentCellHead = currentCellHead->next;
    880880        }
    881881
    882882        //TODO: here, restart music