scummvm/engines/private/funcs.cpp
2021-12-26 18:48:43 +01:00

836 lines
22 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/>.
*
*/
#include "common/str.h"
#include "common/system.h"
#include "common/timer.h"
#include "private/grammar.h"
#include "private/private.h"
#include "private/tokens.h"
namespace Private {
static void fChgMode(ArgArray args) {
// assert types
assert(args.size() == 2 || args.size() == 3);
assert(args[0].type == NUM);
if (args.size() == 2)
debugC(1, kPrivateDebugScript, "ChgMode(%d, %s)", args[0].u.val, args[1].u.sym->name->c_str());
else if (args.size() == 3)
debugC(1, kPrivateDebugScript, "ChgMode(%d, %s, %s)", args[0].u.val, args[1].u.sym->name->c_str(), args[2].u.sym->name->c_str());
else
assert(0);
g_private->_mode = args[0].u.val;
g_private->_nextSetting = args[1].u.sym->name->c_str();
if (g_private->_mode == 0) {
g_private->_origin = Common::Point(kOriginZero[0], kOriginZero[1]);
} else if (g_private->_mode == 1) {
g_private->_origin = Common::Point(kOriginOne[0], kOriginOne[1]);
} else
assert(0);
if (args.size() == 3) {
Symbol *location = g_private->maps.lookupLocation(args[2].u.sym->name);
setSymbol(location, true);
}
// This is the only place where this should be used
if (g_private->_noStopSounds) {
g_private->_noStopSounds = false;
} else {
g_private->stopSound(true);
}
}
static void fVSPicture(ArgArray args) {
assert(args[0].type == STRING);
debugC(1, kPrivateDebugScript, "VSPicture(%s)", args[0].u.str);
g_private->_nextVS = args[0].u.str;
}
static void fDiaryLocList(ArgArray args) {
int x1, y1, x2, y2;
assert(args[0].type == NUM);
assert(args[1].type == NUM);
assert(args[2].type == NUM);
assert(args[3].type == NUM);
debugC(1, kPrivateDebugScript, "DiaryLocList(%d, %d, %d, %d)", args[0].u.val, args[1].u.val, args[2].u.val, args[3].u.val);
x2 = args[0].u.val;
y2 = args[1].u.val;
x1 = args[2].u.val;
y1 = args[3].u.val;
Common::Rect rect(x1, y1, x2, y2);
g_private->loadLocations(rect);
}
static void fDiaryGoLoc(ArgArray args) {
debugC(1, kPrivateDebugScript, "WARNING: DiaryGoLoc not implemented");
}
static void fDiaryInvList(ArgArray args) {
debugC(1, kPrivateDebugScript, "DiaryInvList(%d, ..)", args[0].u.val);
const Common::Rect *r1 = args[1].u.rect;
const Common::Rect *r2 = args[2].u.rect;
g_private->loadInventory(args[0].u.val, *r1, *r2);
}
static void fgoto(ArgArray args) {
// assert types
debugC(1, kPrivateDebugScript, "goto(%s)", args[0].u.str);
g_private->_nextSetting = args[0].u.str;
}
static void fSyncSound(ArgArray args) {
assert(args[0].type == STRING);
assert(args[1].type == NAME);
debugC(1, kPrivateDebugScript, "SyncSound(%s, %s)", args[0].u.str, args[1].u.sym->name->c_str());
g_private->_nextSetting = args[1].u.sym->name->c_str();
Common::String s = args[0].u.str;
if (s != "\"\"") {
g_private->playSound(s, 1, true, false);
while (g_private->isSoundActive())
g_private->ignoreEvents();
uint32 i = 100;
while (i--) // one second extra
g_private->ignoreEvents();
}
}
static void fQuit(ArgArray args) {
debugC(1, kPrivateDebugScript, "Quit()");
g_private->quitGame();
}
static void fLoadGame(ArgArray args) {
assert(args[0].type == STRING);
assert(args[2].type == NAME);
debugC(1, kPrivateDebugScript, "LoadGame(%s, %s)", args[0].u.str, args[2].u.sym->name->c_str());
MaskInfo m;
if (strcmp(args[0].u.str, "\"\"") == 0) // Not sure why the game tries to load an empty mask
return;
m.surf = g_private->loadMask(args[0].u.str, 0, 0, true);
m.cursor = *args[2].u.sym->name;
m.nextSetting = "";
m.flag1 = nullptr;
m.flag2 = nullptr;
if (g_private->_loadGameMask.surf)
g_private->_loadGameMask.surf->free();
delete g_private->_loadGameMask.surf;
g_private->_loadGameMask = m;
g_private->_masks.push_front(m);
}
static void fSaveGame(ArgArray args) {
// assert types
debugC(1, kPrivateDebugScript, "SaveGame(%s, %s)", args[0].u.str, args[1].u.sym->name->c_str());
MaskInfo m;
m.surf = g_private->loadMask(args[0].u.str, 0, 0, true);
m.cursor = *args[1].u.sym->name;
m.nextSetting = "";
m.flag1 = nullptr;
m.flag2 = nullptr;
if (g_private->_saveGameMask.surf)
g_private->_saveGameMask.surf->free();
delete g_private->_saveGameMask.surf;
g_private->_saveGameMask = m;
g_private->_masks.push_front(m);
}
static void fRestartGame(ArgArray args) {
assert(args.size() == 0);
g_private->restartGame();
}
static void fPoliceBust(ArgArray args) {
// assert types
assert(args.size() == 1 || args.size() == 2);
g_private->_policeBustEnabled = args[0].u.val;
//debug("Number of clicks %d", g_private->computePoliceIndex());
if (g_private->_policeBustEnabled)
g_private->startPoliceBust();
if (args.size() == 2) {
if (args[1].u.val == 2) {
// Unclear what it means
} else if (args[1].u.val == 3) {
g_private->_nextSetting = g_private->getMainDesktopSetting();
g_private->_mode = 0;
g_private->_origin = Common::Point(kOriginZero[0], kOriginZero[1]);
} else
assert(0);
}
debugC(1, kPrivateDebugScript, "PoliceBust(%d, ..)", args[0].u.val);
debugC(1, kPrivateDebugScript, "WARNING: PoliceBust partially implemented");
}
static void fBustMovie(ArgArray args) {
// assert types
assert(args.size() == 1);
debugC(1, kPrivateDebugScript, "BustMovie(%s)", args[0].u.sym->name->c_str());
uint policeIndex = g_private->maps.variables.getVal(g_private->getPoliceIndexVariable())->u.val;
int videoIndex = policeIndex / 2 - 1;
if (videoIndex < 0)
videoIndex = 0;
assert(videoIndex <= 5);
Common::String pv =
Common::String::format("po/animatio/spoc%02dxs.smk",
kPoliceBustVideos[videoIndex]);
if (kPoliceBustVideos[videoIndex] == 2) {
Common::String s("global/transiti/audio/spoc02VO.wav");
g_private->playSound(s, 1, false, false);
}
g_private->_nextMovie = pv;
g_private->_nextSetting = args[0].u.sym->name->c_str();
}
static void fDossierAdd(ArgArray args) {
assert(args.size() == 2);
Common::String s1 = args[0].u.str;
Common::String s2 = args[1].u.str;
DossierInfo m;
m.page1 = s1;
if (s2 != "\"\"") {
m.page2 = s2;
} else {
m.page2 = "";
}
g_private->_dossiers.push_back(m);
}
static void fDossierBitmap(ArgArray args) {
assert(args.size() == 2);
int x = args[0].u.val;
int y = args[1].u.val;
assert(x == 40 && y == 30);
g_private->loadDossier();
}
static void fDossierChgSheet(ArgArray args) {
assert(args.size() == 4);
debugC(1, kPrivateDebugScript, "DossierChgSheet(%s,%d,%d,%d)", args[0].u.str, args[1].u.val, args[2].u.val, args[3].u.val);
Common::String s(args[0].u.str);
MaskInfo m;
int p = args[1].u.val;
int x = args[2].u.val;
int y = args[3].u.val;
m.surf = g_private->loadMask(s, x, y, true);
m.cursor = g_private->getExitCursor();
m.nextSetting = "";
m.flag1 = nullptr;
m.flag2 = nullptr;
if (p == 0)
g_private->_dossierPrevSheetMask = m;
else if (p == 1)
g_private->_dossierNextSheetMask = m;
else
error("Invalid sheet number in DossierChgSheet %d", p);
g_private->_masks.push_front(m);
}
static void fDossierPrevSuspect(ArgArray args) {
assert(args.size() == 3);
Common::String s(args[0].u.str);
MaskInfo m;
int x = args[1].u.val;
int y = args[2].u.val;
m.surf = g_private->loadMask(s, x, y, true);
m.cursor = g_private->getExitCursor();
m.nextSetting = "";
m.flag1 = nullptr;
m.flag2 = nullptr;
g_private->_dossierPrevSuspectMask = m;
g_private->_masks.push_front(m);
}
static void fDossierNextSuspect(ArgArray args) {
assert(args.size() == 3);
Common::String s(args[0].u.str);
MaskInfo m;
int x = args[1].u.val;
int y = args[2].u.val;
m.surf = g_private->loadMask(s, x, y, true);
m.cursor = g_private->getExitCursor();
m.nextSetting = "";
m.flag1 = nullptr;
m.flag2 = nullptr;
g_private->_dossierNextSuspectMask = m;
g_private->_masks.push_front(m);
}
static void fNoStopSounds(ArgArray args) {
assert(args.size() == 0);
debugC(1, kPrivateDebugScript, "NoStopSounds()");
g_private->_noStopSounds = true;
}
static void fLoseInventory(ArgArray args) {
assert(args.size() == 0);
debugC(1, kPrivateDebugScript, "LoveInventory()");
g_private->inventory.clear();
}
bool inInventory(Common::String &bmp) {
for (NameList::const_iterator it = g_private->inventory.begin(); it != g_private->inventory.end(); ++it) {
if (*it == bmp)
return true;
}
return false;
}
static void fInventory(ArgArray args) {
// assert types
Datum b1 = args[0];
Datum v1 = args[1];
Datum v2 = args[2];
Datum e = args[3];
Datum i = args[4];
Datum c = args[5];
Datum snd = args[8];
assert(v1.type == STRING || v1.type == NAME);
assert(b1.type == STRING);
assert(e.type == NAME || e.type == NUM);
assert(snd.type == STRING);
assert(i.type == STRING);
Common::String bmp(i.u.str);
assert(g_private->isDemo() || bmp != "\"\"");
if (v1.type == STRING)
assert(strcmp(v1.u.str, "\"\"") == 0);
debugC(1, kPrivateDebugScript, "Inventory(...)");
Common::String mask(b1.u.str);
if (mask != "\"\"") {
MaskInfo m;
m.surf = g_private->loadMask(mask, 0, 0, true);
if (e.type == NUM) {
assert(e.u.val == 0);
m.nextSetting = "";
} else
m.nextSetting = e.u.sym->name->c_str();
m.cursor = g_private->getInventoryCursor();
m.point = Common::Point(0, 0);
if (v1.type == NAME) {
m.flag1 = g_private->maps.lookupVariable(v1.u.sym->name);
} else
m.flag1 = nullptr;
if (v2.type == NAME) {
m.flag2 = g_private->maps.lookupVariable(v2.u.sym->name);
} else
m.flag2 = nullptr;
g_private->_masks.push_front(m);
g_private->_toTake = true;
Common::String sound(snd.u.str);
if (sound != "\"\"") {
g_private->playSound(sound, 1, false, false);
} else {
g_private->playSound(g_private->getTakeLeaveSound(), 1, false, false);
}
if (!inInventory(bmp))
g_private->inventory.push_back(bmp);
} else {
if (v1.type == NAME) {
v1.u.sym = g_private->maps.lookupVariable(v1.u.sym->name);
if (strcmp(c.u.str, "\"REMOVE\"") == 0) {
v1.u.sym->u.val = 0;
if (inInventory(bmp))
g_private->inventory.remove(bmp);
} else {
v1.u.sym->u.val = 1;
if (!inInventory(bmp))
g_private->inventory.push_back(bmp);
}
} else {
if (!inInventory(bmp))
g_private->inventory.push_back(bmp);
}
if (v2.type == NAME) {
v2.u.sym = g_private->maps.lookupVariable(v2.u.sym->name);
v2.u.sym->u.val = 1;
}
}
}
static void fSetFlag(ArgArray args) {
assert(args.size() == 2);
assert(args[0].type == NAME && args[1].type == NUM);
debugC(1, kPrivateDebugScript, "SetFlag(%s, %d)", args[0].u.sym->name->c_str(), args[1].u.val);
args[0].u.sym = g_private->maps.lookupVariable(args[0].u.sym->name);
args[0].u.sym->u.val = args[1].u.val;
}
static void fExit(ArgArray args) {
// assert types
assert(args[2].type == RECT || args[2].type == NAME);
debugC(1, kPrivateDebugScript, "Exit(%d %d %d)", args[0].type, args[1].type, args[2].type); //, args[0].u.str, args[1].u.sym->name->c_str(), "RECT");
ExitInfo e;
if (args[0].type == NUM && args[0].u.val == 0)
e.nextSetting = "";
else
e.nextSetting = args[0].u.sym->name->c_str();
if (args[1].type == NUM && args[1].u.val == 0)
e.cursor = "";
else
e.cursor = *args[1].u.sym->name;
if (args[2].type == NAME) {
Symbol *rect = g_private->maps.lookupRect(args[2].u.sym->name);
assert(rect->type == RECT);
args[2].u.rect = rect->u.rect;
}
e.rect = *args[2].u.rect;
g_private->_exits.push_front(e);
}
static void fSetModifiedFlag(ArgArray args) {
// assert types
debugC(1, kPrivateDebugScript, "SetModifiedFlag(%d)", args[0].u.val);
g_private->_modified = args[0].u.val != 0;
}
static void fPaperShuffleSound(ArgArray args) {
assert(args.size() == 0);
debugC(1, kPrivateDebugScript, "PaperShuffleSound()");
g_private->playSound(g_private->getPaperShuffleSound(), 1, false, false);
}
static void fSoundEffect(ArgArray args) {
// assert types
debugC(1, kPrivateDebugScript, "SoundEffect(%s)", args[0].u.str);
Common::String s(args[0].u.str);
if (s != "\"\"") {
g_private->playSound(s, 1, false, false);
} else {
g_private->stopSound(true);
}
}
static void fSound(ArgArray args) {
// assert types
debugC(1, kPrivateDebugScript, "Sound(%s)", args[0].u.str);
if (args.size() == 4) {
bool b1 = args[1].u.val != 0;
bool b2 = args[2].u.val != 0;
int c = args[3].u.val;
if (!b1 && !b2 && c == 1) {
g_private->stopSound(true);
} else if (!b1 && !b2 && c == 2) {
g_private->stopSound(false);
} else
assert(0);
}
Common::String s(args[0].u.str);
if (s != "\"\"") {
g_private->playSound(s, 1, false, false);
} else {
g_private->stopSound(true);
}
}
static void fLoopedSound(ArgArray args) {
// assert types
assert(args.size() == 1);
debugC(1, kPrivateDebugScript, "LoopedSound(%s)", args[0].u.str);
Common::String s(args[0].u.str);
if (s != "\"\"") {
g_private->playSound(s, 0, true, true);
} else {
g_private->stopSound(true);
}
}
static void fViewScreen(ArgArray args) {
// assert types
debugC(1, kPrivateDebugScript, "WARNING: ViewScreen not implemented!");
}
static void fTransition(ArgArray args) {
assert(args[0].type == STRING);
assert(args[1].type == NAME);
debugC(1, kPrivateDebugScript, "Transition(%s, %s)", args[0].u.str, args[1].u.sym->name->c_str());
g_private->_nextMovie = args[0].u.str;
g_private->_nextSetting = args[1].u.sym->name->c_str();
}
static void fResume(ArgArray args) {
assert(args[0].type == NUM);
debugC(1, kPrivateDebugScript, "Resume(%d)", args[0].u.val); // this value is always 1
g_private->resumeGame();
}
static void fMovie(ArgArray args) {
// assert types
assert(args[0].type == STRING);
assert(args[1].type == NAME);
debugC(1, kPrivateDebugScript, "Movie(%s, %s)", args[0].u.str, args[1].u.sym->name->c_str());
Common::String movie = args[0].u.str;
Common::String nextSetting = *args[1].u.sym->name;
if (!g_private->_playedMovies.contains(movie) && movie != "\"\"") {
g_private->_nextMovie = movie;
g_private->_playedMovies.setVal(movie, true);
g_private->_nextSetting = nextSetting;
} else if (movie == "\"\"") {
g_private->_repeatedMovieExit = nextSetting;
debugC(1, kPrivateDebugScript, "repeated movie exit is %s", nextSetting.c_str());
} else {
debugC(1, kPrivateDebugScript, "movie %s already played", movie.c_str());
g_private->_nextSetting = g_private->_repeatedMovieExit;
}
}
static void fCRect(ArgArray args) {
// assert types
debugC(1, kPrivateDebugScript, "CRect(%d, %d, %d, %d)", args[0].u.val, args[1].u.val, args[2].u.val, args[3].u.val);
int x1, y1, x2, y2;
x1 = args[0].u.val;
y1 = args[1].u.val;
x2 = args[2].u.val;
y2 = args[3].u.val;
Datum d = Datum();
Common::Rect *rect = new Common::Rect(x1, y1, x2, y2);
d.type = RECT;
d.u.rect = rect;
Gen::push(d);
}
static void fBitmap(ArgArray args) {
assert(args.size() == 1 || args.size() == 3);
int x = 0;
int y = 0;
const char *f = args[0].u.str;
if (args.size() == 3) {
x = args[1].u.val;
y = args[2].u.val;
}
debugC(1, kPrivateDebugScript, "Bitmap(%s, %d, %d)", f, x, y);
Common::String s(args[0].u.str);
g_private->loadImage(s, x, y);
}
static void _fMask(ArgArray args, bool drawn) {
assert(args.size() == 3 || args.size() == 5);
int x = 0;
int y = 0;
const char *f = args[0].u.str;
const char *e = args[1].u.sym->name->c_str();
Common::String *c = args[2].u.sym->name;
if (args.size() == 5) {
x = args[3].u.val;
y = args[4].u.val;
}
debugC(1, kPrivateDebugScript, "Mask(%s, %s, %s, %d, %d)", f, e, c->c_str(), x, y);
const Common::String s(f);
MaskInfo m;
m.surf = g_private->loadMask(s, x, y, drawn);
m.nextSetting = e;
m.cursor = *c;
m.flag1 = nullptr;
m.flag2 = nullptr;
m.point = Common::Point(x, y);
g_private->_masks.push_front(m);
}
static void fMask(ArgArray args) {
_fMask(args, false);
}
static void fMaskDrawn(ArgArray args) {
_fMask(args, true);
}
static void fAddSound(Common::String sound, const char *t, Symbol *flag = nullptr, int val = 0) {
if (sound == "\"\"")
return;
if (strcmp(t, "AMRadioClip") == 0)
g_private->_AMRadio.push_back(sound);
else if (strcmp(t, "PoliceClip") == 0)
g_private->_policeRadio.push_back(sound);
else if (strcmp(t, "PhoneClip") == 0) {
// This condition will avoid adding the same phone call twice,
// it is unclear why this could be useful, but it looks like a bug
// in the original scripts
if (g_private->_playedPhoneClips.contains(sound))
return;
g_private->_playedPhoneClips.setVal(sound, true);
PhoneInfo p;
p.sound = sound;
p.flag = flag;
p.val = val;
g_private->_phone.push_back(p);
} else
error("error: invalid sound type %s", t);
}
static void fAMRadioClip(ArgArray args) {
assert(args.size() <= 4);
fAddSound(args[0].u.str, "AMRadioClip");
}
static void fPoliceClip(ArgArray args) {
assert(args.size() <= 4 || args.size() == 6);
fAddSound(args[0].u.str, "PoliceClip");
// In the original, the variable is updated when the clip is played, but here we just update
// the variable when the clip is added to play. The effect for the player, is mostly the same.
if (args.size() == 6) {
assert(args[4].type == NAME);
assert(args[5].type == NUM);
Symbol *flag = g_private->maps.lookupVariable(args[4].u.sym->name);
setSymbol(flag, args[5].u.val);
}
}
static void fPhoneClip(ArgArray args) {
if (args.size() == 2) {
debugC(1, kPrivateDebugScript, "Unimplemented PhoneClip special case");
return;
}
int i = args[2].u.val;
int j = args[3].u.val;
Symbol *flag = g_private->maps.lookupVariable(args[4].u.sym->name);
if (i == j)
fAddSound(args[0].u.str, "PhoneClip", flag, args[5].u.val);
else {
assert(i < j);
Common::String sound = g_private->getRandomPhoneClip(args[0].u.str, i, j);
fAddSound(sound, "PhoneClip", flag, args[5].u.val);
}
}
static void fSoundArea(ArgArray args) {
// assert types
//char *n;
Common::String n;
if (args[1].type == NAME)
n = *(args[1].u.sym->name);
else if (args[1].type == STRING) {
n = Common::String(args[1].u.str);
Common::replace(n, "\"", "");
Common::replace(n, "\"", "");
} else
error("Invalid input for SoundArea");
debugC(1, kPrivateDebugScript, "SoundArea(%s, %s, ..)", args[0].u.str, n.c_str());
Common::String s = args[0].u.str;
MaskInfo m;
if (n == "kAMRadio") {
m.surf = g_private->loadMask(s, 0, 0, true);
m.cursor = *args[2].u.sym->name;
m.nextSetting = "";
m.flag1 = nullptr;
m.flag2 = nullptr;
if (g_private->_AMRadioArea.surf)
g_private->_AMRadioArea.surf->free();
delete g_private->_AMRadioArea.surf;
g_private->_AMRadioArea = m;
g_private->_masks.push_front(m);
} else if (n == "kPoliceRadio") {
m.surf = g_private->loadMask(s, 0, 0, true);
m.cursor = *args[2].u.sym->name;
m.nextSetting = "";
m.flag1 = nullptr;
m.flag2 = nullptr;
if (g_private->_policeRadioArea.surf)
g_private->_policeRadioArea.surf->free();
delete g_private->_policeRadioArea.surf;
g_private->_policeRadioArea = m;
g_private->_masks.push_front(m);
} else if (n == "kPhone") {
m.surf = g_private->loadMask(s, 0, 0, true);
m.cursor = *args[2].u.sym->name;
m.nextSetting = "";
m.flag1 = nullptr;
m.flag2 = nullptr;
if (g_private->_phoneArea.surf)
g_private->_phoneArea.surf->free();
delete g_private->_phoneArea.surf;
g_private->_phoneArea = m;
g_private->_masks.push_front(m);
} else
error("Invalid type for SoundArea");
}
static void fSafeDigit(ArgArray args) {
assert(args[0].type == NUM);
assert(args[1].type == RECT);
debugC(1, kPrivateDebugScript, "SafeDigit(%d, ..)", args[0].u.val);
g_private->addSafeDigit(args[0].u.val, args[1].u.rect);
}
static void fAskSave(ArgArray args) {
// This is not needed, since scummvm will take care of this
debugC(1, kPrivateDebugScript, "WARNING: AskSave is partially implemented");
g_private->_nextSetting = *args[0].u.sym->name;
}
static void fTimer(ArgArray args) {
assert(args.size() == 2 || args.size() == 3);
if (args.size() == 3)
debugC(1, kPrivateDebugScript, "Timer(%d, %s, %s)", args[0].u.val, args[1].u.sym->name->c_str(), args[2].u.sym->name->c_str());
else
debugC(1, kPrivateDebugScript, "Timer(%d, %s)", args[0].u.val, args[1].u.str);
int32 delay = 1000000 * args[0].u.val;
// This pointer is necessary since installTimer needs one
Common::String *s = new Common::String(args[1].u.sym->name->c_str());
if (delay > 0) {
if (!g_private->installTimer(delay, s))
error("Timer installation failed!");
} else if (delay == 0) {
g_private->_nextSetting = *s;
// No need to keep the pointer alive
delete s;
} else {
assert(0);
}
}
const FuncTable funcTable[] = {
// Control flow
{fChgMode, "ChgMode"},
{fResume, "Resume"},
{fgoto, "goto"},
{fTimer, "Timer"},
// Variables
{fSetFlag, "SetFlag"},
{fSetModifiedFlag, "SetModifiedFlag"},
// Sounds
{fSound, "Sound"},
{fSoundEffect, "SoundEffect"},
{fLoopedSound, "LoopedSound"},
{fNoStopSounds, "NoStopSounds"},
{fSyncSound, "SyncSound"},
{fAMRadioClip, "AMRadioClip"},
{fPoliceClip, "PoliceClip"},
{fPhoneClip, "PhoneClip"},
{fSoundArea, "SoundArea"},
{fPaperShuffleSound, "PaperShuffleSound"},
// Images
{fBitmap, "Bitmap"},
{fMask, "Mask"},
{fMaskDrawn, "MaskDrawn"},
{fVSPicture, "VSPicture"},
{fViewScreen, "ViewScreen"},
{fExit, "Exit"},
// Video
{fTransition, "Transition"},
{fMovie, "Movie"},
// Diary
{fDiaryLocList, "DiaryLocList"},
{fDiaryInvList, "DiaryInvList"},
{fDiaryGoLoc, "DiaryGoLoc"},
// Main menu
{fQuit, "Quit"},
{fLoadGame, "LoadGame"},
{fSaveGame, "SaveGame"},
{fAskSave, "AskSave"},
{fRestartGame, "RestartGame"},
// Dossiers
{fDossierAdd, "DossierAdd"},
{fDossierChgSheet, "DossierChgSheet"},
{fDossierBitmap, "DossierBitmap"},
{fDossierPrevSuspect, "DossierPrevSuspect"},
{fDossierNextSuspect, "DossierNextSuspect"},
// Inventory
{fLoseInventory, "LoseInventory"},
{fInventory, "Inventory"},
// PoliceBust
{fPoliceBust, "PoliceBust"},
{fBustMovie, "BustMovie"},
// Others
{fSafeDigit, "SafeDigit"},
{fCRect, "CRect"},
{nullptr, nullptr}};
void call(const char *name, const ArgArray &args) {
Common::String n(name);
if (!g_private->_functions.contains(n)) {
error("I don't know how to execute %s", name);
}
void (*func)(ArgArray) = (void (*)(ArgArray))g_private->_functions.getVal(n);
func(args);
}
} // End of namespace Private