libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-04-05 08:11:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
8f16dad07c
scummvm/engine/lua.cpp

4025 lines
99 KiB
C++
Raw Blame History

/* Residual - Virtual machine to run LucasArts' 3D adventure games
*
* Residual is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the AUTHORS
* file distributed with this source distribution.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
* This library 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
* Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*
* $URL$
* $Id$
*
*/
#ifdef _WIN32
#include <windows.h>
#undef ARRAYSIZE
#endif
#include "common/sys.h"
#include "common/endian.h"
#include "common/util.h"
#include "common/debug.h"
#include "mixer/mixer.h"
#include "engine/lua.h"
#include "engine/resource.h"
#include "engine/actor.h"
#include "engine/registry.h"
#include "engine/localize.h"
#include "engine/color.h"
#include "engine/colormap.h"
#include "engine/costume.h"
#include "engine/engine.h"
#include "engine/smush/smush.h"
#include "engine/textobject.h"
#include "engine/objectstate.h"
#include "engine/font.h"
#include "engine/primitives.h"
#include "engine/savegame.h"
#include "engine/lipsynch.h"
#include "engine/imuse/imuse.h"
#include <cstdio>
#include <cmath>
#ifdef __SYMBIAN32__
#include <zlib\zlib.h>
#else
#include <zlib.h>
#endif
extern Imuse *g_imuse;
#ifdef _WIN32
extern WIN32_FIND_DATAA g_find_file_data;
extern HANDLE g_searchFile;
extern bool g_firstFind;
#else
extern char g_find_file_data[100];
extern DIR *g_searchFile;
#endif
#define strmatch(src, dst) (strlen(src) == strlen(dst) && strcmp(src, dst) == 0)
#define DEBUG_FUNCTION() debugFunction("Function", __FUNCTION__)
static void debugFunction(const char *debugMessage, const char *funcName);
static void stubWarning(const char *funcName);
static inline bool isObject(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('STAT'))
return true;
return false;
}
static inline bool isActor(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('ACTR'))
return true;
return false;
}
static inline bool isColor(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('COLR'))
return true;
return false;
}
static inline bool isFont(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('FONT'))
return true;
return false;
}
static inline bool isBitmapObject(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('VBUF'))
return true;
return false;
}
// Helper functions to ensure the arguments we get are what we expect
static inline ObjectState *check_object(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('STAT'))
return static_cast<ObjectState *>(lua_getuserdata(param));
luaL_argerror(num, "objectstate expected");
return NULL;
}
static inline Actor *check_actor(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('ACTR'))
return static_cast<Actor *>(lua_getuserdata(param));
luaL_argerror(num, "actor expected");
return NULL;
}
static inline Color *check_color(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('COLR'))
return static_cast<Color *>(lua_getuserdata(param));
luaL_argerror(num, "color expected");
return NULL;
}
static inline Font *check_font(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('FONT'))
return static_cast<Font *>(lua_getuserdata(param));
luaL_argerror(num, "font expected");
return NULL;
}
static inline PrimitiveObject *check_primobject(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('PRIM'))
return static_cast<PrimitiveObject *>(lua_getuserdata(param));
luaL_argerror(num, "primitive expected");
return NULL;
}
static inline TextObject *check_textobject(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('TEXT'))
return static_cast<TextObject *>(lua_getuserdata(param));
luaL_argerror(num, "textobject expected");
return NULL;
}
static inline Bitmap *check_bitmapobject(int num) {
lua_Object param = lua_getparam(num);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('VBUF'))
return static_cast<Bitmap *>(lua_getuserdata(param));
luaL_argerror(num, "image object expected");
return NULL;
}
static inline double check_double(int num) {
// Have found some instances, such as in Rubacava if you jump there,
// where doubles of "zero" are called as nil
if (lua_isnil(lua_getparam(num)))
return 0.0;
return luaL_check_number(num);
}
static inline int check_int(int num) {
double val;
// Have found some instances, such as in Rubacava and the tube-switcher
// room, where integers of "zero" are called as nil
if(lua_isnil(lua_getparam(num)))
return 0;
val = luaL_check_number(num);
return int(round(val));
}
static inline int check_control(int num) {
int val = check_int(num);
if (val < 0 || val >= g_driver->getNumControls())
luaL_argerror(num, "control identifier out of range");
return val;
}
static inline ObjectState::Position check_objstate_pos(int num) {
int val = check_int(num);
if (val < 1 || val > 3)
luaL_argerror(num, "object state position out of range");
return (ObjectState::Position) val;
}
static inline bool getbool(int num) {
return ! lua_isnil(lua_getparam(num));
}
static inline void pushbool(bool val) {
if (val)
lua_pushnumber(1);
else
lua_pushnil();
}
static Costume *get_costume(Actor *a, int param, const char *called_from) {
Costume *result;
if (lua_isnil(lua_getparam(param))) {
result = a->currentCostume();
if (result == NULL && (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL))
warning("Actor %s has no costume [%s]\n", a->name(), called_from);
} else {
result = a->findCostume(luaL_check_string(param));
if (result == NULL && (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL))
warning("Actor %s has no costume %s [%s]\n", a->name(), lua_getstring(lua_getparam(param)), called_from);
}
return result;
}
// Lua interface to bundle_dofile
static void new_dofile() {
const char *fname_str = luaL_check_string(1);
bundle_dofile(fname_str);
}
// Debugging message functions
static void PrintDebug() {
DEBUG_FUNCTION();
if (debugLevel == DEBUG_NORMAL || debugLevel == DEBUG_ALL) {
std::string msg = luaL_check_string(1);
msg.insert(0, "Debug: ");
msg.append("\n");
std::fputs(msg.c_str(), stderr);
}
}
static void PrintError() {
DEBUG_FUNCTION();
if (debugLevel == DEBUG_ERROR || debugLevel == DEBUG_ALL) {
std::string msg = luaL_check_string(1);
msg.insert(0, "Error: ");
// don't do 'error()' so we can stay alive if possible
std::fputs(msg.c_str(), stderr);
}
}
static void PrintWarning() {
DEBUG_FUNCTION();
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL) {
std::string msg = luaL_check_string(1);
msg.insert(0, "Warning: ");
warning(msg.c_str());
}
}
static void FunctionName() {
const char *name;
char buf[256];
const char *filename;
int line;
DEBUG_FUNCTION();
if (!lua_isfunction(lua_getparam(1))) {
sprintf(buf, "function InvalidArgsToFunctionName");
lua_pushstring(buf);
return;
}
lua_funcinfo(lua_getparam(1), &filename, &line);
switch (*lua_getobjname(lua_getparam(1), &name)) {
case 'g':
sprintf(buf, "function %.100s", name);
break;
case 't':
sprintf(buf, "`%.100s' tag method", name);
break;
default:
{
if (line == 0)
sprintf(buf, "main of %.100s", filename);
else if (line < 0)
sprintf(buf, "%.100s", filename);
else {
sprintf(buf, "function (%.100s:%d)", filename, line);
filename = NULL;
}
}
}
int curr_line = lua_currentline(lua_getparam(1));
if (curr_line > 0)
sprintf(buf + strlen(buf), " at line %d", curr_line);
if (filename != NULL)
sprintf(buf + strlen(buf), " [in file %.100s]", filename);
lua_pushstring(buf);
}
// File functions
static void CheckForFile() {
const char *filename = luaL_check_string(1);
DEBUG_FUNCTION();
pushbool(g_resourceloader->fileExists(filename));
}
// Color functions
static unsigned char clamp_color(int c) {
if (c < 0)
return 0;
else if (c > 255)
return 255;
else
return c;
}
static void MakeColor() {
Color *c;
DEBUG_FUNCTION();
c = new Color (clamp_color(check_int(1)), clamp_color(check_int(2)), clamp_color(check_int(3)));
lua_pushusertag(c, MKID_BE('COLR'));
}
static void GetColorComponents() {
Color *c;
DEBUG_FUNCTION();
c = check_color(1);
lua_pushnumber(c->red());
lua_pushnumber(c->green());
lua_pushnumber(c->blue());
}
// Registry functions
static void ReadRegistryValue() {
const char *key;
const char *val;
DEBUG_FUNCTION();
key = luaL_check_string(1);
val = g_registry->get(key, NULL);
lua_pushstring(const_cast<char *>(val));
}
static void WriteRegistryValue() {
const char *key;
const char *val;
DEBUG_FUNCTION();
key = luaL_check_string(1);
val = luaL_check_string(2);
g_registry->set(key, val);
}
// Actor functions
static void LoadActor() {
const char *name;
DEBUG_FUNCTION();
if (lua_isnil(lua_getparam(1)))
name = "<unnamed>";
else
name = luaL_check_string(1);
lua_pushusertag(new Actor(name), MKID_BE('ACTR'));
}
static void GetActorTimeScale() {
DEBUG_FUNCTION();
// return 1 so the game doesn't halt when Manny attempts
// to pick up the fire extinguisher
lua_pushnumber(1);
}
static void SetSelectedActor() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
g_engine->setSelectedActor(act);
}
/* Get the currently selected actor, this is used in
* "Camera-Relative" mode to handle the appropriate
* actor for movement
*/
static void GetCameraActor() {
Actor *act;
DEBUG_FUNCTION();
stubWarning("VERIFY: GetCameraActor");
act = g_engine->selectedActor();
lua_pushusertag(act, MKID_BE('ACTR'));
}
static void SetSayLineDefaults() {
const char *key_text = NULL;
lua_Object table_obj;
lua_Object key = LUA_NOOBJECT;
DEBUG_FUNCTION();
table_obj = lua_getparam(1);
for (;;) {
lua_pushobject(table_obj);
if (key_text)
lua_pushobject(key);
else
lua_pushnil();
// If the call to "next" fails then register an error
if (lua_call("next") != 0) {
error("SetSayLineDefaults failed to get next key!\n");
return;
}
key = lua_getresult(1);
if (lua_isnil(key))
break;
key_text = lua_getstring(key);
if (strmatch(key_text, "font"))
sayLineDefaults.font = check_font(2);
else
error("Unknown SetSayLineDefaults key %s\n", key_text);
}
}
static void SetActorTalkColor() {
Actor *act;
Color *c;
DEBUG_FUNCTION();
act = check_actor(1);
c = check_color(2);
act->setTalkColor(*c);
}
static void GetActorTalkColor() {
Actor *act;
Color *c;
DEBUG_FUNCTION();
act = check_actor(1);
c = new Color(act->talkColor());
lua_pushusertag(c, MKID_BE('COLR'));
}
static void SetActorRestChore() {
Actor *act;
int chore;
Costume *costume;
DEBUG_FUNCTION();
act = check_actor(1);
if (lua_isnil(lua_getparam(2))) {
chore = -1;
costume = NULL;
} else {
chore = check_int(2);
costume = get_costume(act, 3, "SetActorRestChore");
}
act->setRestChore(chore, costume);
}
static void SetActorWalkChore() {
Actor *act;
int chore;
Costume *costume;
DEBUG_FUNCTION();
act = check_actor(1);
chore = check_int(2);
costume = get_costume(act, 3, "SetActorWalkChore");
if (costume == NULL) {
if (debugLevel == DEBUG_CHORES || debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("SetActorWalkChore() could not find the requested costume, attempting to load...");
act->pushCostume(lua_getstring(lua_getparam(3)));
costume = get_costume(act, 3, "SetActorWalkChore");
if (costume == NULL) {
if (debugLevel == DEBUG_CHORES || debugLevel == DEBUG_ERROR || debugLevel == DEBUG_ALL)
error("SetActorWalkChore() could not find the requested costume!");
return;
}
}
act->setWalkChore(chore, costume);
}
static void SetActorTurnChores() {
Actor *act;
int left_chore;
int right_chore;
Costume *costume;
DEBUG_FUNCTION();
act = check_actor(1);
left_chore = check_int(2);
right_chore = check_int(3);
costume = get_costume(act, 4, "SetActorTurnChores");
act->setTurnChores(left_chore, right_chore, costume);
}
static void SetActorTalkChore() {
Actor *act;
int index;
int chore;
DEBUG_FUNCTION();
act = check_actor(1);
index = check_int(2);
if (lua_isnumber(lua_getparam(3)))
chore = check_int(3);
else
chore = -1;
Costume *costume = get_costume(act, 4, "setActorTalkChore");
act->setTalkChore(index, chore, costume);
}
static void SetActorMumblechore() {
Actor *act;
int chore;
Costume *costume;
DEBUG_FUNCTION();
act = check_actor(1);
chore = check_int(2);
costume = get_costume(act, 3, "SetActorMumblechore");
act->setMumbleChore(chore, costume);
}
static void SetActorVisibility() {
Actor *act;
bool val;
DEBUG_FUNCTION();
act = check_actor(1);
val = getbool(2);
act->setVisibility(val);
}
static void PutActorAt() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
act->setPos(Vector3d(luaL_check_number(2), luaL_check_number(3), luaL_check_number(4)));
}
static void GetActorPos() {
Actor *act;
Vector3d pos;
DEBUG_FUNCTION();
act = check_actor(1);
pos = act->pos();
// It is important to process this request for all actors,
// even for actors not within the active scene
lua_pushnumber(pos.x());
lua_pushnumber(pos.y());
lua_pushnumber(pos.z());
}
static void SetActorRot() {
float pitch, yaw, roll;
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
pitch = check_double(2);
yaw = check_double(3);
roll = check_double(4);
if (getbool(5))
act->turnTo(pitch, yaw, roll);
else
act->setRot(pitch, yaw, roll);
}
static void GetActorRot() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
lua_pushnumber(act->pitch());
lua_pushnumber(act->yaw());
lua_pushnumber(act->roll());
}
static void IsActorTurning() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
pushbool(act->isTurning());
}
static void GetAngleBetweenActors() {
Actor *act1;
Actor *act2;
DEBUG_FUNCTION();
act1 = check_actor(1);
act2 = check_actor(2);
lua_pushnumber(act1->angleTo(*act2));
}
static void GetActorYawToPoint() {
Vector3d yawVector;
lua_Object param2;
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
param2 = lua_getparam(2);
// when this gets called by the tube-switcher guy it's sending
// only two things: an actor and a table with components x, y, z
if (lua_isnumber(param2)) {
yawVector = Vector3d(luaL_check_number(2), luaL_check_number(3), luaL_check_number(4));
} else if (lua_istable(param2)) {
yawVector = tableToVector(param2);
} else {
if (debugLevel == DEBUG_ERROR || debugLevel == DEBUG_ALL)
error("Unhandled data type for GetActorYawToPoint!");
lua_pushnil();
return;
}
lua_pushnumber(act->yawTo(yawVector));
}
/* Changes the set that an actor is associated with,
* by changing the set to "nil" an actor is disabled
* but should still not be destroyed.
*/
static void PutActorInSet() {
const char *set = "";
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
// If the set is "nil" then set to an empty string, we should not render
// objects in the empty set or bad things will happen like the Bone
// Wagon not changing scenes correctly.
lua_Object param2 = lua_getparam(2);
if (!lua_isnil(param2))
set = luaL_check_string(2);
// Make sure the actor isn't already in the set
if (!act->inSet(set))
act->putInSet(set);
}
static void SetActorWalkRate() {
Actor *act;
float rate;
DEBUG_FUNCTION();
act = check_actor(1);
rate = luaL_check_number(2);
act->setWalkRate(rate);
}
static void GetActorWalkRate() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
lua_pushnumber(act->walkRate());
}
static void SetActorTurnRate() {
Actor *act;
float rate;
DEBUG_FUNCTION();
act = check_actor(1);
rate = luaL_check_number(2);
act->setTurnRate(rate);
}
static void WalkActorForward() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
act->walkForward();
}
static void SetActorReflection() {
Actor *act;
float angle;
DEBUG_FUNCTION();
act = check_actor(1);
angle = luaL_check_number(2);
act->setReflection(angle);
}
static void GetActorPuckVector() {
Actor *act;
Vector3d result;
DEBUG_FUNCTION();
act = check_actor(1);
result = act->puckVector();
lua_pushnumber(result.x());
lua_pushnumber(result.y());
lua_pushnumber(result.z());
}
static void WalkActorTo() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
act->walkTo(Vector3d(luaL_check_number(2), luaL_check_number(3), luaL_check_number(4)));
}
static void IsActorMoving() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
pushbool(act->isWalking());
}
static void Is3DHardwareEnabled() {
DEBUG_FUNCTION();
pushbool(g_driver->isHardwareAccelerated());
}
static void SetHardwareState() {
// changing only in config setup (software/hardware rendering)
bool accel;
DEBUG_FUNCTION();
accel = getbool(1);
if (accel)
g_registry->set("soft", "FALSE");
else
g_registry->set("soft", "TRUE");
g_registry->save();
}
static void SetVideoDevices() {
int devId;
int modeId;
DEBUG_FUNCTION();
devId = check_int(1);
modeId = check_int(2);
// ignore setting video devices
}
static void GetVideoDevices() {
DEBUG_FUNCTION();
lua_pushnumber(0.0);
lua_pushnumber(-1.0);
}
static void EnumerateVideoDevices() {
lua_Object result = lua_createtable();
DEBUG_FUNCTION();
lua_pushobject(result);
lua_pushnumber(0.0); // id of device
lua_pushstring(g_driver->getVideoDeviceName()); // name of device
lua_settable();
lua_pushobject(result);
}
static void Enumerate3DDevices() {
lua_Object result = lua_createtable();
int num;
DEBUG_FUNCTION();
num = check_int(1);
lua_pushobject(result);
lua_pushnumber(-1.0);
if (g_driver->isHardwareAccelerated()) {
lua_pushstring("OpenGL"); // type of 3d renderer
} else {
lua_pushstring("/engn003/Software"); // type of 3d renderer
}
lua_settable();
lua_pushobject(result);
}
static void IsActorResting() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
pushbool(!(act->isWalking() || act->isTurning()));
}
/* Get the location of one of the actor's nodes, this is
* used by Glottis to watch where Manny is located in
* order to hand him the work order. This function is
* also important for when Velasco hands Manny the logbook
* in Rubacava
*/
static void GetActorNodeLocation() {
Model::HierNode *allNodes;
Costume *c;
Actor *act;
int node;
DEBUG_FUNCTION();
act = check_actor(1);
node = check_int(2);
c = act->currentCostume();
if (c == NULL) {
lua_pushnil();
lua_pushnil();
lua_pushnil();
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("GetActorNodeLocation() when actor has no costume (which means no nodes)!");
return;
}
allNodes = c->getModelNodes();
if (allNodes == NULL) {
lua_pushnil();
lua_pushnil();
lua_pushnil();
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("GetActorNodeLocation() when actor has no nodes!");
return;
}
lua_pushnumber(allNodes[node]._pos.x());
lua_pushnumber(allNodes[node]._pos.y());
lua_pushnumber(allNodes[node]._pos.z());
}
/* This function is called to stop walking actions that
* are in progress, it is unknown whether it should start
* walking actions that are not in progress.
*/
static void SetActorWalkDominate() {
lua_Object param2;
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
if (act == NULL) {
lua_pushnil();
return;
}
param2 = lua_getparam(2);
if (lua_isnil(param2)) {
lua_pushnil();
} else if (lua_isnumber(param2)) {
int walkcode = check_int(2);
if (walkcode != 1) {
warning("Unknown SetActorWalkDominate 'walking code' value: %d", walkcode);
lua_pushnil();
return;
}
// When Manny is pursued out of the dam area by a demon
// beaver he needs to stop his walk chore
act->stopWalking();
lua_pushnumber(walkcode);
} else {
warning("Unknown SetActorWalkDominate parameter!");
lua_pushnil();
}
}
static void SetActorColormap() {
const char *mapname;
CMap *_cmap;
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
mapname = luaL_check_string(2);
_cmap = g_resourceloader->loadColormap(mapname);
act->setColormap(mapname);
}
static void TurnActor() {
Actor *act;
int dir;
DEBUG_FUNCTION();
act = check_actor(1);
dir = check_int(2);
act->turn(dir);
}
static void PushActorCostume() {
Actor *act;
const char *costumeName;
DEBUG_FUNCTION();
act = check_actor(1);
costumeName = luaL_check_string(2);
act->pushCostume(costumeName);
}
static void SetActorCostume() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
if (lua_isnil(lua_getparam(2)))
act->clearCostumes();
else {
const char *costumeName = luaL_check_string(2);
act->setCostume(costumeName);
}
}
static void GetActorCostume() {
Actor *act;
Costume *c;
DEBUG_FUNCTION();
act = check_actor(1);
c = act->currentCostume();
if (c == NULL) {
lua_pushnil();
if (debugLevel == DEBUG_NORMAL || debugLevel == DEBUG_ALL)
printf("GetActorCostume() on '%s' when actor has no costume!\n", act->name());
return;
}
lua_pushstring(const_cast<char *>(c->filename()));
}
static void PopActorCostume() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
act->popCostume();
}
static void GetActorCostumeDepth() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
lua_pushnumber(act->costumeStackDepth());
}
static void PlayActorChore() {
Actor *act;
int num;
Costume *cost;
DEBUG_FUNCTION();
act = check_actor(1);
num = check_int(2);
cost = get_costume(act, 3, "playActorChore");
if (!cost) {
if (debugLevel == DEBUG_CHORES || debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("Actor costume not found, unable to perform chore.");
return;
}
cost->playChore(num);
}
static void CompleteActorChore() {
Costume *cost;
Actor *act;
int num;
// CompleteActorChore appears to be an alias for PlayActorChore
// Except that we should jump to the last frame of the chore
//
// Example: When Manny puts the message tube back in his office
// the animation automatically puts the tube back into place
// and then calls this function to show the closed graphic
//
// Note: This does not appear to function entirely as it should
// TODO: Make this operation work better
DEBUG_FUNCTION();
act = check_actor(1);
num = check_int(2);
cost = get_costume(act, 3, "completeActorChore");
if (!cost) {
if (debugLevel == DEBUG_CHORES || debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("Actor costume not found, unable to perform chore.");
return;
}
cost->setChoreLastFrame(num);
}
static void PlayActorChoreLooping() {
Actor *act;
int num;
Costume *cost;
DEBUG_FUNCTION();
act = check_actor(1);
num = check_int(2);
cost = get_costume(act, 3, "playActorChoreLooping");
if (!cost)
return;
cost->playChoreLooping(num);
}
static void SetActorChoreLooping() {
Actor *act;
int num;
bool val;
Costume *cost;
DEBUG_FUNCTION();
act = check_actor(1);
num = check_int(2);
val = getbool(3);
cost = get_costume(act, 4, "setActorChoreLooping");
if (!cost)
return;
cost->setChoreLooping(num, val);
}
static void StopActorChore() {
Actor *act;
Costume *cost;
DEBUG_FUNCTION();
act = check_actor(1);
cost = get_costume(act, 3, "stopActorChore");
if (!cost)
return;
if (lua_isnil(lua_getparam(2)))
cost->stopChores();
else
cost->stopChore(check_int(2));
}
static void IsActorChoring() {
bool excludeLooping;
lua_Object param2;
Costume *cost;
Actor *act;
int result = -1;
DEBUG_FUNCTION();
act = check_actor(1);
excludeLooping = getbool(3);
cost = get_costume(act, 4, "isActorChoring");
if (!cost) {
lua_pushnil();
return;
}
// This function can be called with "nil" to get the current
// chore, a number to check to see if that chore ID is
// running, or a string that will check to see if the
// chore of a particular name is running
param2 = lua_getparam(2);
if (lua_isnil(param2))
result = cost->isChoring(excludeLooping);
else if (lua_isnumber(param2))
result = cost->isChoring(check_int(2), excludeLooping);
else if (lua_isstring(param2))
result = cost->isChoring(lua_getstring(param2), excludeLooping);
else {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("IsActorChoring: LUA Parameter 2 is of unhandled type!");
}
if (result < 0)
lua_pushnil();
else
lua_pushnumber(result);
}
static void ActorLookAt() {
float rate = 100.0; // Give a default rate
lua_Object x, y, z;
bool nullvector = false;
Vector3d vector;
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
x = lua_getparam(2);
y = lua_getparam(3);
z = lua_getparam(4);
// Look at nothing
if (lua_isnil(x)) {
if (act->isLookAtVectorZero()) {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("Actor requested to look at nothing, already looking at nothing!\n");
return;
}
nullvector = true;
if (lua_isnumber(y))
rate = luaL_check_number(3);
} else if ( lua_isnumber(x)) { // look at xyz
float fX;
float fY;
float fZ;
fX = luaL_check_number(2);
if (lua_isnumber(y))
fY = luaL_check_number(3);
else
fY = 0.f;
if (lua_isnumber(z))
fZ = luaL_check_number(4);
else
fZ = 0.f;
vector.set(fX,fY,fZ);
if (lua_isnumber(lua_getparam(5)))
rate = luaL_check_number(5);
} else if (isActor(2)) { // look at another actor
Actor *lookedAct = check_actor(2);
act->setLookAtVector(lookedAct->pos());
if (lua_isnumber(y))
rate = luaL_check_number(3);
} else {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("ActorLookAt: Don't know what to look at!");
return;
}
act->setLookAtRate(rate);
if (nullvector)
act->setLookAtVectorZero();
else
act->setLookAtVector(vector);
act->setLooking(true);
pushbool(act->isTurning());
}
/* Turn the actor to a point specified in the 3D space,
* this should not have the actor look toward the point
* but should rotate the entire actor toward it.
*
* This function must use a yaw value around the unit
* circle and not just a difference in angles.
*/
static void TurnActorTo() {
float x, y, z, yaw;
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
if (lua_isnumber(lua_getparam(2))) {
x = luaL_check_number(2);
y = luaL_check_number(3);
z = luaL_check_number(4);
} else if (isActor(2)) {
Actor *destActor;
destActor = check_actor(2);
x = destActor->pos().x();
y = destActor->pos().y();
z = destActor->pos().z();
} else {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("TurnActorTo() parameter type not understood");
return;
}
// Find the vector pointing from the actor to the desired location
Vector3d turnToVector(x, y, z);
Vector3d lookVector = turnToVector - act->pos();
// find the angle the requested position is around the unit circle
yaw = lookVector.unitCircleAngle();
// yaw is offset from forward by 90 degrees
yaw -= 90.0f;
act->turnTo(0, yaw, 0);
// Game will lock in elevator if this doesn't return false
pushbool(false);
}
/* PointActorAt seems to be an alias for TurnActorTo
*/
static void PointActorAt() {
DEBUG_FUNCTION();
TurnActorTo();
}
/* WalkActorVector handles the movement of the selected actor
* when the game is in "Camera-Relative Movement Mode"
*
* NOTE: The usage for paramaters 1 and 5 are as-yet unknown.
*/
static void WalkActorVector() {
float moveHoriz, moveVert, yaw;
Actor *act;
DEBUG_FUNCTION();
stubWarning("VERIFY: WalkActorVector");
// Second option is the actor returned by GetCameraActor
act = check_actor(2);
// Third option is the "left/right" movement
moveHoriz = luaL_check_number(3);
// Fourth Option is the "up/down" movement
moveVert = luaL_check_number(4);
// Get the direction the camera is pointing
Vector3d cameraVector = g_engine->currScene()->_currSetup->_interest - g_engine->currScene()->_currSetup->_pos;
// find the angle the camera direction is around the unit circle
float cameraYaw = cameraVector.unitCircleAngle();
// Handle the turning
Vector3d adjustVector(moveHoriz, moveVert, 0);
// find the angle the adjust vector is around the unit circle
float adjustYaw = adjustVector.unitCircleAngle();
yaw = cameraYaw + adjustYaw;
// yaw is offset from forward by 180 degrees
yaw -= 180.0f;
// set the yaw so it can be compared against the current
// value for the actor yaw
if (yaw < 0.0f)
yaw += 360.0f;
if (yaw >= 360.0f)
yaw -= 360.0f;
// set the new direction or walk forward
if (act->yaw() != yaw)
act->turnTo(0, yaw, 0);
else
act->walkForward();
}
/* RotateVector takes a vector and rotates it around
* the point (0,0,0) by the requested number of degrees.
* This function is used to calculate the locations for
* getting on and off of the Bone Wagon.
*/
static void RotateVector() {
lua_Object param1, param2, result;
DEBUG_FUNCTION();
stubWarning("VERIFY: RotateVector");
param1 = lua_getparam(1);
param2 = lua_getparam(2);
if (lua_istable(param1) && lua_istable(param2)) {
Vector3d vec1 = tableToVector(param1);
lua_Object rotateObject = getTableValue(param2, "y");
float rotate, currAngle, newAngle;
// The signpost uses an indexed table (1,2,3) instead of
// a value-based table (x,y,z)
if (rotateObject == 0)
rotateObject = getIndexedTableValue(param2, 2);
rotate = lua_getnumber(rotateObject);
Vector3d baseVector(std::sin(0.0f), std::cos(0.0f), 0);
currAngle = angle(baseVector, vec1) * (180 / LOCAL_PI);
newAngle = (currAngle - rotate) * (LOCAL_PI / 180);
Vector3d vec2(std::sin(newAngle), std::cos(newAngle), 0);
vec2 *= vec1.magnitude();
result = lua_createtable();
lua_pushobject(result);
lua_pushstring("x");
lua_pushnumber(vec2.x());
lua_settable();
lua_pushobject(result);
lua_pushstring("y");
lua_pushnumber(vec2.y());
lua_settable();
lua_pushobject(result);
lua_pushstring("z");
lua_pushnumber(vec2.z());
lua_settable();
} else {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("RotateVector() parameter type not understood!");
// This will likely cause a crash since LUA is expecting
// a table out of this function
lua_pushnil();
return;
}
lua_pushobject(result);
}
/* Set the pitch of the actor to the requested value,
* this will rotate an actor toward/away from the ground.
* This is used when Glottis runs over the signpost in
* the Petrified Forest
*/
static void SetActorPitch() {
lua_Object param2;
Actor *act;
DEBUG_FUNCTION();
stubWarning("VERIFY: SetActorPitch");
act = check_actor(1);
param2 = lua_getparam(2);
if (lua_isnumber(param2)) {
float pitch = lua_getnumber(param2);
act->setRot(pitch, act->yaw(), act->roll());
} else {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("SetActorPitch() parameter type not understood!");
return;
}
}
static void SetActorLookRate() {
Actor *act;
float rate;
DEBUG_FUNCTION();
act = check_actor(1);
rate = luaL_check_number(2);
act->setLookAtRate(rate);
}
static void GetActorLookRate() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
lua_pushnumber(act->lookAtRate());
}
static void SetActorHead() {
float maxRoll, maxPitch, maxYaw;
int joint1, joint2, joint3;
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
joint1 = check_int(2);
joint2 = check_int(3);
joint3 = check_int(4);
maxRoll = luaL_check_number(5); // Yaz: recheck to see if it's really roll
maxPitch = luaL_check_number(6);
maxYaw = luaL_check_number(7);
act->setHead(joint1, joint2, joint3, maxRoll, maxPitch, maxYaw);
}
static void PutActorAtInterest() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
if (!g_engine->currScene())
return;
act->setPos(g_engine->currScene()->_currSetup->_interest);
}
static void SetActorFollowBoxes() {
Actor *act;
bool mode;
DEBUG_FUNCTION();
act = check_actor(1);
mode = !lua_isnil(lua_getparam(2));
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("SetActorFollowBoxes() not implemented");
// that is not walkbox walking, but temporary hack
// act->enableWalkbox(mode);
act->setConstrain(mode);
}
static void SetActorConstrain() {
// Actor *act = check_actor(1);
// bool constrain = !lua_isnil(lua_getparam(2));
// that below should be enabled, but for now it's disabled realated to
// above func SetActorFollowBoxes.
// act->setConstrain(constrain);
stubWarning("SetActorConstrain");
}
static void GetVisibleThings() {
lua_Object result = lua_createtable();
Actor *sel;
DEBUG_FUNCTION();
sel = g_engine->selectedActor();
for (Engine::ActorListType::const_iterator i = g_engine->actorsBegin(); i != g_engine->actorsEnd(); i++) {
if (!(*i)->inSet(g_engine->sceneName()))
continue;
// Consider the active actor visible
if (sel == (*i) || sel->angleTo(*(*i)) < 90) {
lua_pushobject(result);
lua_pushusertag(*i, MKID_BE('ACTR'));
lua_pushnumber(1);
lua_settable();
}
}
lua_pushobject(result);
}
static void SetShadowColor() {
DEBUG_FUNCTION();
int r = check_int(1);
int g = check_int(2);
int b = check_int(3);
g_driver->setShadowColor(r, g, b);
}
static void KillActorShadows() {
DEBUG_FUNCTION();
Actor *act = check_actor(1);
act->clearShadowPlanes();
}
static void SetActiveShadow() {
DEBUG_FUNCTION();
Actor *act = check_actor(1);
int shadowId = check_int(2);
act->setActiveShadow(shadowId);
}
static void SetActorShadowPoint() {
DEBUG_FUNCTION();
Actor *act = check_actor(1);
float x = luaL_check_number(2);
float y = luaL_check_number(3);
float z = luaL_check_number(4);
act->setShadowPoint(Vector3d(x, y, z));
}
static void SetActorShadowPlane() {
DEBUG_FUNCTION();
Actor *act = check_actor(1);
const char *name = lua_getstring(lua_getparam(2));
act->setShadowPlane(name);
}
static void AddShadowPlane() {
DEBUG_FUNCTION();
Actor *act = check_actor(1);
const char *name = lua_getstring(lua_getparam(2));
act->addShadowPlane(name);
}
static void ActivateActorShadow() {
DEBUG_FUNCTION();
Actor *act = check_actor(1);
int shadowId = check_int(2);
bool state = getbool(3);
act->setActivateShadow(shadowId, state);
g_engine->flagRefreshShadowMask(true);
}
static void SetActorShadowValid() {
DEBUG_FUNCTION();
Actor *act = check_actor(1);
int valid = check_int(2);
warning("SetActorShadowValid(%d) unknown purpose", valid);
act->setShadowValid(valid);
}
// 0 - translate from '/msgId/'
// 1 - don't translate - message after '/msgId'
// 2 - return '/msgId/'
int translationMode = 0;
std::string parseMsgText(const char *msg, char *msgId) {
std::string translation = g_localizer->localize(msg);
const char *secondSlash = NULL;
if ((msg[0] == '/') && (msgId)) {
secondSlash = std::strchr(msg + 1, '/');
if (secondSlash != NULL) {
strncpy(msgId, msg + 1, secondSlash - msg - 1);
msgId[secondSlash - msg - 1] = 0;
} else {
msgId[0] = 0;
}
}
if (translationMode == 1)
return secondSlash;
if (translationMode == 2)
return msg;
return translation;
}
static void TextFileGetLine() {
char textBuf[512];
textBuf[0] = 0;
const char *filename;
FILE *file;
DEBUG_FUNCTION();
filename = luaL_check_string(1);
file = fopen(filename, "r");
if (!file) {
lua_pushnil();
return;
}
int pos = check_int(2);
fseek(file, pos, SEEK_SET);
fgets(textBuf, 512, file);
fclose(file);
lua_pushstring(textBuf);
}
static void TextFileGetLineCount() {
char textBuf[512];
const char *filename;
FILE *file;
DEBUG_FUNCTION();
filename = luaL_check_string(1);
file = fopen(filename, "r");
if (!file) {
lua_pushnil();
return;
}
lua_Object result = lua_createtable();
int line = 0;
for (;;) {
if (feof(file))
break;
lua_pushobject(result);
lua_pushnumber(line);
int pos = ftell(file);
lua_pushnumber(pos);
lua_settable();
fgets(textBuf, 512, file);
line++;
}
fclose(file);
lua_pushobject(result);
lua_pushstring("count");
lua_pushnumber(line);
lua_settable();
lua_pushobject(result);
}
// Localization function
static void LocalizeString() {
char msgId[32], buf[640];
const char *str, *result;
DEBUG_FUNCTION();
str = luaL_check_string(1);
// If the string that we're passed isn't localized yet then
// construct the localized string, otherwise spit back what
// we've been given
if (str[0] == '/' && str[strlen(str)-1] == '/') {
std::string msg = parseMsgText(str, msgId);
sprintf(buf, "/%s/%s", msgId, msg.c_str());
result = buf;
} else {
result = str;
}
lua_pushstring(result);
}
static void SayLine() {
int pan = 64, param_number = 2;
char msgId[32];
std::string msg = "";
lua_Object param2;
Actor *act;
DEBUG_FUNCTION();
param2 = lua_getparam(param_number++);
act = check_actor(1);
if (!lua_isnil(param2)) {
do {
if (lua_isstring(param2)) {
const char *tmpstr = lua_getstring(param2);
msg = parseMsgText(tmpstr, msgId);
} else if (lua_isnumber(param2)) {
pan = 64;
} else if (lua_istable(param2)) {
warning("SayLine() param is table");
} else {
error("SayLine() unknown type of param");
}
param2 = lua_getparam(param_number++);
} while (!lua_isnil(param2));
if (msg.empty()) {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("SayLine: Did not find a message ID!");
stubWarning("ERROR: SayLine");
return;
}
act->sayLine(msg.c_str(), msgId);
}
}
static void InputDialog() {
int c, i = 0;
char buf[512];
DEBUG_FUNCTION();
fprintf(stderr, "%s %s: ", luaL_check_string(1), luaL_check_string(2));
while (i < 512 && (c = fgetc(stdin)) != EOF && c != '\n')
buf[i++] = c;
buf[i] = '\0';
lua_pushstring(buf);
}
static void IsMessageGoing() {
Actor *act;
DEBUG_FUNCTION();
if (lua_getparam(1) == LUA_NOOBJECT) {
pushbool(g_imuse->isVoicePlaying());
} else {
act = check_actor(1);
pushbool(act->talking());
}
}
static void ShutUpActor() {
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
if (act)
act->shutUp();
}
// Sector functions
/* Find the sector (of any type) which contains
* the requested coordinate (x,y,z).
*/
static void GetPointSector(void) {
lua_Object xparam, yparam, zparam;
Sector *result;
float x = 0.0f, y = 0.0f, z = 0.0f;
DEBUG_FUNCTION();
stubWarning("VERIFY: GetPointSector");
xparam = lua_getparam(1);
yparam = lua_getparam(2);
zparam = lua_getparam(3);
if (lua_isnumber(xparam) && lua_isnumber(yparam) && lua_isnumber(zparam)) {
Vector3d point(x, y, z);
// Find the point in any available sector
result = g_engine->currScene()->findPointSector(point, 0xFFFF);
} else {
result = NULL;
}
if (result == NULL) {
if (debugLevel == DEBUG_ERROR || debugLevel == DEBUG_ALL)
error("GetPointSector() passed an unhandled type or failed to find any matching sector!");
lua_pushnil();
lua_pushnil();
lua_pushnil();
return;
}
lua_pushnumber(result->id());
lua_pushstring(const_cast<char *>(result->name()));
lua_pushnumber(result->type());
}
static void GetActorSector(void) {
Actor *act;
int sectorType;
DEBUG_FUNCTION();
act = check_actor(1);
sectorType = check_int(2);
Sector *result = g_engine->currScene()->findPointSector(act->pos(), sectorType);
if (result != NULL) {
lua_pushnumber(result->id());
lua_pushstring(const_cast<char *>(result->name()));
lua_pushnumber(result->type());
} else {
lua_pushnil();
lua_pushnil();
lua_pushnil();
}
}
static void IsActorInSector(void) {
int i, numSectors;
const char *name;
Actor *act;
DEBUG_FUNCTION();
act = check_actor(1);
name = luaL_check_string(2);
numSectors = g_engine->currScene()->getSectorCount();
for (i = 0; i < numSectors; i++) {
Sector *sector = g_engine->currScene()->getSectorBase(i);
if (sector->visible() && strmatch(sector->name(), name)) {
if (sector->isPointInSector(act->pos())) {
lua_pushnumber(sector->id());
lua_pushstring((char *)sector->name());
lua_pushnumber(sector->type());
return;
}
}
}
lua_pushnil();
lua_pushnil();
lua_pushnil();
}
static void MakeSectorActive(void) {
lua_Object sectorName;
bool visible;
int i = 0, numSectors;
DEBUG_FUNCTION();
sectorName = lua_getparam(1);
visible = !lua_isnil(lua_getparam(2));
// FIXME: This happens on initial load. Are we initting something in the wrong order?
if (!g_engine->currScene() && (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)) {
warning("!!!! Trying to call MakeSectorActive without a scene!");
return;
}
numSectors = g_engine->currScene()->getSectorCount();
if (lua_isstring(sectorName)) {
const char *name = luaL_check_string(1);
for (i = 0; i < numSectors; i++) {
Sector *sector = g_engine->currScene()->getSectorBase(i);
if (strmatch(sector->name(), name)) {
sector->setVisible(visible);
return;
}
}
} else if (lua_isnumber(sectorName)) {
int id = check_int(1);
for (i = 0; i < numSectors; i++) {
Sector *sector = g_engine->currScene()->getSectorBase(i);
if (sector->id() == id) {
sector->setVisible(visible);
return;
}
}
} else if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL){
warning("MakeSectorActive Parameter is not a sector ID or Name");
return;
} else
return;
}
// Scene functions
static void LockSet() {
const char *name;
DEBUG_FUNCTION();
name = luaL_check_string(1);
// We should lock the set so it isn't destroyed
g_engine->setSceneLock(name, true);
}
static void UnLockSet() {
const char *name;
DEBUG_FUNCTION();
name = luaL_check_string(1);
// We should unlock the set so it can be destroyed again
g_engine->setSceneLock(name, false);
}
static void MakeCurrentSet() {
const char *name;
DEBUG_FUNCTION();
name = luaL_check_string(1);
if (debugLevel == DEBUG_NORMAL || debugLevel == DEBUG_ALL)
printf("Entered new scene '%s'.\n", name);
g_engine->setScene(name);
}
static void MakeCurrentSetup() {
int num, prevSetup;
DEBUG_FUNCTION();
num = check_int(1);
prevSetup = g_engine->currScene()->setup();
g_engine->currScene()->setSetup(num);
lua_beginblock();
lua_Object camChangeHandler = getEventHandler("camChangeHandler");
if (camChangeHandler != LUA_NOOBJECT) {
lua_pushnumber(prevSetup);
lua_pushnumber(num);
lua_callfunction(camChangeHandler);
}
lua_endblock();
lua_beginblock();
lua_Object postCamChangeHandler = getEventHandler("postCamChangeHandler");
if (postCamChangeHandler != LUA_NOOBJECT) {
lua_pushnumber(num);
lua_callfunction(postCamChangeHandler);
}
lua_endblock();
}
/* Find the requested scene and return the current setup
* id number. This function cannot just use the current
* scene or else when Manny opens his inventory information
* gets lost, such as the position for the demon beavors
* in the Petrified Forest.
*/
static void GetCurrentSetup() {
const char *name;
Scene *scene;
DEBUG_FUNCTION();
name = luaL_check_string(1);
scene = g_engine->findScene(name);
if (scene == NULL) {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("GetCurrentSetup() Requested scene (%s) is not loaded!", name);
lua_pushnil();
return;
}
lua_pushnumber(scene->setup());
}
// FIXME: Function only spits back what it's given
static void GetShrinkPos() {
double x, y, z, r;
DEBUG_FUNCTION();
x = luaL_check_number(1);
y = luaL_check_number(2);
z = luaL_check_number(3);
r = luaL_check_number(4);
lua_pushnumber(x);
lua_pushnumber(y);
lua_pushnumber(z);
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("Stub function GetShrinkPos(%g,%g,%g,%g) called", x, y, z, r);
}
// Sound functions
enum ImuseParam {
IM_SOUND_PLAY_COUNT = 0x100,
IM_SOUND_PEND_COUNT = 0x200,
IM_SOUND_GROUP = 0x400,
IM_SOUND_PRIORITY = 0x500,
IM_SOUND_VOL = 0x600,
IM_SOUND_PAN = 0x700
};
static void ImStartSound() {
int priority, group;
const char *soundName;
DEBUG_FUNCTION();
soundName = luaL_check_string(1);
priority = check_int(2);
group = check_int(3);
// Start the sound with the appropriate settings
if (g_imuse->startSound(soundName, group, 0, 127, 0, priority, NULL)) {
lua_pushstring(soundName);
} else {
// Allow soft failing when loading sounds, hard failing when not
if (priority == 127) {
if (debugLevel == DEBUG_IMUSE || debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("ImStartSound failed to load '%s'", soundName);
} else {
if (debugLevel == DEBUG_IMUSE || debugLevel == DEBUG_ERROR || debugLevel == DEBUG_ALL)
error("ImStartSound failed to start '%s'", soundName);
}
lua_pushnil();
}
}
static void ImStopSound() {
const char *soundName;
DEBUG_FUNCTION();
soundName = luaL_check_string(1);
g_imuse->stopSound(soundName);
}
static void ImStopAllSounds() {
DEBUG_FUNCTION();
g_imuse->stopAllSounds();
}
static void ImPause() {
DEBUG_FUNCTION();
g_imuse->pause(true);
}
static void ImResume() {
DEBUG_FUNCTION();
g_imuse->pause(false);
}
static void ImSetVoiceEffect() {
const char *effectName;
DEBUG_FUNCTION();
effectName = luaL_check_string(1);
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("ImSetVoiceEffect(%s) Voice effects are not yet supported", effectName);
}
static void ImSetMusicVol() {
DEBUG_FUNCTION();
g_driver->getMixer()->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, check_int(1));
}
static void ImGetMusicVol() {
DEBUG_FUNCTION();
lua_pushnumber(g_driver->getMixer()->getVolumeForSoundType(Audio::Mixer::kMusicSoundType));
}
static void ImSetVoiceVol() {
DEBUG_FUNCTION();
g_driver->getMixer()->setVolumeForSoundType(Audio::Mixer::kSpeechSoundType, check_int(1));
}
static void ImGetVoiceVol() {
DEBUG_FUNCTION();
lua_pushnumber(g_driver->getMixer()->getVolumeForSoundType(Audio::Mixer::kSpeechSoundType));
}
static void ImSetSfxVol() {
DEBUG_FUNCTION();
g_driver->getMixer()->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, check_int(1));
}
static void ImGetSfxVol() {
DEBUG_FUNCTION();
lua_pushnumber(g_driver->getMixer()->getVolumeForSoundType(Audio::Mixer::kSFXSoundType));
}
static void ImSetParam() {
int param, value;
const char *soundName;
DEBUG_FUNCTION();
soundName = luaL_check_string(1);
param = check_int(2);
value = check_int(3);
switch (param) {
case IM_SOUND_VOL:
g_imuse->setVolume(soundName, value);
break;
case IM_SOUND_PAN:
g_imuse->setPan(soundName, value);
break;
default:
lua_pushnil();
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("ImSetParam() Unimplemented %d, %d\n", param, value);
}
}
void ImGetParam() {
const char *soundName;
int param;
DEBUG_FUNCTION();
soundName = luaL_check_string(1);
param = check_int(2);
switch (param) {
case IM_SOUND_PLAY_COUNT:
lua_pushnumber(g_imuse->getCountPlayedTracks(soundName));
break;
case IM_SOUND_VOL:
lua_pushnumber(g_imuse->getVolume(soundName));
break;
default:
lua_pushnil();
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("ImGetParam() Unimplemented %d\n", param);
}
}
static void ImFadeParam() {
int opcode, value, duration;
const char *soundName;
DEBUG_FUNCTION();
soundName = luaL_check_string(1);
opcode = check_int(2);
value = check_int(3);
duration = check_int(4);
switch (opcode) {
case IM_SOUND_PAN:
g_imuse->setFadePan(soundName, value, duration);
break;
default:
error("ImFadeParam(%s, %h, %d, %d)", soundName, opcode, value, duration);
break;
}
}
static void ImSetState() {
DEBUG_FUNCTION();
g_imuseState = check_int(1);
}
static void ImSetSequence() {
int state;
DEBUG_FUNCTION();
state = check_int(1);
lua_pushnumber(g_imuse->setMusicSequence(state));
}
static void SaveIMuse() {
DEBUG_FUNCTION();
SaveGame *savedIMuse = new SaveGame("grim.tmp", true);
g_imuse->saveState(savedIMuse);
delete savedIMuse;
}
static void RestoreIMuse() {
DEBUG_FUNCTION();
SaveGame *savedIMuse = new SaveGame("grim.tmp", false);
g_imuse->stopAllSounds();
g_imuse->resetState();
g_imuse->restoreState(savedIMuse);
delete savedIMuse;
unlink("grim.tmp");
}
static void SetSoundPosition() {
Vector3d pos;
int minVolume = 10;
int maxVolume = 127;
DEBUG_FUNCTION();
if (g_engine->currScene()) {
g_engine->currScene()->getSoundParameters(&minVolume, &maxVolume);
}
const char *soundName = lua_getstring(lua_getresult(1));
if (isActor(lua_getparam(2))) {
Actor *act = check_actor(2);
if (act) {
pos = act->pos();
} else {
return;
}
minVolume = check_int(3);
maxVolume = check_int(4);
} else if (lua_isnumber(lua_getparam(2))) {
error("SetSoundPosition() Position x,y,z as params is not suported.");
} else {
return;
}
if (g_engine->currScene()) {
g_engine->currScene()->setSoundParameters(minVolume, maxVolume);
g_engine->currScene()->setSoundPosition(soundName, pos);
}
}
static void IsSoundPlaying() {
// dummy
DEBUG_FUNCTION();
}
static void PlaySoundAt() {
// dummy
DEBUG_FUNCTION();
}
static void FileFindDispose() {
DEBUG_FUNCTION();
if (g_searchFile) {
#ifdef _WIN32
FindClose(g_searchFile);
#else
closedir(g_searchFile);
#endif
g_searchFile = NULL;
}
}
static void luaFileFindNext() {
bool found = false;
#ifndef _WIN32
dirent *de;
#endif
DEBUG_FUNCTION();
if (g_searchFile) {
#ifdef _WIN32
if (g_firstFind) {
g_firstFind = false;
found = true;
} else {
do {
if (FindNextFile(g_searchFile, &g_find_file_data) != 0)
found = true;
} while (found && (g_find_file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY));
}
#else
do {
de = readdir(g_searchFile);
if (de) {
// If the 'extension' is a wildcard pattern then check only the extensions,
// otherwise check the entire filename
if (g_find_file_data[0] == '*' && g_find_file_data[1] == '.') {
char *c = strrchr(de->d_name, '.');
if (c != NULL && !strcasecmp(c, &g_find_file_data[1])) {
found = true;
break;
}
} else if (!strcasecmp(de->d_name, g_find_file_data)) {
found = true;
break;
}
}
} while (de);
#endif
#ifdef _WIN32
if (g_find_file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
#else
if (!de)
#endif
found = false;
}
if (found) {
#ifdef _WIN32
lua_pushstring(g_find_file_data.cFileName);
#else
lua_pushstring(de->d_name);
#endif
} else {
lua_pushnil();
}
}
static void luaFileFindFirst() {
const char *path, *extension;
lua_Object pathObj;
DEBUG_FUNCTION();
extension = luaL_check_string(1);
pathObj = lua_getparam(2);
FileFindDispose();
if (lua_isnil(pathObj))
path = ".";
else
path = lua_getstring(pathObj);
#ifdef _WIN32
std::string dir_strWin32 = path;
dir_strWin32 += "/";
dir_strWin32 += extension;
g_searchFile = FindFirstFile(dir_strWin32.c_str(), &g_find_file_data);
g_firstFind = true;
if (g_searchFile == INVALID_HANDLE_VALUE)
g_searchFile = NULL;
#else
g_searchFile = opendir(path);
strcpy(g_find_file_data, extension);
#endif
if (g_searchFile) {
luaFileFindNext();
} else {
lua_pushnil();
}
}
void setFrameTime(float frameTime) {
lua_pushobject(lua_getglobal("system"));
lua_pushstring("frameTime");
lua_pushnumber(frameTime);
lua_settable();
}
void setMovieTime(float movieTime) {
lua_pushobject(lua_getglobal("system"));
lua_pushstring("movieTime");
lua_pushnumber(movieTime);
lua_settable();
}
void PerSecond() {
float rate;
DEBUG_FUNCTION();
rate = luaL_check_number(1);
lua_pushnumber(g_engine->perSecond(rate));
}
void EnableControl() {
int num;
DEBUG_FUNCTION();
num = check_control(1);
g_engine->enableControl(num);
}
void DisableControl() {
int num;
DEBUG_FUNCTION();
num = check_control(1);
g_engine->disableControl(num);
}
void GetControlState() {
int num;
DEBUG_FUNCTION();
num = check_control(1);
if (g_driver->controlIsAxis(num))
lua_pushnumber(g_driver->getControlAxis(num));
else
pushbool(g_driver->getControlState(num));
}
static void killBitmapPrimitives(Bitmap *bitmap)
{
for (Engine::PrimitiveListType::const_iterator i = g_engine->primitivesBegin(); i != g_engine->primitivesEnd(); i++) {
PrimitiveObject *p = *i;
if (p->isBitmap() && p->getBitmapHandle() == bitmap) {
g_engine->killPrimitiveObject(p);
break;
}
}
}
static void GetImage() {
const char *bitmapName;
DEBUG_FUNCTION();
bitmapName = luaL_check_string(1);
Bitmap *image = g_resourceloader->loadBitmap(bitmapName);
image->luaRef();
lua_pushusertag(image, MKID_BE('VBUF'));
}
static void FreeImage() {
Bitmap *bitmap;
DEBUG_FUNCTION();
bitmap = check_bitmapobject(1);
killBitmapPrimitives(bitmap);
}
static void BlastImage() {
bool transparent;
Bitmap *bitmap;
int x, y;
DEBUG_FUNCTION();
bitmap = check_bitmapobject(1);
x = check_int(2);
y = check_int(3);
transparent = getbool(4);
bitmap->setX(x);
bitmap->setY(y);
// transparent: what to do ?
g_driver->createBitmap(bitmap);
g_driver->drawBitmap(bitmap);
}
void getTextObjectParams(TextObject *textObject, lua_Object table_obj) {
const char *key_text = NULL;
lua_Object key = LUA_NOOBJECT;
DEBUG_FUNCTION();
for (;;) {
lua_pushobject(table_obj);
if (key_text)
lua_pushobject(key);
else
lua_pushnil();
// If the call to "next" fails then register an error
if (lua_call("next") != 0) {
error("getTextObjectParams failed to get next key!\n");
return;
}
key = lua_getresult(1);
if (lua_isnil(key))
break;
// printf("debug param: %s %s\n", lua_getstring(key), lua_getstring(lua_getresult(2)));
key_text = lua_getstring(key);
if (strmatch(key_text, "x"))
textObject->setX(atoi(lua_getstring(lua_getresult(2))));
else if (strmatch(key_text, "y"))
textObject->setY(atoi(lua_getstring(lua_getresult(2))));
else if (strmatch(key_text, "width"))
textObject->setWidth(atoi(lua_getstring(lua_getresult(2))));
else if (strmatch(key_text, "height"))
textObject->setHeight(atoi(lua_getstring(lua_getresult(2))));
else if (strmatch(key_text, "font"))
textObject->setFont(check_font(2));
else if (strmatch(key_text, "fgcolor"))
textObject->setFGColor(check_color(2));
else if (strmatch(key_text, "hicolor"));
// this is only used in credits screen, can be ignored, seems not needed
else if (strmatch(key_text, "disabled"))
textObject->setDisabled(atoi(lua_getstring(lua_getresult(2))) != 0);
else if (strmatch(key_text, "center"))
textObject->setJustify(1);
else if (strmatch(key_text, "ljustify"))
textObject->setJustify(2);
else if (strmatch(key_text, "rjustify"))
textObject->setJustify(3);
else
error("Unknown getTextObjectParams key '%s'\n", key_text);
}
}
static void CleanBuffer() {
DEBUG_FUNCTION();
g_driver->copyStoredToDisplay();
}
static void Exit() {
DEBUG_FUNCTION();
g_driver->quit();
}
/* Check for an existing object by a certain name
* this function is used by several functions that look
* for text objects to see if they need to be created/modified/destroyed.
*/
TextObject *TextObjectExists(char *name) {
TextObject *modifyObject = NULL;
DEBUG_FUNCTION();
for (Engine::TextListType::const_iterator i = g_engine->textsBegin(); i != g_engine->textsEnd(); i++) {
TextObject *textO = *i;
if (strlen(name) == strlen(textO->name()) && strcmp(textO->name(), name) == 0) {
modifyObject = textO;
break;
}
}
return modifyObject;
}
/* Destroy a text object since we don't need it anymore
* note that the menu creates more objects than it needs,
* so it deletes some objects right after creating them
*/
static void KillTextObject() {
TextObject *textObjectParm, *delText;
DEBUG_FUNCTION();
if (lua_isnil(lua_getparam(1))) {
if (debugLevel == DEBUG_ERROR || debugLevel == DEBUG_ALL)
error("KillTextObject(NULL)");
return;
}
textObjectParm = check_textobject(1);
delText = TextObjectExists((char *) textObjectParm->name());
if (delText != NULL)
g_engine->killTextObject(delText);
}
/* Make changes to a text object based on the parameters passed
* in the table in the LUA parameter 2.
*/
static void ChangeTextObject() {
TextObject *modifyObject, *textObject;
lua_Object tableObj;
DEBUG_FUNCTION();
textObject = check_textobject(1);
// when called in certain instances (such as don's computer)
// the second parameter is the string and the third is the table
if (lua_isstring(lua_getparam(2)))
tableObj = lua_getparam(3);
else
tableObj = lua_getparam(2);
modifyObject = TextObjectExists((char *)textObject->name());
if (!modifyObject) {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("ChangeTextObject(): Cannot find active text object");
return;
}
if (lua_istable(tableObj))
getTextObjectParams(modifyObject, tableObj);
else if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("Expecting table parameter!");
// to modify current bitmap it need recreate it
modifyObject->destroyBitmap();
modifyObject->createBitmap();
lua_pushnumber(modifyObject->getBitmapWidth());
lua_pushnumber(modifyObject->getBitmapHeight());
}
/* Return the "text speed", this option must be handled
* to prevent errors in the "Options" menu even though
* we're not currently using the value
*/
static void GetTextSpeed() {
DEBUG_FUNCTION();
lua_pushnumber(g_engine->getTextSpeed());
}
static void SetTextSpeed() {
int speed;
DEBUG_FUNCTION();
speed = check_int(1);
g_engine->setTextSpeed(speed);
}
static void MakeTextObject() {
TextObject *textObject = new TextObject();
lua_Object tableObj;
const char *line;
DEBUG_FUNCTION();
line = lua_getstring(lua_getparam(1));
std::string text = line;
tableObj = lua_getparam(2);
textObject->setDefaults(&textObjectDefaults);
if (lua_istable(tableObj))
getTextObjectParams(textObject, tableObj);
while (TextObjectExists((char *)text.c_str()) != NULL)
text += TEXT_NULL;
//printf("Make: %s\n", (char *)text.c_str());
textObject->setText((char *)text.c_str());
textObject->createBitmap();
g_engine->registerTextObject(textObject);
lua_pushusertag(textObject, MKID_BE('TEXT'));
lua_pushnumber(textObject->getBitmapWidth());
lua_pushnumber(textObject->getBitmapHeight());
}
static void GetTextObjectDimensions() {
TextObject *textObjectParam;
DEBUG_FUNCTION();
textObjectParam = check_textobject(1);
lua_pushnumber(textObjectParam->getBitmapWidth());
lua_pushnumber(textObjectParam->getBitmapHeight());
}
static void ExpireText() {
DEBUG_FUNCTION();
// Expire all the text objects
g_engine->killTextObjects();
// Cleanup actor references to deleted text objects
for (Engine::ActorListType::const_iterator i = g_engine->actorsBegin(); i != g_engine->actorsEnd(); i++)
(*i)->lineCleanup();
}
static void GetTextCharPosition() {
TextObject *textObjectParam;
int pos;
DEBUG_FUNCTION();
textObjectParam = check_textobject(1);
pos = (int)lua_getnumber(lua_getparam(2));
lua_pushnumber((double)textObjectParam->getTextCharPosition(pos));
}
static void BlastText() {
DEBUG_FUNCTION();
TextObject *textObject = new TextObject();
lua_Object tableObj;
const char *line;
DEBUG_FUNCTION();
line = lua_getstring(lua_getparam(1));
std::string text = line;
tableObj = lua_getparam(2);
textObject->setDefaults(&textObjectDefaults);
if (lua_istable(tableObj))
getTextObjectParams(textObject, tableObj);
//printf("Blast: %s\n", (char *)text.c_str());
textObject->setText((char *)text.c_str());
textObject->createBitmap();
textObject->draw();
delete textObject;
}
static void SetOffscreenTextPos() {
// this sets where we shouldn't put dialog maybe?
stubWarning("SetOffscreenTextPos");
}
static void SetSpeechMode() {
int mode;
DEBUG_FUNCTION();
mode = check_int(1);
if ((mode >= 1) && (mode <= 3))
g_engine->setSpeechMode(mode);
}
static void GetSpeechMode() {
int mode;
DEBUG_FUNCTION();
mode = g_engine->getSpeechMode();
lua_pushnumber(mode);
}
static void StartFullscreenMovie() {
bool mode = getbool(2);
DEBUG_FUNCTION();
warning("StartFullscreenMovie() mode: %d", (int)mode);
// Clean out any text objects on the display before running the
// movie, otherwise things like Bruno's "Nice bathrobe." will stay
// on-screen the whole movie
// ExpireText(); --- disable above hack
CleanBuffer();
g_engine->setMode(ENGINE_MODE_SMUSH);
pushbool(g_smush->play(luaL_check_string(1), 0, 0));
}
static void StartMovie() {
bool mode = getbool(2);
int x = 0, y = 0;
DEBUG_FUNCTION();
warning("StartMovie() mode: %d", (int)mode);
if (!lua_isnil(lua_getparam(3)))
x = check_int(3);
if (!lua_isnil(lua_getparam(4)))
y = check_int(4);
g_engine->setMode(ENGINE_MODE_NORMAL);
pushbool(g_smush->play(luaL_check_string(1), x, y));
}
/* Fullscreen movie playing query and normal movie
* query should actually detect correctly and not
* just return true whenever ANY movie is playing
*/
static void IsFullscreenMoviePlaying() {
DEBUG_FUNCTION();
pushbool(g_smush->isPlaying() && g_engine->getMode() == ENGINE_MODE_SMUSH);
}
static void IsMoviePlaying() {
DEBUG_FUNCTION();
pushbool(g_smush->isPlaying() && g_engine->getMode() == ENGINE_MODE_NORMAL);
}
static void StopMovie() {
DEBUG_FUNCTION();
g_smush->stop();
}
static void PauseMovie() {
DEBUG_FUNCTION();
g_smush->pause(lua_isnil(lua_getparam(1)) != 0);
}
static void PurgePrimitiveQueue() {
DEBUG_FUNCTION();
g_engine->killPrimitiveObjects();
}
static void DrawPolygon() {
lua_Object tableObj1, tableObj2, pointObj;
int x1 = 0, y1 = 0, x2 = 0, y2 = 0, x3 = 0, y3 = 0, x4 = 0, y4 = 0;
Color color;
color._vals[0] = 255;
color._vals[1] = 255;
color._vals[2] = 255;
tableObj1 = lua_getparam(1);
tableObj2 = lua_getparam(2);
if (lua_istable(tableObj1)) {
lua_pushobject(tableObj1);
lua_pushnumber(1);
pointObj = lua_gettable();
x1 = (int)lua_getnumber(pointObj);
lua_pushobject(tableObj1);
lua_pushnumber(2);
pointObj = lua_gettable();
y1 = (int)lua_getnumber(pointObj);
lua_pushobject(tableObj1);
lua_pushnumber(3);
pointObj = lua_gettable();
x2 = (int)lua_getnumber(pointObj);
lua_pushobject(tableObj1);
lua_pushnumber(4);
pointObj = lua_gettable();
y2 = (int)lua_getnumber(pointObj);
lua_pushobject(tableObj1);
lua_pushnumber(5);
pointObj = lua_gettable();
x3 = (int)lua_getnumber(pointObj);
lua_pushobject(tableObj1);
lua_pushnumber(6);
pointObj = lua_gettable();
y3 = (int)lua_getnumber(pointObj);
lua_pushobject(tableObj1);
lua_pushnumber(7);
pointObj = lua_gettable();
x4 = (int)lua_getnumber(pointObj);
lua_pushobject(tableObj1);
lua_pushnumber(8);
pointObj = lua_gettable();
y4 = (int)lua_getnumber(pointObj);
} else {
lua_pushnil();
}
if (lua_istable(tableObj2)) {
lua_pushobject(tableObj2);
lua_pushstring("color");
lua_Object colorObj = lua_gettable();
if (lua_isuserdata(colorObj) && lua_tag(colorObj) == MKID_BE('COLR')) {
color = static_cast<Color *>(lua_getuserdata(colorObj));
}
}
PrimitiveObject *p = new PrimitiveObject();
p->createPolygon(x1, y1, x2, y2, x3, y3, x4, y4, color);
g_engine->registerPrimitiveObject(p);
lua_pushusertag(p, MKID_BE('PRIM'));
}
static void DrawLine() {
int x1, y1, x2, y2;
lua_Object tableObj;
Color color;
DEBUG_FUNCTION();
x1 = check_int(1);
y1 = check_int(2);
x2 = check_int(3);
y2 = check_int(4);
tableObj = lua_getparam(5);
color._vals[0] = 255;
color._vals[1] = 255;
color._vals[2] = 255;
if (lua_istable(tableObj)) {
lua_pushobject(tableObj);
lua_pushstring("color");
lua_Object colorObj = lua_gettable();
if (lua_isuserdata(colorObj) && lua_tag(colorObj) == MKID_BE('COLR')) {
color = static_cast<Color *>(lua_getuserdata(colorObj));
}
}
PrimitiveObject *p = new PrimitiveObject();
p->createLine(x1, x2, y1, y2, color);
g_engine->registerPrimitiveObject(p);
lua_pushusertag(p, MKID_BE('PRIM'));
}
static void ChangePrimitive() {
PrimitiveObject *psearch, *pmodify = NULL;
lua_Object tableObj;
Color color;
DEBUG_FUNCTION();
tableObj = lua_getparam(2);
color._vals[0] = 255;
color._vals[1] = 255;
color._vals[2] = 255;
if (lua_isnil(lua_getparam(1)) || !lua_istable(tableObj))
return;
psearch = check_primobject(1);
for (Engine::PrimitiveListType::const_iterator i = g_engine->primitivesBegin(); i != g_engine->primitivesEnd(); i++) {
PrimitiveObject *p = *i;
if (p->getX1() == psearch->getX1() && p->getX2() == psearch->getX2() && p->getY1() == psearch->getY1() && p->getY2() == psearch->getY2()) {
pmodify = p;
break;
}
}
if (!pmodify) {
// When Manny exists Don's computer (using ESC) the primitive objects
// are destroyed just before the last call to change them
if (debugLevel == DEBUG_WARN)
warning("Primitive object not found.");
return;
}
lua_pushobject(tableObj);
lua_pushstring("color");
lua_Object colorObj = lua_gettable();
if (lua_isuserdata(colorObj) && lua_tag(colorObj) == MKID_BE('COLR')) {
color = static_cast<Color *>(lua_getuserdata(colorObj));
pmodify->setColor(color);
}
lua_pushobject(tableObj);
lua_pushstring("y");
lua_Object yObj = lua_gettable();
if (!lua_isnil(yObj)) {
int y = atoi(lua_getstring(yObj));
if (pmodify->getType() == 4) {
int y1 = pmodify->getY1();
int y2 = pmodify->getY2();
int y3 = pmodify->getY3();
int y4 = pmodify->getY4();
int dy = y - y1;
pmodify->setY1(y1 + dy);
pmodify->setY2(y2 + dy);
pmodify->setY3(y3 + dy);
pmodify->setY4(y4 + dy);
} else {
pmodify->setY1(y);
pmodify->setY2(y);
}
}
}
static void DrawRectangle() {
int x1, y1, x2, y2;
lua_Object tableObj;
Color color;
DEBUG_FUNCTION();
x1 = check_int(1);
y1 = check_int(2);
x2 = check_int(3);
y2 = check_int(4);
tableObj = lua_getparam(5);
color._vals[0] = 255;
color._vals[1] = 255;
color._vals[2] = 255;
bool filled = false;
if (lua_istable(tableObj)){
lua_pushobject(tableObj);
lua_pushstring("color");
lua_Object colorObj = lua_gettable();
if (lua_isuserdata(colorObj) && lua_tag(colorObj) == MKID_BE('COLR')) {
color = static_cast<Color *>(lua_getuserdata(colorObj));
}
lua_pushobject(tableObj);
lua_pushstring("filled");
lua_Object objFilled = lua_gettable();
if (!lua_isnil(objFilled))
filled = true;
}
PrimitiveObject *p = new PrimitiveObject();
p->createRectangle(x1, x2, y1, y2, color, filled);
g_engine->registerPrimitiveObject(p);
lua_pushusertag(p, MKID_BE('PRIM'));
}
static void BlastRect() {
DEBUG_FUNCTION();
int x1, y1, x2, y2;
lua_Object tableObj;
Color color;
DEBUG_FUNCTION();
x1 = check_int(1);
y1 = check_int(2);
x2 = check_int(3);
y2 = check_int(4);
tableObj = lua_getparam(5);
color._vals[0] = 255;
color._vals[1] = 255;
color._vals[2] = 255;
bool filled = false;
if (lua_istable(tableObj)){
lua_pushobject(tableObj);
lua_pushstring("color");
lua_Object colorObj = lua_gettable();
if (lua_isuserdata(colorObj) && lua_tag(colorObj) == MKID_BE('COLR')) {
color = static_cast<Color *>(lua_getuserdata(colorObj));
}
lua_pushobject(tableObj);
lua_pushstring("filled");
lua_Object objFilled = lua_gettable();
if (!lua_isnil(objFilled))
filled = true;
}
PrimitiveObject *p = new PrimitiveObject();
p->createRectangle(x1, x2, y1, y2, color, filled);
p->draw();
delete p;
}
static void DimScreen() {
DEBUG_FUNCTION();
g_driver->dimScreen();
}
static void DimRegion() {
DEBUG_FUNCTION();
int x = check_int(1);
int y = check_int(2);
int w = check_int(3);
int h = check_int(4);
float level = luaL_check_number(5);
g_driver->dimRegion(x, y, w, h, level);
}
static void GetDiskFreeSpace() {
DEBUG_FUNCTION();
// amount of free space in MB, used for creating saves
lua_pushnumber(50);
}
static void NewObjectState() {
ObjectState *state = NULL;
ObjectState::Position pos;
const char *bitmap, *zbitmap;
bool visible;
int setupID;
DEBUG_FUNCTION();
// Called with "nil" if you jump to zone "sp"
setupID = check_int(1); // Setup ID
pos = check_objstate_pos(2); // When to draw
bitmap = luaL_check_string(3); // Bitmap
zbitmap = NULL; // Zbuffer Bitmap
visible = getbool(5); // Starts visible?
if (!lua_isnil(lua_getparam(4)))
zbitmap = luaL_check_string(4);
state = new ObjectState(setupID, pos, bitmap, zbitmap, visible);
g_engine->currScene()->addObjectState(state);
lua_pushusertag(state, MKID_BE('STAT'));
}
static void FreeObjectState() {
ObjectState *state;
DEBUG_FUNCTION();
state = check_object(1);
g_engine->currScene()->deleteObjectState(state);
}
static void SendObjectToBack() {
lua_Object param;
DEBUG_FUNCTION();
param = lua_getparam(1);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('STAT')) {
ObjectState *state = static_cast<ObjectState *>(lua_getuserdata(param));
// moving object to top in list ?
g_engine->currScene()->moveObjectStateToFirst(state);
}
}
static void SendObjectToFront() {
lua_Object param;
DEBUG_FUNCTION();
param = lua_getparam(1);
if (lua_isuserdata(param) && lua_tag(param) == MKID_BE('STAT')) {
ObjectState *state = static_cast<ObjectState *>(lua_getuserdata(param));
// moving object to last in list ?
g_engine->currScene()->moveObjectStateToLast(state);
}
}
static void SetObjectType() {
ObjectState::Position pos;
ObjectState *state;
DEBUG_FUNCTION();
state = check_object(1);
pos = check_objstate_pos(2);
state->setPos(pos);
}
static void GetCurrentScript() {
DEBUG_FUNCTION();
current_script();
}
static void ScreenShot() {
int width, height;
DEBUG_FUNCTION();
width = check_int(1);
height = check_int(2);
int mode = g_engine->getMode();
g_engine->setMode(ENGINE_MODE_NORMAL);
g_engine->updateDisplayScene();
Bitmap *screenshot = g_driver->getScreenshot(width, height);
g_engine->setMode(mode);
if (screenshot) {
screenshot->luaRef();
lua_pushusertag(screenshot, MKID_BE('VBUF'));
} else {
lua_pushnil();
}
}
/*
* Restore a screenshot from a savegame file
*
*/
static void GetSaveGameImage() {
int width = 250, height = 188;
const char *filename;
char *data;
Bitmap *screenshot;
int dataSize;
printf("GetSaveGameImage() started.\n");
DEBUG_FUNCTION();
filename = luaL_check_string(1);
SaveGame *savedState = new SaveGame(filename, false);
dataSize = savedState->beginSection('SIMG');
data = new char[dataSize];
savedState->read(data, dataSize);
screenshot = new Bitmap(data, width, height, "screenshot");
if (screenshot) {
screenshot->luaRef();
lua_pushusertag(screenshot, MKID_BE('VBUF'));
} else {
lua_pushnil();
error("Could not restore screenshot from file!");
}
savedState->endSection();
printf("GetSaveGameImage() finished.\n");
}
static void SubmitSaveGameData() {
lua_Object table, table2;
SaveGame *savedState;
int count = 0;
const char *str;
printf("SubmitSaveGameData() started.\n");
DEBUG_FUNCTION();
table = lua_getparam(1);
savedState = g_engine->savedState();
if (savedState == NULL)
error("Cannot obtain saved game!");
savedState->beginSection('SUBS');
count = 0;
for (;;) {
lua_pushobject(table);
lua_pushnumber(count);
count++;
table2 = lua_gettable();
if (lua_isnil(table2))
break;
str = lua_getstring(table2);
int len = strlen(str) + 1;
savedState->write(&len, sizeof(int));
savedState->write(str, len);
}
savedState->endSection();
printf("SubmitSaveGameData() finished.\n");
}
static void GetSaveGameData() {
lua_Object result;
const char *filename;
int dataSize;
printf("GetSaveGameData() started.\n");
DEBUG_FUNCTION();
filename = luaL_check_string(1);
SaveGame *savedState = new SaveGame(filename, false);
dataSize = savedState->beginSection('SUBS');
result = lua_createtable();
char str[128];
int strSize;
int count = 0;
for (;;) {
if (dataSize <= 0)
break;
savedState->read(&strSize, sizeof(int));
savedState->read(str, strSize);
lua_pushobject(result);
lua_pushnumber(count);
lua_pushstring(str);
lua_settable();
dataSize -= strSize;
dataSize -= 4;
count++;
}
lua_pushobject(result);
savedState->endSection();
delete savedState;
printf("GetSaveGameData() finished.\n");
}
static void Load() {
lua_Object fileName;
DEBUG_FUNCTION();
fileName = lua_getparam(1);
if (lua_isnil(fileName)) {
g_engine->_savegameFileName = NULL;
} else if (lua_isstring(fileName)) {
g_engine->_savegameFileName = lua_getstring(fileName);
} else {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("Load() fileName is wrong");
return;
}
g_engine->_savegameLoadRequest = true;
}
static void Save() {
lua_Object fileName;
DEBUG_FUNCTION();
fileName = lua_getparam(1);
if (lua_isnil(fileName)) {
g_engine->_savegameFileName = NULL;
} else if (lua_isstring(fileName)) {
g_engine->_savegameFileName = lua_getstring(fileName);
} else {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("Save() fileName is wrong");
return;
}
g_engine->_savegameSaveRequest = true;
}
static int SaveCallback(int /*tag*/, int value, SaveRestoreFunc /*savedState*/) {
DEBUG_FUNCTION();
return value;
}
static int RestoreCallback(int /*tag*/, int value, SaveRestoreFunc /*savedState*/) {
DEBUG_FUNCTION();
return value;
}
static void LockFont() {
lua_Object param1;
DEBUG_FUNCTION();
param1 = lua_getparam(1);
if (lua_isstring(param1)) {
const char *fontName = lua_getstring(param1);
Font *result = g_resourceloader->loadFont(fontName);
if (result) {
result->luaRef();
lua_pushusertag(result, MKID_BE('FONT'));
}
}
}
static void EnableDebugKeys() {
DEBUG_FUNCTION();
// in residual all keys are handled/enabled
}
static void LightMgrSetChange() {
DEBUG_FUNCTION();
// that seems only used when some control panel is opened
}
static void SetAmbientLight() {
int mode;
DEBUG_FUNCTION();
mode = check_int(1);
if (mode == 0) {
if (g_engine->currScene() != NULL) {
g_engine->currScene()->setLightEnableState(true);
}
} else if (mode == 1) {
if (g_engine->currScene() != NULL) {
g_engine->currScene()->setLightEnableState(false);
}
} else {
error("SetAmbientLight() Unknown param %d", mode);
}
}
static void RenderModeUser() {
lua_Object param1;
DEBUG_FUNCTION();
param1 = lua_getparam(1);
if (lua_isnumber(param1)) {
g_engine->setPreviousMode(g_engine->getMode());
g_smush->pause(true);
g_engine->setMode(ENGINE_MODE_DRAW);
} else if (lua_isnil(param1)) {
g_smush->pause(false);
g_engine->refreshDrawMode();
g_engine->setMode(g_engine->getPreviousMode());
} else {
error("RenderModeUser() Unknown type of param");
}
}
static void SetGamma() {
DEBUG_FUNCTION();
stubWarning("SetGamma");
}
static void Display() {
DEBUG_FUNCTION();
if (g_engine->getFlipEnable()) {
g_driver->flipBuffer();
}
}
static void EngineDisplay() {
// it enable/disable updating display
DEBUG_FUNCTION();
bool mode = check_int(1) != 0;
if (mode) {
g_engine->setFlipEnable(true);
} else {
g_engine->setFlipEnable(false);
}
}
static void ForceRefresh() {
g_engine->refreshDrawMode();
}
static void JustLoaded() {
DEBUG_FUNCTION();
if(debugLevel == DEBUG_ERROR || debugLevel == DEBUG_ALL)
error("OPCODE USAGE VERIFICATION: JustLoaded");
}
static void PlaySound() {
DEBUG_FUNCTION();
if(debugLevel == DEBUG_ERROR || debugLevel == DEBUG_ALL)
error("OPCODE USAGE VERIFICATION: PlaySound");
}
static void SetEmergencyFont() {
DEBUG_FUNCTION();
if(debugLevel == DEBUG_ERROR || debugLevel == DEBUG_ALL)
error("OPCODE USAGE VERIFICATION: SetEmergencyFont");
}
static void LoadBundle() {
// loading grimdemo.mus is allready handled
}
/* Generate debug information for all functions
*
* When the debug flag is set to debug everything or "Functions"
* then this will be called to print out the information on a
* function. This is useful for finding problems in a LUA script
* that are due to a few function calls leading up to a failure.
*
* This function is also used by the "Stub" handler which will
* generate warnings about missing functions when the debug flag
* is set to "Stub", warnings, or everything.
*/
static void debugFunction(const char *debugMessage, const char *funcName) {
bool stubFn = strcmp(debugMessage, "WARNING: Stub function") == 0;
FILE *output;
if (!stubFn && debugLevel != DEBUG_FUNC && debugLevel != DEBUG_ALL)
return;
if (stubFn)
output = stderr;
else
output = stdout;
fprintf(output, "%s %s(", debugMessage, funcName);
for (int i = 1; ; i++) {
if (lua_getparam(i) == LUA_NOOBJECT)
break;
if (lua_isnil(lua_getparam(i)))
fprintf(output, "nil");
else if (lua_istable(lua_getparam(i)))
fprintf(output, "{...}");
else if (lua_isuserdata(lua_getparam(i))) {
if (lua_tag(lua_getparam(i)) == MKID_BE('ACTR')) {
Actor *a = check_actor(i);
fprintf(output, "<actor \"%s\">", a->name());
} else if (lua_tag(lua_getparam(i)) == MKID_BE('COLR')) {
Color *c = check_color(i);
fprintf(output, "<color #%02x%02x%02x>", c->red(), c->green(), c->blue());
} else
fprintf(output, "<userdata %p>", lua_getuserdata(lua_getparam(i)));
} else if (lua_isfunction(lua_getparam(i)))
fprintf(output, "<function>");
else if (lua_isnumber(lua_getparam(i)))
fprintf(output, "%g", lua_getnumber(lua_getparam(i)));
else if (lua_isstring(lua_getparam(i)))
fprintf(output, "\"%s\"", lua_getstring(lua_getparam(i)));
else
fprintf(output, "<unknown>");
if (lua_getparam(i+1) != LUA_NOOBJECT)
fprintf(output, ", ");
}
fprintf(output, ") called\n");
#if 0
lua_call("print_stack");
#endif
}
// Stub function for builtin functions not yet implemented
static void stubWarning(const char *funcName) {
// If the user doesn't want these debug messages then don't print them
if (debugLevel != DEBUG_WARN && debugLevel != DEBUG_STUB && debugLevel != DEBUG_FUNC && debugLevel != DEBUG_ALL)
return;
debugFunction("WARNING: Stub function", funcName);
}
#define STUB_FUNC(name) static void name() { stubWarning(#name); }
STUB_FUNC(SetActorInvClipNode)
STUB_FUNC(NukeResources)
STUB_FUNC(UnShrinkBoxes)
STUB_FUNC(ShrinkBoxes)
STUB_FUNC(ResetTextures)
STUB_FUNC(AttachToResources)
STUB_FUNC(DetachFromResources)
STUB_FUNC(IrisUp)
STUB_FUNC(IrisDown)
STUB_FUNC(FadeInChore)
STUB_FUNC(FadeOutChore)
STUB_FUNC(SetActorClipPlane)
STUB_FUNC(SetActorClipActive)
STUB_FUNC(SetActorCollisionScale)
STUB_FUNC(SetActorCollisionMode)
STUB_FUNC(FlushControls)
STUB_FUNC(ActorToClean)
STUB_FUNC(LightMgrStartup)
STUB_FUNC(SetLightIntensity)
STUB_FUNC(SetLightPosition)
STUB_FUNC(TurnLightOn)
STUB_FUNC(GetAngleBetweenVectors)
STUB_FUNC(GetCameraLookVector)
STUB_FUNC(SetCameraRoll)
STUB_FUNC(SetCameraInterest)
STUB_FUNC(GetCameraPosition)
STUB_FUNC(LoadCostume)
STUB_FUNC(PrintActorCostumes)
STUB_FUNC(SpewStartup)
STUB_FUNC(PreRender)
STUB_FUNC(GetSectorOppositeEdge)
STUB_FUNC(PreviousSetup)
STUB_FUNC(NextSetup)
STUB_FUNC(WorldToScreen)
STUB_FUNC(SetActorRoll)
STUB_FUNC(IsPointInSector)
STUB_FUNC(SetActorFrustrumCull)
STUB_FUNC(DriveActorTo)
STUB_FUNC(GetActorRect)
STUB_FUNC(SetActorTimeScale)
STUB_FUNC(SetActorScale)
STUB_FUNC(GetTranslationMode)
STUB_FUNC(SetTranslationMode)
STUB_FUNC(PrintLine)
STUB_FUNC(KillPrimitive)
STUB_FUNC(WalkActorToAvoiding)
STUB_FUNC(GetActorChores)
STUB_FUNC(SetCameraPosition)
STUB_FUNC(GetCameraFOV)
STUB_FUNC(SetCameraFOV)
STUB_FUNC(GetCameraRoll)
STUB_FUNC(ActorPuckOrient)
STUB_FUNC(GetMemoryUsage)
STUB_FUNC(GetFontDimensions)
STUB_FUNC(PurgeText)
// new Monkey 4 opcodes:
STUB_FUNC(SetActiveCD)
STUB_FUNC(GetActiveCD)
STUB_FUNC(AreWeInternational)
STUB_FUNC(MakeScreenTextures)
STUB_FUNC(ThumbnailFromFile)
STUB_FUNC(ClearSpecialtyTexture)
STUB_FUNC(UnloadActor)
STUB_FUNC(PutActorInOverworld)
STUB_FUNC(RemoveActorFromOverworld)
STUB_FUNC(ClearOverworld)
STUB_FUNC(ToggleOverworld)
STUB_FUNC(ActorStopMoving)
STUB_FUNC(SetActorFOV)
STUB_FUNC(SetActorLighting)
STUB_FUNC(SetActorHeadLimits)
STUB_FUNC(ActorActivateShadow)
STUB_FUNC(EnableActorPuck)
STUB_FUNC(SetActorGlobalAlpha)
STUB_FUNC(SetActorLocalAlpha)
STUB_FUNC(SetActorSortOrder)
STUB_FUNC(GetActorSortOrder)
STUB_FUNC(AttachActor)
STUB_FUNC(DetachActor)
STUB_FUNC(IsChoreValid)
STUB_FUNC(IsChorePlaying)
STUB_FUNC(IsChoreLooping)
STUB_FUNC(StopActorChores)
STUB_FUNC(PlayChore)
STUB_FUNC(StopChore)
STUB_FUNC(PauseChore)
STUB_FUNC(AdvanceChore)
STUB_FUNC(CompleteChore)
STUB_FUNC(LockChore)
STUB_FUNC(UnlockChore)
STUB_FUNC(LockChoreSet)
STUB_FUNC(UnlockChoreSet)
STUB_FUNC(LockBackground)
STUB_FUNC(UnLockBackground)
STUB_FUNC(EscapeMovie)
STUB_FUNC(StopAllSounds)
STUB_FUNC(LoadSound)
STUB_FUNC(FreeSound)
STUB_FUNC(PlayLoadedSound)
STUB_FUNC(SetGroupVolume)
STUB_FUNC(GetSoundVolume)
STUB_FUNC(SetSoundVolume)
STUB_FUNC(EnableAudioGroup)
STUB_FUNC(EnableVoiceFX)
STUB_FUNC(PlaySoundFrom)
STUB_FUNC(PlayLoadedSoundFrom)
STUB_FUNC(SetReverb)
STUB_FUNC(UpdateSoundPosition)
STUB_FUNC(ImSelectSet)
STUB_FUNC(ImStateHasLooped)
STUB_FUNC(ImStateHasEnded)
STUB_FUNC(ImPushState)
STUB_FUNC(ImPopState)
STUB_FUNC(ImFlushStack)
STUB_FUNC(ImGetMillisecondPosition)
STUB_FUNC(GetSectorName)
STUB_FUNC(GetCameraYaw)
STUB_FUNC(YawCamera)
STUB_FUNC(GetCameraPitch)
STUB_FUNC(PitchCamera)
STUB_FUNC(RollCamera)
STUB_FUNC(UndimAll)
STUB_FUNC(UndimRegion)
STUB_FUNC(GetCPUSpeed)
STUB_FUNC(NewLayer)
STUB_FUNC(FreeLayer)
STUB_FUNC(SetLayerSortOrder)
STUB_FUNC(SetLayerFrame)
STUB_FUNC(AdvanceLayerFrame)
STUB_FUNC(PushText)
STUB_FUNC(PopText)
STUB_FUNC(NukeAllScriptLocks)
STUB_FUNC(ToggleDebugDraw)
STUB_FUNC(ToggleDrawCameras)
STUB_FUNC(ToggleDrawLights)
STUB_FUNC(ToggleDrawSectors)
STUB_FUNC(ToggleDrawBBoxes)
STUB_FUNC(ToggleDrawFPS)
STUB_FUNC(ToggleDrawPerformance)
STUB_FUNC(ToggleDrawActorStats)
STUB_FUNC(SectEditSelect)
STUB_FUNC(SectEditPlace)
STUB_FUNC(SectEditDelete)
STUB_FUNC(SectEditInsert)
STUB_FUNC(SectEditSortAdd)
STUB_FUNC(SectEditForgetIt)
STUB_FUNC(FRUTEY_Begin)
STUB_FUNC(FRUTEY_End)
static void dummyHandler() {
}
// Entries in the system table
static struct {
const char *name;
int key;
} system_defaults[] = {
{ "frameTime", 0 },
{ "movieTime", 0 }
};
struct luaL_reg mainOpcodes[] = {
{ "EngineDisplay", EngineDisplay },
{ "CheckForFile", CheckForFile },
{ "Load", Load },
{ "Save", Save },
{ "SetActorColormap", SetActorColormap },
{ "GetActorCostume", GetActorCostume },
{ "SetActorCostume", SetActorCostume },
{ "SetActorScale", SetActorScale },
{ "GetActorTimeScale", GetActorTimeScale },
{ "SetActorTimeScale", SetActorTimeScale },
{ "GetActorNodeLocation", GetActorNodeLocation },
{ "SetActorWalkChore", SetActorWalkChore },
{ "SetActorTurnChores", SetActorTurnChores },
{ "SetActorRestChore", SetActorRestChore },
{ "SetActorMumblechore", SetActorMumblechore },
{ "SetActorTalkChore", SetActorTalkChore },
{ "SetActorWalkRate", SetActorWalkRate },
{ "GetActorWalkRate", GetActorWalkRate },
{ "SetActorTurnRate", SetActorTurnRate },
{ "SetSelectedActor", SetSelectedActor },
{ "LoadActor", LoadActor },
{ "GetActorPos", GetActorPos },
{ "GetActorRect", GetActorRect },
{ "GetActorPuckVector", GetActorPuckVector },
{ "GetActorYawToPoint", GetActorYawToPoint },
{ "SetActorReflection", SetActorReflection },
{ "PutActorAtInterest", PutActorAtInterest },
{ "PutActorAt", PutActorAt },
{ "PutActorInSet", PutActorInSet },
{ "WalkActorVector", WalkActorVector },
{ "WalkActorForward", WalkActorForward },
{ "DriveActorTo", DriveActorTo },
{ "WalkActorTo", WalkActorTo },
{ "WalkActorToAvoiding", WalkActorToAvoiding },
{ "ActorLookAt", ActorLookAt },
{ "SetActorLookRate", SetActorLookRate },
{ "GetActorLookRate", GetActorLookRate },
{ "GetVisibleThings", GetVisibleThings },
{ "GetCameraActor", GetCameraActor },
{ "SetActorHead", SetActorHead },
{ "SetActorVisibility", SetActorVisibility },
{ "SetActorFollowBoxes", SetActorFollowBoxes },
{ "ShutUpActor", ShutUpActor },
{ "SetActorFrustrumCull", SetActorFrustrumCull },
{ "IsActorInSector", IsActorInSector },
{ "GetActorSector", GetActorSector },
{ "IsPointInSector", IsPointInSector },
{ "GetPointSector", GetPointSector },
{ "TurnActor", TurnActor },
{ "GetActorRot", GetActorRot },
{ "SetActorRot", SetActorRot },
{ "SetActorPitch", SetActorPitch },
{ "SetActorRoll", SetActorRoll },
{ "IsActorTurning", IsActorTurning },
{ "PlayActorChore", PlayActorChore },
{ "PlayActorChoreLooping", PlayActorChoreLooping },
{ "StopActorChore", StopActorChore },
{ "CompleteActorChore", CompleteActorChore },
{ "IsActorMoving", IsActorMoving },
{ "IsActorChoring", IsActorChoring },
{ "IsActorResting", IsActorResting },
{ "SetActorChoreLooping", SetActorChoreLooping },
{ "GetActorChores", GetActorChores },
{ "GetActorCostumeDepth", GetActorCostumeDepth },
{ "WorldToScreen", WorldToScreen },
{ "exit", Exit },
{ "FunctionName", FunctionName },
{ "EnableDebugKeys", EnableDebugKeys },
{ "LockFont", LockFont },
{ "EnableControl", EnableControl },
{ "DisableControl", DisableControl },
{ "GetControlState", GetControlState },
{ "PrintError", PrintError },
{ "PrintWarning", PrintWarning },
{ "PrintDebug", PrintDebug },
{ "MakeCurrentSet", MakeCurrentSet },
{ "LockSet", LockSet },
{ "UnLockSet", UnLockSet },
{ "MakeCurrentSetup", MakeCurrentSetup },
{ "GetCurrentSetup", GetCurrentSetup },
{ "NextSetup", NextSetup },
{ "PreviousSetup", PreviousSetup },
{ "StartFullscreenMovie", StartFullscreenMovie },
{ "IsFullscreenMoviePlaying", IsFullscreenMoviePlaying },
{ "StartMovie", StartMovie },
{ "StopMovie", StopMovie },
{ "PauseMovie", PauseMovie },
{ "IsMoviePlaying", IsMoviePlaying },
{ "PlaySound", PlaySound },
{ "PlaySoundAt", PlaySoundAt },
{ "IsSoundPlaying", IsSoundPlaying },
{ "SetSoundPosition", SetSoundPosition },
{ "FileFindFirst", luaFileFindFirst },
{ "FileFindNext", luaFileFindNext },
{ "FileFindDispose", FileFindDispose },
{ "InputDialog", InputDialog },
{ "WriteRegistryValue", WriteRegistryValue },
{ "ReadRegistryValue", ReadRegistryValue },
{ "GetSectorOppositeEdge", GetSectorOppositeEdge },
{ "MakeSectorActive", MakeSectorActive },
{ "PreRender", PreRender },
{ "SpewStartup", SpewStartup },
{ "GetCurrentScript", GetCurrentScript },
{ "PrintActorCostumes", PrintActorCostumes },
{ "PushActorCostume", PushActorCostume },
{ "PopActorCostume", PopActorCostume },
{ "LoadCostume", LoadCostume },
{ "RotateVector", RotateVector },
{ "GetCameraPosition", GetCameraPosition },
{ "SetCameraPosition", SetCameraPosition },
{ "SetCameraInterest", SetCameraInterest },
{ "GetCameraFOV", GetCameraFOV },
{ "SetCameraFOV", SetCameraFOV },
{ "GetCameraRoll", GetCameraRoll },
{ "SetCameraRoll", SetCameraRoll },
{ "GetCameraLookVector", GetCameraLookVector },
{ "PointActorAt", PointActorAt },
{ "TurnActorTo", TurnActorTo },
{ "PerSecond", PerSecond },
{ "GetAngleBetweenVectors", GetAngleBetweenVectors },
{ "GetAngleBetweenActors", GetAngleBetweenActors },
{ "SetAmbientLight", SetAmbientLight },
{ "TurnLightOn", TurnLightOn },
{ "SetLightPosition", SetLightPosition },
{ "SetLightIntensity", SetLightIntensity },
{ "LightMgrSetChange", LightMgrSetChange },
{ "LightMgrStartup", LightMgrStartup },
{ "ImStartSound", ImStartSound },
{ "ImStopSound", ImStopSound },
{ "ImStopAllSounds", ImStopAllSounds },
{ "ImGetParam", ImGetParam },
{ "ImSetParam", ImSetParam },
{ "ImFadeParam", ImFadeParam },
{ "ImGetSfxVol", ImGetSfxVol },
{ "ImSetSfxVol", ImSetSfxVol },
{ "ImGetVoiceVol", ImGetVoiceVol },
{ "ImSetVoiceVol", ImSetVoiceVol },
{ "ImGetMusicVol", ImGetMusicVol },
{ "ImSetMusicVol", ImSetMusicVol },
{ "ImSetState", ImSetState },
{ "ImSetSequence", ImSetSequence },
{ "ImPause", ImPause },
{ "ImResume", ImResume },
{ "ImSetVoiceEffect", ImSetVoiceEffect },
{ "LoadBundle", LoadBundle },
{ "SetGamma", SetGamma },
{ "SetActorWalkDominate", SetActorWalkDominate },
{ "SetActorConstrain", SetActorConstrain },
{ "RenderModeUser", RenderModeUser },
{ "ForceRefresh", ForceRefresh },
{ "DimScreen", DimScreen },
{ "DimRegion", DimRegion },
{ "CleanBuffer", CleanBuffer },
{ "Display", Display },
{ "SetSpeechMode", SetSpeechMode },
{ "GetSpeechMode", GetSpeechMode },
{ "SetShadowColor", SetShadowColor },
{ "ActivateActorShadow", ActivateActorShadow },
{ "SetActorShadowPlane", SetActorShadowPlane },
{ "SetActorShadowPoint", SetActorShadowPoint },
{ "SetActiveShadow", SetActiveShadow },
{ "KillActorShadows", KillActorShadows },
{ "AddShadowPlane", AddShadowPlane },
{ "SetActorShadowValid", SetActorShadowValid },
{ "FreeObjectState", FreeObjectState },
{ "NewObjectState", NewObjectState },
{ "SetObjectType", SetObjectType },
{ "SendObjectToBack", SendObjectToBack },
{ "SendObjectToFront", SendObjectToFront },
{ "ActorToClean", ActorToClean },
{ "FlushControls", FlushControls },
{ "SetActorCollisionMode", SetActorCollisionMode },
{ "SetActorCollisionScale", SetActorCollisionScale },
{ "SetActorClipActive", SetActorClipActive },
{ "SetActorClipPlane", SetActorClipPlane },
{ "FadeOutChore", FadeOutChore },
{ "FadeInChore", FadeInChore },
{ "IrisDown", IrisDown },
{ "IrisUp", IrisUp },
{ "TextFileGetLineCount", TextFileGetLineCount },
{ "TextFileGetLine", TextFileGetLine },
{ "ScreenShot", ScreenShot },
{ "GetSaveGameImage", GetSaveGameImage },
{ "GetImage", GetImage },
{ "FreeImage", FreeImage },
{ "BlastImage", BlastImage },
{ "BlastRect", BlastRect },
{ "SubmitSaveGameData", SubmitSaveGameData },
{ "GetSaveGameData", GetSaveGameData },
{ "SetTextSpeed", SetTextSpeed },
{ "GetTextSpeed", GetTextSpeed },
{ "DetachFromResources", DetachFromResources },
{ "AttachToResources", AttachToResources },
{ "ActorPuckOrient", ActorPuckOrient },
{ "JustLoaded", JustLoaded },
{ "ResetTextures", ResetTextures },
{ "ShrinkBoxes", ShrinkBoxes },
{ "UnShrinkBoxes", UnShrinkBoxes },
{ "GetShrinkPos", GetShrinkPos },
{ "NukeResources", NukeResources },
{ "SetActorInvClipNode", SetActorInvClipNode },
{ "GetDiskFreeSpace", GetDiskFreeSpace },
{ "SaveIMuse", SaveIMuse },
{ "RestoreIMuse", RestoreIMuse },
{ "GetMemoryUsage", GetMemoryUsage },
{ "dofile", new_dofile },
// new Monkey 4 opcodes:
{ "SetActiveCD", SetActiveCD },
{ "GetActiveCD", GetActiveCD },
{ "AreWeInternational", AreWeInternational },
{ "MakeScreenTextures", MakeScreenTextures },
{ "ThumbnailFromFile", ThumbnailFromFile },
{ "ClearSpecialtyTexture", ClearSpecialtyTexture },
{ "UnloadActor", UnloadActor },
{ "PutActorInOverworld", PutActorInOverworld },
{ "RemoveActorFromOverworld", RemoveActorFromOverworld },
{ "ClearOverworld", ClearOverworld },
{ "ToggleOverworld", ToggleOverworld },
{ "ActorStopMoving", ActorStopMoving },
{ "SetActorFOV", SetActorFOV },
{ "SetActorLighting", SetActorLighting },
{ "SetActorHeadLimits", SetActorHeadLimits },
{ "ActorActivateShadow", ActorActivateShadow },
{ "EnableActorPuck", EnableActorPuck },
{ "SetActorGlobalAlpha", SetActorGlobalAlpha },
{ "SetActorLocalAlpha", SetActorLocalAlpha },
{ "SetActorSortOrder", SetActorSortOrder },
{ "GetActorSortOrder", GetActorSortOrder },
{ "AttachActor", AttachActor },
{ "DetachActor", DetachActor },
{ "IsChoreValid", IsChoreValid },
{ "IsChorePlaying", IsChorePlaying },
{ "IsChoreLooping", IsChoreLooping },
{ "StopActorChores", StopActorChores },
{ "PlayChore", PlayChore },
{ "StopChore", StopChore },
{ "PauseChore", PauseChore },
{ "AdvanceChore", AdvanceChore },
{ "CompleteChore", CompleteChore },
{ "LockChore", LockChore },
{ "UnlockChore", UnlockChore },
{ "LockChoreSet", LockChoreSet },
{ "UnlockChoreSet", UnlockChoreSet },
{ "LockBackground", LockBackground },
{ "UnLockBackground", UnLockBackground },
{ "EscapeMovie", EscapeMovie },
{ "StopAllSounds", StopAllSounds },
{ "LoadSound", LoadSound },
{ "FreeSound", FreeSound },
{ "PlayLoadedSound", PlayLoadedSound },
{ "SetGroupVolume", SetGroupVolume },
{ "GetSoundVolume", GetSoundVolume },
{ "SetSoundVolume", SetSoundVolume },
{ "EnableAudioGroup", EnableAudioGroup },
{ "EnableVoiceFX", EnableVoiceFX },
{ "PlaySoundFrom", PlaySoundFrom },
{ "PlayLoadedSoundFrom", PlayLoadedSoundFrom },
{ "SetReverb", SetReverb },
{ "UpdateSoundPosition", UpdateSoundPosition },
{ "ImSelectSet", ImSelectSet },
{ "ImStateHasLooped", ImStateHasLooped },
{ "ImStateHasEnded", ImStateHasEnded },
{ "ImPushState", ImPushState },
{ "ImPopState", ImPopState },
{ "ImFlushStack", ImFlushStack },
{ "ImGetMillisecondPosition", ImGetMillisecondPosition },
{ "GetSectorName", GetSectorName },
{ "GetCameraYaw", GetCameraYaw },
{ "YawCamera", YawCamera },
{ "GetCameraPitch", GetCameraPitch },
{ "PitchCamera", PitchCamera },
{ "RollCamera", RollCamera },
{ "UndimAll", UndimAll },
{ "UndimRegion", UndimRegion },
{ "GetCPUSpeed", GetCPUSpeed },
{ "NewLayer", NewLayer },
{ "FreeLayer", FreeLayer },
{ "SetLayerSortOrder", SetLayerSortOrder },
{ "SetLayerFrame", SetLayerFrame },
{ "AdvanceLayerFrame", AdvanceLayerFrame },
{ "PushText", PushText },
{ "PopText", PopText },
{ "NukeAllScriptLocks", NukeAllScriptLocks },
{ "ToggleDebugDraw", ToggleDebugDraw },
{ "ToggleDrawCameras", ToggleDrawCameras },
{ "ToggleDrawLights", ToggleDrawLights },
{ "ToggleDrawSectors", ToggleDrawSectors },
{ "ToggleDrawBBoxes", ToggleDrawBBoxes },
{ "ToggleDrawFPS", ToggleDrawFPS },
{ "ToggleDrawPerformance", ToggleDrawPerformance },
{ "ToggleDrawActorStats", ToggleDrawActorStats },
{ "SectEditSelect", SectEditSelect },
{ "SectEditPlace", SectEditPlace },
{ "SectEditDelete", SectEditDelete },
{ "SectEditInsert", SectEditInsert },
{ "SectEditSortAdd", SectEditSortAdd },
{ "SectEditForgetIt", SectEditForgetIt },
{ "FRUTEY_Begin", FRUTEY_Begin },
{ "FRUTEY_End", FRUTEY_End }
};
struct luaL_reg textOpcodes[] = {
{ "IsMessageGoing", IsMessageGoing },
{ "SetSayLineDefaults", SetSayLineDefaults },
{ "SetActorTalkColor", SetActorTalkColor },
{ "GetActorTalkColor", GetActorTalkColor },
{ "SayLine", SayLine },
{ "PrintLine", PrintLine },
{ "MakeTextObject", MakeTextObject },
{ "GetTextObjectDimensions", GetTextObjectDimensions },
{ "GetFontDimensions", GetFontDimensions },
{ "ChangeTextObject", ChangeTextObject },
{ "KillTextObject", KillTextObject },
{ "BlastText", BlastText },
{ "ExpireText", ExpireText },
{ "PurgeText", PurgeText },
{ "MakeColor", MakeColor },
{ "GetColorComponents", GetColorComponents },
{ "SetTranslationMode", SetTranslationMode },
{ "GetTranslationMode", GetTranslationMode },
{ "GetTextCharPosition", GetTextCharPosition },
{ "LocalizeString", LocalizeString },
{ "SetEmergencyFont", SetEmergencyFont },
{ "SetOffscreenTextPos", SetOffscreenTextPos }
};
struct luaL_reg primitivesOpcodes[] = {
{ "DrawLine", DrawLine },
{ "DrawPolygon", DrawPolygon },
{ "DrawRectangle", DrawRectangle },
{ "ChangePrimitive", ChangePrimitive },
{ "KillPrimitive", KillPrimitive },
{ "PurgePrimitiveQueue", PurgePrimitiveQueue }
};
struct luaL_reg hardwareOpcodes[] = {
{ "Is3DHardwareEnabled", Is3DHardwareEnabled },
{ "GetVideoDevices", GetVideoDevices },
{ "SetVideoDevices", SetVideoDevices },
{ "SetHardwareState", SetHardwareState },
{ "Enumerate3DDevices", Enumerate3DDevices },
{ "EnumerateVideoDevices", EnumerateVideoDevices }
};
void register_lua() {
// Register main opcodes functions
luaL_openlib(mainOpcodes, ARRAYSIZE(mainOpcodes));
// Register text opcodes functions
luaL_openlib(textOpcodes, ARRAYSIZE(textOpcodes));
// Register primitives opcodes functions
luaL_openlib(primitivesOpcodes, ARRAYSIZE(primitivesOpcodes));
// Register hardware opcodes functions
luaL_openlib(hardwareOpcodes, ARRAYSIZE(hardwareOpcodes));
// Register system table
lua_Object system_table = lua_createtable();
lua_pushobject(system_table);
lua_setglobal("system");
for (unsigned i = 0; i < ARRAYSIZE(system_defaults); i++) {
lua_pushobject(system_table);
lua_pushstring(system_defaults[i].name);
lua_pushnumber(system_defaults[i].key);
lua_settable();
}
// Create and populate system.controls table
lua_Object controls_table = lua_createtable();
lua_pushobject(system_table);
lua_pushstring("controls");
lua_pushobject(controls_table);
lua_settable();
const Driver::ControlDescriptor *controls = g_driver->listControls();
for (unsigned i = 0; controls[i].name != NULL; i++) {
lua_pushobject(controls_table);
lua_pushstring(controls[i].name);
lua_pushnumber(controls[i].key);
lua_settable();
}
lua_pushobject(system_table);
lua_pushstring("camChangeHandler");
lua_pushcfunction(dummyHandler);
lua_settable();
lua_pushobject(system_table);
lua_pushstring("axisHandler");
lua_pushcfunction(dummyHandler);
lua_settable();
// Register constants for box types
lua_pushnumber(0);
lua_setglobal("NONE");
lua_pushnumber(0x1000);
lua_setglobal("WALK");
lua_pushnumber(0x2000);
lua_setglobal("CAMERA");
lua_pushnumber(0x4000);
lua_setglobal("SPECIAL");
lua_pushnumber(0x8000);
lua_setglobal("HOT");
saveCallback = SaveCallback;
restoreCallback = RestoreCallback;
}
int bundle_dofile(const char *filename) {
Block *b = g_resourceloader->getFileBlock(filename);
if (b == NULL) {
delete b;
// Don't print warnings on Scripts\foo.lua,
// d:\grimFandango\Scripts\foo.lua
if (std::strstr(filename, "Scripts\\") == NULL && (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL))
warning("Cannot find script %s\n", filename);
return 2;
}
int result = lua_dobuffer(const_cast<char *>(b->data()), b->len(), const_cast<char *>(filename));
delete b;
return result;
}
lua_Object getTableFunction(lua_Object table, const char *name) {
lua_pushobject(table);
lua_pushstring(const_cast<char *>(name));
lua_Object handler = lua_gettable();
if (lua_isnil(handler))
return LUA_NOOBJECT;
if (lua_istable(handler)) {
lua_pushobject(handler); // Push handler object
lua_pushobject(handler); // For gettable
lua_pushstring(const_cast<char *>(name));
handler = lua_gettable();
if (lua_isnil(handler))
return LUA_NOOBJECT;
}
if (!lua_isfunction(handler)) {
if (debugLevel == DEBUG_WARN || debugLevel == DEBUG_ALL)
warning("Invalid event handler %s", name);
return LUA_NOOBJECT;
}
return handler;
}
lua_Object getTableValue(lua_Object table, const char *name) {
const char *key_text = NULL;
lua_Object key = LUA_NOOBJECT;
if (!lua_istable(table)) {
error("getTableValue(): Parameter not a table!\n");
return 0;
}
for (;;) {
lua_pushobject(table);
if (key_text)
lua_pushobject(key);
else
lua_pushnil();
// If getTableValue is called against a bad value
// that it doesn't understand then an infinite loop
// will be set up repeating the same error.
if(lua_call("next") != 0) {
error("getTableValue could not find the next key!\n");
return 0;
}
key = lua_getresult(1);
if (lua_isnil(key))
break;
// If this function is called against a table that is
// indexed (rather than keyed) then return zero so
// the indexed version can be called instead. This
// operation cannot be done automatically since the
// index number needs to be known in order to obtain
// the correct value.
if (lua_isnumber(key))
return 0;
key_text = lua_getstring(key);
if (strmatch(key_text, name))
return lua_getresult(2);
}
return 0;
}
lua_Object getIndexedTableValue(lua_Object table, int index) {
if (!lua_istable(table)) {
error("getIndexedTableValue(): Parameter not a table!\n");
return 0;
}
lua_pushobject(table);
if (index == 1)
lua_pushnil();
else
lua_pushnumber(index - 1);
// If the call to "next" fails then register an error
if (lua_call("next") != 0) {
error("getIndexedTableValue failed to get next key!\n");
return 0;
}
return lua_getresult(2);
}
void setTableValue(lua_Object table, const char *name, int newvalue) {
lua_pushobject(table);
lua_pushstring(name);
lua_pushnumber(newvalue);
lua_settable();
}
void setTableValue(lua_Object table, const char *name, lua_Object newvalue) {
lua_pushobject(table);
lua_pushstring(name);
if (newvalue == 0)
lua_pushnil();
else
lua_pushobject(newvalue);
lua_settable();
}
/* Obtain the x, y, and z coordinates from a LUA table
* and then create a Vector3d object with these values
*/
Vector3d tableToVector(lua_Object table) {
lua_Object xparam, yparam, zparam;
float x, y, z;
if (!lua_istable(table))
error("tableToVector passed a LUA object that is not a table!");
xparam = getTableValue(table, "x");
yparam = getTableValue(table, "y");
zparam = getTableValue(table, "z");
if (!lua_isnumber(xparam) || !lua_isnumber(yparam) || !lua_isnumber(zparam))
error("tableToVector passed a LUA table that does not contain vector coordinates!");
x = lua_getnumber(xparam);
y = lua_getnumber(yparam);
z = lua_getnumber(zparam);
return Vector3d(x, y, z);
}
lua_Object getEventHandler(const char *name) {
lua_Object system_table = lua_getglobal("system");
return getTableFunction(system_table, name);
}
Reference in New Issue View Git Blame Copy Permalink