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
|
/* 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 ILLUSIONS_ILLUSIONS_DUCKMAN_H
#define ILLUSIONS_ILLUSIONS_DUCKMAN_H
#include "illusions/illusions.h"
#include "common/algorithm.h"
#include "common/stack.h"
namespace Illusions {
class Dictionary;
class ScriptStack;
class DuckmanDialogSystem;
class DuckmanMenuSystem;
class DuckmanVideoPlayer;
struct Cursor_Duckman {
int _gameState;
Control *_control;
Common::Point _position;
uint32 _objectId;
int _actorIndex;
int _savedActorIndex;
bool _field14[14];
Control *_currOverlappedControl;
uint32 _sequenceId1;
uint32 _sequenceId2;
uint32 _notifyThreadId30;
int16 *_op113_choiceOfsPtr;
int _dialogItemsCount;
uint32 _overlappedObjectId;
uint32 _field3C;
uint32 _field40;
};
struct ScreenShakerPoint {
int16 x, y;
};
struct ScreenShakeEffect {
uint32 _duration;
uint _pointsCount;
const ScreenShakerPoint *_points;
};
struct ScreenShaker {
uint _pointsIndex;
uint _pointsCount;
bool _finished;
uint32 _duration;
uint32 _nextTime;
uint32 _notifyThreadId;
const ScreenShakerPoint *_points;
};
struct OpCall;
class IllusionsEngine_Duckman : public IllusionsEngine {
public:
IllusionsEngine_Duckman(OSystem *syst, const IllusionsGameDescription *gd);
protected:
virtual Common::Error run();
virtual bool hasFeature(EngineFeature f) const;
public:
uint32 _prevSceneId;
uint32 _theSceneId;
uint32 _theThreadId;
uint32 _globalSceneId;
uint _activeScenesCount;
uint32 _activeScenes[6];
Cursor_Duckman _cursor;
Control *_currWalkOverlappedControl;
DuckmanDialogSystem *_dialogSys;
int _savedInventoryActorIndex;
ScreenShaker *_screenShaker;
DuckmanMenuSystem *_menuSystem;
DuckmanVideoPlayer *_videoPlayer;
void initInput();
void initUpdateFunctions();
int updateScript(uint flags);
void startScreenShaker(uint pointsCount, uint32 duration, const ScreenShakerPoint *points, uint32 threadId);
void stopScreenShaker();
int updateScreenShaker(uint flags);
void startFader(int duration, int minValue, int maxValue, int firstIndex, int lastIndex, uint32 threadId);
void updateFader();
void clearFader();
void pauseFader();
void unpauseFader();
int updateVideoPlayer(uint flags);
void playVideo(uint32 videoId, uint32 callingThreadId);
bool isVideoPlaying();
void setDefaultTextCoords();
void loadSpecialCode(uint32 resId);
void unloadSpecialCode(uint32 resId);
void notifyThreadId(uint32 &threadId);
bool testMainActorFastWalk(Control *control);
bool testMainActorCollision(Control *control);
Control *getObjectControl(uint32 objectId);
Common::Point getNamedPointPosition(uint32 namedPointId);
uint32 getPriorityFromBase(int16 priority);
uint32 getCurrentScene();
uint32 getPrevScene();
bool isCursorObject(uint32 actorTypeId, uint32 objectId);
void setCursorControlRoutine(Control *control);
void placeCursorControl(Control *control, uint32 sequenceId);
void setCursorControl(Control *control);
void showCursor();
void hideCursor();
void initCursor();
void setCursorActorIndex(int actorIndex, int a, int b);
void enableCursorVerb(int verbNum);
void disableCursorVerb(int verbNum);
void setCursorHandMode(int mode);
void setCursorInventoryMode(int mode, int value);
void startCursorHoldingObject(uint32 objectId, uint32 sequenceId);
void stopCursorHoldingObject();
void cursorControlRoutine(Control *control, uint32 deltaTime);
void startScriptThreadSimple(uint32 threadId, uint32 callingThreadId);
void startScriptThread(uint32 threadId, uint32 callingThreadId);
void startScriptThread2(uint32 threadId, uint32 callingThreadId, uint32 unk);
uint32 startAbortableTimerThread(uint32 duration, uint32 threadId);
uint32 startTimerThread(uint32 duration, uint32 threadId);
uint32 startAbortableThread(byte *scriptCodeIp1, byte *scriptCodeIp2, uint32 callingThreadId);
uint32 startTalkThread(uint32 objectId, uint32 talkId, uint32 sequenceId1,
uint32 sequenceId2, uint32 callingThreadId);
uint32 startTempScriptThread(byte *scriptCodeIp, uint32 callingThreadId,
uint32 value8, uint32 valueC, uint32 value10);
void resumeFromSavegame(uint32 callingThreadId);
void newScriptThread(uint32 threadId, uint32 callingThreadId, uint notifyFlags,
byte *scriptCodeIp);
uint32 newTimerThread(uint32 duration, uint32 callingThreadId, bool isAbortable);
uint32 newTempThreadId();
void initActiveScenes();
void pushActiveScene(uint32 sceneId);
void popActiveScene();
bool loadScene(uint32 sceneId);
bool enterScene(uint32 sceneId, uint32 threadId);
void exitScene();
bool changeScene(uint32 sceneId, uint32 threadId, uint32 callerThreadId);
void enterPause(uint32 sceneId, uint32 threadId);
void leavePause(uint32 sceneId, uint32 threadId);
void dumpActiveScenes(uint32 sceneId, uint32 threadId);
void dumpCurrSceneFiles(uint32 sceneId, uint32 threadId);
void pause(uint32 callerThreadId);
void unpause(uint32 callerThreadId);
void setSceneIdThreadId(uint32 theSceneId, uint32 theThreadId);
bool findTriggerCause(uint32 sceneId, uint32 verbId, uint32 objectId2, uint32 objectId, uint32 &codeOffs);
void reset();
uint32 getObjectActorTypeId(uint32 objectId);
Common::Point convertMousePos(Common::Point mousePos);
void startCursorSequence();
int getCursorActorIndex();
void updateGameState2();
void playSoundEffect(int index);
bool getTriggerCause(uint32 verbId, uint32 objectId2, uint32 objectId, uint32 &outThreadId);
uint32 runTriggerCause(uint32 verbId, uint32 objectId2, uint32 objectId);
void playTriggerCauseSound(uint32 verbId, uint32 objectId2, uint32 objectId);
bool loadSavegameFromScript(int16 slotNum, uint32 callingThreadId);
bool saveSavegameFromScript(int16 slotNum, uint32 callingThreadId);
void activateSavegame(uint32 callingThreadId);
};
} // End of namespace Illusions
#endif // ILLUSIONS_ILLUSIONS_H
|
