data.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef VOYEUR_DATA_H
#define VOYEUR_DATA_H

#include "common/scummsys.h"
#include "common/serializer.h"
#include "voyeur/files.h"

namespace Voyeur {

#define TOTAL_EVENTS 1000

enum VoyeurEventType {
    EVTYPE_NONE = 0,
    EVTYPE_VIDEO = 1,
    EVTYPE_AUDIO = 2,
    EVTYPE_EVID = 3,
    EVTYPE_COMPUTER = 4
};

enum EventFlag { EVTFLAG_TIME_DISABLED = 1, EVTFLAG_2 = 2, EVTFLAG_8 = 8, EVTFLAG_RECORDING = 0x10,
    EVTFLAG_40 = 0x40, EVTFLAG_VICTIM_PRESET = 0x80, EVTFLAG_100 = 0x100 };

struct VoyeurEvent {
    int _hour;
    int _minute;
    bool _isAM;
    VoyeurEventType _type;
    int _audioVideoId;
    int _computerOn;
    int _computerOff;
    int _dead;

    void synchronize(Common::Serializer &s);
};

class VoyeurEngne;

template<int SLOTS>
class HotspotTimes {
public:
    int _min[SLOTS][20];    // Min time expired
    int _max[SLOTS][20];    // Max time expired

    HotspotTimes() {
        reset();
    }

    void reset() {
        for (int hotspotIdx = 0; hotspotIdx < 20; ++hotspotIdx) {
            for (int slotIdx = 0; slotIdx < SLOTS; ++slotIdx) {
                _min[slotIdx][hotspotIdx] = 9999;
                _max[slotIdx][hotspotIdx] = 0;
            }
        }
    }

    void synchronize(Common::Serializer &s) {
        for (int slotIndex = 0; slotIndex < SLOTS; ++slotIndex) {
            for (int hotspotIndex = 0; hotspotIndex < 20; ++hotspotIndex) {
                s.syncAsSint16LE(_min[slotIndex][hotspotIndex]);
                s.syncAsSint16LE(_max[slotIndex][hotspotIndex]);
            }
        }
    }

    bool isInRange(int slotIndex, int hotspotIndex, int v) const {
        return _min[slotIndex][hotspotIndex] <= v &&
            v < _max[slotIndex][hotspotIndex];
    }
};

class SVoy {
private:
    VoyeurEngine *_vm;

public:
    bool _abortInterface;
    bool _isAM;
    bool _phoneCallsReceived[5];
    bool _roomHotspotsEnabled[32];
    bool _victimMurdered;

    int _aptLoadMode;
    int _audioVisualStartTime;
    int _audioVisualDuration;
    int _boltGroupId2;
    int _computerTextId;
    int _computerTimeMin;
    int _computerTimeMax;
    int _eventCount;
    int _eventFlags;
    int _fadingAmount1;
    int _fadingAmount2;
    int _fadingStep1;
    int _fadingStep2;
    int _fadingType;
    int _incriminatedVictimNumber;
    int _murderThreshold;
    int _musicStartTime;
    int _playStampMode;
    int _switchBGNum;
    int _totalPhoneCalls;
    int _transitionId;
    int _videoEventId;
    int _vocSecondsOffset;
    int _RTANum;
    int _RTVLimit;
    int _RTVNum;

    HotspotTimes<3> _audioHotspotTimes;
    HotspotTimes<3> _evidenceHotspotTimes;
    HotspotTimes<8> _videoHotspotTimes;

    Common::Rect _computerScreenRect;
    RectResource *_viewBounds;
    PictureResource *_evPicPtrs[6];
    CMapResource *_evCmPtrs[6];
    VoyeurEvent _events[TOTAL_EVENTS];

    SVoy(VoyeurEngine *vm);

    void synchronize(Common::Serializer &s);

    void addEvent(int hour, int minute, VoyeurEventType type, int audioVideoId,
        int on, int off, int dead);

    void addVideoEventStart();

    void addVideoEventEnd();

    void addAudioEventStart();

    void addAudioEventEnd();

    void addEvidEventStart(int v);

    void addEvidEventEnd(int totalPages);

    void addComputerEventStart();

    void addComputerEventEnd(int v);

    void reviewAnEvidEvent(int eventIndex);

    void reviewComputerEvent(int eventIndex);

    bool checkForKey();

private:
    int _policeEvent;
};

} // End of namespace Voyeur

#endif /* VOYEUR_DATA_H */