1 /* ScummVM - Graphic Adventure Engine
2  *
3  * ScummVM is the legal property of its developers, whose names
4  * are too numerous to list here. Please refer to the COPYRIGHT
5  * file distributed with this source distribution.
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20  *
21  */
22 
23 #ifndef CRYOMNI3D_VERSAILLES_ENGINE_H
24 #define CRYOMNI3D_VERSAILLES_ENGINE_H
25 
26 #include "common/events.h"
27 #include "common/random.h"
28 #include "common/array.h"
29 #include "common/hashmap.h"
30 #include "common/hash-str.h"
31 #include "common/str.h"
32 
33 #include "cryomni3d/cryomni3d.h"
34 #include "cryomni3d/omni3d.h"
35 #include "cryomni3d/sprites.h"
36 #include "cryomni3d/wam_parser.h"
37 
38 #include "cryomni3d/versailles/documentation.h"
39 #include "cryomni3d/versailles/toolbar.h"
40 #include "cryomni3d/versailles/dialogs_manager.h"
41 
42 namespace Graphics {
43 class ManagedSurface;
44 struct Surface;
45 }
46 
47 namespace CryOmni3D {
48 struct FixedImageConfiguration;
49 class ZonFixedImage;
50 }
51 
52 namespace CryOmni3D {
53 namespace Versailles {
54 struct PlaceStateActionKey {
55 	uint placeId;
56 	uint placeState;
57 	uint actionId;
PlaceStateActionKeyPlaceStateActionKey58 	PlaceStateActionKey(uint placeId_, uint placeState_, uint actionId_) :
59 		placeId(placeId_), placeState(placeState_), actionId(actionId_) {}
60 
61 	bool operator==(const PlaceStateActionKey &other) const {
62 		return other.placeId == placeId && other.placeState == placeState && other.actionId == actionId;
63 	}
64 };
65 
66 struct PlaceActionKey {
67 	uint placeId;
68 	uint actionId;
PlaceActionKeyPlaceActionKey69 	PlaceActionKey(uint placeId_, uint actionId_) :
70 		placeId(placeId_), actionId(actionId_) {}
71 
72 	bool operator==(const PlaceActionKey &other) const {
73 		return other.placeId == placeId && other.actionId == actionId;
74 	}
75 };
76 }
77 }
78 
79 namespace Common {
80 template<>
81 struct Hash<CryOmni3D::Versailles::PlaceStateActionKey> {
82 	uint operator()(const CryOmni3D::Versailles::PlaceStateActionKey &k) const {
83 		// placeState shouldn't be greater than 8 and placeId shouldn't be greater than 100
84 		// originalActionId shouldn't be greater than 65536
85 		return (k.placeId << 24 | k.placeState << 16) ^ k.actionId;
86 	}
87 };
88 template<>
89 struct Hash<CryOmni3D::Versailles::PlaceActionKey> {
90 	uint operator()(const CryOmni3D::Versailles::PlaceActionKey &k) const {
91 		// placeId shouldn't be greater than 100
92 		// originalActionId shouldn't be greater than 65536
93 		return (k.placeId << 16) ^ k.actionId;
94 	}
95 };
96 }
97 
98 namespace CryOmni3D {
99 namespace Versailles {
100 
101 class CryOmni3DEngine_Versailles;
102 
103 enum AbortCommand {
104 	kAbortNoAbort = 0,
105 	kAbortQuit = 1,
106 	kAbortLoadGame = 2,
107 	kAbortNewGame = 3,
108 	kAbortNextLevel = 5,
109 	kAbortFinished = 6,
110 	kAbortGameOver = 7
111 };
112 
113 struct GameVariables {
114 	enum Var {
115 		kCollectScore = 0,             // 0
116 		kUnlockHiddenDoor,
117 		kAlreadyWent3_19,
118 		kMedalsDrawerStatus,
119 		kCurrentTime,
120 		kGotMedalsSolution,
121 		kCabinetDrawerStatus,
122 		kDecipherScore,
123 		kCollectLampoonArchitecture,
124 		kGotRevealedPaper,
125 		kCollectKey,                   // 10
126 		kCollectPortfolio,
127 		kSketchState,
128 		kFakeSketchChatState,
129 		kCollectFood,
130 		kCollectQuill,
131 		kStateLampoonReligion,
132 		kCollectSmallKey3,
133 		kCollectEngraving,
134 		kCollectCord,
135 		kCollectVaubanBlueprint1,      // 20
136 		kCollectVaubanBlueprint2,
137 		kLadderState,
138 		kOpenedCurtain,
139 		kLoweredChandelier,
140 		kCombedOrangeTree,
141 		kMaineTalked,
142 		kUsedLitCandle,
143 		kBombState,
144 		kInkSpilled,
145 		kCollectedPaperOnTable,        // 30
146 		kSafeUnlocked,
147 		//kUselessVar,
148 		kCollectedPaperInTrunk = 33,
149 		kBrushColor,
150 		kUsedScissors,
151 		kUnlockedAttic,
152 		kHasPlayedLebrun,
153 		kWarnedIncomplete,
154 		kUsedVaubanBlueprint1,
155 		kUsedVaubanBlueprint2,         // 40
156 		kSeenMemorandum,
157 		kCollectScissors,
158 		kSavedCountdown,
159 		kMax
160 	};
161 };
162 
163 // For random sounds we set a constant ID and avoid to use it elsewhere
164 struct SoundIds {
165 	enum {
166 		kOrgue = 0,
167 		kLeb001,
168 		kMax
169 	};
170 };
171 
172 struct LocalizedFilenames {
173 	enum {
174 		kDialogs = 0,
175 		kAllDocs,
176 		kLinksDocs,
177 		kCredits,
178 		kLeb001,
179 		kMax
180 	};
181 };
182 
183 struct PlaceState {
184 	typedef void (CryOmni3DEngine_Versailles::*InitFunc)();
185 	typedef bool (CryOmni3DEngine_Versailles::*FilterEventFunc)(uint *event);
186 
187 	PlaceState() : initPlace(nullptr), filterEvent(nullptr), docImage(nullptr), state(0) {}
188 	PlaceState(InitFunc initPlace_, FilterEventFunc filterEvent_, const char *docImage_) :
189 		initPlace(initPlace_), filterEvent(filterEvent_), docImage(docImage_), state(0) {}
190 
191 	InitFunc initPlace;
192 	FilterEventFunc filterEvent;
193 	const char *docImage;
194 	uint state;
195 };
196 
197 struct LevelInitialState {
198 	uint placeId;
199 	double alpha;
200 	double beta;
201 };
202 
203 struct FakeTransitionActionPlace {
204 	uint actionId;
205 	uint placeId;
206 };
207 
208 typedef void (CryOmni3DEngine_Versailles::*FixedImgCallback)(ZonFixedImage *);
209 
210 struct MsgBoxParameters {
211 	int font;
212 	byte foreColor;
213 	uint lineHeight;
214 	uint spaceWidth;
215 	uint charSpacing;
216 	uint initialWidth;
217 	uint incrementWidth;
218 	uint initialHeight;
219 	uint incrementHeight;
220 	uint timeoutChar;
221 };
222 
223 struct SubtitleEntry {
224 	uint32 frameStart;
225 	Common::String text;
226 };
227 
228 class CryOmni3DEngine_Versailles : public CryOmni3DEngine {
229 	friend class Versailles_DialogsManager;
230 protected:
231 	Common::Error run() override;
232 
233 public:
234 	CryOmni3DEngine_Versailles(OSystem *syst, const CryOmni3DGameDescription *gamedesc);
235 	~CryOmni3DEngine_Versailles() override;
236 
237 	void initializePath(const Common::FSNode &gamePath) override;
238 
239 	bool hasFeature(EngineFeature f) const override;
240 	Common::Error loadGameState(int slot) override;
241 	Common::Error saveGameState(int slot, const Common::String &desc, bool isAutosave = false) override;
242 	Common::String getSaveStateName(int slot) const override;
243 
244 	Common::String prepareFileName(const Common::String &baseName, const char *extension) const {
245 		const char *const extensions[] = { extension, nullptr };
246 		return prepareFileName(baseName, extensions);
247 	}
248 	Common::String prepareFileName(const Common::String &baseName,
249 	                                       const char *const *extensions) const override;
250 
251 	void setupPalette(const byte *colors, uint start, uint num) override { setupPalette(colors, start, num, true); }
252 	void makeTranslucent(Graphics::Surface &dst, const Graphics::Surface &src) const override;
253 
254 	bool displayToolbar(const Graphics::Surface *original) override { return _toolbar.displayToolbar(original); };
255 	bool hasPlaceDocumentation() override;
256 	bool displayPlaceDocumentation() override;
257 	uint displayOptions() override;
258 	bool shouldAbort() override;
259 
260 private:
261 	void setupFonts();
262 	void setupSprites();
263 	void loadCursorsPalette();
264 	void calculateTransparentMapping();
265 	void setupObjects();
266 	void setupDialogVariables();
267 	void setupImgScripts();
268 	void loadStaticData();
269 
270 	void syncOmni3DSettings();
271 	void syncSoundSettings() override;
272 
273 	void playTransitionEndLevel(int level);
274 	void changeLevel(int level);
275 	void initNewLevel(int level);
276 	void setupLevelWarps(int level);
277 	void initPlacesStates();
278 	void initWhoSpeaksWhere();
279 	void initDocPeopleRecord();
280 	void setupLevelActionsMask();
281 
282 	uint currentGameTime() const { return _gameVariables[GameVariables::kCurrentTime]; }
283 	void setGameTime(uint newTime, uint level);
284 	void updateGameTimeDialVariables();
285 
286 	void gameStep();
287 	void doGameOver();
288 
289 	void setPlaceState(uint placeId, uint newState);
290 	void doPlaceChange();
291 	void executeTransition(uint nextPlaceId);
292 	void fakeTransition(uint dstPlaceId);
293 	uint determineTransitionAnimation(uint srcId, uint dstId,
294 	                                  const Transition **transition);
295 
296 	uint getFakeTransition(uint actionId) const;
297 	void fixActionId(uint *actionId) const;
298 
299 	int handleWarp();
300 	bool handleWarpMouse(uint *actionId, uint movingCuror);
301 	void animateWarpTransition(const Transition *transition);
302 	void redrawWarp();
303 
304 	void handleFixedImg(const FixedImgCallback &callback);
305 	void executeSeeAction(uint actionId);
306 
307 	void executeSpeakAction(uint actionId);
308 	void setupDialogShows();
309 	bool preprocessDialog(const Common::String &sequence);
310 	void postprocessDialog(const Common::String &sequence);
311 
312 	void executeDocAction(uint actionId);
313 
314 	void drawMenuTitle(Graphics::ManagedSurface *surface, byte color);
315 	uint displayFilePicker(const Graphics::Surface *bgFrame, bool saveMode,
316 	                       Common::String &saveName);
317 	uint displayYesNoBox(Graphics::ManagedSurface &surface, const Common::Rect &position,
318 	                     uint msg_id);
319 	void displayMessageBox(const MsgBoxParameters &params, const Graphics::Surface *surface,
320 	                       uint msg_id, const Common::Point &position,
321 	                       const Common::Functor0<void> &callback) { displayMessageBox(params, surface, _messages[msg_id], position, callback); }
322 	void displayMessageBox(const MsgBoxParameters &params, const Graphics::Surface *surface,
323 	                       const Common::String &msg, const Common::Point &position,
324 	                       const Common::Functor0<void> &callback);
325 	void displayMessageBoxWarp(const Common::String &message);
326 	void displayMessageBoxWarp(uint msg_id) { displayMessageBoxWarp(_messages[msg_id]); }
327 	void displayCredits();
328 
329 	void warpMsgBoxCB();
330 
331 	bool canVisit() const;
332 	Common::String getSaveFileName(bool visit, uint saveNum) const;
333 	void getSavesList(bool visit, Common::Array<Common::String> &saveNames, int &nextSaveNum);
334 	void saveGame(bool visit, uint saveNum, const Common::String &saveName);
335 	bool loadGame(bool visit, uint saveNum);
336 
337 	void animateCursor(const Object *object);
338 	void collectObject(Object *object, const ZonFixedImage *fimg = nullptr,
339 	                   bool showObject = true);
340 	void collectObject(uint nameID, const ZonFixedImage *fimg = nullptr,
341 	                   bool showObject = true) { collectObject(_objects.findObjectByNameID(nameID), fimg, showObject); }
342 	typedef void (CryOmni3DEngine_Versailles::*DisplayObjectHook)(Graphics::ManagedSurface &surface);
343 	void displayObject(const Common::String &imgName, DisplayObjectHook hook = nullptr);
344 
345 	void setMainPaletteColor(byte color, byte red, byte green, byte blue);
346 	void setupPalette(const byte *colors, uint start, uint num, bool commit);
347 
348 	bool showSubtitles() const;
349 
350 	void playInGameVideo(const Common::String &filename, bool restoreCursorPalette = true);
351 	void playSubtitledVideo(const Common::String &filename);
352 
353 	void loadBMPs(const char *pattern, Graphics::Surface *bmps, uint count);
354 
355 	uint getMusicId(uint level, uint placeId) const;
356 	bool musicWouldChange(uint level, uint placeId) const;
357 	void musicUpdate();
358 	void musicPause();
359 	void musicResume();
360 	void musicStop();
361 	void musicSetQuiet(bool quiet);
362 
363 	Common::StringArray _localizedFilenames;
364 	Common::StringArray _messages;
365 	static const uint kSpritesMapTable[];
366 	static const uint kSpritesMapTableSize;
367 	static const LevelInitialState kLevelInitialStates[];
368 	static const FakeTransitionActionPlace kFakeTransitions[];
369 	Common::HashMap<uint, FixedImgCallback> _imgScripts;
370 	Common::Array<Common::String> _paintingsTitles;
371 
372 	Toolbar _toolbar;
373 
374 	byte *_mainPalette;
375 	byte *_cursorPalette;
376 	bool _fadedPalette;
377 	bool _forcePaletteUpdate;
378 	bool _forceRedrawWarp;
379 
380 	byte *_transparentPaletteMap;
381 	uint _transparentSrcStart;
382 	uint _transparentSrcStop;
383 	uint _transparentDstStart;
384 	uint _transparentDstStop;
385 	uint _transparentNewStart;
386 	uint _transparentNewStop;
387 
388 	bool _isPlaying;
389 	bool _isVisiting;
390 	AbortCommand _abortCommand;
391 	uint _loadedSave;
392 
393 	int _omni3dSpeed;
394 
395 	uint _currentLevel;
396 	Versailles_DialogsManager _dialogsMan;
397 
398 	Omni3DManager _omni3dMan;
399 	ZonFixedImage *_fixedImage;
400 
401 	Common::Array<uint> _gameVariables;
402 	Common::Array<PlaceState> _placeStates;
403 	Common::HashMap<PlaceStateActionKey, uint> _actionMasks;
404 	Common::HashMap<PlaceActionKey, Common::String> _whoSpeaksWhere;
405 	Common::HashMap<uint, const char *> _docPeopleRecord;
406 	bool _transitionAnimateWarp;
407 	uint _nextPlaceId;
408 	WAMParser _wam;
409 	uint _currentPlaceId;
410 	const Place *_currentPlace;
411 	const Image::ImageDecoder *_currentWarpImage;
412 
413 	const char *_musicCurrentFile;
414 	Audio::SoundHandle _musicHandle;
415 	float _musicVolumeFactor;
416 	static const char *kMusicFiles[8][8];
417 
418 	Versailles_Documentation _docManager;
419 
420 	static const MsgBoxParameters kWarpMsgBoxParameters;
421 	static const MsgBoxParameters kFixedimageMsgBoxParameters;
422 	static const FixedImageConfiguration kFixedImageConfiguration;
423 
424 	// Countdown
425 	void initCountdown();
426 	void syncCountdown();
427 	inline bool countDown() { if (_countingDown) { return doCountDown(); } else { return false; } }
428 	inline void drawCountdown(Graphics::ManagedSurface *surface = nullptr) { if (_countingDown) { doDrawCountdown(surface); } }
429 	void drawCountdownVideo(uint frameNum) { drawCountdown(); }
430 
431 	bool _countingDown;
432 	uint _countdownNextEvent;
433 	char _countdownValue[6];
434 	Graphics::ManagedSurface _countdownSurface;
435 	bool doCountDown();
436 	void doDrawCountdown(Graphics::ManagedSurface *surface);
437 
438 	// Video subtitles
439 	Common::HashMap<Common::String, Common::Array<SubtitleEntry> > _subtitles;
440 	const Common::Array<SubtitleEntry> *_currentSubtitleSet;
441 	Common::Array<SubtitleEntry>::const_iterator _currentSubtitle;
442 	void drawVideoSubtitles(uint frameNum);
443 
444 	// Objects
445 	template<uint ID>
446 	void genericDisplayObject();
447 	void obj_105();
448 	void obj_106();
449 	void obj_107();
450 	void obj_118();
451 	void obj_121();
452 	void obj_125();
453 	void obj_126();
454 	void obj_126hk(Graphics::ManagedSurface &surface);
455 	void obj_129();
456 	void obj_129hk(Graphics::ManagedSurface &surface);
457 	void obj_142();
458 	void obj_142hk(Graphics::ManagedSurface &surface);
459 
460 	// Fixed image
461 	template<uint ID>
462 	void genericDumbImage(ZonFixedImage *fimg);
463 	template<uint ID>
464 	void genericPainting(ZonFixedImage *fimg);
465 #define IMG_CB(name) void img_ ## name(ZonFixedImage *fimg)
466 	IMG_CB(31101);
467 	IMG_CB(31101b);
468 	IMG_CB(31142);
469 	IMG_CB(31142b);
470 	IMG_CB(31142c);
471 	IMG_CB(31142d);
472 	IMG_CB(31143);
473 	IMG_CB(31143b);
474 	IMG_CB(31143c);
475 	IMG_CB(31143d);
476 	IMG_CB(32120);
477 	IMG_CB(32120b);
478 	IMG_CB(32120c);
479 	IMG_CB(32201);
480 	IMG_CB(32202);
481 	IMG_CB(32203);
482 	IMG_CB(32204);
483 	IMG_CB(32204b);
484 	IMG_CB(34131);
485 	IMG_CB(34132);
486 	IMG_CB(34172);
487 	IMG_CB(34173);
488 	IMG_CB(34173b);
489 	IMG_CB(34173c);
490 	IMG_CB(34174);
491 	IMG_CB(34174b);
492 	IMG_CB(34174c);
493 	IMG_CB(34174d);
494 	IMG_CB(34174e);
495 	IMG_CB(34174f);
496 	static const uint kSafeDigitsCount = 12;
497 	static const uint16 kSafeDigitsX[];
498 	static const uint16 kSafeDigitsY[];
499 	static const char *kSafeDates[];
500 	bool handleSafe(ZonFixedImage *fimg);
501 	void drawSafeDigits(Graphics::ManagedSurface &surface, const Graphics::Surface(&bmpDigits)[10],
502 	                    const unsigned char (&safeDigits)[kSafeDigitsCount]);
503 	bool checkSafeDigits(unsigned char (&safeDigits)[kSafeDigitsCount]);
504 
505 	IMG_CB(41202);
506 	IMG_CB(41202b);
507 	IMG_CB(41801);
508 	IMG_CB(41801b);
509 	IMG_CB(41801c);
510 	IMG_CB(41802);
511 	IMG_CB(41802b);
512 	IMG_CB(41802c);
513 	IMG_CB(41802d);
514 	IMG_CB(43143);
515 	IMG_CB(43143b);
516 	IMG_CB(43145);
517 	IMG_CB(43145b);
518 	IMG_CB(43145c);
519 	IMG_CB(43146);
520 	IMG_CB(43146b);
521 	IMG_CB(43146c);
522 	IMG_CB(43160);
523 	IMG_CB(43160b);
524 	IMG_CB(43160c);
525 	IMG_CB(43160d);
526 	IMG_CB(43190);
527 	IMG_CB(43190b);
528 	IMG_CB(43190c);
529 	IMG_CB(43190d);
530 	IMG_CB(43190e);
531 	IMG_CB(43190f);
532 	IMG_CB(44071);
533 	IMG_CB(44071b);
534 	IMG_CB(44161);
535 	IMG_CB(44161b);
536 	IMG_CB(44161c);
537 	IMG_CB(44161d);
538 	IMG_CB(44161e);
539 	IMG_CB(44161f);
540 	static const uint kEpigraphMaxLetters = 32;
541 	Common::String _epigraphContent;
542 	Common::String _epigraphPassword;
543 	bool handleEpigraph(ZonFixedImage *fimg);
544 	void drawEpigraphLetters(Graphics::ManagedSurface &surface,
545 	                         const Graphics::Surface(&bmpLetters)[28], const Common::String &letters);
546 	IMG_CB(45130);
547 	IMG_CB(45270);
548 	IMG_CB(45270b);
549 	IMG_CB(45270c);
550 	IMG_CB(45270d);
551 	IMG_CB(45280);
552 
553 	IMG_CB(88001);
554 	IMG_CB(88001b);
555 	IMG_CB(88001c);
556 	IMG_CB(88002);
557 	IMG_CB(88003);
558 	IMG_CB(88003b);
559 	IMG_CB(88003c);
560 	IMG_CB(88003d);
561 	IMG_CB(88003e);
562 	IMG_CB(88003f);
563 	Common::U32String _bombAlphabet; // For Japanese edition
564 	Common::U32String _bombPassword;
565 	static const uint kBombPasswordSmallLength = 40;
566 	static const uint kBombPasswordMaxLength = 60;
567 	static const uint16 kBombLettersPos[2][kBombPasswordMaxLength][2];
568 	bool handleBomb(ZonFixedImage *fimg);
569 	void handleBombTranslation(Graphics::ManagedSurface &surface);
570 	void drawBombLetters(Graphics::ManagedSurface &surface, const Graphics::Surface(&bmpLetters)[28],
571 	                     const uint bombPasswordLength,
572 	                     const uint32(&bombPossibilites)[kBombPasswordMaxLength][5],
573 	                     const byte(&bombCurrentLetters)[kBombPasswordMaxLength]);
574 	IMG_CB(88004);
575 	IMG_CB(88004b);
576 #undef IMG_CB
577 
578 #define FILTER_EVENT(level, place) bool filterEventLevel ## level ## Place ## place(uint *event)
579 #define INIT_PLACE(level, place) void initPlaceLevel ## level ## Place ## place()
580 	FILTER_EVENT(1, 1);
581 	FILTER_EVENT(1, 2);
582 	INIT_PLACE(1, 3);
583 	FILTER_EVENT(1, 3);
584 	//FILTER_EVENT(1, 7); // Not used
585 	FILTER_EVENT(1, 14);
586 
587 	FILTER_EVENT(2, 1);
588 	FILTER_EVENT(2, 2);
589 	FILTER_EVENT(2, 5);
590 	INIT_PLACE(2, 9);
591 	FILTER_EVENT(2, 9);
592 	FILTER_EVENT(2, 11);
593 	FILTER_EVENT(2, 12);
594 	FILTER_EVENT(2, 14);
595 
596 	FILTER_EVENT(3, 3);
597 	FILTER_EVENT(3, 10);
598 	FILTER_EVENT(3, 13);
599 	FILTER_EVENT(3, 15);
600 	FILTER_EVENT(3, 17);
601 	FILTER_EVENT(3, 18);
602 	FILTER_EVENT(3, 19);
603 	FILTER_EVENT(3_5, 20);
604 	FILTER_EVENT(3, 22);
605 	FILTER_EVENT(3, 23);
606 	bool filterEventLevel3Obj23151();
607 	void collectLampoonArchitecture(const ZonFixedImage *fimg = nullptr);
608 
609 	INIT_PLACE(4, 9);
610 	FILTER_EVENT(4, 10);
611 	FILTER_EVENT(4, 12_13_14);
612 	FILTER_EVENT(4, 15);
613 	FILTER_EVENT(4, 16);
614 	FILTER_EVENT(4, 17);
615 
616 	INIT_PLACE(5, 6);
617 	FILTER_EVENT(5, 9);
618 	FILTER_EVENT(5, 14);
619 	FILTER_EVENT(5, 15);
620 	FILTER_EVENT(5, 16);
621 	void filterEventLevel5UpdatePlaceStates();
622 	//FILTER_EVENT(3_5, 20);
623 	FILTER_EVENT(5, 23);
624 	FILTER_EVENT(5, 27);
625 	FILTER_EVENT(5, 28);
626 	FILTER_EVENT(5, 29);
627 	FILTER_EVENT(5, 33);
628 	FILTER_EVENT(5, 34);
629 
630 	FILTER_EVENT(6, 1);
631 	FILTER_EVENT(6, 3);
632 	FILTER_EVENT(6, Orangery);
633 	FILTER_EVENT(6, 19);
634 
635 	FILTER_EVENT(7, 2);
636 	FILTER_EVENT(7, 9);
637 	FILTER_EVENT(7, 10_11_13);
638 	FILTER_EVENT(7, 20);
639 #undef FILTER_EVENT
640 #undef INIT_PLACE
641 
642 	// Dialogs shows
643 	void dialogShowBontempsShowThird();
644 	void dialogShowHuissierShowPamphlet();
645 	void dialogShowMonseigneurSorts();
646 	void dialogShowLeBrunWatches();
647 	void dialogShowDoorsOpen();
648 	void dialogShowSwissGuardGives();
649 	void dialogShowLullyCorrects();
650 	void dialogShowBontempsGivesAuth();
651 	void dialogShowCroissyLeave();
652 	void dialogShowMaintenonGives();
653 	void dialogShowLaChaizeGivesBack();
654 	void dialogShowLaChaizeWrites();
655 	void dialogShowLaChaizeGivesPamphlet();
656 	void dialogShowBontempsGivesKey();
657 	void dialogShowDuMaineLeaves();
658 	void dialogShowTransitionScene();
659 	void dialogShowEndOfGame();
660 	void dialogShowLeBrunGives();
661 	void dialogShowLeBrunLeave();
662 };
663 
664 } // End of namespace Versailles
665 } // End of namespace CryOmni3D
666 
667 #endif
668