From 94f5a989873151d435f144de59bf06146a48a4b6 Mon Sep 17 00:00:00 2001 From: Paul Gilbert Date: Sun, 13 May 2012 23:44:08 +1000 Subject: [PATCH] TONY: Moved remaining globals to Globals class --- engines/tony/globals.cpp | 41 ++++ engines/tony/globals.h | 66 +++++ engines/tony/mpal/expr.cpp | 2 +- engines/tony/mpal/loadmpc.cpp | 124 +++++----- engines/tony/mpal/mpal.cpp | 438 ++++++++++++++-------------------- engines/tony/mpal/mpaldll.h | 44 +--- 6 files changed, 354 insertions(+), 361 deletions(-) diff --git a/engines/tony/globals.cpp b/engines/tony/globals.cpp index 9bc9ea5d7c56..0ce99f88e76c 100644 --- a/engines/tony/globals.cpp +++ b/engines/tony/globals.cpp @@ -20,6 +20,7 @@ * */ +#include "common/algorithm.h" #include "tony/globals.h" namespace Tony { @@ -31,6 +32,8 @@ Globals::Globals() { curChannel = 0; flipflop = 0; curBackText = NULL; + bTonyIsSpeaking = false; + curChangedHotspot = 0; Tony = NULL; Pointer = NULL; Boxes = NULL; @@ -89,6 +92,44 @@ Globals::Globals() { Common::fill(&tappeti[0], &tappeti[200], 0); SFM_nLoc = 0; vdb = NULL; + + // MPAL global variables + mpalError = 0; + lpiifCustom = NULL; + lplpFunctions = NULL; + lplpFunctionStrings = NULL; + nObjs = 0; + nVars = 0; + hVars = NULL; + lpmvVars = NULL; + nMsgs = 0; + hMsgs = NULL; + lpmmMsgs = NULL; + nDialogs = 0; + hDialogs = NULL; + lpmdDialogs = NULL; + nItems = 0; + hItems = NULL; + lpmiItems = NULL; + nLocations = 0; + hLocations = NULL; + lpmlLocations = NULL; + nScripts = 0; + hScripts = NULL; + lpmsScripts = NULL; + nResources = 0; + lpResources = NULL; + bExecutingAction = false; + bExecutingDialog = false; + Common::fill(&nPollingLocations[0], &nPollingLocations[MAXPOLLINGLOCATIONS], 0); + Common::fill(&hEndPollingLocations[0], &hEndPollingLocations[MAXPOLLINGLOCATIONS], 0); + Common::fill(&PollingThreads[0], &PollingThreads[MAXPOLLINGLOCATIONS], 0); + hAskChoice = 0; + hDoneChoice = 0; + nExecutingAction = 0; + nExecutingDialog = 0; + nExecutingChoice = 0; + nSelectedChoice = 0; } } // End of namespace Tony diff --git a/engines/tony/globals.h b/engines/tony/globals.h index 7f6f8ed8800b..1a11a871d0b9 100644 --- a/engines/tony/globals.h +++ b/engines/tony/globals.h @@ -29,6 +29,8 @@ #include "tony/inventory.h" #include "tony/loc.h" #include "tony/tonychar.h" +#include "tony/mpal/mpal.h" +#include "tony/mpal/mpaldll.h" namespace Tony { @@ -140,6 +142,28 @@ struct ChangedHotspotStruct { } }; +/****************************************************************************\ +* typedef CFCALL +* -------------- +* Description: Descrizione di una chiamata a una custom function +\****************************************************************************/ + +typedef struct { + int nCf; + + int arg1, arg2, arg3, arg4; +} CFCALL; +typedef CFCALL* LPCFCALL; +typedef LPCFCALL* LPLPCFCALL; + + +/****************************************************************************\ +* Global variables +\****************************************************************************/ + +/** + * Globals class + */ class Globals { public: Globals(); @@ -225,6 +249,48 @@ class Globals { int tappeti[200]; RMPoint SFM_pt; int SFM_nLoc; + + /** + * @defgroup MPAL variables + * + */ + uint32 mpalError; + LPITEMIRQFUNCTION lpiifCustom; + LPLPCUSTOMFUNCTION lplpFunctions; + Common::String * lplpFunctionStrings; + uint16 nObjs; + uint16 nVars; + HGLOBAL hVars; + LPMPALVAR lpmvVars; + uint16 nMsgs; + HGLOBAL hMsgs; + LPMPALMSG lpmmMsgs; + uint16 nDialogs; + HGLOBAL hDialogs; + LPMPALDIALOG lpmdDialogs; + uint16 nItems; + HGLOBAL hItems; + LPMPALITEM lpmiItems; + uint16 nLocations; + HGLOBAL hLocations; + LPMPALLOCATION lpmlLocations; + uint16 nScripts; + HGLOBAL hScripts; + LPMPALSCRIPT lpmsScripts; + Common::File hMpr; + uint16 nResources; + uint32 * lpResources; + bool bExecutingAction; + bool bExecutingDialog; + uint32 nPollingLocations[MAXPOLLINGLOCATIONS]; + uint32 hEndPollingLocations[MAXPOLLINGLOCATIONS]; + uint32 PollingThreads[MAXPOLLINGLOCATIONS]; + uint32 hAskChoice; + uint32 hDoneChoice; + uint32 nExecutingAction; + uint32 nExecutingDialog; + uint32 nExecutingChoice; + uint32 nSelectedChoice; }; } // End of namespace Tony diff --git a/engines/tony/mpal/expr.cpp b/engines/tony/mpal/expr.cpp index 0ca02d29318e..19170ce60ce6 100644 --- a/engines/tony/mpal/expr.cpp +++ b/engines/tony/mpal/expr.cpp @@ -209,7 +209,7 @@ static int Compute(int a, int b, byte symbol) { case OP_OR: return a||b; default: - mpalError=1; + GLOBALS.mpalError = 1; break; } diff --git a/engines/tony/mpal/loadmpc.cpp b/engines/tony/mpal/loadmpc.cpp index 9d6ef19e5529..937374517f01 100644 --- a/engines/tony/mpal/loadmpc.cpp +++ b/engines/tony/mpal/loadmpc.cpp @@ -517,58 +517,58 @@ bool ParseMpc(const byte *lpBuf) { return false; lpBuf += 4; - nVars = READ_LE_UINT16(lpBuf); + GLOBALS.nVars = READ_LE_UINT16(lpBuf); lpBuf += 2; - hVars = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(MPALVAR) * (uint32)nVars); - if (hVars == NULL) + GLOBALS.hVars = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(MPALVAR) * (uint32)GLOBALS.nVars); + if (GLOBALS.hVars == NULL) return false; - lpmvVars = (LPMPALVAR)GlobalLock(hVars); + GLOBALS.lpmvVars = (LPMPALVAR)GlobalLock(GLOBALS.hVars); - for (i = 0; i < nVars; i++) { + for (i = 0; i < GLOBALS.nVars; i++) { wLen = *(const byte *)lpBuf; lpBuf++; - CopyMemory(lpmvVars->lpszVarName, lpBuf, MIN(wLen, (uint16)32)); + CopyMemory(GLOBALS.lpmvVars->lpszVarName, lpBuf, MIN(wLen, (uint16)32)); lpBuf += wLen; - lpmvVars->dwVal = READ_LE_UINT32(lpBuf); + GLOBALS.lpmvVars->dwVal = READ_LE_UINT32(lpBuf); lpBuf += 4; lpBuf++; // Salta 'ext' - lpmvVars++; + GLOBALS.lpmvVars++; } - GlobalUnlock(hVars); + GlobalUnlock(GLOBALS.hVars); /* 2. Messaggi */ if (lpBuf[0] != 'M' || lpBuf[1] != 'S' || lpBuf[2] != 'G' || lpBuf[3] != 'S') return false; lpBuf += 4; - nMsgs = READ_LE_UINT16(lpBuf); + GLOBALS.nMsgs = READ_LE_UINT16(lpBuf); lpBuf += 2; #ifdef NEED_LOCK_MSGS - hMsgs = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(MPALMSG) * (uint32)nMsgs); - if (hMsgs == NULL) + GLOBALS.hMsgs = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(MPALMSG) * (uint32)GLOBALS.nMsgs); + if (GLOBALS.hMsgs == NULL) return false; - lpmmMsgs = (LPMPALMSG)GlobalLock(hMsgs); + GLOBALS.lpmmMsgs = (LPMPALMSG)GlobalLock(GLOBALS.hMsgs); #else - lpmmMsgs=(LPMPALMSG)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,sizeof(MPALMSG)*(uint32)nMsgs); - if (lpmmMsgs==NULL) + GLOBALS.lpmmMsgs=(LPMPALMSG)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,sizeof(MPALMSG)*(uint32)GLOBALS.nMsgs); + if (GLOBALS.lpmmMsgs==NULL) return false; #endif - for (i = 0; i < nMsgs; i++) { - lpmmMsgs->wNum = READ_LE_UINT16(lpBuf); + for (i = 0; i < GLOBALS.nMsgs; i++) { + GLOBALS.lpmmMsgs->wNum = READ_LE_UINT16(lpBuf); lpBuf += 2; for (j = 0; lpBuf[j] != 0;) j += lpBuf[j] + 1; - lpmmMsgs->hText = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, j + 1); - lpTemp2 = lpTemp = (byte *)GlobalLock(lpmmMsgs->hText); + GLOBALS.lpmmMsgs->hText = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, j + 1); + lpTemp2 = lpTemp = (byte *)GlobalLock(GLOBALS.lpmmMsgs->hText); for (j = 0; lpBuf[j] != 0;) { CopyMemory(lpTemp, &lpBuf[j + 1], lpBuf[j]); @@ -580,12 +580,12 @@ bool ParseMpc(const byte *lpBuf) { lpBuf += j + 1; *lpTemp = '\0'; - GlobalUnlock(lpmmMsgs->hText); - lpmmMsgs++; + GlobalUnlock(GLOBALS.lpmmMsgs->hText); + GLOBALS.lpmmMsgs++; } #ifdef NEED_LOCK_MSGS - GlobalUnlock(hMsgs); + GlobalUnlock(GLOBALS.hMsgs); #endif /* 3. Oggetti */ @@ -593,96 +593,96 @@ bool ParseMpc(const byte *lpBuf) { return false; lpBuf += 4; - nObjs = READ_LE_UINT16(lpBuf); + GLOBALS.nObjs = READ_LE_UINT16(lpBuf); lpBuf += 2; // Controlla i dialoghi - nDialogs = 0; - hDialogs = lpmdDialogs = NULL; + GLOBALS.nDialogs = 0; + GLOBALS.hDialogs = GLOBALS.lpmdDialogs = NULL; if (*((const byte *)lpBuf + 2) == 6 && strncmp((const char *)lpBuf + 3, "Dialog", 6) == 0) { - nDialogs = READ_LE_UINT16(lpBuf); lpBuf += 2; + GLOBALS.nDialogs = READ_LE_UINT16(lpBuf); lpBuf += 2; - hDialogs = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)nDialogs * sizeof(MPALDIALOG)); - if (hDialogs == NULL) + GLOBALS.hDialogs = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS.nDialogs * sizeof(MPALDIALOG)); + if (GLOBALS.hDialogs == NULL) return false; - lpmdDialogs = (LPMPALDIALOG)GlobalLock(hDialogs); + GLOBALS.lpmdDialogs = (LPMPALDIALOG)GlobalLock(GLOBALS.hDialogs); - for (i = 0;i < nDialogs; i++) - if ((lpBuf = ParseDialog(lpBuf + 7, &lpmdDialogs[i])) == NULL) + for (i = 0;i < GLOBALS.nDialogs; i++) + if ((lpBuf = ParseDialog(lpBuf + 7, &GLOBALS.lpmdDialogs[i])) == NULL) return false; - GlobalUnlock(hDialogs); + GlobalUnlock(GLOBALS.hDialogs); } // Controlla gli item - nItems = 0; - hItems = lpmiItems = NULL; + GLOBALS.nItems = 0; + GLOBALS.hItems = GLOBALS.lpmiItems = NULL; if (*(lpBuf + 2) == 4 && strncmp((const char *)lpBuf + 3, "Item", 4)==0) { - nItems = READ_LE_UINT16(lpBuf); lpBuf += 2; + GLOBALS.nItems = READ_LE_UINT16(lpBuf); lpBuf += 2; // Alloca la memoria e li legge - hItems=GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)nItems * sizeof(MPALITEM)); - if (hItems == NULL) + GLOBALS.hItems = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS.nItems * sizeof(MPALITEM)); + if (GLOBALS.hItems == NULL) return false; - lpmiItems=(LPMPALITEM)GlobalLock(hItems); + GLOBALS.lpmiItems=(LPMPALITEM)GlobalLock(GLOBALS.hItems); - for (i = 0; i < nItems; i++) - if ((lpBuf = ParseItem(lpBuf + 5, &lpmiItems[i])) == NULL) + for (i = 0; i < GLOBALS.nItems; i++) + if ((lpBuf = ParseItem(lpBuf + 5, &GLOBALS.lpmiItems[i])) == NULL) return false; - GlobalUnlock(hItems); + GlobalUnlock(GLOBALS.hItems); } // Controlla le locazioni - nLocations = 0; - hLocations = lpmlLocations = NULL; + GLOBALS.nLocations = 0; + GLOBALS.hLocations = GLOBALS.lpmlLocations = NULL; if (*(lpBuf + 2) == 8 && strncmp((const char *)lpBuf + 3, "Location", 8)==0) { - nLocations = READ_LE_UINT16(lpBuf); lpBuf += 2; + GLOBALS.nLocations = READ_LE_UINT16(lpBuf); lpBuf += 2; // Alloca la memoria e li legge - hLocations=GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)nLocations*sizeof(MPALLOCATION)); - if (hLocations == NULL) + GLOBALS.hLocations=GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS.nLocations*sizeof(MPALLOCATION)); + if (GLOBALS.hLocations == NULL) return false; - lpmlLocations = (LPMPALLOCATION)GlobalLock(hLocations); + GLOBALS.lpmlLocations = (LPMPALLOCATION)GlobalLock(GLOBALS.hLocations); - for (i = 0; i < nLocations; i++) - if ((lpBuf = ParseLocation(lpBuf + 9, &lpmlLocations[i])) == NULL) + for (i = 0; i < GLOBALS.nLocations; i++) + if ((lpBuf = ParseLocation(lpBuf + 9, &GLOBALS.lpmlLocations[i])) == NULL) return false; - GlobalUnlock(hLocations); + GlobalUnlock(GLOBALS.hLocations); } // Controlla gli script - nScripts = 0; - hScripts = lpmsScripts = NULL; + GLOBALS.nScripts = 0; + GLOBALS.hScripts = GLOBALS.lpmsScripts = NULL; if (*(lpBuf + 2) == 6 && strncmp((const char *)lpBuf + 3, "Script", 6) == 0) { - nScripts = READ_LE_UINT16(lpBuf); lpBuf += 2; + GLOBALS.nScripts = READ_LE_UINT16(lpBuf); lpBuf += 2; // Alloca la memoria - hScripts = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)nScripts * sizeof(MPALSCRIPT)); - if (hScripts == NULL) + GLOBALS.hScripts = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (uint32)GLOBALS.nScripts * sizeof(MPALSCRIPT)); + if (GLOBALS.hScripts == NULL) return false; - lpmsScripts = (LPMPALSCRIPT)GlobalLock(hScripts); + GLOBALS.lpmsScripts = (LPMPALSCRIPT)GlobalLock(GLOBALS.hScripts); - for (i = 0; i < nScripts; i++) { - if ((lpBuf = ParseScript(lpBuf + 7, &lpmsScripts[i])) == NULL) + for (i = 0; i < GLOBALS.nScripts; i++) { + if ((lpBuf = ParseScript(lpBuf + 7, &GLOBALS.lpmsScripts[i])) == NULL) return false; // Ordina i vari moments dello script //qsort( - //lpmsScripts[i].Moment, - //lpmsScripts[i].nMoments, - //sizeof(lpmsScripts[i].Moment[0]), + //GLOBALS.lpmsScripts[i].Moment, + //GLOBALS.lpmsScripts[i].nMoments, + //sizeof(GLOBALS.lpmsScripts[i].Moment[0]), //(int (*)(const void *, const void *))CompareMoments //); } - GlobalUnlock(hScripts); + GlobalUnlock(GLOBALS.hScripts); } if (lpBuf[0] != 'E' || lpBuf[1] != 'N' || lpBuf[2] != 'D' || lpBuf[3] != '0') diff --git a/engines/tony/mpal/mpal.cpp b/engines/tony/mpal/mpal.cpp index bfde7fe2a655..66d467f301aa 100644 --- a/engines/tony/mpal/mpal.cpp +++ b/engines/tony/mpal/mpal.cpp @@ -72,84 +72,6 @@ const char *mpalCopyright = "\n" "\n"; -/****************************************************************************\ -* Structures -\****************************************************************************/ - -/****************************************************************************\ -* typedef CFCALL -* -------------- -* Description: Descrizione di una chiamata a una custom function -\****************************************************************************/ - -typedef struct { - int nCf; - - int arg1, arg2, arg3, arg4; -} CFCALL; -typedef CFCALL* LPCFCALL; -typedef LPCFCALL* LPLPCFCALL; - - -/****************************************************************************\ -* Global variables -\****************************************************************************/ - -uint32 mpalError; - -static byte * lpMpcImage; - -LPITEMIRQFUNCTION lpiifCustom=NULL; - -LPLPCUSTOMFUNCTION lplpFunctions = NULL; -Common::String * lplpFunctionStrings = NULL; -uint16 nObjs; - -uint16 nVars; -HGLOBAL hVars; -LPMPALVAR lpmvVars; - -uint16 nMsgs; -HGLOBAL hMsgs; -LPMPALMSG lpmmMsgs; - -uint16 nDialogs; -HGLOBAL hDialogs; -LPMPALDIALOG lpmdDialogs; - -uint16 nItems; -HGLOBAL hItems; -LPMPALITEM lpmiItems; - -uint16 nLocations; -HGLOBAL hLocations; -LPMPALLOCATION lpmlLocations; - -uint16 nScripts; -HGLOBAL hScripts; -LPMPALSCRIPT lpmsScripts; - -Common::File hMpr; -uint16 nResources; -uint32 * lpResources; - -bool bExecutingAction; -bool bExecutingDialog; - -uint32 nPollingLocations[MAXPOLLINGLOCATIONS]; -uint32 hEndPollingLocations[MAXPOLLINGLOCATIONS]; -uint32 PollingThreads[MAXPOLLINGLOCATIONS]; - -uint32 hAskChoice; -uint32 hDoneChoice; - -uint32 nExecutingAction; - -uint32 nExecutingDialog; -uint32 nExecutingChoice; -uint32 nSelectedChoice; - - /****************************************************************************\ * Internal functions \****************************************************************************/ @@ -163,7 +85,7 @@ uint32 nSelectedChoice; \****************************************************************************/ void LockVar(void) { - lpmvVars=(LPMPALVAR)GlobalLock(hVars); + GLOBALS.lpmvVars = (LPMPALVAR)GlobalLock(GLOBALS.hVars); } /****************************************************************************\ @@ -175,7 +97,7 @@ void LockVar(void) { \****************************************************************************/ void UnlockVar(void) { - GlobalUnlock(hVars); + GlobalUnlock(GLOBALS.hVars); } @@ -189,7 +111,7 @@ void UnlockVar(void) { static void LockMsg(void) { #ifdef NEED_LOCK_MSGS - lpmmMsgs=(LPMPALMSG)GlobalLock(hMsgs); + GLOBALS.lpmmMsgs = (LPMPALMSG)GlobalLock(GLOBALS.hMsgs); #endif } @@ -204,7 +126,7 @@ static void LockMsg(void) { static void UnlockMsg(void) { #ifdef NEED_LOCK_MSGS - GlobalUnlock(hMsgs); + GlobalUnlock(GLOBALS.hMsgs); #endif } @@ -218,7 +140,7 @@ static void UnlockMsg(void) { \****************************************************************************/ static void LockDialogs(void) { - lpmdDialogs=(LPMPALDIALOG)GlobalLock(hDialogs); + GLOBALS.lpmdDialogs = (LPMPALDIALOG)GlobalLock(GLOBALS.hDialogs); } @@ -231,7 +153,7 @@ static void LockDialogs(void) { \****************************************************************************/ static void UnlockDialogs(void) { - GlobalUnlock(hDialogs); + GlobalUnlock(GLOBALS.hDialogs); } @@ -244,7 +166,7 @@ static void UnlockDialogs(void) { \****************************************************************************/ static void LockLocations(void) { - lpmlLocations=(LPMPALLOCATION)GlobalLock(hLocations); + GLOBALS.lpmlLocations = (LPMPALLOCATION)GlobalLock(GLOBALS.hLocations); } @@ -257,7 +179,7 @@ static void LockLocations(void) { \****************************************************************************/ static void UnlockLocations(void) { - GlobalUnlock(hLocations); + GlobalUnlock(GLOBALS.hLocations); } @@ -270,7 +192,7 @@ static void UnlockLocations(void) { \****************************************************************************/ static void LockItems(void) { - lpmiItems=(LPMPALITEM)GlobalLock(hItems); + GLOBALS.lpmiItems = (LPMPALITEM)GlobalLock(GLOBALS.hItems); } @@ -283,7 +205,7 @@ static void LockItems(void) { \****************************************************************************/ static void UnlockItems(void) { - GlobalUnlock(hItems); + GlobalUnlock(GLOBALS.hItems); } /****************************************************************************\ @@ -295,7 +217,7 @@ static void UnlockItems(void) { \****************************************************************************/ static void LockScripts(void) { - lpmsScripts=(LPMPALSCRIPT)GlobalLock(hScripts); + GLOBALS.lpmsScripts = (LPMPALSCRIPT)GlobalLock(GLOBALS.hScripts); } @@ -308,7 +230,7 @@ static void LockScripts(void) { \****************************************************************************/ static void UnlockScripts(void) { - GlobalUnlock(hScripts); + GlobalUnlock(GLOBALS.hScripts); } @@ -330,13 +252,13 @@ static void UnlockScripts(void) { int32 varGetValue(const char *lpszVarName) { int i; - LPMPALVAR v=lpmvVars; + LPMPALVAR v=GLOBALS.lpmvVars; - for (i = 0; i < nVars; v++, i++) + for (i = 0; i < GLOBALS.nVars; v++, i++) if (strcmp(lpszVarName, v->lpszVarName) == 0) return v->dwVal; - mpalError = 1; + GLOBALS.mpalError = 1; return 0; } @@ -354,24 +276,24 @@ int32 varGetValue(const char *lpszVarName) { void varSetValue(const char *lpszVarName, int32 val) { uint i; - LPMPALVAR v = lpmvVars; + LPMPALVAR v = GLOBALS.lpmvVars; - for (i = 0; i < nVars; v++, i++) + for (i = 0; i < GLOBALS.nVars; v++, i++) if (strcmp(lpszVarName, v->lpszVarName) == 0) { v->dwVal = val; - if (lpiifCustom != NULL && strncmp(v->lpszVarName, "Pattern.", 8) == 0) { + if (GLOBALS.lpiifCustom != NULL && strncmp(v->lpszVarName, "Pattern.", 8) == 0) { i = 0; sscanf(v->lpszVarName, "Pattern.%u", &i); - lpiifCustom(i, val, -1); - } else if (lpiifCustom != NULL && strncmp(v->lpszVarName, "Status.", 7) == 0) { + GLOBALS.lpiifCustom(i, val, -1); + } else if (GLOBALS.lpiifCustom != NULL && strncmp(v->lpszVarName, "Status.", 7) == 0) { i = 0; sscanf(v->lpszVarName,"Status.%u", &i); - lpiifCustom(i, -1, val); + GLOBALS.lpiifCustom(i, -1, val); } return; } - mpalError = 1; + GLOBALS.mpalError = 1; return; } @@ -394,9 +316,9 @@ void varSetValue(const char *lpszVarName, int32 val) { static int locGetOrderFromNum(uint32 nLoc) { int i; - LPMPALLOCATION loc = lpmlLocations; + LPMPALLOCATION loc = GLOBALS.lpmlLocations; - for (i = 0; i < nLocations; i++,loc++) + for (i = 0; i < GLOBALS.nLocations; i++, loc++) if (loc->nObj == nLoc) return i; @@ -421,9 +343,9 @@ static int locGetOrderFromNum(uint32 nLoc) { static int msgGetOrderFromNum(uint32 nMsg) { int i; - LPMPALMSG msg = lpmmMsgs; + LPMPALMSG msg = GLOBALS.lpmmMsgs; - for (i = 0; i < nMsgs; i++, msg++) + for (i = 0; i < GLOBALS.nMsgs; i++, msg++) if (msg->wNum == nMsg) return i; @@ -449,9 +371,9 @@ static int msgGetOrderFromNum(uint32 nMsg) { static int itemGetOrderFromNum(uint32 nItem) { int i; - LPMPALITEM item=lpmiItems; + LPMPALITEM item = GLOBALS.lpmiItems; - for (i = 0; i < nItems; i++, item++) + for (i = 0; i < GLOBALS.nItems; i++, item++) if (item->nObj == nItem) return i; @@ -477,9 +399,9 @@ static int itemGetOrderFromNum(uint32 nItem) { static int scriptGetOrderFromNum(uint32 nScript) { int i; - LPMPALSCRIPT script = lpmsScripts; + LPMPALSCRIPT script = GLOBALS.lpmsScripts; - for (i = 0; i < nScripts; i++,script++) + for (i = 0; i < GLOBALS.nScripts; i++, script++) if (script->nObj == nScript) return i; @@ -505,9 +427,9 @@ static int scriptGetOrderFromNum(uint32 nScript) { static int dialogGetOrderFromNum(uint32 nDialog) { int i; - LPMPALDIALOG dialog=lpmdDialogs; + LPMPALDIALOG dialog = GLOBALS.lpmdDialogs; - for (i = 0; i < nDialogs; i++, dialog++) + for (i = 0; i < GLOBALS.nDialogs; i++, dialog++) if (dialog->nObj == nDialog) return i; @@ -538,7 +460,7 @@ static char *DuplicateMessage(uint32 nMsgOrd) { if (nMsgOrd == (uint32)-1) return NULL; - origmsg = (const char *)GlobalLock(lpmmMsgs[nMsgOrd].hText); + origmsg = (const char *)GlobalLock(GLOBALS.lpmmMsgs[nMsgOrd].hText); j = 0; while (origmsg[j] != '\0' || origmsg[j + 1] != '\0') @@ -550,7 +472,7 @@ static char *DuplicateMessage(uint32 nMsgOrd) { return NULL; CopyMemory(clonemsg, origmsg, j); - GlobalUnlock(lpmmMsgs[nMsgOrd].hText); + GlobalUnlock(GLOBALS.lpmmMsgs[nMsgOrd].hText); return clonemsg; } @@ -575,7 +497,7 @@ static char *DuplicateMessage(uint32 nMsgOrd) { static char *DuplicateDialogPeriod(uint32 nPeriod) { const char *origmsg; char *clonemsg; - LPMPALDIALOG dialog=lpmdDialogs+nExecutingDialog; + LPMPALDIALOG dialog = GLOBALS.lpmdDialogs + GLOBALS.nExecutingDialog; int i,j; for (j = 0; dialog->Periods[j] != NULL; j++) @@ -623,28 +545,28 @@ HGLOBAL resLoad(uint32 dwId) { uint32 nSizeComp, nSizeDecomp; byte *temp, *buf; - for (i = 0; i < nResources; i++) - if (lpResources[i * 2] == dwId) { - hMpr.seek(lpResources[i * 2 + 1]); - nBytesRead = hMpr.read(head, 4); + for (i = 0; i < GLOBALS.nResources; i++) + if (GLOBALS.lpResources[i * 2] == dwId) { + GLOBALS.hMpr.seek(GLOBALS.lpResources[i * 2 + 1]); + nBytesRead = GLOBALS.hMpr.read(head, 4); if (nBytesRead != 4) return NULL; if (head[0] != 'R' || head[1] != 'E' || head[2] != 'S' || head[3] != 'D') return NULL; - nSizeDecomp = hMpr.readUint32LE(); - if (hMpr.err()) + nSizeDecomp = GLOBALS.hMpr.readUint32LE(); + if (GLOBALS.hMpr.err()) return NULL; - nSizeComp = hMpr.readUint32LE(); - if (hMpr.err()) + nSizeComp = GLOBALS.hMpr.readUint32LE(); + if (GLOBALS.hMpr.err()) return NULL; h = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, nSizeDecomp + (nSizeDecomp / 1024) * 16); buf = (byte *)GlobalLock(h); temp = (byte *)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT,nSizeComp); - nBytesRead = hMpr.read(temp, nSizeComp); + nBytesRead = GLOBALS.hMpr.read(temp, nSizeComp); if (nBytesRead != nSizeComp) return NULL; @@ -663,7 +585,7 @@ HGLOBAL resLoad(uint32 dwId) { static uint32 *GetSelectList(uint32 i) { uint32 *sl; int j,k,num; - LPMPALDIALOG dialog=lpmdDialogs+nExecutingDialog; + LPMPALDIALOG dialog=GLOBALS.lpmdDialogs+GLOBALS.nExecutingDialog; /* Conta quanti select attivi ci sono */ num = 0; @@ -692,10 +614,10 @@ static uint32 *GetSelectList(uint32 i) { static uint32 *GetItemList(uint32 nLoc) { uint32 *il; uint32 num,i,j; - LPMPALVAR v = lpmvVars; + LPMPALVAR v = GLOBALS.lpmvVars; num = 0; - for (i = 0; i < nVars; i++,v++) { + for (i = 0; i < GLOBALS.nVars; i++,v++) { if (strncmp(v->lpszVarName,"Location",8) == 0 && v->dwVal == nLoc) num++; } @@ -704,9 +626,9 @@ static uint32 *GetItemList(uint32 nLoc) { if (il == NULL) return NULL; - v = lpmvVars; + v = GLOBALS.lpmvVars; j = 0; - for (i = 0; i < nVars; i++,v++) { + for (i = 0; i < GLOBALS.nVars; i++,v++) { if (strncmp(v->lpszVarName,"Location",8) == 0 && v->dwVal == nLoc) { sscanf(v->lpszVarName, "Location.%u", &il[j]); j++; @@ -718,7 +640,7 @@ static uint32 *GetItemList(uint32 nLoc) { } static LPITEM GetItemData(uint32 nOrdItem) { - LPMPALITEM curitem = lpmiItems+nOrdItem; + LPMPALITEM curitem = GLOBALS.lpmiItems+nOrdItem; LPITEM ret; HGLOBAL hDat; char *dat; @@ -838,7 +760,7 @@ void CustomThread(CORO_PARAM, const void *param) { _ctx->p = *(LPCFCALL *)param; - CORO_INVOKE_4(lplpFunctions[_ctx->p->nCf], _ctx->p->arg1, _ctx->p->arg2, _ctx->p->arg3, _ctx->p->arg4); + CORO_INVOKE_4(GLOBALS.lplpFunctions[_ctx->p->nCf], _ctx->p->arg1, _ctx->p->arg2, _ctx->p->arg3, _ctx->p->arg4); GlobalFree(_ctx->p); @@ -899,7 +821,7 @@ void ScriptThread(CORO_PARAM, const void *param) { if (s->Command[_ctx->k].type == 1) { _ctx->p=(LPCFCALL)GlobalAlloc(GMEM_FIXED, sizeof(CFCALL)); if (_ctx->p == NULL) { - mpalError = 1; + GLOBALS.mpalError = 1; CORO_KILL_SELF(); return; @@ -913,7 +835,7 @@ void ScriptThread(CORO_PARAM, const void *param) { // !!! Nuova gestione dei thread if ((cfHandles[_ctx->numHandles++] = CoroScheduler.createProcess(CustomThread, &_ctx->p, sizeof(LPCFCALL))) == 0) { - mpalError = 1; + GLOBALS.mpalError = 1; CORO_KILL_SELF(); return; @@ -927,7 +849,7 @@ void ScriptThread(CORO_PARAM, const void *param) { UnlockVar(); } else { - mpalError = 1; + GLOBALS.mpalError = 1; GlobalFree(s); CORO_KILL_SELF(); @@ -968,19 +890,19 @@ void ActionThread(CORO_PARAM, const void *param) { CORO_BEGIN_CODE(_ctx); - mpalError = 0; + GLOBALS.mpalError = 0; for (_ctx->j = 0; _ctx->j < item->Action[item->dwRes].nCmds; _ctx->j++) { _ctx->k = item->Action[item->dwRes].CmdNum[_ctx->j]; if (item->Command[_ctx->k].type == 1) { // Custom function debugC(DEBUG_DETAILED, kTonyDebugActions, "Action Process %d Call=%s params=%d,%d,%d,%d", - CoroScheduler.getCurrentPID(), lplpFunctionStrings[item->Command[_ctx->k].nCf].c_str(), + CoroScheduler.getCurrentPID(), GLOBALS.lplpFunctionStrings[item->Command[_ctx->k].nCf].c_str(), item->Command[_ctx->k].arg1, item->Command[_ctx->k].arg2, item->Command[_ctx->k].arg3, item->Command[_ctx->k].arg4 ); - CORO_INVOKE_4(lplpFunctions[item->Command[_ctx->k].nCf], + CORO_INVOKE_4(GLOBALS.lplpFunctions[item->Command[_ctx->k].nCf], item->Command[_ctx->k].arg1, item->Command[_ctx->k].arg2, item->Command[_ctx->k].arg3, @@ -997,7 +919,7 @@ void ActionThread(CORO_PARAM, const void *param) { UnlockVar(); } else { - mpalError = 1; + GLOBALS.mpalError = 1; break; } } @@ -1027,7 +949,7 @@ void ShutUpActionThread(CORO_PARAM, const void *param) { CORO_INVOKE_2(CoroScheduler.waitForSingleObject, pid, CORO_INFINITE); - bExecutingAction = false; + GLOBALS.bExecutingAction = false; CORO_KILL_SELF(); @@ -1088,7 +1010,7 @@ void LocationPollThread(CORO_PARAM, const void *param) { /* Tanto per cominciare, e' necessario richiedere la lista degli item presenti nella locazione. */ - _ctx->il = mpalQueryItemList(nPollingLocations[id]); + _ctx->il = mpalQueryItemList(GLOBALS.nPollingLocations[id]); /* Contiamo gli items */ for (_ctx->numitems = 0; _ctx->il[_ctx->numitems] != 0; _ctx->numitems++) @@ -1104,7 +1026,7 @@ void LocationPollThread(CORO_PARAM, const void *param) { if (_ctx->ord == -1) continue; - _ctx->curItem = lpmiItems + _ctx->ord; + _ctx->curItem = GLOBALS.lpmiItems + _ctx->ord; _ctx->k = 0; for (_ctx->j = 0; _ctx->j < _ctx->curItem->nActions; _ctx->j++) @@ -1157,7 +1079,7 @@ void LocationPollThread(CORO_PARAM, const void *param) { if (_ctx->il[_ctx->i] == 0) continue; - _ctx->curItem = lpmiItems + itemGetOrderFromNum(_ctx->il[_ctx->i]); + _ctx->curItem = GLOBALS.lpmiItems + itemGetOrderFromNum(_ctx->il[_ctx->i]); for (_ctx->j = 0; _ctx->j < _ctx->curItem->nActions; _ctx->j++) if (_ctx->curItem->Action[_ctx->j].num == 0xFF) { @@ -1199,7 +1121,7 @@ void LocationPollThread(CORO_PARAM, const void *param) { /* Ci addormentiamo, ma controllando sempre l'evento che viene settato quando viene richiesta la nostra chiusura */ - CORO_INVOKE_3(CoroScheduler.waitForSingleObject, hEndPollingLocations[id], _ctx->dwSleepTime, &_ctx->expired); + CORO_INVOKE_3(CoroScheduler.waitForSingleObject, GLOBALS.hEndPollingLocations[id], _ctx->dwSleepTime, &_ctx->expired); //if (_ctx->k == WAIT_OBJECT_0) if (!_ctx->expired) @@ -1226,7 +1148,7 @@ void LocationPollThread(CORO_PARAM, const void *param) { byte randomVal = (byte)_vm->_randomSource.getRandomNumber(99); if (randomVal < _ctx->MyActions[_ctx->k].perc) { /* Controlliamo se c'e' una action in esecuzione sull'item */ - if ((bExecutingAction) && (nExecutingAction == _ctx->MyActions[_ctx->k].nItem)) + if ((GLOBALS.bExecutingAction) && (GLOBALS.nExecutingAction == _ctx->MyActions[_ctx->k].nItem)) continue; /* Controlliamo se c'e' gia' un'altra idle function in esecuzione @@ -1240,7 +1162,7 @@ void LocationPollThread(CORO_PARAM, const void *param) { /* Ok, siamo gli unici :) */ LockItems(); - _ctx->curItem=lpmiItems+itemGetOrderFromNum(_ctx->MyActions[_ctx->k].nItem); + _ctx->curItem=GLOBALS.lpmiItems+itemGetOrderFromNum(_ctx->MyActions[_ctx->k].nItem); /* Controlliamo se c'e' un esperessione WhenExecute */ _ctx->j=_ctx->MyActions[_ctx->k].nAction; @@ -1308,7 +1230,7 @@ void LocationPollThread(CORO_PARAM, const void *param) { // Set idle skip on // FIXME: Convert to co-routine - CORO_INVOKE_4(lplpFunctions[200], 0, 0, 0, 0); + CORO_INVOKE_4(GLOBALS.lplpFunctions[200], 0, 0, 0, 0); for (_ctx->i = 0; _ctx->i < _ctx->nRealItems; _ctx->i++) if (_ctx->MyThreads[_ctx->i].nItem != 0) { @@ -1323,7 +1245,7 @@ void LocationPollThread(CORO_PARAM, const void *param) { } // Set idle skip off - CORO_INVOKE_4(lplpFunctions[201], 0, 0, 0, 0); + CORO_INVOKE_4(GLOBALS.lplpFunctions[201], 0, 0, 0, 0); /* Abbiamo finito */ GlobalFree(_ctx->MyThreads); @@ -1362,11 +1284,11 @@ void ShutUpDialogThread(CORO_PARAM, const void *param) { CORO_INVOKE_2(CoroScheduler.waitForSingleObject, pid, CORO_INFINITE); - bExecutingDialog = false; - nExecutingDialog = 0; - nExecutingChoice = 0; + GLOBALS.bExecutingDialog = false; + GLOBALS.nExecutingDialog = 0; + GLOBALS.nExecutingChoice = 0; - CoroScheduler.setEvent(hAskChoice); + CoroScheduler.setEvent(GLOBALS.hAskChoice); CORO_KILL_SELF(); @@ -1394,7 +1316,7 @@ void GroupThread(CORO_PARAM, const void *param) { LockDialogs(); // Find the pointer to the current _ctx->dialog - _ctx->dialog = lpmdDialogs + nExecutingDialog; + _ctx->dialog = GLOBALS.lpmdDialogs + GLOBALS.nExecutingDialog; // Search inside the group requesting the _ctx->dialog for (_ctx->i = 0; _ctx->dialog->Group[_ctx->i].num != 0; _ctx->i++) { @@ -1406,7 +1328,7 @@ void GroupThread(CORO_PARAM, const void *param) { _ctx->type = _ctx->dialog->Command[_ctx->k].type; if (_ctx->type == 1) { // Call custom function - CORO_INVOKE_4(lplpFunctions[_ctx->dialog->Command[_ctx->k].nCf], + CORO_INVOKE_4(GLOBALS.lplpFunctions[_ctx->dialog->Command[_ctx->k].nCf], _ctx->dialog->Command[_ctx->k].arg1, _ctx->dialog->Command[_ctx->k].arg2, _ctx->dialog->Command[_ctx->k].arg3, @@ -1424,7 +1346,7 @@ void GroupThread(CORO_PARAM, const void *param) { CORO_INVOKE_1(DoChoice, (uint32)_ctx->dialog->Command[_ctx->k].nChoice); } else { - mpalError = 1; + GLOBALS.mpalError = 1; UnlockDialogs(); CORO_KILL_SELF(); @@ -1441,7 +1363,7 @@ void GroupThread(CORO_PARAM, const void *param) { } /* Se siamo qui, vuol dire che non abbiamo trovato il gruppo richiesto */ - mpalError = 1; + GLOBALS.mpalError = 1; UnlockDialogs(); CORO_KILL_SELF(); @@ -1473,7 +1395,7 @@ void DoChoice(CORO_PARAM, uint32 nChoice) { LockDialogs(); /* Trova il puntatore al dialogo corrente */ - _ctx->dialog=lpmdDialogs+nExecutingDialog; + _ctx->dialog=GLOBALS.lpmdDialogs+GLOBALS.nExecutingDialog; /* Cerca la scelta richiesta tra quelle nel dialogo */ for (_ctx->i = 0; _ctx->dialog->Choice[_ctx->i].nChoice != 0; _ctx->i++) @@ -1483,7 +1405,7 @@ void DoChoice(CORO_PARAM, uint32 nChoice) { /* Se non l'ha trovata, esce con errore */ if (_ctx->dialog->Choice[_ctx->i].nChoice == 0) { /* Se siamo qui, non abbiamo trovato la choice richiesta */ - mpalError = 1; + GLOBALS.mpalError = 1; UnlockDialogs(); CORO_KILL_SELF(); @@ -1492,10 +1414,10 @@ void DoChoice(CORO_PARAM, uint32 nChoice) { /* Abbiamo trova la choice richiesta. Ricordiamoci qual e' nella variabile globale */ - nExecutingChoice = _ctx->i; + GLOBALS.nExecutingChoice = _ctx->i; while (1) { - nExecutingChoice = _ctx->i; + GLOBALS.nExecutingChoice = _ctx->i; _ctx->k = 0; /* Calcoliamo le when expression di ciascun select, per vedere se sono @@ -1518,13 +1440,13 @@ void DoChoice(CORO_PARAM, uint32 nChoice) { /* Avvertiamo il gioco che c'e' una scelta da far fare all'utente, e restiamo in attesa della risposta */ - CoroScheduler.resetEvent(hDoneChoice); - CoroScheduler.setEvent(hAskChoice); - CORO_INVOKE_2(CoroScheduler.waitForSingleObject, hDoneChoice, CORO_INFINITE); + CoroScheduler.resetEvent(GLOBALS.hDoneChoice); + CoroScheduler.setEvent(GLOBALS.hAskChoice); + CORO_INVOKE_2(CoroScheduler.waitForSingleObject, GLOBALS.hDoneChoice, CORO_INFINITE); /* Ora che la scelta e' stata effettuata, possiamo eseguire _ctx->i gruppi associati con la scelta */ - _ctx->j = nSelectedChoice; + _ctx->j = GLOBALS.nSelectedChoice; for (_ctx->k = 0; _ctx->dialog->Choice[_ctx->i].Select[_ctx->j].wPlayGroup[_ctx->k] != 0; _ctx->k++) { _ctx->nGroup = _ctx->dialog->Choice[_ctx->i].Select[_ctx->j].wPlayGroup[_ctx->k]; CORO_INVOKE_1(GroupThread, &_ctx->nGroup); @@ -1579,7 +1501,7 @@ void DoChoice(CORO_PARAM, uint32 nChoice) { \****************************************************************************/ static uint32 DoAction(uint32 nAction, uint32 ordItem, uint32 dwParam) { - LPMPALITEM item = lpmiItems; + LPMPALITEM item = GLOBALS.lpmiItems; int i; LPMPALITEM newitem; uint32 h; @@ -1624,8 +1546,8 @@ static uint32 DoAction(uint32 nAction, uint32 ordItem, uint32 dwParam) { if (CoroScheduler.createProcess(ShutUpActionThread, &h, sizeof(uint32)) == CORO_INVALID_PID_VALUE) return CORO_INVALID_PID_VALUE; - nExecutingAction = item->nObj; - bExecutingAction = true; + GLOBALS.nExecutingAction = item->nObj; + GLOBALS.bExecutingAction = true; return h; } @@ -1648,13 +1570,13 @@ static uint32 DoDialog(uint32 nDlgOrd, uint32 nGroup) { uint32 h; // Store the running dialog in a global variable - nExecutingDialog = nDlgOrd; + GLOBALS.nExecutingDialog = nDlgOrd; // Enables the flag to indicate that there is' a running dialogue - bExecutingDialog = true; + GLOBALS.bExecutingDialog = true; - CoroScheduler.resetEvent(hAskChoice); - CoroScheduler.resetEvent(hDoneChoice); + CoroScheduler.resetEvent(GLOBALS.hAskChoice); + CoroScheduler.resetEvent(GLOBALS.hDoneChoice); // Create a thread that performs the dialogue group @@ -1688,7 +1610,7 @@ static uint32 DoDialog(uint32 nDlgOrd, uint32 nGroup) { \****************************************************************************/ bool DoSelection(uint32 i, uint32 dwData) { - LPMPALDIALOG dialog=lpmdDialogs+nExecutingDialog; + LPMPALDIALOG dialog=GLOBALS.lpmdDialogs+GLOBALS.nExecutingDialog; int j; for (j = 0; dialog->Choice[i].Select[j].dwData != 0; j++) @@ -1698,8 +1620,8 @@ bool DoSelection(uint32 i, uint32 dwData) { if (dialog->Choice[i].Select[j].dwData == 0) return false; - nSelectedChoice = j; - CoroScheduler.setEvent(hDoneChoice); + GLOBALS.nSelectedChoice = j; + CoroScheduler.setEvent(GLOBALS.hDoneChoice); return true; } @@ -1742,8 +1664,8 @@ bool mpalInit(const char *lpszMpcFileName, const char *lpszMprFileName, //printf("Dialog: %lu\n", sizeof(MPALDIALOG)); /* Si salva l'array delle funzioni custom */ - lplpFunctions = lplpcfArray; - lplpFunctionStrings = lpcfStrings; + GLOBALS.lplpFunctions = lplpcfArray; + GLOBALS.lplpFunctionStrings = lpcfStrings; /* Apre il file MPC in lettura */ if (!hMpc.open(lpszMpcFileName)) @@ -1764,7 +1686,7 @@ bool mpalInit(const char *lpszMpcFileName, const char *lpszMprFileName, if (hMpc.err()) return false; - lpMpcImage = (byte *)GlobalAlloc(GMEM_FIXED,dwSizeDecomp+16); + byte *lpMpcImage = (byte *)GlobalAlloc(GMEM_FIXED,dwSizeDecomp+16); if (lpMpcImage == NULL) return false; @@ -1811,73 +1733,73 @@ bool mpalInit(const char *lpszMpcFileName, const char *lpszMprFileName, { char errbuf[256]; wsprintf(errbuf,"Utilizzo in RAM: VAR %lu, MSG %lu, DLG %lu, ITM %lu, LOC %lu, SCR %lu", - nVars*sizeof(MPALVAR), - nMsgs*sizeof(MPALMSG), - nDialogs*sizeof(MPALDIALOG), - nItems*sizeof(MPALITEM), - nLocations*sizeof(MPALLOCATION), - nScripts*sizeof(MPALSCRIPT)); + GLOBALS.nVars*sizeof(MPALVAR), + GLOBALS.nMsgs*sizeof(MPALMSG), + GLOBALS.nDialogs*sizeof(MPALDIALOG), + GLOBALS.nItems*sizeof(MPALITEM), + GLOBALS.nLocations*sizeof(MPALLOCATION), + GLOBALS.nScripts*sizeof(MPALSCRIPT)); MessageBox(NULL,errbuf,"Dump",MB_OK); } */ /* Apre il file MPR in lettura */ - if (!hMpr.open(lpszMprFileName)) + if (!GLOBALS.hMpr.open(lpszMprFileName)) return false; /* Si posiziona a 8 byte dalla fine del file */ - hMpr.seek(-12, SEEK_END); + GLOBALS.hMpr.seek(-12, SEEK_END); - dwSizeComp = hMpr.readUint32LE(); - if (hMpr.err()) + dwSizeComp = GLOBALS.hMpr.readUint32LE(); + if (GLOBALS.hMpr.err()) return false; - nResources = hMpr.readUint32LE(); - if (hMpr.err()) + GLOBALS.nResources = GLOBALS.hMpr.readUint32LE(); + if (GLOBALS.hMpr.err()) return false; - nBytesRead = hMpr.read(buf, 4); - if (hMpr.err()) + nBytesRead = GLOBALS.hMpr.read(buf, 4); + if (GLOBALS.hMpr.err()) return false; if (buf[0] !='E' || buf[1] != 'N' || buf[2] != 'D' || buf[3] != '0') return false; /* Si posiziona all'inizio dell'header delle risorse */ - hMpr.seek(-(12 + (int)dwSizeComp), SEEK_END); + GLOBALS.hMpr.seek(-(12 + (int)dwSizeComp), SEEK_END); - lpResources = (uint32 *)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, nResources * 8); - if (lpResources == NULL) + GLOBALS.lpResources = (uint32 *)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, GLOBALS.nResources * 8); + if (GLOBALS.lpResources == NULL) return false; cmpbuf = (byte *)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, dwSizeComp); if (cmpbuf == NULL) return false; - nBytesRead = hMpr.read(cmpbuf, dwSizeComp); + nBytesRead = GLOBALS.hMpr.read(cmpbuf, dwSizeComp); if (nBytesRead != dwSizeComp) return false; - lzo1x_decompress((const byte *)cmpbuf, dwSizeComp, (byte *)lpResources, (uint32 *)&nBytesRead); - if (nBytesRead != (uint32)nResources*8) + lzo1x_decompress((const byte *)cmpbuf, dwSizeComp, (byte *)GLOBALS.lpResources, (uint32 *)&nBytesRead); + if (nBytesRead != (uint32)GLOBALS.nResources*8) return false; GlobalFree(cmpbuf); /* Si riposiziona all'inizio lasciando il file di risorse aperto */ - hMpr.seek(0, SEEK_SET); + GLOBALS.hMpr.seek(0, SEEK_SET); /* Non c'e' nessuna azione ne' dialogo in esecuzione */ - bExecutingAction = false; - bExecutingDialog = false; + GLOBALS.bExecutingAction = false; + GLOBALS.bExecutingDialog = false; /* Non c'e' nessuna locazione in polling */ - Common::fill(nPollingLocations, nPollingLocations + MAXPOLLINGLOCATIONS, 0); + Common::fill(GLOBALS.nPollingLocations, GLOBALS.nPollingLocations + MAXPOLLINGLOCATIONS, 0); /* Crea l'evento che verra' utilizzato per avvertire il gioco che c'e' da effettuare una scelta */ - hAskChoice = CoroScheduler.createEvent(true, false); - hDoneChoice = CoroScheduler.createEvent(true, false); + GLOBALS.hAskChoice = CoroScheduler.createEvent(true, false); + GLOBALS.hDoneChoice = CoroScheduler.createEvent(true, false); return true; } @@ -1920,7 +1842,7 @@ uint32 mpalQueryDWORD(uint16 wQueryType, ...) { va_list v; va_start(v, wQueryType); - mpalError = OK; + GLOBALS.mpalError = OK; if (wQueryType == MPQ_VERSION) { /* @@ -1961,13 +1883,13 @@ uint32 mpalQueryDWORD(uint16 wQueryType, ...) { y = GETARG(uint32); if (x != -1) { if (y == MPQ_X) - dwRet = lpmlLocations[x].dwXlen; + dwRet = GLOBALS.lpmlLocations[x].dwXlen; else if (y == MPQ_Y) - dwRet = lpmlLocations[x].dwYlen; + dwRet = GLOBALS.lpmlLocations[x].dwYlen; else - mpalError = 1; + GLOBALS.mpalError = 1; } else - mpalError = 1; + GLOBALS.mpalError = 1; UnlockLocations(); @@ -2022,7 +1944,7 @@ uint32 mpalQueryDWORD(uint16 wQueryType, ...) { else { LockItems(); y = itemGetOrderFromNum(x); - CopyMemory(n, (char *)(lpmiItems + y)->lpszDescribe, MAX_DESCRIBE_SIZE); + CopyMemory(n, (char *)(GLOBALS.lpmiItems + y)->lpszDescribe, MAX_DESCRIBE_SIZE); UnlockItems(); } @@ -2070,7 +1992,7 @@ uint32 mpalQueryDWORD(uint16 wQueryType, ...) { dwRet = DoAction(x, y, GETARG(uint32)); } else { dwRet = CORO_INVALID_PID_VALUE; - mpalError = 1; + GLOBALS.mpalError = 1; } UnlockVar(); @@ -2080,7 +2002,7 @@ uint32 mpalQueryDWORD(uint16 wQueryType, ...) { /* * int mpalQuery(MPQ_DO_DIALOG, uint32 nDialog, uint32 nGroup); */ - if (!bExecutingDialog) { + if (!GLOBALS.bExecutingDialog) { LockDialogs(); x = dialogGetOrderFromNum(GETARG(uint32)); @@ -2092,7 +2014,7 @@ uint32 mpalQueryDWORD(uint16 wQueryType, ...) { /* * DEFAULT -> ERROR */ - mpalError = 1; + GLOBALS.mpalError = 1; } va_end(v); @@ -2114,7 +2036,7 @@ HANDLE mpalQueryHANDLE(uint16 wQueryType, ...) { va_start(v, wQueryType); void *hRet = NULL; - mpalError = OK; + GLOBALS.mpalError = OK; if (wQueryType == MPQ_VERSION) { /* @@ -2154,7 +2076,7 @@ HANDLE mpalQueryHANDLE(uint16 wQueryType, ...) { */ LockLocations(); x = locGetOrderFromNum(GETARG(uint32)); - hRet = resLoad(lpmlLocations[x].dwPicRes); + hRet = resLoad(GLOBALS.lpmlLocations[x].dwPicRes); UnlockLocations(); } else if (wQueryType == MPQ_RESOURCE) { @@ -2198,7 +2120,7 @@ HANDLE mpalQueryHANDLE(uint16 wQueryType, ...) { else { LockItems(); y = itemGetOrderFromNum(x); - CopyMemory(n, (char *)(lpmiItems + y)->lpszDescribe, MAX_DESCRIBE_SIZE); + CopyMemory(n, (char *)(GLOBALS.lpmiItems + y)->lpszDescribe, MAX_DESCRIBE_SIZE); UnlockItems(); } @@ -2248,7 +2170,7 @@ HANDLE mpalQueryHANDLE(uint16 wQueryType, ...) { /* * DEFAULT -> ERROR */ - mpalError = 1; + GLOBALS.mpalError = 1; } va_end(v); @@ -2277,12 +2199,12 @@ void mpalQueryCORO(CORO_PARAM, uint16 wQueryType, uint32 *dwRet, ...) { /* * void mpalQuery(MPQ_DIALOG_WAITFORCHOICE); */ - CORO_INVOKE_2(CoroScheduler.waitForSingleObject, hAskChoice, CORO_INFINITE); + CORO_INVOKE_2(CoroScheduler.waitForSingleObject, GLOBALS.hAskChoice, CORO_INFINITE); - CoroScheduler.resetEvent(hAskChoice); + CoroScheduler.resetEvent(GLOBALS.hAskChoice); - if (bExecutingDialog) - *dwRet = (uint32)nExecutingChoice; + if (GLOBALS.bExecutingDialog) + *dwRet = (uint32)GLOBALS.nExecutingChoice; else *dwRet = (uint32)((int)-1); } else { @@ -2306,7 +2228,7 @@ void mpalQueryCORO(CORO_PARAM, uint16 wQueryType, uint32 *dwRet, ...) { \****************************************************************************/ uint32 mpalGetError(void) { - return mpalError; + return GLOBALS.mpalError; } @@ -2333,7 +2255,7 @@ bool mpalExecuteScript(int nScript) { if (s == NULL) return false; - CopyMemory(s, lpmsScripts+n, sizeof(MPALSCRIPT)); + CopyMemory(s, GLOBALS.lpmsScripts + n, sizeof(MPALSCRIPT)); UnlockScripts(); // !!! Nuova gestione dei thread @@ -2346,17 +2268,17 @@ bool mpalExecuteScript(int nScript) { /****************************************************************************\ * -* Function: void mpalInstallItemIrq(LPITEMIRQFUNCTION lpiifCustom); +* Function: void mpalInstallItemIrq(LPITEMIRQFUNCTION GLOBALS.lpiifCustom); * * Description: Install a custom routine that will be called by MPAL every * time the pattern of an item has been changed. * -* Input: LPITEMIRQFUNCTION lpiifCustom Custom function to install +* Input: LPITEMIRQFUNCTION GLOBALS.lpiifCustom Custom function to install * \****************************************************************************/ void mpalInstallItemIrq(LPITEMIRQFUNCTION lpiifCus) { - lpiifCustom = lpiifCus; + GLOBALS.lpiifCustom = lpiifCus; } @@ -2380,17 +2302,17 @@ bool mpalStartIdlePoll(int nLoc) { uint32 i; for (i = 0; i < MAXPOLLINGLOCATIONS; i++) - if (nPollingLocations[i] == (uint32)nLoc) + if (GLOBALS.nPollingLocations[i] == (uint32)nLoc) return false; for (i = 0; i < MAXPOLLINGLOCATIONS; i++) { - if (nPollingLocations[i] == 0) { - nPollingLocations[i] = nLoc; + if (GLOBALS.nPollingLocations[i] == 0) { + GLOBALS.nPollingLocations[i] = nLoc; - hEndPollingLocations[i] = CoroScheduler.createEvent(true, false); + GLOBALS.hEndPollingLocations[i] = CoroScheduler.createEvent(true, false); // !!! Nuova gestione dei thread - if ((PollingThreads[i] = CoroScheduler.createProcess(LocationPollThread, &i, sizeof(uint32))) == 0) -// if ((hEndPollingLocations[i]=(void*)_beginthread(LocationPollThread, 10240,(void *)i))==(void*)-1) + if ((GLOBALS.PollingThreads[i] = CoroScheduler.createProcess(LocationPollThread, &i, sizeof(uint32))) == CORO_INVALID_PID_VALUE) +// if ((GLOBALS.hEndPollingLocations[i]=(void*)_beginthread(LocationPollThread, 10240,(void *)i))==(void*)-1) return false; return true; @@ -2423,13 +2345,13 @@ void mpalEndIdlePoll(CORO_PARAM, int nLoc, bool *result) { CORO_BEGIN_CODE(_ctx); for (_ctx->i = 0; _ctx->i < MAXPOLLINGLOCATIONS; _ctx->i++) { - if (nPollingLocations[_ctx->i] == (uint32)nLoc) { - CoroScheduler.setEvent(hEndPollingLocations[_ctx->i]); + if (GLOBALS.nPollingLocations[_ctx->i] == (uint32)nLoc) { + CoroScheduler.setEvent(GLOBALS.hEndPollingLocations[_ctx->i]); - CORO_INVOKE_2(CoroScheduler.waitForSingleObject, PollingThreads[_ctx->i], CORO_INFINITE); + CORO_INVOKE_2(CoroScheduler.waitForSingleObject, GLOBALS.PollingThreads[_ctx->i], CORO_INFINITE); - CoroScheduler.closeEvent(hEndPollingLocations[_ctx->i]); - nPollingLocations[_ctx->i] = 0; + CoroScheduler.closeEvent(GLOBALS.hEndPollingLocations[_ctx->i]); + GLOBALS.nPollingLocations[_ctx->i] = 0; if (result) *result = true; @@ -2456,7 +2378,7 @@ void mpalEndIdlePoll(CORO_PARAM, int nLoc, bool *result) { \****************************************************************************/ int mpalGetSaveStateSize(void) { - return nVars * sizeof(MPALVAR) + 4; + return GLOBALS.nVars * sizeof(MPALVAR) + 4; } @@ -2473,8 +2395,8 @@ int mpalGetSaveStateSize(void) { void mpalSaveState(byte *buf) { LockVar(); - WRITE_LE_UINT32(buf, nVars); - CopyMemory(buf + 4, (byte *)lpmvVars, nVars * sizeof(MPALVAR)); + WRITE_LE_UINT32(buf, GLOBALS.nVars); + CopyMemory(buf + 4, (byte *)GLOBALS.lpmvVars, GLOBALS.nVars * sizeof(MPALVAR)); UnlockVar(); } @@ -2492,16 +2414,16 @@ void mpalSaveState(byte *buf) { int mpalLoadState(byte *buf) { // Dobbiamo distruggere tutte le variabili e ricrearle - GlobalFree(hVars); + GlobalFree(GLOBALS.hVars); - nVars = READ_LE_UINT32(buf); + GLOBALS.nVars = READ_LE_UINT32(buf); - hVars = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE, nVars * sizeof(MPALVAR)); + GLOBALS.hVars = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE, GLOBALS.nVars * sizeof(MPALVAR)); LockVar(); - CopyMemory((byte *)lpmvVars, buf + 4, nVars * sizeof(MPALVAR)); + CopyMemory((byte *)GLOBALS.lpmvVars, buf + 4, GLOBALS.nVars * sizeof(MPALVAR)); UnlockVar(); - return nVars*sizeof(MPALVAR)+4; + return GLOBALS.nVars*sizeof(MPALVAR)+4; } bool bDontOutput; @@ -2652,18 +2574,18 @@ void mpalDumpMessages(void) { f = g_system->getSavefileManager()->openForSaving("Messages.htm"); f->writeString("\n\n\n"); - for (i = 0; i < nMsgs; i++) { - lpMessage = (char*)GlobalLock(lpmmMsgs[i].hText); + for (i = 0; i < GLOBALS.nMsgs; i++) { + lpMessage = (char*)GlobalLock(GLOBALS.lpmmMsgs[i].hText); if (*lpMessage != '\0') { // bernie: debug - /*if (lpmmMsgs[i].wNum == 1950) { + /*if (GLOBALS.lpmmMsgs[i].wNum == 1950) { int a = 1; }*/ nPeriods = 1; p=lpPeriods[0] = lpMessage; - OutputStartMsgComment(lpmmMsgs[i].wNum, f); + OutputStartMsgComment(GLOBALS.lpmmMsgs[i].wNum, f); while (1) { // Trova la fine del periodo corrente @@ -2682,9 +2604,9 @@ void mpalDumpMessages(void) { // Ora fa un ciclo su tutti i periodi for (j = 0;jwriteString("\n\n"); - for (i = 0; i < nMsgs; i++) { - lpMessage = (char*)GlobalLock(lpmmMsgs[i].hText); + for (i = 0; i < GLOBALS.nMsgs; i++) { + lpMessage = (char*)GlobalLock(GLOBALS.lpmmMsgs[i].hText); if (*lpMessage != '\0') { nPeriods = 1; p=lpPeriods[0] = lpMessage; - if (OutputStartOther(lpmmMsgs[i].wNum, f)) { + if (OutputStartOther(GLOBALS.lpmmMsgs[i].wNum, f)) { while (1) { // Trova la fine del periodo corrente while (*p!='\0') @@ -2768,9 +2690,9 @@ void mpalDumpOthers(void) { // Ora fa un ciclo su tutti i periodi for (j = 0; j < nPeriods; j++) { if (nPeriods == 1) - sprintf(fname, "000-%05d.WAV", lpmmMsgs[i].wNum); + sprintf(fname, "000-%05d.WAV", GLOBALS.lpmmMsgs[i].wNum); else - sprintf(fname, "000-%05d-%02d.WAV", lpmmMsgs[i].wNum,j); + sprintf(fname, "000-%05d-%02d.WAV", GLOBALS.lpmmMsgs[i].wNum,j); strcpy(frase,lpPeriods[j]); @@ -2792,9 +2714,9 @@ void mpalDumpOthers(void) { } } - OutputEndOther(lpmmMsgs[i].wNum, f); + OutputEndOther(GLOBALS.lpmmMsgs[i].wNum, f); - GlobalUnlock(lpmmMsgs[i].hText); + GlobalUnlock(GLOBALS.lpmmMsgs[i].hText); } } @@ -3284,8 +3206,8 @@ void mpalDumpDialogs(void) { LockDialogs(); - for (i = 0; i < nDialogs; i++) - mpalDumpDialog(&lpmdDialogs[i]); + for (i = 0; i < GLOBALS.nDialogs; i++) + mpalDumpDialog(&GLOBALS.lpmdDialogs[i]); UnlockDialogs(); } diff --git a/engines/tony/mpal/mpaldll.h b/engines/tony/mpal/mpaldll.h index ee3820531a3f..a7b6dfc5aa31 100644 --- a/engines/tony/mpal/mpaldll.h +++ b/engines/tony/mpal/mpaldll.h @@ -51,8 +51,10 @@ #define __MPALDLL_H #include "common/file.h" -#include "memory.h" -#include "stubs.h" +#include "tony/mpal/memory.h" +#include "tony/mpal/stubs.h" +#include "tony/mpal/loadmpc.h" +#include "tony/mpal/expr.h" namespace Tony { @@ -332,41 +334,6 @@ typedef LPMPALSCRIPT* LPLPMPALSCRIPT; #include "common/pack-end.h" -/****************************************************************************\ -* Variabili globali -\****************************************************************************/ - -extern uint32 mpalError; -extern LPLPCUSTOMFUNCTION lplpFunctions; -extern uint16 nObjs; - -extern uint16 nVars; -extern HGLOBAL hVars; -extern LPMPALVAR lpmvVars; - -extern uint16 nMsgs; -extern HGLOBAL hMsgs; -extern LPMPALMSG lpmmMsgs; - -extern uint16 nDialogs; -extern HGLOBAL hDialogs; -extern LPMPALDIALOG lpmdDialogs; - -extern uint16 nItems; -extern HGLOBAL hItems; -extern LPMPALITEM lpmiItems; - -extern uint16 nLocations; -extern HGLOBAL hLocations; -extern LPMPALLOCATION lpmlLocations; - -extern uint16 nScripts; -extern HGLOBAL hScripts; -extern LPMPALSCRIPT lpmsScripts; - -extern Common::File hMpr; -extern uint16 nResources; -extern uint32 * lpResources; /****************************************************************************\ * Prototipi di funzione @@ -412,8 +379,5 @@ void varSetValue(const char *lpszVarName, int32 val); } // end of namespace Tony -#include "loadmpc.h" -#include "expr.h" - #endif