Ticket #8693: TEST5.patch

File TEST5.patch, 23.8 KB (added by SF/h00ligan, 13 years ago)

Recorder patch

  • backends/events/default/default-events.cpp

     
    2727
    2828#include "common/stdafx.h"
    2929#include "common/system.h"
     30#include "common/config-manager.h"
    3031#include "backends/events/default/default-events.h"
    3132
     33#define RECORD_SIGNATURE 0x54455354
     34#define RECORD_VERSION 1
     35
     36void readRecord(Common::InSaveFile *inFile, uint32 &diff, Common::Event &event) {
     37        diff = inFile->readUint32LE();
     38
     39        inFile->read(&event.type, sizeof(event.type));
     40       
     41        switch(event.type) {
     42                case Common::EVENT_KEYDOWN:
     43                case Common::EVENT_KEYUP:
     44                        inFile->read(&event.kbd, sizeof(event.kbd));
     45                        break;
     46                case Common::EVENT_MOUSEMOVE:
     47                case Common::EVENT_LBUTTONDOWN:
     48                case Common::EVENT_LBUTTONUP:
     49                case Common::EVENT_RBUTTONDOWN:
     50                case Common::EVENT_RBUTTONUP:
     51                case Common::EVENT_WHEELUP:
     52                case Common::EVENT_WHEELDOWN:
     53                        inFile->read(&event.mouse, sizeof(event.mouse));
     54                        break;
     55        }       
     56}
     57
     58void writeRecord(Common::OutSaveFile *outFile, uint32 diff, Common::Event &event) {
     59        outFile->writeUint32LE(diff);
     60
     61        outFile->write(&event.type, sizeof(event.type));
     62       
     63        switch(event.type) {
     64                case Common::EVENT_KEYDOWN:
     65                case Common::EVENT_KEYUP:
     66                        outFile->write(&event.kbd, sizeof(event.kbd));
     67                        break;
     68                case Common::EVENT_MOUSEMOVE:
     69                case Common::EVENT_LBUTTONDOWN:
     70                case Common::EVENT_LBUTTONUP:
     71                case Common::EVENT_RBUTTONDOWN:
     72                case Common::EVENT_RBUTTONUP:
     73                case Common::EVENT_WHEELUP:
     74                case Common::EVENT_WHEELDOWN:
     75                        outFile->write(&event.mouse, sizeof(event.mouse));
     76                        break;
     77        }
     78}
     79
    3280DefaultEventManager::DefaultEventManager(OSystem *boss) :
    3381        _boss(boss),
    3482        _buttonState(0),
     
    3785
    3886        assert(_boss);
    3987
     88        _recordFile = NULL;
     89        _recordTimeFile = NULL;
     90        _playbackFile = NULL;
     91        _playbackTimeFile = NULL;
     92        _timeMutex = _boss->createMutex();
     93
     94        _eventCount = 0;
     95        _lastEventCount = 0;
     96        _lastMillis = 0;
     97
     98        Common::String recordModeString = ConfMan.get("record_mode");
     99        if (recordModeString.compareToIgnoreCase("record") == 0) {
     100                _recordMode = kRecorderRecord;
     101        } else {
     102                if (recordModeString.compareToIgnoreCase("playback") == 0) {
     103                        _recordMode = kRecorderPlayback;
     104                } else {
     105                        _recordMode = kPassthrough;
     106                }
     107        }
     108
     109        _recordFileName = ConfMan.get("record_file_name");
     110        if (_recordFileName.empty()) {
     111                _recordFileName = "record.bin";
     112        }
     113        _recordTempFileName = ConfMan.get("record_temp_file_name");
     114        if (_recordTempFileName.empty()) {
     115                _recordTempFileName = "record.tmp";
     116        }
     117        _recordTimeFileName = ConfMan.get("record_time_file_name");
     118        if (_recordTimeFileName.empty()) {
     119                _recordTimeFileName = "record.time";
     120        }
     121
    40122        // Reset key repeat
    41123        _currentKeyDown.keycode = 0;
     124
     125        // recorder stuff
     126        if (_recordMode == kRecorderRecord) {
     127                _recordCount = 0;
     128                _recordTimeCount = 0;
     129                _recordFile = _boss->getSavefileManager()->openForSaving(_recordTempFileName.c_str());
     130                _recordTimeFile = _boss->getSavefileManager()->openForSaving(_recordTimeFileName.c_str());
     131                _recordSubtitles = ConfMan.getBool("subtitles");
     132        }
     133
     134        uint32 sign;
     135        uint32 version;
     136        uint32 randomSourceCount;
     137        if (_recordMode == kRecorderPlayback) {
     138                _playbackCount = 0;
     139                _playbackTimeCount = 0;
     140                _playbackFile = _boss->getSavefileManager()->openForLoading(_recordFileName.c_str());
     141                _playbackTimeFile = _boss->getSavefileManager()->openForLoading(_recordTimeFileName.c_str());
     142                sign = _playbackFile->readUint32LE();
     143                if (sign != RECORD_SIGNATURE) {
     144                        error("Unknown record file signature");
     145                }
     146                version = _playbackFile->readUint32LE();
     147
     148                // conf vars
     149                ConfMan.setBool("subtitles", _playbackFile->readByte() != 0);
     150               
     151                _recordCount = _playbackFile->readUint32LE();
     152                _recordTimeCount = _playbackFile->readUint32LE();
     153                randomSourceCount = _playbackFile->readUint32LE();
     154                for (uint i = 0; i < randomSourceCount; ++i) {
     155                        RandomSourceRecord rec;
     156                        rec.name = "";
     157                        uint32 sLen = _playbackFile->readUint32LE();
     158                        for (uint j = 0; j < sLen; ++j) {
     159                                char c = _playbackFile->readSByte();
     160                                rec.name += c;
     161                        }
     162                        rec.seed = _playbackFile->readUint32LE();
     163                        _randomSourceRecords.push_back(rec);
     164                }
     165
     166                _hasPlaybackEvent = false;
     167        }
    42168}
    43169
     170DefaultEventManager::~DefaultEventManager() {
     171        _boss->lockMutex(_timeMutex);
     172        _recordMode = kPassthrough;
     173        _boss->unlockMutex(_timeMutex);
     174       
     175        if (_playbackFile != NULL) {
     176                delete _playbackFile;
     177        }
     178        if (_playbackTimeFile != NULL) {
     179                delete _playbackTimeFile;
     180        }
     181
     182        if (_recordFile != NULL) {
     183                _recordFile->finalize();
     184                delete _recordFile;
     185                _recordTimeFile->finalize();
     186                delete _recordTimeFile;
     187
     188                _playbackFile = _boss->getSavefileManager()->openForLoading(_recordTempFileName.c_str());
     189
     190                _recordFile = _boss->getSavefileManager()->openForSaving(_recordFileName.c_str());
     191                _recordFile->writeUint32LE(RECORD_SIGNATURE);
     192                _recordFile->writeUint32LE(RECORD_VERSION);
     193               
     194                // conf vars
     195                _recordFile->writeByte(_recordSubtitles ? 1 : 0);
     196               
     197                _recordFile->writeUint32LE(_recordCount);
     198                _recordFile->writeUint32LE(_recordTimeCount);
     199               
     200                _recordFile->writeUint32LE(_randomSourceRecords.size());
     201                for (uint i = 0; i < _randomSourceRecords.size(); ++i) {
     202                        _recordFile->writeUint32LE(_randomSourceRecords[i].name.size());
     203                        _recordFile->writeString(_randomSourceRecords[i].name);
     204                        _recordFile->writeUint32LE(_randomSourceRecords[i].seed);
     205                }
     206
     207                for (uint i = 0; i < _recordCount; ++i) {
     208                        uint32 tempDiff;
     209                        Common::Event tempEvent;
     210                        readRecord(_playbackFile, tempDiff, tempEvent);
     211                        writeRecord(_recordFile, tempDiff, tempEvent);
     212                }
     213
     214                _recordFile->finalize();
     215                delete _recordFile;
     216                delete _playbackFile;
     217               
     218                //TODO: remove recordTempFileName'ed file
     219        }
     220        _boss->deleteMutex(_timeMutex);
     221}
     222
     223bool DefaultEventManager::playback(Common::Event &event) {
     224       
     225        if (!_hasPlaybackEvent) {
     226                if (_recordCount > _playbackCount) {
     227                        readRecord(_playbackFile, _playbackDiff, _playbackEvent);
     228                        _playbackCount++;
     229                        _hasPlaybackEvent = true;
     230                }
     231        }
     232
     233        if (_hasPlaybackEvent) {
     234                if (_playbackDiff <= (_eventCount - _lastEventCount)) {
     235                        switch(_playbackEvent.type) {
     236                                case Common::EVENT_MOUSEMOVE:
     237                                case Common::EVENT_LBUTTONDOWN:
     238                                case Common::EVENT_LBUTTONUP:
     239                                case Common::EVENT_RBUTTONDOWN:
     240                                case Common::EVENT_RBUTTONUP:
     241                                case Common::EVENT_WHEELUP:
     242                                case Common::EVENT_WHEELDOWN:
     243                                        _boss->warpMouse(_playbackEvent.mouse.x, _playbackEvent.mouse.y);
     244                                        break;
     245                        }       
     246                        event = _playbackEvent;
     247                        _hasPlaybackEvent = false;
     248                        _lastEventCount = _eventCount;
     249                        return true;
     250                }
     251        }
     252               
     253        return false;
     254}
     255
     256void DefaultEventManager::record(Common::Event &event) {
     257        writeRecord(_recordFile, _eventCount - _lastEventCount, event);
     258       
     259        _recordCount++;
     260        _lastEventCount = _eventCount;
     261}
     262
     263void DefaultEventManager::registerRandomSource(Common::RandomSource &rnd, const char *name) {
     264       
     265        if (_recordMode == kRecorderRecord) {
     266                RandomSourceRecord rec;
     267                rec.name = name;
     268                rec.seed = rnd.getSeed();
     269                _randomSourceRecords.push_back(rec);
     270        }
     271
     272        if (_recordMode == kRecorderPlayback) {
     273                for (uint i = 0; i < _randomSourceRecords.size(); ++i) {
     274                        if (_randomSourceRecords[i].name == name) {
     275                                rnd.setSeed(_randomSourceRecords[i].seed);
     276                                _randomSourceRecords.remove_at(i);
     277                                break;
     278                        }
     279                }
     280        }
     281}
     282
     283void DefaultEventManager::processMillis(uint32 &millis) {
     284        uint32 d;
     285        if (_recordMode == kPassthrough) {
     286                return;
     287        }
     288
     289        _boss->lockMutex(_timeMutex);
     290        if (_recordMode == kRecorderRecord) {
     291                //Simple RLE compression
     292                d = millis - _lastMillis;
     293                if (d >= 0xff) {
     294                        _recordTimeFile->writeByte(0xff);
     295                        _recordTimeFile->writeUint32LE(d);
     296                } else {
     297                        _recordTimeFile->writeByte(d);
     298                }
     299                _recordTimeCount++;
     300        }
     301
     302        if (_recordMode == kRecorderPlayback) {
     303                if (_recordTimeCount > _playbackTimeCount) {
     304                        d = _playbackTimeFile->readByte();
     305                        if (d == 0xff) {
     306                                d = _playbackTimeFile->readUint32LE();
     307                        }
     308                        millis = _lastMillis + d;
     309                        _playbackTimeCount++;
     310                }
     311        }
     312        _lastMillis = millis;
     313        _boss->unlockMutex(_timeMutex);
     314}
     315
    44316bool DefaultEventManager::pollEvent(Common::Event &event) {
    45317        uint32 time = _boss->getMillis();
    46318        bool result;
    47319       
     320        _eventCount++;
     321
    48322        result = _boss->pollEvent(event);
    49        
     323
     324        if ((_recordMode == kRecorderPlayback) && (event.type != Common::EVENT_QUIT))  {
     325                result = playback(event);
     326        } else {               
     327
     328                if (_recordMode == kRecorderRecord) {
     329                        if (result) {
     330                                record(event);
     331                        }
     332                }
     333        }
     334               
    50335        if (result) {
    51336                event.synthetic = false;
    52337                switch (event.type) {
  • backends/events/default/default-events.h

     
    2828
    2929#include "common/stdafx.h"
    3030#include "common/events.h"
     31#include "common/savefile.h"
    3132
    3233/*
    3334At some point we will remove pollEvent from OSystem and change
     
    4849        int _buttonState;
    4950        int _modifierState;
    5051        bool _shouldQuit;
     52       
     53        class RandomSourceRecord {
     54        public:
     55                Common::String name;
     56                uint32 seed;
     57        };
     58        Common::Array<RandomSourceRecord> _randomSourceRecords;
    5159
     60        bool _recordSubtitles;
     61        uint32 _recordCount;
     62        uint32 _lastRecordEvent;
     63        uint32 _recordTimeCount;
     64        Common::OutSaveFile *_recordFile;
     65        Common::OutSaveFile *_recordTimeFile;
     66        Common::MutexRef _timeMutex;
     67        uint32 _lastMillis;
     68
     69        uint32 _playbackCount;
     70        uint32 _playbackDiff;
     71        bool _hasPlaybackEvent;
     72        uint32 _playbackTimeCount;
     73        Common::Event _playbackEvent;   
     74        Common::InSaveFile *_playbackFile;
     75        Common::InSaveFile *_playbackTimeFile;
     76
     77        uint32 _eventCount;
     78        uint32 _lastEventCount;
     79
     80        enum RecordMode {
     81                kPassthrough = 0,
     82                kRecorderRecord = 1,
     83                kRecorderPlayback = 2
     84        };
     85        RecordMode _recordMode;
     86        Common::String _recordFileName;
     87        Common::String _recordTempFileName;
     88        Common::String _recordTimeFileName;
     89       
    5290        // for continuous events (keyDown)
    5391        enum {
    5492                kKeyRepeatInitialDelay = 400,
     
    62100        } _currentKeyDown;
    63101        uint32 _keyRepeatTime;
    64102
     103        void record(Common::Event &event);
     104        bool playback(Common::Event &event);
    65105public:
    66106        DefaultEventManager(OSystem *boss);
     107        ~DefaultEventManager();
    67108
    68109        virtual bool pollEvent(Common::Event &event);
     110        virtual void registerRandomSource(Common::RandomSource &rnd, const char *name);
     111        virtual void processMillis(uint32 &millis);
    69112
    70113        virtual Common::Point getMousePos() const { return _mousePos; }
    71114        virtual int getButtonState() const { return _buttonState; }
  • backends/platform/sdl/sdl.cpp

     
    3333#include "backends/plugins/sdl/sdl-provider.h"
    3434#include "common/config-manager.h"
    3535#include "common/util.h"
     36#include "common/events.h"
    3637#include "base/main.h"
    3738
    3839#include "backends/saves/default/default-saves.h"
     
    273274}
    274275
    275276uint32 OSystem_SDL::getMillis() {
    276         return SDL_GetTicks();
     277        uint32 millis = SDL_GetTicks();
     278        getEventManager()->processMillis(millis);
     279        return millis;
    277280}
    278281
    279282void OSystem_SDL::delayMillis(uint msecs) {
     
    354357        SDL_ShowCursor(SDL_ENABLE);
    355358        SDL_Quit();
    356359
     360        delete getEventManager();
    357361        exit(0);
    358362}
    359363
  • common/events.h

     
    167167         */
    168168        virtual bool pollEvent(Common::Event &event) = 0;
    169169
    170 
     170        /** Register random source so it can be serialized in game test purposes **/
     171        virtual void registerRandomSource(Common::RandomSource &rnd, const char *name) = 0;
     172       
     173        virtual void processMillis(uint32 &millis) = 0;
     174       
    171175        /** Return the current key state */
    172176        virtual Common::Point getMousePos() const = 0;
    173177       
  • common/util.h

     
    7272public:
    7373        RandomSource();
    7474        void setSeed(uint32 seed);
     75       
     76        uint32 getSeed() {
     77                return _randSeed;
     78        }
    7579
    7680        /**
    7781         * Generates a random unsigned integer in the interval [0, max].
  • engines/agi/agi.cpp

     
    546546                        _gameId = g->id;
    547547
    548548        _rnd = new Common::RandomSource();
     549        syst->getEventManager()->registerRandomSource(*_rnd, "agi");
    549550
    550551        Common::addSpecialDebugLevel(kDebugLevelMain, "Main", "Generic debug level");
    551552        Common::addSpecialDebugLevel(kDebugLevelResources, "Resources", "Resources debugging");
  • engines/agos/agos.cpp

     
    2828#include "common/config-manager.h"
    2929#include "common/file.h"
    3030#include "common/system.h"
     31#include "common/events.h"
    3132
    3233#include "agos/debugger.h"
    3334#include "agos/intern.h"
     
    534535        File::addDefaultDirectory(_gameDataPath + "SFX");
    535536        File::addDefaultDirectory(_gameDataPath + "speech");
    536537        File::addDefaultDirectory(_gameDataPath + "SPEECH");
     538       
     539        syst->getEventManager()->registerRandomSource(_rnd, "agos");
    537540}
    538541
    539542int AGOSEngine::init() {
  • engines/cine/main_loop.cpp

     
    125125                                }
    126126                                break;
    127127                        case 291: // F10
    128                                 if (!disableSystemMenu && !inMenu) {
     128                                disableSystemMenu = false;
     129                                //if (!disableSystemMenu && !inMenu) {
    129130                                        g_cine->makeSystemMenu();
    130                                 }
     131                                //}
    131132                                break;
    132133                        default:
    133134                                lastKeyStroke = event.kbd.keycode;
  • engines/gob/gob.cpp

     
    2525
    2626#include "common/stdafx.h"
    2727#include "common/endian.h"
     28#include "common/events.h"
    2829
    2930#include "base/plugins.h"
    3031#include "common/config-manager.h"
     
    8889        Common::addSpecialDebugLevel(kDebugFileIO, "FileIO", "File Input/Output debug level");
    8990        Common::addSpecialDebugLevel(kDebugGraphics, "Graphics", "Graphics debug level");
    9091        Common::addSpecialDebugLevel(kDebugCollisions, "Collisions", "Collisions debug level");
     92        syst->getEventManager()->registerRandomSource(_rnd, "gob");
    9193}
    9294
    9395GobEngine::~GobEngine() {
  • engines/kyra/kyra.cpp

     
    121121        Common::addSpecialDebugLevel(kDebugLevelGUI, "GUI", "GUI debug level");
    122122        Common::addSpecialDebugLevel(kDebugLevelSequence, "Sequence", "Sequence debug level");
    123123        Common::addSpecialDebugLevel(kDebugLevelMovie, "Movie", "Movie debug level");
     124        system->getEventManager()->registerRandomSource(_rnd, "kyra");
    124125}
    125126
    126127int KyraEngine::init() {
  • engines/kyra/sprites.cpp

     
    2828#include "common/stream.h"
    2929#include "common/util.h"
    3030#include "common/system.h"
     31#include "common/events.h"
    3132#include "kyra/screen.h"
    3233#include "kyra/kyra.h"
    3334#include "kyra/sprites.h"
     
    4748        _spriteDefStart = 0;
    4849        memset(_drawLayerTable, 0, sizeof(_drawLayerTable));
    4950        _sceneAnimatorBeaconFlag = 0;
     51        system->getEventManager()->registerRandomSource(_rnd, "kyraSprites");
    5052}
    5153
    5254Sprites::~Sprites() {
  • engines/lure/hotspots.cpp

     
    542542        Common::RandomSource rnd;
    543543        int16 xp, yp;
    544544
     545        g_system->getEventManager()->registerRandomSource(rnd, "lureHotspots");
     546
    545547        if (_currentActions.isEmpty())
    546548                _currentActions.addFront(START_WALKING, roomNumber());
    547549        else
     
    28352837        Common::RandomSource rnd;
    28362838        RandomActionType actionType;
    28372839        uint16 scheduleId;
     2840        g_system->getEventManager()->registerRandomSource(rnd, "lureHotspots");
     2841
    28382842        int actionIndex = rnd.getRandomNumber(set->numActions() - 1);
    28392843        set->getEntry(actionIndex, actionType, scheduleId);
    28402844
     
    30233027        ValueTableData &fields = Resources::getReference().fieldList();
    30243028        Common::RandomSource rnd;
    30253029
     3030        g_system->getEventManager()->registerRandomSource(rnd, "lureHotspots");
     3031
    30263032        h.handleTalkDialog();
    30273033        if (h.frameCtr() > 0) {
    30283034                h.setFrameCtr(h.frameCtr() - 1);
     
    30633069        if (h.executeScript()) {
    30643070                // Script is done - set new script to one of two alternates randomly
    30653071                Common::RandomSource rnd;
     3072                g_system->getEventManager()->registerRandomSource(rnd, "lureHotspots");
     3073
    30663074                h.setHotspotScript(rnd.getRandomNumber(100) >= 50 ? 0x54 : 0);
    30673075                h.setFrameCtr(20 + rnd.getRandomNumber(63));
    30683076        }
     
    33193327        Common::RandomSource rnd;
    33203328        static bool ewanXOffset = false;
    33213329
     3330        g_system->getEventManager()->registerRandomSource(rnd, "lureHotspots");
     3331
    33223332        h.handleTalkDialog();
    33233333        if (h.delayCtr() > 0) {
    33243334                h.setDelayCtr(h.delayCtr() - 1);
  • engines/lure/res.cpp

     
    2828#include "lure/scripts.h"
    2929#include "lure/screen.h"
    3030#include "common/endian.h"
     31#include "common/events.h"
    3132
    3233namespace Lure {
    3334
     
    4041}
    4142
    4243Resources::Resources() {
     44        g_system->getEventManager()->registerRandomSource(_rnd, "lureResources");
    4345        int_resources = this;
    4446        reloadData();
    4547}
  • engines/lure/scripts.cpp

     
    566566
    567567void Script::randomToGeneral(uint16 maxVal, uint16 minVal, uint16 v3) {
    568568        Common::RandomSource rnd;
     569        g_system->getEventManager()->registerRandomSource(rnd, "lureScripts");
    569570        uint16 v = minVal + rnd.getRandomNumber(maxVal - minVal);
    570571        Resources::getReference().fieldList().setField(GENERAL, v);
    571572}
  • engines/queen/display.cpp

     
    2525
    2626#include "common/stdafx.h"
    2727#include "common/system.h"
     28#include "common/events.h"
    2829
    2930#include "graphics/cursorman.h"
    3031
     
    8182        memset(&_dynalum, 0, sizeof(_dynalum));
    8283
    8384        setupInkColors();
     85        system->getEventManager()->registerRandomSource(_rnd, "queenDisplay");
    8486}
    8587
    8688Display::~Display() {
  • engines/queen/music.cpp

     
    2424 */
    2525
    2626#include "common/stdafx.h"
     27#include "common/system.h"
     28#include "common/events.h"
    2729#include "queen/music.h"
    2830#include "queen/queen.h"
    2931#include "queen/resource.h"
     
    4850        this->open();
    4951
    5052        _tune = vm->resource()->isDemo() ? Sound::_tuneDemo : Sound::_tune;
     53        vm->_system->getEventManager()->registerRandomSource(_rnd, "queenMusic");
    5154}
    5255
    5356MidiMusic::~MidiMusic() {
  • engines/queen/queen.cpp

     
    3232#include "common/fs.h"
    3333#include "common/savefile.h"
    3434#include "common/system.h"
     35#include "common/events.h"
    3536
    3637#include "queen/queen.h"
    3738#include "queen/bankman.h"
     
    110111
    111112QueenEngine::QueenEngine(OSystem *syst)
    112113        : Engine(syst), _debugger(0) {
     114        syst->getEventManager()->registerRandomSource(randomizer, "queen");
    113115}
    114116
    115117QueenEngine::~QueenEngine() {
  • engines/saga/saga.cpp

     
    2828#include "common/file.h"
    2929#include "common/config-manager.h"
    3030#include "common/system.h"
     31#include "common/events.h"
    3132
    3233#include "sound/mixer.h"
    3334
     
    114115        }
    115116
    116117        _displayClip.left = _displayClip.top = 0;
     118        syst->getEventManager()->registerRandomSource(_rnd, "saga");
    117119}
    118120
    119121SagaEngine::~SagaEngine() {
  • engines/scumm/scumm.cpp

     
    532532        // Add debug levels     
    533533        for (int i = 0; i < ARRAYSIZE(debugChannels); ++i)
    534534                Common::addSpecialDebugLevel(debugChannels[i].flag,  debugChannels[i].channel, debugChannels[i].desc);
     535
     536        syst->getEventManager()->registerRandomSource(_rnd, "scumm");
    535537}
    536538
    537539
  • engines/sky/logic.cpp

     
    2626#include "common/stdafx.h"
    2727#include "common/endian.h"
    2828#include "common/rect.h"
     29#include "common/events.h"
    2930
    3031#include "sky/autoroute.h"
    3132#include "sky/compact.h"
     
    7172}
    7273
    7374Logic::Logic(SkyCompact *skyCompact, Screen *skyScreen, Disk *skyDisk, Text *skyText, MusicBase *skyMusic, Mouse *skyMouse, Sound *skySound) {
     75        g_system->getEventManager()->registerRandomSource(_rnd, "sky");
     76
    7477        _skyCompact = skyCompact;
    7578        _skyScreen = skyScreen;
    7679        _skyDisk = skyDisk;
  • engines/sword1/logic.cpp

     
    2626#include "common/stdafx.h"
    2727#include "common/endian.h"
    2828#include "common/util.h"
     29#include "common/system.h"
     30#include "common/events.h"
    2931
    3032#include "sword1/logic.h"
    3133#include "sword1/text.h"
     
    5456uint32 Logic::_scriptVars[NUM_SCRIPT_VARS];
    5557
    5658Logic::Logic(ObjectMan *pObjMan, ResMan *resMan, Screen *pScreen, Mouse *pMouse, Sound *pSound, Music *pMusic, Menu *pMenu, OSystem *system, Audio::Mixer *mixer) {
     59        g_system->getEventManager()->registerRandomSource(_rnd, "sword1");
     60
    5761        _objMan = pObjMan;
    5862        _resMan = resMan;
    5963        _screen = pScreen;
  • engines/sword1/sound.cpp

     
    2727#include "common/endian.h"
    2828
    2929#include "common/util.h"
     30#include "common/system.h"
     31#include "common/events.h"
    3032
    3133#include "sword1/sound.h"
    3234#include "sword1/resman.h"
     
    4345#define SPEECH_FLAGS (Audio::Mixer::FLAG_16BITS | Audio::Mixer::FLAG_AUTOFREE | Audio::Mixer::FLAG_LITTLE_ENDIAN)
    4446
    4547Sound::Sound(const char *searchPath, Audio::Mixer *mixer, ResMan *pResMan) {
     48        g_system->getEventManager()->registerRandomSource(_rnd, "sword1sound");
    4649        strcpy(_filePath, searchPath);
    4750        _mixer = mixer;
    4851        _resMan = pResMan;
  • engines/sword2/sword2.cpp

     
    209209        _gameSpeed = 1;
    210210
    211211        _quit = false;
     212        syst->getEventManager()->registerRandomSource(_rnd, "sword2");
    212213}
    213214
    214215Sword2Engine::~Sword2Engine() {
  • engines/touche/touche.cpp

     
    7373        Common::addSpecialDebugLevel(kDebugResource, "Resource", "Resource debug level");
    7474        Common::addSpecialDebugLevel(kDebugOpcodes,  "Opcodes",  "Opcodes debug level");
    7575        Common::addSpecialDebugLevel(kDebugUserIntf, "UserIntf", "UserInterface debug level");
     76        system->getEventManager()->registerRandomSource(_rnd, "touche");
    7677}
    7778
    7879ToucheEngine::~ToucheEngine() {