246 lines
6.6 KiB
C++
246 lines
6.6 KiB
C++
|
|
/* 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 M4_WSCRIPT_WS_MACHINE_H
|
|
#define M4_WSCRIPT_WS_MACHINE_H
|
|
|
|
#include "common/algorithm.h"
|
|
#include "m4/m4_types.h"
|
|
#include "m4/gui/gui.h"
|
|
|
|
namespace M4 {
|
|
|
|
#define DEAD_MACHINE_ID 0xdeaddead
|
|
|
|
enum {
|
|
NOSEPICK = 0,
|
|
STARTWALK = 1,
|
|
WALKSEQ = 2,
|
|
ENDWALK = 3,
|
|
DEMAND_FACING = 4,
|
|
DEMAND_LOCATION = 5,
|
|
TERMINATE = 6,
|
|
PLAYER_HIDE = 7,
|
|
PLAYER_UNHIDE = 8,
|
|
TURN_TO_FACE = 9,
|
|
ACTION_11 = 11,
|
|
ACTION_12 = 12,
|
|
ACTION_13 = 13,
|
|
ACTION_14 = 14,
|
|
ACTION_15 = 15,
|
|
ACTION_17 = 17,
|
|
ACTION_18 = 18,
|
|
ACTION_19 = 19,
|
|
ACTION_20 = 20,
|
|
ACTION_21 = 21,
|
|
ACTION_22 = 22,
|
|
ACTION_23 = 23,
|
|
ACTION_24 = 24,
|
|
ACTION_25 = 25,
|
|
ACTION_26 = 26,
|
|
ACTION_27 = 27,
|
|
ACTION_28 = 28,
|
|
ACTION_29 = 29,
|
|
ACTION_30 = 30,
|
|
ACTION_31 = 31,
|
|
ACTION_32 = 32,
|
|
ACTION_33 = 33,
|
|
ACTION_666 = 666,
|
|
ACTION_900 = 900,
|
|
ACTION_902 = 902
|
|
};
|
|
|
|
// A message request
|
|
struct msgRequest {
|
|
msgRequest *nextMsg = nullptr;
|
|
uint32 msgHash = 0;
|
|
frac16 msgValue = 0;
|
|
int32 pcOffset = 0;
|
|
int32 pcCount = 0;
|
|
};
|
|
|
|
struct machine;
|
|
typedef void (*MessageCB)(frac16 myMessage, struct machine *sender);
|
|
|
|
//timebase request structure.
|
|
struct onTimeReq {
|
|
onTimeReq *next = nullptr;
|
|
int32 myTime = 0;
|
|
struct machine *myXM = nullptr;
|
|
int32 pcOffset = 0;
|
|
int32 pcCount = 0;
|
|
};
|
|
|
|
// rails algorithm struct
|
|
struct railNode {
|
|
uint8 nodeID = 0;
|
|
int32 x = 0, y = 0;
|
|
railNode *shortPath = nullptr;
|
|
int32 pathWeight = 0;
|
|
};
|
|
|
|
struct CCB {
|
|
uint32 flags = 0;
|
|
M4sprite *source = nullptr;
|
|
M4Rect *currLocation = nullptr;
|
|
M4Rect *newLocation = nullptr;
|
|
M4Rect *maxArea = nullptr;
|
|
int32 scaleX = 0;
|
|
int32 scaleY = 0;
|
|
int32 layer = 0;
|
|
uint32 *streamSSHeader = nullptr;
|
|
uint32 *streamSpriteSource = nullptr;
|
|
void *myStream = nullptr;
|
|
char *seriesName = nullptr;
|
|
};
|
|
|
|
#define JSR_STACK_MAX 8
|
|
struct Anim8 {
|
|
machine *myMachine = nullptr; // Pointer back to myMachine
|
|
int32 eosReqOffset = 0; // The machine PC offset to be executed at the EOS
|
|
int32 eosReqCount = 0;
|
|
Anim8 *next = nullptr; // The linked list used for execution order
|
|
Anim8 *prev = nullptr;
|
|
int32 myLayer = 0;
|
|
Anim8 *infront = nullptr; // The linked list used for layering
|
|
Anim8 *behind = nullptr;
|
|
Anim8 *myParent = nullptr; // The parent anim8
|
|
int32 sequHash = 0; // The current sequence Hash = 0;
|
|
MemHandle sequHandle = nullptr; // The sequence Handle
|
|
int32 pcOffset = 0; // The offset into the sequence of the current PC
|
|
CCB *myCCB = nullptr;
|
|
int32 dataHash = 0; // The array of data
|
|
MemHandle dataHandle = nullptr;
|
|
int32 dataOffset = 0;
|
|
int32 startTime = 0;
|
|
int32 switchTime = 0;
|
|
frac16 transTime = 0;
|
|
int32 flags = 0;
|
|
frac16 start_s = 0;
|
|
frac16 start_r = 0;
|
|
frac16 start_x = 0;
|
|
frac16 start_y = 0;
|
|
int32 numLocalVars = 0;
|
|
frac16 *myRegs = nullptr;
|
|
bool active = false;
|
|
int32 returnStackIndex = 0;
|
|
uint32 returnHashes[JSR_STACK_MAX] = { 0 };
|
|
int32 returnOffsets[JSR_STACK_MAX] = { 0 };
|
|
|
|
Anim8() {
|
|
Common::fill(returnHashes, returnHashes + JSR_STACK_MAX, 0);
|
|
Common::fill(returnOffsets, returnOffsets + JSR_STACK_MAX, 0);
|
|
}
|
|
};
|
|
|
|
struct machine {
|
|
machine *next = nullptr;
|
|
machine *prev = nullptr;
|
|
uint32 myHash = 0;
|
|
uint32 machID = 0;
|
|
char *machName = nullptr;
|
|
MemHandle machHandle = 0;
|
|
int32 machInstrOffset = 0;
|
|
int32 stateTableOffset = 0;
|
|
int32 curState = 0;
|
|
int32 numOfStates = 0;
|
|
uint32 recurseLevel = 0;
|
|
Anim8 *myAnim8 = nullptr;
|
|
Anim8 *parentAnim8 = nullptr;
|
|
int32 dataHash = 0;
|
|
MemHandle dataHandle = 0;
|
|
int32 dataOffset = 0;
|
|
int32 targetCount = 0;
|
|
struct machine *msgReplyXM = nullptr;
|
|
MessageCB CintrMsg;
|
|
msgRequest *myMsgs = nullptr;
|
|
msgRequest *myPersistentMsgs = nullptr;
|
|
msgRequest *usedPersistentMsgs = nullptr;
|
|
railNode *walkPath = nullptr;
|
|
};
|
|
|
|
struct globalMsgReq {
|
|
globalMsgReq *next = nullptr;
|
|
ulong msgHash = 0;
|
|
frac16 msgValue = 0;
|
|
ulong machHash = 0;
|
|
machine *sendM = nullptr;
|
|
int32 msgCount = 0;
|
|
};
|
|
|
|
struct WSMachine_Globals {
|
|
int32 _pauseTime = 0;
|
|
int32 _oldTime = 0;
|
|
bool _enginesPaused = false;
|
|
|
|
int32 *_dataFormats = nullptr;
|
|
uint32 _machineIDCount = 0;
|
|
machine *_firstMachine = nullptr;
|
|
|
|
machine *_nextXM = nullptr;
|
|
globalMsgReq *_myGlobalMessages = nullptr;
|
|
|
|
// Used for processing pCodes
|
|
frac16 *_ws_globals = nullptr;
|
|
void *_addrExists = nullptr;
|
|
};
|
|
|
|
bool ws_Initialize(frac16 *theGlobals);
|
|
void ws_Shutdown();
|
|
void pauseEngines();
|
|
void unpauseEngines();
|
|
void addPauseTime(int32 myTime);
|
|
|
|
void cycleEngines(Buffer *cleanBackground, int16 *depth_table, Buffer *screenCodes,
|
|
uint8 *myPalette, uint8 *ICT, bool updateVideo);
|
|
void ws_RefreshWoodscriptBuffer(Buffer *cleanBackground, int16 *depth_table,
|
|
Buffer *screenCodes, uint8 *myPalette, uint8 *ICT);
|
|
|
|
void terminateMachine(machine *m);
|
|
void terminateMachinesByHash(uint32 machHash);
|
|
void terminateMachineAndNull(machine *&m);
|
|
bool verifyMachineExists(machine *m);
|
|
int32 ws_KillMachines();
|
|
void ws_KillDeadMachines();
|
|
void ws_StepWhile(machine *m, int32 pcOffset, int32 pcCount);
|
|
void IntoTheState(machine *m);
|
|
machine *TriggerMachineByHash(int32 myHash, Anim8 *parentAnim8, int32 dataHash, int32 dataRow, MessageCB CintrMsg, bool debug, const char *machName);
|
|
machine *TriggerMachineByHash(int32 val1, int32 val2, int32 val3, int32 val4, int32 val5, int32 val6,
|
|
int32 x, int32 y, int32 scale, int32 layer, bool flag,
|
|
MessageCB intrMsg, const char *machName);
|
|
machine *TriggerMachineByHash(MessageCB intrMsg, const char *machName);
|
|
|
|
/**
|
|
* This proc is what allows a machine to send a message to another machine(s)
|
|
*/
|
|
void sendWSMessage(uint32 msgHash, frac16 msgValue, machine *recvM,
|
|
uint32 machHash, machine *sendM, int32 msgCount);
|
|
void sendWSMessage(int32 val1, machine *recv, int32 series1, int32 val3, int32 val4,
|
|
int32 trigger, int32 series2, int32 val6, int32 val7, int32 val8);
|
|
|
|
#define kernel_spawn_machine(name,hash,callback) TriggerMachineByHash(hash, nullptr, -1, -1, callback, false, name)
|
|
#define kernel_terminate_machine(m) terminateMachine(m)
|
|
|
|
} // End of namespace M4
|
|
|
|
#endif
|