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
|
/* 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_SCRIPT_MANAGER_H
#define ZVISION_SCRIPT_MANAGER_H
#include "common/hashmap.h"
#include "common/queue.h"
#include "zvision/puzzle.h"
#include "zvision/control.h"
namespace Common {
class String;
class SeekableReadStream;
}
namespace ZVision {
class ZVision;
class ActionNode;
struct Location {
char world;
char room;
char node;
char view;
uint32 offset;
};
class ScriptManager {
public:
ScriptManager(ZVision *engine);
~ScriptManager();
private:
ZVision *_engine;
/**
* Holds the global state variable. Do NOT directly modify this. Use the accessors and
* mutators getStateValue() and setStateValue(). This ensures that Puzzles that reference a
* particular state key are checked after the key is modified.
*/
Common::HashMap<uint32, uint> _globalState;
/** Holds the currently active ActionNodes */
Common::List<ActionNode *> _activeNodes;
/** References _globalState keys to Puzzles */
Common::HashMap<uint32, Common::Array<Puzzle *> > _referenceTable;
/** Holds the Puzzles that should be checked this frame */
Common::Queue<Puzzle *> _puzzlesToCheck;
/** Holds the currently active puzzles */
Common::List<Puzzle *> _activePuzzles;
/** Holds the global puzzles */
Common::List<Puzzle *>_globalPuzzles;
/** Holds the currently active controls */
Common::HashMap<uint32, Control *> _activeControls;
Location _nextLocation;
bool _changeLocation;
public:
void initialize();
void update(uint deltaTimeMillis);
uint getStateValue(uint32 key);
void setStateValue(uint32 key, uint value);
void addToStateValue(uint32 key, uint valueToAdd);
void addControl(Control *control);
void enableControl(uint32 key);
void disableControl(uint32 key);
void changeLocation(char world, char room, char node, char view, uint32 offset);
private:
void createReferenceTable();
void changeLocationIntern();
void updateNodes(uint deltaTimeMillis);
void checkPuzzleCriteria();
/**
* Parses a script file into triggers and events
*
* @param fileName Name of the .scr file
* @param isGlobal Are the puzzles included in the file global (true). AKA, the won't be purged during location changes
*/
void parseScrFile(const Common::String &fileName, bool isGlobal = false);
/**
* Parses the stream into a Puzzle object
* Helper method for parseScrFile.
*
* @param puzzle The object to store what is parsed
* @param stream Scr file stream
*/
void parsePuzzle(Puzzle *puzzle, Common::SeekableReadStream &stream);
/**
* Parses the stream into a Criteria object
* Helper method for parsePuzzle.
*
* @param criteria Pointer to the Criteria object to fill
* @param stream Scr file stream
* @return Whether any criteria were read
*/
bool parseCriteria(Common::SeekableReadStream &stream, Common::List<Common::List<Puzzle::CriteriaEntry> > &criteriaList) const;
/**
* Parses the stream into a ResultAction objects
* Helper method for parsePuzzle.
*
* @param stream Scr file stream
* @param actionList The list where the results will be added
* @return Created Results object
*/
void parseResults(Common::SeekableReadStream &stream, Common::List<ResultAction *> &actionList) const;
/**
* Helper method for parsePuzzle. Parses the stream into a bitwise or of the StateFlags enum
*
* @param stream Scr file stream
* @return Bitwise OR of all the flags set within the puzzle
*/
uint parseFlags(Common::SeekableReadStream &stream) const;
/**
* Helper method for parseScrFile. Parses the stream into a Control object
*
* @param line The line initially read
* @param stream Scr file stream
*/
void parseControl(Common::String &line, Common::SeekableReadStream &stream);
};
} // End of namespace ZVision
#endif
|
