Initial commit

engines/hypno/grammar.h

@@ -0,0 +1,770 @@
+/* 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 HYPNO_GRAMMAR_H
+#define HYPNO_GRAMMAR_H
+
+#include "common/array.h"
+#include "common/hash-ptr.h"
+#include "common/hash-str.h"
+#include "common/list.h"
+#include "common/queue.h"
+#include "common/rect.h"
+#include "common/str.h"
+
+#include "video/smk_decoder.h"
+
+namespace Hypno {
+
+typedef Common::String Filename;
+typedef Common::List<Filename> Filenames;
+
+class HypnoSmackerDecoder : public Video::SmackerDecoder {
+public:
+	bool loadStream(Common::SeekableReadStream *stream) override;
+
+protected:
+	uint32 getSignatureVersion(uint32 signature) const override;
+};
+
+class MVideo {
+public:
+	MVideo(Filename, Common::Point, bool, bool, bool);
+	Filename path;
+	Common::Point position;
+	bool scaled;
+	bool transparent;
+	bool loop;
+	HypnoSmackerDecoder *decoder;
+};
+
+typedef Common::Array<MVideo> Videos;
+
+enum HotspotType {
+	MakeMenu,
+	MakeHotspot
+};
+
+enum ActionType {
+	MiceAction,
+	TimerAction,
+	PaletteAction,
+	BackgroundAction,
+	HighlightAction,
+	OverlayAction,
+	EscapeAction,
+	SaveAction,
+	LoadAction,
+	LoadCheckpointAction,
+	QuitAction,
+	CutsceneAction,
+	PlayAction,
+	IntroAction,
+	AmbientAction,
+	WalNAction,
+	GlobalAction,
+	TalkAction,
+	SwapPointerAction,
+	SoundAction,
+	ChangeLevelAction
+};
+
+class Action {
+public:
+	virtual ~Action() {} // needed to make Action polymorphic
+	ActionType type;
+};
+
+typedef Common::Array<Action *> Actions;
+
+class Hotspot;
+
+typedef Common::Array<Hotspot> Hotspots;
+typedef Common::Array<Hotspots *> HotspotsStack;
+typedef Common::Array<Graphics::Surface *> Frames;
+
+class Hotspot {
+public:
+	Hotspot(HotspotType type_, Common::Rect rect_ = Common::Rect(0, 0, 0, 0)) {
+		type = type_;
+		rect = rect_;
+		smenu = nullptr;
+	}
+	HotspotType type;
+	Common::String flags[3];
+	Common::Rect rect;
+	Common::String setting;
+	Filename background;
+	Frames backgroundFrames;
+	Actions actions;
+	Hotspots *smenu;
+};
+
+class Mice : public Action {
+public:
+	Mice(Filename path_, uint32 index_) {
+		type = MiceAction;
+		path = path_;
+		index = index_;
+	}
+	Filename path;
+	uint32 index;
+};
+
+class SwapPointer : public Action {
+public:
+	SwapPointer(uint32 index_) {
+		type = SwapPointerAction;
+		index = index_;
+	}
+	uint32 index;
+};
+
+class Timer : public Action {
+public:
+	Timer(uint32 delay_, Common::String flag_) {
+		type = TimerAction;
+		delay = delay_;
+		flag = flag_;
+	}
+	uint32 delay;
+	Common::String flag;
+};
+
+class Palette : public Action {
+public:
+	Palette(Filename path_) {
+		type = PaletteAction;
+		path = path_;
+	}
+	Filename path;
+};
+
+class Highlight : public Action {
+public:
+	Highlight(Common::String condition_) {
+		type = HighlightAction;
+		condition = condition_;
+	}
+	Common::String condition;
+};
+
+class Background : public Action {
+public:
+	Background(Filename path_, Common::Point origin_, Common::String condition_, Common::String flag1_, Common::String flag2_) {
+		type = BackgroundAction;
+		path = path_;
+		origin = origin_;
+		condition = condition_;
+		flag1 = flag1_;
+		flag2 = flag2_;
+	}
+	Filename path;
+	Common::Point origin;
+	Common::String condition;
+	Common::String flag1;
+	Common::String flag2;
+};
+
+class Overlay : public Action {
+public:
+	Overlay(Filename path_, Common::Point origin_, Common::String flag_) {
+		type = OverlayAction;
+		path = path_;
+		origin = origin_;
+		flag = flag_;
+	}
+	Filename path;
+	Common::Point origin;
+	Common::String flag;
+};
+
+class Escape : public Action {
+public:
+	Escape() {
+		type = EscapeAction;
+	}
+};
+
+class Save : public Action {
+public:
+	Save() {
+		type = SaveAction;
+	}
+};
+
+class Load : public Action {
+public:
+	Load() {
+		type = LoadAction;
+	}
+};
+
+class LoadCheckpoint : public Action {
+public:
+	LoadCheckpoint() {
+		type = LoadCheckpointAction;
+	}
+};
+
+class Quit : public Action {
+public:
+	Quit() {
+		type = QuitAction;
+	}
+};
+
+class Cutscene : public Action {
+public:
+	Cutscene(Filename path_) {
+		type = CutsceneAction;
+		path = path_;
+	}
+	Filename path;
+};
+
+class Sound : public Action {
+public:
+	Sound(Filename path_) {
+		type = SoundAction;
+		path = path_;
+	}
+	Filename path;
+};
+
+class Intro : public Action {
+public:
+	Intro(Filename path_) {
+		type = IntroAction;
+		path = path_;
+	}
+	Filename path;
+};
+
+class Play : public Action {
+public:
+	Play(Filename path_, Common::Point origin_, Common::String condition_, Common::String flag_) {
+		type = PlayAction;
+		path = path_;
+		origin = origin_;
+		condition = condition_;
+		flag = flag_;
+	}
+	Filename path;
+	Common::Point origin;
+	Common::String condition;
+	Common::String flag;
+};
+
+class Ambient : public Action {
+public:
+	Ambient(Filename path_, Common::Point origin_, Common::String flag_) {
+		type = AmbientAction;
+		path = path_;
+		origin = origin_;
+		flag = flag_;
+		fullscreen = false;
+		frameNumber = 0;
+	}
+	Filename path;
+	Common::Point origin;
+	Common::String flag;
+	uint32 frameNumber;
+	bool fullscreen;
+};
+
+class WalN : public Action {
+public:
+	WalN(Common::String wn_, Filename path_, Common::Point origin_, Common::String condition_, Common::String flag_) {
+		wn = wn_;
+		type = WalNAction;
+		path = path_;
+		origin = origin_;
+		condition = condition_;
+		flag = flag_;
+	}
+	Common::String wn;
+	Filename path;
+	Common::Point origin;
+	Common::String condition;
+	Common::String flag;
+};
+
+class Global : public Action {
+public:
+	Global(Common::String variable_, Common::String command_) {
+		type = GlobalAction;
+		variable = variable_;
+		command = command_;
+	}
+	Common::String variable;
+	Common::String command;
+};
+
+class TalkCommand {
+public:
+	Common::String command;
+	Common::String variable;
+	Filename path;
+	uint32 num;
+	Common::Point position;
+};
+
+typedef Common::Array<TalkCommand> TalkCommands;
+
+class Talk : public Action {
+public:
+	Talk()  {
+		type = TalkAction;
+		boxPos = Common::Point(0, 0);
+		escape = false;
+		active = true;
+	}
+
+	Talk(Talk *t)  {
+		*this = *t;
+	}
+
+	TalkCommands commands;
+	bool active;
+	bool escape;
+	Common::Point introPos;
+	Filename intro;
+	Common::Point boxPos;
+	Filename background;
+	Common::Point backgroundPos;
+	Common::Rect rect;
+	Filename second;
+	Common::Point secondPos;
+};
+
+class ChangeLevel : public Action {
+public:
+	ChangeLevel(Filename level_) {
+		type = ChangeLevelAction;
+		level = level_;
+	}
+	Filename level;
+};
+
+enum LevelType {
+	TransitionLevel,
+	SceneLevel,
+	ArcadeLevel,
+	CodeLevel
+};
+
+class Level {
+public:
+	Level() {
+		type = CodeLevel;
+		musicRate = 22050;
+		playMusicDuringIntro = false;
+		musicStereo = false;
+	}
+	virtual ~Level() {} // needed to make Level polymorphic
+	LevelType type;
+	Filenames intros;
+	Filename prefix;
+	Filename levelIfWin;
+	Filename levelIfLose;
+	bool playMusicDuringIntro;
+	Filename music;
+	uint32 musicRate;
+	bool musicStereo;
+};
+
+class Scene : public Level {
+public:
+	Scene()  {
+		type = SceneLevel;
+		resolution = "640x480";
+	}
+	Common::String resolution;
+	Hotspots hots;
+};
+
+class FrameInfo {
+public:
+	FrameInfo(uint32 start_, uint32 length_) {
+		start = start_;
+		length = length_;
+	}
+
+	uint32 lastFrame() {
+		return start + length;
+	}
+	uint32 start;
+	uint32 length;
+};
+
+enum ScriptMode {
+	Interactive = 1,
+	NonInteractive,
+};
+
+class ScriptInfo {
+public:
+	ScriptInfo(uint32 time_, uint32 mode_, uint32 actor_, uint32 cursor_) {
+		time = time_;
+		mode = ScriptMode(mode_);
+		actor = actor_;
+		cursor = cursor_;
+	}
+	uint32 time;
+	ScriptMode mode;
+	uint32 actor;
+	uint32 cursor;
+};
+
+typedef Common::List<ScriptInfo> Script;
+
+class Shoot {
+public:
+	Shoot() {
+		destroyed = false;
+		video = nullptr;
+		timesToShoot = 1;
+		pointsToShoot = 0;
+		attackWeight = 0;
+		paletteOffset = 0;
+		paletteSize = 0;
+		missedAnimation = 0;
+		objKillsCount = 0;
+		objMissesCount = 0;
+		animation = "NONE";
+		explosionAnimation = "";
+		startFrame = 0;
+		lastFrame = 1024;
+		interactionFrame = 0;
+		noEnemySound = false;
+		enemySoundRate = 22050;
+		isAnimal = false;
+		nonHostile = false;
+		playInteractionAudio = false;
+		animalSound = "";
+		jumpToTimeAfterKilled = 0;
+		warningVideoIdx = 0;
+		waitForClickAfterInteraction = 0;
+		direction = 0;
+	}
+	Common::String name;
+	Filename animation;
+	Filename startSound;
+	Common::Point position;
+	Common::Point deathPosition;
+
+
+	uint32 timesToShoot;
+	uint32 pointsToShoot;
+	uint32 attackWeight;
+
+	// Objectives
+	uint32 objKillsCount;
+	uint32 objMissesCount;
+
+	// Palette
+	uint32 paletteOffset;
+	uint32 paletteSize;
+
+	// Missed animation
+	uint32 missedAnimation;
+
+	// Sounds
+	Filename enemySound;
+	uint32 enemySoundRate;
+	Filename deathSound;
+	Filename hitSound;
+	Filename animalSound;
+
+	MVideo *video;
+	Common::List<uint32> attackFrames;
+	Common::Array<FrameInfo> bodyFrames;
+	Common::Array<FrameInfo> explosionFrames;
+	uint32 startFrame;
+	uint32 lastFrame;
+	uint32 interactionFrame;
+	Filename explosionAnimation;
+	Filename additionalVideo;
+	bool playInteractionAudio;
+	bool destroyed;
+	bool noEnemySound;
+
+	// Soldier Boyz specific
+	bool nonHostile;
+	bool isAnimal;
+	Common::String checkIfDestroyed;
+	int jumpToTimeAfterKilled;
+	char direction;
+	uint32 waitForClickAfterInteraction;
+	uint32 warningVideoIdx;
+};
+
+typedef Common::Array<Shoot> Shoots;
+
+class ShootInfo {
+public:
+	Common::String name;
+	uint32 timestamp;
+};
+
+typedef Common::List<ShootInfo> ShootSequence;
+
+class SegmentShoots {
+public:
+	SegmentShoots() {
+		segmentRepetition = 0;
+	}
+	ShootSequence shootSequence;
+	uint32 segmentRepetition;
+};
+
+typedef Common::Array<SegmentShoots> SegmentShootsSequence;
+typedef Common::Array<Common::String> Sounds;
+
+enum SegmentType {
+	Straight,
+	Select3,
+	TurnLeft3,
+	Straight3,
+	TurnRight3,
+	Select2,
+	TurnLeft2,
+	TurnRight2,
+};
+
+class Segment {
+public:
+	Segment(byte type_, uint32 start_, uint32 size_)  {
+		type = type_;
+		start = start_;
+		size = size_;
+		end = false;
+	}
+
+	byte type;
+	uint32 start;
+	uint32 size;
+	bool end;
+};
+
+typedef Common::Array<Segment> Segments;
+
+class ArcadeTransition {
+public:
+	ArcadeTransition(Filename video_, Filename palette_, Filename sound_, uint32 soundRate_, uint32 time_)  {
+		video = video_;
+		palette = palette_;
+		sound = sound_;
+		soundRate = soundRate_;
+		soundStereo = false;
+		loseLevel = false;
+		winLevel = false;
+		selection = false;
+		jumpToTime = 0;
+		time = time_;
+	}
+
+	Filename video;
+	Filename palette;
+	Filename sound;
+	uint32 soundRate;
+	bool soundStereo;
+	bool loseLevel;
+	bool winLevel;
+	bool selection;
+	uint32 jumpToTime;
+	uint32 time;
+};
+
+typedef Common::List<ArcadeTransition> ArcadeTransitions;
+
+class ArcadeShooting : public Level {
+public:
+	ArcadeShooting()  {
+		type = ArcadeLevel;
+		health = 100;
+		id = 0;
+		objKillsRequired[0] = 0;
+		objKillsRequired[1] = 0;
+		objMissesAllowed[0] = 0;
+		objMissesAllowed[1] = 0;
+		mouseBox = Common::Rect(0, 0, 320, 200);
+		frameDelay = 0;
+		targetSoundRate = 0; // TODO: unused
+		shootSoundRate = 0;
+		enemySoundRate = 0;
+		hitSoundRate = 0;
+		additionalSoundRate = 0;
+		noAmmoSoundRate = 0;
+	}
+	void clear() {
+		nextLevelVideo.clear();
+		postStatsVideo.clear();
+		backgroundVideo.clear();
+		transitions.clear();
+		maskVideo.clear();
+		player.clear();
+		shoots.clear();
+		intros.clear();
+		defeatNoEnergyFirstVideo.clear();
+		defeatMissBossVideo.clear();
+		defeatNoEnergySecondVideo.clear();
+		missBoss1Video.clear();
+		missBoss2Video.clear();
+		hitBoss1Video.clear();
+		hitBoss2Video.clear();
+		beforeVideo.clear();
+		briefingVideo.clear();
+		additionalVideo.clear();
+		additionalSound.clear();
+		noAmmoSound.clear();
+		segments.clear();
+		script.clear();
+		objKillsRequired[0] = 0;
+		objKillsRequired[1] = 0;
+		objMissesAllowed[0] = 0;
+		objMissesAllowed[1] = 0;
+		mouseBox = Common::Rect(0, 0, 320, 200);
+		anchor = Common::Point(0, 0);
+		targetSoundRate = 0;
+		shootSoundRate = 0;
+		enemySoundRate = 0;
+		hitSoundRate = 0;
+		noAmmoSoundRate = 0;
+	}
+
+	uint32 id;
+	uint32 frameDelay;
+	Common::String mode;
+	Common::Rect mouseBox;
+	Common::Point anchor;
+	ArcadeTransitions transitions;
+	Segments segments;
+
+	// Objectives
+	uint32 objKillsRequired [2];
+	uint32 objMissesAllowed [2];
+
+	// Script
+	Script script;
+
+	// Videos
+	Filename nextLevelVideo;
+	Filename postStatsVideo;
+	Filename defeatNoEnergyFirstVideo;
+	Filename defeatNoEnergySecondVideo;
+	Filename defeatMissBossVideo;
+	Filename hitBoss1Video;
+	Filename missBoss1Video;
+	Filename hitBoss2Video;
+	Filename missBoss2Video;
+	Filename beforeVideo;
+	Filename additionalVideo;
+	Filename briefingVideo;
+
+	Filename backgroundVideo;
+	Filename backgroundPalette;
+	Filename maskVideo;
+	Filename player;
+	int health;
+	Shoots shoots;
+	SegmentShootsSequence shootSequence;
+
+	// Sounds
+	Filename targetSound;
+	uint32 targetSoundRate;
+	Filename shootSound;
+	uint32 shootSoundRate;
+	Filename enemySound;
+	uint32 enemySoundRate;
+	Filename hitSound;
+	uint32 hitSoundRate;
+	Filename additionalSound;
+	uint32 additionalSoundRate;
+	Filename noAmmoSound;
+	uint32 noAmmoSoundRate;
+};
+
+class Transition : public Level {
+public:
+	Transition(Common::String level)  {
+		type = TransitionLevel;
+		nextLevel = level;
+		levelEasy = "";
+		levelHard = "";
+		frameNumber = 0;
+		frameImage = "";
+	}
+
+	Transition(Common::String easy, Common::String hard)  {
+		type = TransitionLevel;
+		levelEasy = easy;
+		levelHard = hard;
+		frameNumber = 0;
+		frameImage = "";
+	}
+	Common::String nextLevel;
+	Common::String levelEasy;
+	Common::String levelHard;
+	Filename frameImage;
+	uint32 frameNumber;
+};
+
+class Code : public Level {
+public:
+	Code(Common::String name_)  {
+		type = CodeLevel;
+		name = name_;
+	}
+	Common::String name;
+};
+
+typedef Common::HashMap<Filename, Level*> Levels;
+extern Hotspots *g_parsedHots;
+extern ArcadeShooting *g_parsedArc;
+
+class ArcadeStats {
+	public:
+	ArcadeStats()  {
+		livesUsed = 0;
+		shootsFired = 0;
+		enemyHits = 0;
+		enemyTargets = 0;
+		targetsDestroyed = 0;
+		targetsMissed = 0;
+		friendliesEncountered = 0;
+		infoReceived = 0;
+	}
+	uint32 livesUsed;
+	uint32 shootsFired;
+	uint32 enemyHits;
+	uint32 enemyTargets;
+	uint32 targetsDestroyed;
+	uint32 targetsMissed;
+	uint32 friendliesEncountered;
+	uint32 infoReceived;
+};
+
+} // End of namespace Hypno
+
+#endif
+