Ticket #8849: hashmap_v2.patch

File hashmap_v2.patch, 17.7 KB (added by lordhoto, 17 years ago)

patch against current svn

  • common/hashmap.h

     
    150150        int lookupAndCreateIfMissing(const Key &key);
    151151        void expand_array(uint newsize);
    152152
    153         class Iterator;
    154         class ConstIterator;
    155         friend class Iterator;
    156         friend class ConstIterator;
     153        template<class T> friend class IteratorImpl;
    157154
    158155        /**
    159156         * Simple HashMap iterator implementation.
    160157         */
    161         class Iterator {
     158        template<class NodeType>
     159        class IteratorImpl {
     160                friend class HashMap;
     161                template<class T> friend class IteratorImpl;
    162162        protected:
    163163                typedef const HashMap hashmap_t;
    164                 friend class HashMap;
    165164
    166                 // Allow ConstIterator to read member vars, so that Iterators can be converted to ConstIterator
    167                 friend class HashMap::ConstIterator;
    168 
    169165                uint _idx;
    170166                hashmap_t *_hashmap;
    171167
    172168        protected:
    173                 Iterator(uint idx, hashmap_t *hashmap) : _idx(idx), _hashmap(hashmap) {}
     169                IteratorImpl(uint idx, hashmap_t *hashmap) : _idx(idx), _hashmap(hashmap) {}
    174170
    175                 Node *deref() const {
     171                NodeType *deref() const {
    176172                        assert(_hashmap != 0);
    177173                        assert(_idx < _hashmap->_arrsize);
    178174                        Node *node = _hashmap->_arr[_idx];
    … …  
    181177                }
    182178
    183179        public:
    184                 Iterator() : _idx(0), _hashmap(0) {}
     180                IteratorImpl() : _idx(0), _hashmap(0) {}
     181                template<class T>
     182                IteratorImpl(const IteratorImpl<T> &c) : _idx(c._idx), _hashmap(c._hashmap) {}
    185183
    186                 Node &operator *() const { return *deref(); }
    187                 Node *operator->() const { return deref(); }
     184                NodeType &operator *() const { return *deref(); }
     185                NodeType *operator->() const { return deref(); }
    188186
    189                 bool operator ==(const Iterator &iter) const { return _idx == iter._idx && _hashmap == iter._hashmap; }
    190                 bool operator !=(const Iterator &iter) const { return !(*this == iter); }
     187                bool operator ==(const IteratorImpl &iter) const { return _idx == iter._idx && _hashmap == iter._hashmap; }
     188                bool operator !=(const IteratorImpl &iter) const { return !(*this == iter); }
    191189
    192                 Iterator &operator ++() {
     190                IteratorImpl &operator ++() {
    193191                        assert(_hashmap);
    194192                        do {
    195193                                _idx++;
    … …  
    200198                        return *this;
    201199                }
    202200
    203                 Iterator operator ++(int) {
    204                         Iterator old = *this;
     201                IteratorImpl operator ++(int) {
     202                        IteratorImpl old = *this;
    205203                        operator ++();
    206204                        return old;
    207205                }
    208206        };
    209207
    210         /**
    211          * Simple HashMap const iterator implementation.
    212          * This is almost completely identical to the normal iterator class, only
    213          * with some const keywords added here and there, plus a conversion
    214          * operator which makes it possible to transparently convert iterators to
    215          * const iterators.
    216          * It is sadly not really possible to reduce this code duplication using
    217          * template, unless one is willing to accept various warnings on certain
    218          * compilers. Note that many (most? all?) implementations of the standard
    219          * C++ library use a similar approach for their implementations.
    220          */
    221         class ConstIterator {
    222         protected:
    223                 typedef const HashMap hashmap_t;
    224                 friend class HashMap;
    225 
    226                 uint _idx;
    227                 hashmap_t *_hashmap;
    228 
    229         protected:
    230                 ConstIterator(uint idx, hashmap_t *hashmap) : _idx(idx), _hashmap(hashmap) {}
    231 
    232                 const Node *deref() const {
    233                         assert(_hashmap != 0);
    234                         assert(_idx < _hashmap->_arrsize);
    235                         const Node *node = _hashmap->_arr[_idx];
    236                         assert(node != 0);
    237                         return node;
    238                 }
    239 
    240         public:
    241                 ConstIterator() : _idx(0), _hashmap(0) {}
    242 
    243                 // Converting a non-const iterator to a const one is allowed
    244                 ConstIterator(const Iterator &iter) : _idx(iter._idx), _hashmap(iter._hashmap) {}
    245 
    246                 const Node &operator *() const { return *deref(); }
    247                 const Node *operator->() const { return deref(); }
    248 
    249                 bool operator ==(const ConstIterator &iter) const { return _idx == iter._idx && _hashmap == iter._hashmap; }
    250                 bool operator !=(const ConstIterator &iter) const { return !(*this == iter); }
    251 
    252                 ConstIterator &operator ++() {
    253                         assert(_hashmap);
    254                         do {
    255                                 _idx++;
    256                         } while (_idx < _hashmap->_arrsize && _hashmap->_arr[_idx] == 0);
    257                         if (_idx >= _hashmap->_arrsize)
    258                                 _idx = (uint)-1;
    259 
    260                         return *this;
    261                 }
    262 
    263                 ConstIterator operator ++(int) {
    264                         ConstIterator old = *this;
    265                         operator ++();
    266                         return old;
    267                 }
    268         };
    269 
    270208public:
    271         typedef Iterator iterator;
    272         typedef ConstIterator const_iterator;
     209        typedef IteratorImpl<Node> iterator;
     210        typedef IteratorImpl<const Node> const_iterator;
    273211
    274212        HashMap();
    275213        HashMap(const HM_t& map);

  • engines/sword1/sword1.cpp

     
    339339        _logic->initialize();
    340340        _objectMan->initialize();
    341341        _mouse->initialize();
    342         _control = new Control(_saveFileMan, _resMan, _objectMan, _system, _mouse, _sound, _music);
     342        _control = new Control(this, _saveFileMan, _resMan, _objectMan, _system, _mouse, _sound, _music);
    343343
    344344        return 0;
    345345}

  • engines/sword1/control.h

     
    4242class Mouse;
    4343class Music;
    4444class Sound;
     45class SwordEngine;
    4546
    4647#define MAX_BUTTONS 16
    4748
    … …  
    8283
    8384class Control {
    8485public:
    85         Control(Common::SaveFileManager *saveFileMan, ResMan *pResMan, ObjectMan *pObjMan, OSystem *system, Mouse *pMouse, Sound *pSound, Music *pMusic);
     86        Control(SwordEngine *engine, Common::SaveFileManager *saveFileMan, ResMan *pResMan, ObjectMan *pObjMan, OSystem *system, Mouse *pMouse, Sound *pSound, Music *pMusic);
    8687        uint8 runPanel(void);
    8788        void doRestore(void);
    8889        void askForCd(void);
    … …  
    134135        static const uint8 _languageStrings[8 * 20][43];
    135136        const uint8 (*_lStrings)[43];
    136137        Common::SaveFileManager *_saveFileMan;
     138        SwordEngine *_engine;
    137139        ObjectMan *_objMan;
    138140        ResMan *_resMan;
    139141        OSystem *_system;

  • engines/sword1/control.cpp

     
    160160        draw();
    161161}
    162162
    163 Control::Control(Common::SaveFileManager *saveFileMan, ResMan *pResMan, ObjectMan *pObjMan, OSystem *system, Mouse *pMouse, Sound *pSound, Music *pMusic) {
     163Control::Control(SwordEngine *engine, Common::SaveFileManager *saveFileMan, ResMan *pResMan, ObjectMan *pObjMan, OSystem *system, Mouse *pMouse, Sound *pSound, Music *pMusic) {
     164        _engine = engine;
    164165        _saveFileMan = saveFileMan;
    165166        _resMan = pResMan;
    166167        _objMan = pObjMan;
    … …  
    717718
    718719void Control::readSavegameDescriptions(void) {
    719720        Common::InSaveFile *inf;
    720         inf = _saveFileMan->openForLoading("SAVEGAME.INF");
     721        inf = _saveFileMan->openForLoading((_engine->getTargetName() + ".inf").c_str());
    721722        _saveScrollPos = _saveFiles = 0;
    722723        _selectedSavegame = 255;
    723724        for (uint8 cnt = 0; cnt < 64; cnt++) {
    … …  
    761762
    762763void Control::writeSavegameDescriptions(void) {
    763764        Common::OutSaveFile *outf;
    764         outf = _saveFileMan->openForSaving("SAVEGAME.INF");
     765        outf = _saveFileMan->openForSaving((_engine->getTargetName() + ".inf").c_str());
    765766
    766767        if (!outf) {
    767768                // Display an error message, and do nothing
    768                 displayMessage(0, "Can't create SAVEGAME.INF. (%s)", _saveFileMan->popErrorDesc().c_str());
     769                displayMessage(0, "Can't create %s.inf. (%s)", _engine->getTargetName().c_str(), _saveFileMan->popErrorDesc().c_str());
    769770                return;
    770771        }
    771772
    … …  
    784785        }
    785786        outf->finalize();
    786787        if (outf->ioFailed())
    787                 displayMessage(0, "Can't write to SAVEGAME.INF. Device full? (%s)", _saveFileMan->popErrorDesc().c_str());
     788                displayMessage(0, "Can't write to %s.inf. Device full? (%s)", _engine->getTargetName().c_str(), _saveFileMan->popErrorDesc().c_str());
    788789        delete outf;
    789790}
    790791
    … …  
    947948}
    948949
    949950void Control::saveGameToFile(uint8 slot) {
    950         char fName[15];
     951        Common::String filename = _engine->getTargetName();
     952        char fName[5];
     953        snprintf(fName, 5, ".%03d", slot);
     954        filename += fName;
     955
    951956        uint16 cnt;
    952         sprintf(fName, "SAVEGAME.%03d", slot);
    953957        uint16 liveBuf[TOTAL_SECTIONS];
    954958        Common::OutSaveFile *outf;
    955         outf = _saveFileMan->openForSaving(fName);
     959        outf = _saveFileMan->openForSaving(filename.c_str());
    956960        if (!outf) {
    957961                // Display an error message and do nothing
    958                 displayMessage(0, "Unable to create file '%s'. (%s)", fName, _saveFileMan->popErrorDesc().c_str());
     962                displayMessage(0, "Unable to create file '%s'. (%s)", filename.c_str(), _saveFileMan->popErrorDesc().c_str());
    959963                return;
    960964        }
    961965
    … …  
    979983                outf->writeUint32LE(playerRaw[cnt2]);
    980984        outf->finalize();
    981985        if (outf->ioFailed())
    982                 displayMessage(0, "Couldn't write to file '%s'. Device full? (%s)", fName, _saveFileMan->popErrorDesc().c_str());
     986                displayMessage(0, "Couldn't write to file '%s'. Device full? (%s)", filename.c_str(), _saveFileMan->popErrorDesc().c_str());
    983987        delete outf;
    984988}
    985989
    986990bool Control::restoreGameFromFile(uint8 slot) {
    987         char fName[15];
     991        Common::String filename = _engine->getTargetName();
     992        char fName[5];
     993        snprintf(fName, 5, ".%03d", slot);
     994        filename += fName;
     995
    988996        uint16 cnt;
    989         sprintf(fName, "SAVEGAME.%03d", slot);
    990997        Common::InSaveFile *inf;
    991         inf = _saveFileMan->openForLoading(fName);
     998        inf = _saveFileMan->openForLoading(filename.c_str());
    992999        if (!inf) {
    9931000                // Display an error message, and do nothing
    994                 displayMessage(0, "Can't open file '%s'. (%s)", fName, _saveFileMan->popErrorDesc().c_str());
     1001                displayMessage(0, "Can't open file '%s'. (%s)", filename.c_str(), _saveFileMan->popErrorDesc().c_str());
    9951002                return false;
    9961003        }
    9971004
    … …  
    10151022                playerBuf[cnt2] = inf->readUint32LE();
    10161023
    10171024        if (inf->ioFailed()) {
    1018                 displayMessage(0, "Can't read from file '%s'. (%s)", fName, _saveFileMan->popErrorDesc().c_str());
     1025                displayMessage(0, "Can't read from file '%s'. (%s)", filename.c_str(), _saveFileMan->popErrorDesc().c_str());
    10191026                delete inf;
    10201027                free(_restoreBuf);
    10211028                _restoreBuf = NULL;

  • engines/sword1/sword1.h

     
    8080        void reinitialize(void);
    8181
    8282        uint32 _features;
     83
     84        Common::String getTargetName() const { return _targetName; }
    8385protected:
    8486        int go();
    8587        int init();

  • engines/kyra/sequences_v2.cpp

     
    24082408                        int m = cnt * 11;
    24092409                        uint16 cH = cnt ? READ_LE_UINT16(&tmp[m + 2]) + tmp[m + 9] + (tmp[m + 9] >> 3) : d->h;
    24102410
    2411                         const char *str = (const char*)ptr;
     2411                        char *str = (char*)ptr;
    24122412
    2413                         ptr = (uint8*)strpbrk((const char*)str, mark);
     2413                        ptr = (uint8*)strpbrk(str, mark);
    24142414                        if (!ptr)
    2415                                 ptr = (uint8*)strchr((const char*)str, 0);
     2415                                ptr = (uint8*)strchr(str, 0);
    24162416
    24172417                        tmp[m + 19] = *ptr;
    24182418                        *ptr = 0;

  • engines/kyra/staticres.cpp

     
    14961496        }
    14971497
    14981498        Button::Callback clickLoadSlotFunctor = BUTTON_FUNCTOR(GUI_v2, this, &GUI_v2::clickLoadSlot);
     1499        Button::Callback clickLoadMenuFunctor = BUTTON_FUNCTOR(GUI_v2, this, &GUI_v2::loadMenu);
    14991500
    15001501        GUI_V2_MENU(_loadMenu, -1, -1, 0x120, 0xA0, 0xF8, 0xF9, 0xFA, 8, 0xFB, -1, 8, 0, 6, 0x84, 0x16, 0x84, 0x7C);
    15011502        GUI_V2_MENU_ITEM(_loadMenu.item[0], 1, 0x29, -1, 0x27, 0x100, 0xF, 0xFC, 0xFD, 5, 0xF8, 0xF9, 0xFA, -1, 0, 0, 0, 0);
    … …  
    15081509
    15091510        GUI_V2_MENU_ITEM(_loadMenu.item[5], 1, 0x0B, 0xB8, 0x86, 0x58, 0xF, 0xFC, 0xFD, -1, 0xF8, 0xF9, 0xFA, -1, 0, 0, 0, 0);
    15101511        _loadMenu.item[6].enabled = false;
     1512
     1513        GUI_V2_MENU(_deathMenu, -1, -1, 0xD0, 0x4C, 0xF8, 0xF9, 0xFA, 0xE, 0xFB, -1, 8, 0, 2, -1, -1, -1, -1);
     1514        GUI_V2_MENU_ITEM(_deathMenu.item[0], 1, 2, -1, 0x1E, 0xB4, 0x0F, 0xFC, 0xFD, 8, 0xF8, 0xF9, 0xFA, -1, 0, 0, 0, 0);
     1515        _deathMenu.item[0].callback = clickLoadMenuFunctor;
     1516        GUI_V2_MENU_ITEM(_deathMenu.item[1], 1, 5, -1, 0x2F, 0xB4, 0x0F, 0xFC, 0xFD, 8, 0xF8, 0xF9, 0xFA, -1, 0, 0, 0, 0);
     1517        for (int i = 2; i <= 6; ++i)
     1518                _deathMenu.item[i].enabled = false;
    15111519}
    15121520
    15131521const uint16 KyraEngine_v2::_itemMagicTable[] = {

  • engines/kyra/kyra_v2.h

     
    310310
    311311        void dinoRide();
    312312
    313         int checkInput(Button *buttonList, bool mainLoop = false);
     313        int checkInput(Button *buttonList, bool mainLoop = false, bool guiCode = false);
    314314        void removeInputTop();
    315315        void handleInput(int x, int y);
    316316        bool handleInputUnkSub(int x, int y);

  • engines/kyra/gui_v2.h

     
    111111        Button _menuButtons[7];
    112112        Button _scrollUpButton;
    113113        Button _scrollDownButton;
    114         Menu _loadMenu;
     114        Menu _loadMenu, _deathMenu;
    115115        void initStaticData();
    116116
    117117        const char *getMenuTitle(const Menu &menu);
    … …  
    151151        Menu *_currentMenu;
    152152        bool _isDeathMenu;
    153153        bool _isSaveMenu;
     154        bool _madeTempSave;
    154155        bool _loadedSave;
    155156        bool _restartGame;
    156157        bool _reloadTemporarySave;

  • engines/kyra/kyra_v2.cpp

     
    411411        _quitFlag = false;
    412412        _runFlag = true;
    413413        while (!_quitFlag && _runFlag) {
    414                 //if (_deathHandler >= 0) {
    415                 //      removeHandItem();
    416                 //      waitTicks(5);
    417                 //      sub_270A0();
    418                 //}
     414                if (_deathHandler >= 0) {
     415                        removeHandItem();
     416                        delay(5);
     417                        _drawNoShapeFlag = 0;
     418                        _gui->optionsButton(0);
     419                        _deathHandler = -1;
     420                }
    419421
    420422                if (_system->getMillis() > _nextIdleAnim)
    421423                        showIdleAnim();
    … …  
    770772                        _eventList.push_back(Event(event, true));
    771773                        break;
    772774
     775                case Common::EVENT_LBUTTONDOWN:
     776                case Common::EVENT_MOUSEMOVE:
     777                        _eventList.push_back(event);
     778                        break;
     779
    773780                default:
    774781                        break;
    775782                }
    776783        }
    777784}
    778785
    779 int KyraEngine_v2::checkInput(Button *buttonList, bool mainLoop) {
     786int KyraEngine_v2::checkInput(Button *buttonList, bool mainLoop, bool guiCode) {
    780787        updateInput();
    781788
    782789        int keys = 0;
    … …  
    806813                        }
    807814                        break;
    808815
     816                case Common::EVENT_MOUSEMOVE: {
     817                        Common::Point pos = getMousePos();
     818                        _mouseX = pos.x;
     819                        _mouseY = pos.y;
     820                        _screen->updateScreen();
     821                        } break;
     822
     823                case Common::EVENT_LBUTTONDOWN:
     824                        if (guiCode) {
     825                                Common::Point pos = getMousePos();
     826                                _mouseX = pos.x;
     827                                _mouseY = pos.y;
     828                                keys = 198;
     829                                breakLoop = true;
     830                        }
     831                        break;
     832
    809833                case Common::EVENT_LBUTTONUP: {
    810834                        Common::Point pos = getMousePos();
    811835                        _mouseX = pos.x;
    812836                        _mouseY = pos.y;
    813                         keys = 198;
     837                        keys = 199;
    814838                        breakLoop = true;
    815839                        } break;
    816840

  • engines/kyra/gui_v2.cpp

     
    265265void GUI_v2::processButton(Button *button) {
    266266        if (!button)
    267267                return;
    268        
     268
    269269        if (button->flags & 8) {
    270270                if (button->flags & 0x10) {
    271271                        // XXX
    … …  
    379379                // but did some other magic, which looks like it depends on how the handle
    380380                // key input... so we just enable 0x1000 and 0x4000 here to allow
    381381                // all GUI buttons to work (for now at least...)
    382                 if (inFlags == 199 || inFlags == 198)
     382                if (inFlags == 198)
     383                        temp = 0x100/* | 0x400*/;
     384                else if (inFlags == 199)
    383385                        temp = 0x1000 | 0x4000;
    384386
    385387                //if (inputFlag & 0x800)
    … …  
    11561158#pragma mark -
    11571159
    11581160void GUI_v2::getInput() {
    1159         _vm->checkInput(_menuButtonList);
     1161        if (!_displayMenu)
     1162                return;
     1163
     1164        _vm->checkInput(_menuButtonList, false, true);
     1165        _vm->removeInputTop();
    11601166        if (_vm->quit()) {
    11611167                _displayMenu = false;
    11621168                _displaySubMenu = false;
    … …  
    11711177        updateButton(&_vm->_inventoryButtons[0]);
    11721178        _screen->showMouse();
    11731179
    1174         if (!_screen->isMouseVisible())
     1180        if (!_screen->isMouseVisible() && button)
    11751181                return 0;
    11761182
    11771183        _vm->showMessage(0, 0xCF);
    … …  
    11841190                return 0;
    11851191        }
    11861192
    1187         //int oldHandItem = _vm->_itemInHand;
     1193        int oldHandItem = _vm->_itemInHand;
    11881194        _screen->setMouseCursor(0, 0, _vm->getShapePtr(0));
    11891195        _vm->displayInvWsaLastFrame();
    11901196        //XXX
    … …  
    12031209        //XXX
    12041210        _loadMenu.numberOfItems = 6;
    12051211        initMenuLayout(_loadMenu);
     1212        //XXX
     1213        initMenuLayout(_deathMenu);
    12061214       
    12071215        if (_vm->_menuDirectlyToLoad) {
    12081216                backUpPage1(_vm->_screenBuffer);
    … …  
    12251233                return 0;
    12261234        }
    12271235
     1236        if (!button) {
     1237                _currentMenu = &_deathMenu;
     1238                _isDeathMenu = true;
     1239        } else {
     1240                //XXX just fail for now
     1241                return 0;
     1242        }
     1243
     1244        backUpPage1(_vm->_screenBuffer);
     1245        setupPalette();
     1246        initMenu(*_currentMenu);
     1247        _madeTempSave = false;
     1248        _loadedSave = false;
     1249        _vm->_itemInHand = -1;
     1250        updateAllMenuButtons();
     1251
     1252        if (_isDeathMenu) {
     1253                while (!_screen->isMouseVisible())
     1254                        _screen->showMouse();
     1255        }
     1256
     1257        while (_displayMenu) {
     1258                processHighlights(*_currentMenu, _vm->_mouseX, _vm->_mouseY);
     1259                getInput();
     1260        }
     1261
     1262        if (_vm->_runFlag && !_loadedSave && !_madeTempSave) {
     1263                restorePalette();
     1264                restorePage1(_vm->_screenBuffer);
     1265        }
     1266
     1267        if (_vm->_runFlag)
     1268                updateMenuButton(&_vm->_inventoryButtons[0]);
     1269
     1270        resetState(oldHandItem);
     1271
     1272        if (!_loadedSave && _reloadTemporarySave) {
     1273                _vm->_unkSceneScreenFlag1 = true;
     1274                //XXX
     1275                _vm->_unkSceneScreenFlag1 = false;
     1276        }
     1277
    12281278        return 0;
    12291279}
    12301280
    … …  
    13541404
    13551405        _screen->updateScreen();
    13561406        while (_displaySubMenu) {
    1357                 Common::Point mouse = _vm->getMousePos();
    1358                 processHighlights(_loadMenu, mouse.x, mouse.y);
     1407                processHighlights(_loadMenu, _vm->_mouseX, _vm->_mouseY);
    13591408                getInput();
    13601409        }
    13611410
    … …  
    13661415                        initMenu(*_currentMenu);
    13671416                        updateAllMenuButtons();
    13681417                }
    1369         } else {
     1418        } else if (_vm->_gameToLoad >= 0) {
    13701419                restorePage1(_vm->_screenBuffer);
    13711420                restorePalette();
    13721421                _vm->loadGame(_vm->getSavegameFilename(_vm->_gameToLoad));
     1422                backUpPage1(_vm->_screenBuffer);
    13731423                if (_vm->_gameToLoad == 0) {
    13741424                        _restartGame = true;
    13751425                        for (int i = 0; i < 23; ++i)