aboutsummaryrefslogtreecommitdiff
path: root/engines/zvision/zvision.h
blob: 2ada66c45da061d32416b0ee03bdfad99c8e581f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
/* 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 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.
 *
 *
 */

#ifndef ZVISION_ZVISION_H
#define ZVISION_ZVISION_H

#include "zvision/core/clock.h"
#include "zvision/file/search_manager.h"

#include "common/random.h"
#include "common/events.h"

#include "engines/engine.h"

#include "graphics/pixelformat.h"

#include "gui/debugger.h"

namespace Video {
class VideoDecoder;
}

/**
 * This is the namespace of the ZVision engine.
 *
 * Status of this engine: complete
 *
 * Games using this engine:
 * - Zork Nemesis: The Forbidden Lands
 * - Zork: Grand Inquisitor
 *
 */
namespace ZVision {

struct ZVisionGameDescription;
class Console;
class ScriptManager;
class RenderManager;
class CursorManager;
class StringManager;
class SaveManager;
class RLFDecoder;
class MenuHandler;
class TextRenderer;
class Subtitle;
class MidiManager;

enum {
	WINDOW_WIDTH = 640,
	WINDOW_HEIGHT = 480,

	HIRES_WINDOW_WIDTH = 800,
	HIRES_WINDOW_HEIGHT = 600,

	// Zork Nemesis working window sizes
	ZNM_WORKING_WINDOW_WIDTH = 512,
	ZNM_WORKING_WINDOW_HEIGHT = 320,

	// ZGI working window sizes
	ZGI_WORKING_WINDOW_WIDTH = 640,
	ZGI_WORKING_WINDOW_HEIGHT = 344,

	ROTATION_SCREEN_EDGE_OFFSET = 60,
	MAX_ROTATION_SPEED = 400, // Pixels per second

	KEYBUF_SIZE = 20
};

enum ZVisionGameId {
	GID_NONE = 0,
	GID_NEMESIS = 1,
	GID_GRANDINQUISITOR = 2
};

enum ZVisionFeatures {
	GF_DVD = (1 << 0) // ZGI DVD version
};

class ZVision : public Engine {
public:
	ZVision(OSystem *syst, const ZVisionGameDescription *gameDesc);
	~ZVision();

public:
	/**
	 * A Rectangle centered inside the actual window. All in-game coordinates
	 * are given in this coordinate space. Also, all images are clipped to the
	 * edges of this Rectangle
	 */
	Common::Rect _workingWindow;
	const Graphics::PixelFormat _resourcePixelFormat;
	const Graphics::PixelFormat _screenPixelFormat;

private:
	Console *_console;
	const ZVisionGameDescription *_gameDescription;

	const int _desiredFrameTime;

	// We need random numbers
	Common::RandomSource *_rnd;

	// Managers
	ScriptManager *_scriptManager;
	RenderManager *_renderManager;
	CursorManager *_cursorManager;
	StringManager *_stringManager;
	SearchManager *_searchManager;
	TextRenderer *_textRenderer;
	MidiManager *_midiManager;
	SaveManager *_saveManager;
	MenuHandler *_menu;

	// Clock
	Clock _clock;

	// Audio ID
	int _audioId;

	// To prevent allocation every time we process events
	Common::Event _event;

	int _frameRenderDelay;
	int _renderedFrameCount;
	int _fps;
	int16 _mouseVelocity;
	int16 _keyboardVelocity;
	bool _doubleFPS;
	bool _videoIsPlaying;

	uint8 _cheatBuffer[KEYBUF_SIZE];

public:
	Common::Error run();
	void pauseEngineIntern(bool pause);

	ZVisionGameId getGameId() const;
	Common::Language getLanguage() const;
	uint32 getFeatures() const;

	ScriptManager *getScriptManager() const {
		return _scriptManager;
	}
	RenderManager *getRenderManager() const {
		return _renderManager;
	}
	CursorManager *getCursorManager() const {
		return _cursorManager;
	}
	SaveManager *getSaveManager() const {
		return _saveManager;
	}
	StringManager *getStringManager() const {
		return _stringManager;
	}
	SearchManager *getSearchManager() const {
		return _searchManager;
	}
	TextRenderer *getTextRenderer() const {
		return _textRenderer;
	}
	MidiManager *getMidiManager() const {
		return _midiManager;
	}
	MenuHandler *getMenuHandler() const {
		return _menu;
	}

	Common::RandomSource *getRandomSource() const {
		return _rnd;
	}
	int16 getKeyboardVelocity() const {
		return _keyboardVelocity;
	}
	int16 getMouseVelocity() const {
		return _mouseVelocity;
	}

	uint8 getZvisionKey(Common::KeyCode scummKeyCode);

	void startClock() {
		_clock.start();
	}

	void stopClock() {
		_clock.stop();
	}

	void initScreen();
	void initHiresScreen();

	/**
	 * Play a video until it is finished. This is a blocking call. It will call
	 * _clock.stop() when the video starts and _clock.start() when the video finishes.
	 * It will also consume all events during video playback.
	 *
	 * @param videoDecoder    The video to play
	 * @param destRect        Where to put the video. (In working window coords)
	 * @param skippable       If true, the video can be skipped at any time using [Spacebar]
	 */
	void playVideo(Video::VideoDecoder &videoDecoder, const Common::Rect &destRect = Common::Rect(0, 0, 0, 0), bool skippable = true, Subtitle *sub = NULL);
	Video::VideoDecoder *loadAnimation(const Common::String &fileName);

	Common::String generateSaveFileName(uint slot);

	void setRenderDelay(uint);
	bool canRender();
	static void fpsTimerCallback(void *refCon);
	void fpsTimer();
	int getFPS() const {
		return _fps;
	}

	GUI::Debugger *getDebugger();
	void syncSoundSettings();

	void loadSettings();
	void saveSettings();

	bool ifQuit();

	// Engine features
	bool hasFeature(EngineFeature f) const;
	bool canLoadGameStateCurrently();
	bool canSaveGameStateCurrently();
	Common::Error loadGameState(int slot);
	Common::Error saveGameState(int slot, const Common::String &desc);

private:
	void initialize();
	void initFonts();

	void parseStrFile(const Common::String fileName);

	/** Called every frame from ZVision::run() to process any events from EventMan */
	void processEvents();

	void onMouseMove(const Common::Point &pos);

	void registerDefaultSettings();
	void shortKeys(Common::Event);

	void cheatCodes(uint8 key);
	void pushKeyToCheatBuf(uint8 key);
	bool checkCode(const char *code);
	uint8 getBufferedKey(uint8 pos);
};

} // End of namespace ZVision

#endif