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
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
|
/* 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.
*
* $URL$
* $Id$
*
*/
/*
* This code is based on original Hugo Trilogy source code
*
* Copyright (c) 1989-1995 David P. Gray
*
*/
// This module contains all the scheduling and timing stuff
#include "common/system.h"
#include "hugo/game.h"
#include "hugo/hugo.h"
#include "hugo/schedule.h"
#include "hugo/global.h"
#include "hugo/file.h"
#include "hugo/display.h"
#include "hugo/parser.h"
#include "hugo/util.h"
#include "hugo/sound.h"
#include "hugo/object.h"
namespace Hugo {
Scheduler_v2d::Scheduler_v2d(HugoEngine *vm) : Scheduler_v1d(vm) {
}
Scheduler_v2d::~Scheduler_v2d() {
}
const char *Scheduler_v2d::getCypher() {
return "Copyright 1991, Gray Design Associates";
}
/**
* Delete an event structure (i.e. return it to the free list)
* Historical note: Originally event p was assumed to be at head of queue
* (i.e. earliest) since all events were deleted in order when proceeding to
* a new screen. To delete an event from the middle of the queue, the action
* was overwritten to be ANULL. With the advent of GLOBAL events, delQueue
* was modified to allow deletes anywhere in the list, and the DEL_EVENT
* action was modified to perform the actual delete.
*/
void Scheduler_v2d::delQueue(event_t *curEvent) {
debugC(4, kDebugSchedule, "delQueue()");
if (curEvent == _headEvent) { // If p was the head ptr
_headEvent = curEvent->nextEvent; // then make new head_p
} else { // Unlink p
curEvent->prevEvent->nextEvent = curEvent->nextEvent;
if (curEvent->nextEvent)
curEvent->nextEvent->prevEvent = curEvent->prevEvent;
else
_tailEvent = curEvent->prevEvent;
}
if (_headEvent)
_headEvent->prevEvent = 0; // Mark end of list
else
_tailEvent = 0; // Empty queue
curEvent->nextEvent = _freeEvent; // Return p to free list
if (_freeEvent) // Special case, if free list was empty
_freeEvent->prevEvent = curEvent;
_freeEvent = curEvent;
}
/**
* Insert the action pointed to by p into the timer event queue
* The queue goes from head (earliest) to tail (latest) timewise
*/
void Scheduler_v2d::insertAction(act *action) {
debugC(1, kDebugSchedule, "insertAction() - Action type A%d", action->a0.actType);
// First, get and initialise the event structure
event_t *curEvent = getQueue();
curEvent->action = action;
switch (action->a0.actType) { // Assign whether local or global
case AGSCHEDULE:
curEvent->localActionFl = false; // Lasts over a new screen
break;
default:
curEvent->localActionFl = true; // Rest are for current screen only
break;
}
curEvent->time = action->a0.timer + getDosTicks(false); // Convert rel to abs time
// Now find the place to insert the event
if (!_tailEvent) { // Empty queue
_tailEvent = _headEvent = curEvent;
curEvent->nextEvent = curEvent->prevEvent = 0;
} else {
event_t *wrkEvent = _tailEvent; // Search from latest time back
bool found = false;
while (wrkEvent && !found) {
if (wrkEvent->time <= curEvent->time) { // Found if new event later
found = true;
if (wrkEvent == _tailEvent) // New latest in list
_tailEvent = curEvent;
else
wrkEvent->nextEvent->prevEvent = curEvent;
curEvent->nextEvent = wrkEvent->nextEvent;
wrkEvent->nextEvent = curEvent;
curEvent->prevEvent = wrkEvent;
}
wrkEvent = wrkEvent->prevEvent;
}
if (!found) { // Must be earliest in list
_headEvent->prevEvent = curEvent; // So insert as new head
curEvent->nextEvent = _headEvent;
curEvent->prevEvent = 0;
_headEvent = curEvent;
}
}
}
/**
* This function performs the action in the event structure pointed to by p
* It dequeues the event and returns it to the free list. It returns a ptr
* to the next action in the list, except special case of NEW_SCREEN
*/
event_t *Scheduler_v2d::doAction(event_t *curEvent) {
debugC(1, kDebugSchedule, "doAction - Event action type : %d", curEvent->action->a0.actType);
status_t &gameStatus = _vm->getGameStatus();
act *action = curEvent->action;
char *response; // User's response string
object_t *obj1;
object_t *obj2;
int dx, dy;
event_t *wrkEvent; // Save ev_p->next_p for return
event_t *saveEvent; // Used in DEL_EVENTS
switch (action->a0.actType) {
case ANULL: // Big NOP from DEL_EVENTS
break;
case ASCHEDULE: // act0: Schedule an action list
insertActionList(action->a0.actIndex);
break;
case START_OBJ: // act1: Start an object cycling
_vm->_object->_objects[action->a1.objNumb].cycleNumb = action->a1.cycleNumb;
_vm->_object->_objects[action->a1.objNumb].cycling = action->a1.cycle;
break;
case INIT_OBJXY: // act2: Initialise an object
_vm->_object->_objects[action->a2.objNumb].x = action->a2.x; // Coordinates
_vm->_object->_objects[action->a2.objNumb].y = action->a2.y;
break;
case PROMPT: { // act3: Prompt user for key phrase
response = Utils::Box(BOX_PROMPT, "%s", _vm->_file->fetchString(action->a3.promptIndex));
warning("STUB: doAction(act3), expecting answer %s", _vm->_file->fetchString(action->a3.responsePtr[0]));
// TODO: The answer of the player is not handled currently! Once it'll be read in the messageBox, uncomment this block
#if 0
bool found;
char *tmpStr; // General purpose string ptr
for (found = false, dx = 0; !found && (action->a3.responsePtr[dx] != -1); dx++) {
tmpStr = _vm->_file->fetchString(action->a3.responsePtr[dx]);
if (strstr(Utils::strlwr(response) , tmpStr))
found = true;
}
if (found)
insertActionList(action->a3.actPassIndex);
else
insertActionList(action->a3.actFailIndex);
#endif
// HACK: As the answer is not read, currently it's always considered correct
insertActionList(action->a3.actPassIndex);
break;
}
case BKGD_COLOR: // act4: Set new background color
_vm->_screen->setBackgroundColor(action->a4.newBackgroundColor);
break;
case INIT_OBJVXY: // act5: Initialise an object velocity
_vm->_object->setVelocity(action->a5.objNumb, action->a5.vx, action->a5.vy);
break;
case INIT_CARRY: // act6: Initialise an object
_vm->_object->setCarry(action->a6.objNumb, action->a6.carriedFl); // carried status
break;
case INIT_HF_COORD: // act7: Initialise an object to hero's "feet" coords
_vm->_object->_objects[action->a7.objNumb].x = _vm->_hero->x - 1;
_vm->_object->_objects[action->a7.objNumb].y = _vm->_hero->y + _vm->_hero->currImagePtr->y2 - 1;
_vm->_object->_objects[action->a7.objNumb].screenIndex = *_vm->_screen_p; // Don't forget screen!
break;
case NEW_SCREEN: // act8: Start new screen
newScreen(action->a8.screenIndex);
break;
case INIT_OBJSTATE: // act9: Initialise an object state
_vm->_object->_objects[action->a9.objNumb].state = action->a9.newState;
break;
case INIT_PATH: // act10: Initialise an object path and velocity
_vm->_object->setPath(action->a10.objNumb, (path_t) action->a10.newPathType, action->a10.vxPath, action->a10.vyPath);
break;
case COND_R: // act11: action lists conditional on object state
if (_vm->_object->_objects[action->a11.objNumb].state == action->a11.stateReq)
insertActionList(action->a11.actPassIndex);
else
insertActionList(action->a11.actFailIndex);
break;
case TEXT: // act12: Text box (CF WARN)
Utils::Box(BOX_ANY, "%s", _vm->_file->fetchString(action->a12.stringIndex)); // Fetch string from file
break;
case SWAP_IMAGES: // act13: Swap 2 object images
_vm->_object->swapImages(action->a13.obj1, action->a13.obj2);
break;
case COND_SCR: // act14: Conditional on current screen
if (_vm->_object->_objects[action->a14.objNumb].screenIndex == action->a14.screenReq)
insertActionList(action->a14.actPassIndex);
else
insertActionList(action->a14.actFailIndex);
break;
case AUTOPILOT: // act15: Home in on a (stationary) object
// object p1 will home in on object p2
obj1 = &_vm->_object->_objects[action->a15.obj1];
obj2 = &_vm->_object->_objects[action->a15.obj2];
obj1->pathType = AUTO;
dx = obj1->x + obj1->currImagePtr->x1 - obj2->x - obj2->currImagePtr->x1;
dy = obj1->y + obj1->currImagePtr->y1 - obj2->y - obj2->currImagePtr->y1;
if (dx == 0) // Don't EVER divide by zero!
dx = 1;
if (dy == 0)
dy = 1;
if (abs(dx) > abs(dy)) {
obj1->vx = action->a15.dx * -SIGN(dx);
obj1->vy = abs((action->a15.dy * dy) / dx) * -SIGN(dy);
} else {
obj1->vy = action->a15.dy * -SIGN(dy);
obj1->vx = abs((action->a15.dx * dx) / dy) * -SIGN(dx);
}
break;
case INIT_OBJ_SEQ: // act16: Set sequence number to use
// Note: Don't set a sequence at time 0 of a new screen, it causes
// problems clearing the boundary bits of the object! t>0 is safe
_vm->_object->_objects[action->a16.objNumb].currImagePtr = _vm->_object->_objects[action->a16.objNumb].seqList[action->a16.seqIndex].seqPtr;
break;
case SET_STATE_BITS: // act17: OR mask with curr obj state
_vm->_object->_objects[action->a17.objNumb].state |= action->a17.stateMask;
break;
case CLEAR_STATE_BITS: // act18: AND ~mask with curr obj state
_vm->_object->_objects[action->a18.objNumb].state &= ~action->a18.stateMask;
break;
case TEST_STATE_BITS: // act19: If all bits set, do apass else afail
if ((_vm->_object->_objects[action->a19.objNumb].state & action->a19.stateMask) == action->a19.stateMask)
insertActionList(action->a19.actPassIndex);
else
insertActionList(action->a19.actFailIndex);
break;
case DEL_EVENTS: // act20: Remove all events of this action type
// Note: actions are not deleted here, simply turned into NOPs!
wrkEvent = _headEvent; // The earliest event
while (wrkEvent) { // While events found in list
saveEvent = wrkEvent->nextEvent;
if (wrkEvent->action->a20.actType == action->a20.actTypeDel)
delQueue(wrkEvent);
wrkEvent = saveEvent;
}
break;
case GAMEOVER: // act21: Game over!
// NOTE: Must wait at least 1 tick before issuing this action if
// any objects are to be made invisible!
gameStatus.gameOverFl = true;
break;
case INIT_HH_COORD: // act22: Initialise an object to hero's actual coords
_vm->_object->_objects[action->a22.objNumb].x = _vm->_hero->x;
_vm->_object->_objects[action->a22.objNumb].y = _vm->_hero->y;
_vm->_object->_objects[action->a22.objNumb].screenIndex = *_vm->_screen_p;// Don't forget screen!
break;
case EXIT: // act23: Exit game back to DOS
_vm->endGame();
break;
case BONUS: // act24: Get bonus score for action
processBonus(action->a24.pointIndex);
break;
case COND_BOX: // act25: Conditional on bounding box
obj1 = &_vm->_object->_objects[action->a25.objNumb];
dx = obj1->x + obj1->currImagePtr->x1;
dy = obj1->y + obj1->currImagePtr->y2;
if ((dx >= action->a25.x1) && (dx <= action->a25.x2) &&
(dy >= action->a25.y1) && (dy <= action->a25.y2))
insertActionList(action->a25.actPassIndex);
else
insertActionList(action->a25.actFailIndex);
break;
// case SOUND: // act26: Play a sound (or tune)
// if (action->a26.soundIndex < _vm->_tunesNbr)
// _vm->_sound->playMusic(action->a26.soundIndex);
// else
// _vm->_sound->playSound(action->a26.soundIndex, BOTH_CHANNELS, MED_PRI);
// break;
case ADD_SCORE: // act27: Add object's value to score
_vm->adjustScore(_vm->_object->_objects[action->a27.objNumb].objValue);
break;
case SUB_SCORE: // act28: Subtract object's value from score
_vm->adjustScore(-_vm->_object->_objects[action->a28.objNumb].objValue);
break;
case COND_CARRY: // act29: Conditional on object being carried
if (_vm->_object->isCarried(action->a29.objNumb))
insertActionList(action->a29.actPassIndex);
else
insertActionList(action->a29.actFailIndex);
break;
case INIT_MAZE: // act30: Enable and init maze structure
_maze.enabledFl = true;
_maze.size = action->a30.mazeSize;
_maze.x1 = action->a30.x1;
_maze.y1 = action->a30.y1;
_maze.x2 = action->a30.x2;
_maze.y2 = action->a30.y2;
_maze.x3 = action->a30.x3;
_maze.x4 = action->a30.x4;
_maze.firstScreenIndex = action->a30.firstScreenIndex;
break;
case EXIT_MAZE: // act31: Disable maze mode
_maze.enabledFl = false;
break;
case INIT_PRIORITY:
_vm->_object->_objects[action->a32.objNumb].priority = action->a32.priority;
break;
case INIT_SCREEN:
_vm->_object->_objects[action->a33.objNumb].screenIndex = action->a33.screenIndex;
break;
case AGSCHEDULE: // act34: Schedule a (global) action list
insertActionList(action->a34.actIndex);
break;
case REMAPPAL: // act35: Remap a palette color
_vm->_screen->remapPal(action->a35.oldColorIndex, action->a35.newColorIndex);
break;
case COND_NOUN: // act36: Conditional on noun mentioned
if (_vm->_parser->isWordPresent(_vm->_arrayNouns[action->a36.nounIndex]))
insertActionList(action->a36.actPassIndex);
else
insertActionList(action->a36.actFailIndex);
break;
case SCREEN_STATE: // act37: Set new screen state
_vm->_screenStates[action->a37.screenIndex] = action->a37.newState;
break;
case INIT_LIPS: // act38: Position lips on object
_vm->_object->_objects[action->a38.lipsObjNumb].x = _vm->_object->_objects[action->a38.objNumb].x + action->a38.dxLips;
_vm->_object->_objects[action->a38.lipsObjNumb].y = _vm->_object->_objects[action->a38.objNumb].y + action->a38.dyLips;
_vm->_object->_objects[action->a38.lipsObjNumb].screenIndex = *_vm->_screen_p; // Don't forget screen!
_vm->_object->_objects[action->a38.lipsObjNumb].cycling = CYCLE_FORWARD;
break;
case OLD_SONG:
//TODO For Hugo 1 and Hugo2 DOS: The songs were not stored in a DAT file, but directly as
//strings. the current play_music should be modified to use a strings instead of reading
//the file, in those cases. This replaces, for those DOS versions, act26.
warning("STUB: doAction(act49)");
break;
default:
Utils::Error(EVNT_ERR, "%s", "doAction");
break;
}
if (action->a0.actType == NEW_SCREEN) { // New_screen() deletes entire list
return 0; // next_p = 0 since list now empty
} else {
wrkEvent = curEvent->nextEvent;
delQueue(curEvent); // Return event to free list
return wrkEvent; // Return next event ptr
}
}
} // End of namespace Hugo
|
