/**
* Send a request to register a game to the server.
*
* @param data A JS array of game attributes
*/
void XmppClient::SendIqRegisterGame(ScriptInterface& scriptInterface, CScriptVal data)
{
glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
jsval dataval = data.get();
// Setup some base stanza attributes
GameListQuery* g = new GameListQuery();
g->m_Command = "register";
glooxwrapper::Tag* game = glooxwrapper::Tag::allocate("game");
// Add a fake ip which will be overwritten by the ip stamp XMPP module on the server.
game->addAttribute("ip", "fake");
// Iterate through all the properties reported and add them to the stanza.
std::vector<std::string> properties;
scriptInterface.EnumeratePropertyNamesWithPrefix(dataval, "", properties);
for (std::vector<int>::size_type i = 0; i != properties.size(); i++)
{
std::wstring value;
scriptInterface.GetProperty(dataval, properties[i].c_str(), value);
game->addAttribute(properties[i], utf8_from_wstring(value));
}
// Push the stanza onto the IQ
g->m_GameList.push_back(game);
// Send IQ
glooxwrapper::IQ iq(gloox::IQ::Set, xpartamuppJid);
iq.addExtension(g);
DbgXMPP("SendIqRegisterGame [" << tag_xml(iq) << "]");
m_client->send(iq);
}
/**
* Send game report containing numerous game properties to the server.
*
* @param data A JS array of game statistics
*/
void XmppClient::SendIqGameReport(ScriptInterface& scriptInterface, CScriptVal data)
{
glooxwrapper::JID xpartamuppJid(m_xpartamuppId);
jsval dataval = data.get();
// Setup some base stanza attributes
GameReport* game = new GameReport();
glooxwrapper::Tag* report = glooxwrapper::Tag::allocate("game");
// Iterate through all the properties reported and add them to the stanza.
std::vector<std::string> properties;
scriptInterface.EnumeratePropertyNamesWithPrefix(dataval, "", properties);
for (std::vector<int>::size_type i = 0; i != properties.size(); i++)
{
std::wstring value;
scriptInterface.GetProperty(dataval, properties[i].c_str(), value);
report->addAttribute(properties[i], utf8_from_wstring(value));
}
// Add stanza to IQ
game->m_GameReport.push_back(report);
// Send IQ
glooxwrapper::IQ iq(gloox::IQ::Set, xpartamuppJid);
iq.addExtension(game);
DbgXMPP("SendGameReport [" << tag_xml(iq) << "]");
m_client->send(iq);
};
CBinarySerializerScriptImpl::CBinarySerializerScriptImpl(ScriptInterface& scriptInterface, ISerializer& serializer) :
m_ScriptInterface(scriptInterface), m_Serializer(serializer), m_ScriptBackrefs(scriptInterface.GetRuntime()),
m_SerializablePrototypes(new ObjectIdCache<std::wstring>(scriptInterface.GetRuntime())), m_ScriptBackrefsNext(1)
{
m_ScriptBackrefs.init();
m_SerializablePrototypes->init();
}
void
Sector::try_expose(GameObject* object)
{
ScriptInterface* interface = dynamic_cast<ScriptInterface*> (object);
if(interface != NULL) {
HSQUIRRELVM vm = Scripting::global_vm;
sq_pushobject(vm, sector_table);
interface->expose(vm, -1);
sq_pop(vm, 1);
}
}
static std::vector<SimulationCommand> CloneCommandsFromOtherContext(ScriptInterface& oldScript, ScriptInterface& newScript,
const std::vector<SimulationCommand>& commands)
{
std::vector<SimulationCommand> newCommands = commands;
for (size_t i = 0; i < newCommands.size(); ++i)
{
newCommands[i].data = CScriptValRooted(newScript.GetContext(),
newScript.CloneValueFromOtherContext(oldScript, newCommands[i].data.get()));
}
return newCommands;
}
int main(int argc, char* argv[])
{
QCoreApplication app(argc, argv);
QCoreApplication::setOrganizationName("SL Studios");
QCoreApplication::setOrganizationDomain("SLStudios.org");
QCoreApplication::setApplicationName("PortalCalibration");
ScriptInterface scriptInterface;
// Add our types
scriptInterface.AddObject(scriptInterface, "Global");
#ifdef USE_LIGHTCRAFTER_PROJECTOR
scriptInterface.AddObjectType<LightCrafter>( "LightCrafterProjector" );
#endif
#ifdef USE_LIGHTCOMMANDER_PROJECTOR
scriptInterface.AddObjectType<LightCommanderProjector>( "LightCommanderProjector" );
#endif
#ifdef USE_QTFULLSCREEN
scriptInterface.AddObjectType<QTFullscreen>("QTFullscreen");
#endif
scriptInterface.AddObjectType<CalibrationData>( "CalibrationData" );
scriptInterface.AddObjectType<JSSerializer, QString>( "JSSerializer" );
scriptInterface.AddObjectType<CalibrationEngine, int, int, float>( "CalibrationEngine" );
// Add our camera types
scriptInterface.AddObjectType<lens::OpenCVCamera>( "OpenCVCamera" );
#ifdef USE_FILE_CAMERA
scriptInterface.AddObjectType<lens::FileCamera>( "FileCamera" );
#endif
#ifdef USE_IC_CAMERA
scriptInterface.AddObjectType<lens::ICCamera>( "ICCamera" );
#endif
#ifdef USE_JAI_CAMERA
scriptInterface.AddObjectType<lens::JAICamera>( "JAICamera" );
#endif
#ifdef USE_POINT_GREY_CAMERA
scriptInterface.AddObjectType<lens::PointGreyCamera>( "PointGreyCamera" );
scriptInterface.AddObjectType<lens::PointGreyCamera, unsigned int>( "PointGreyCamera" );
#endif
#ifdef USE_PHANTOM_CAMERA
scriptInterface.AddObjectType<lens::PhantomCamera>( "PhantomCamera" );
#endif
// Register types we want to pass around
scriptInterface.RegisterMetaObjectType<CalibrationData>( );
scriptInterface.RunScript("Calibrate.js");
return 0;
}
JS::Value CProfileViewer::SaveToJS(ScriptInterface& scriptInterface)
{
JSContext* cx = scriptInterface.GetContext();
JSAutoRequest rq(cx);
JS::RootedValue root(cx);
scriptInterface.Eval("({})", &root);
std::vector<AbstractProfileTable*> tables = m->rootTables;
sort(tables.begin(), tables.end(), SortByName);
for_each(tables.begin(), tables.end(), DumpTable(scriptInterface, root));
return root;
}
JSBool JSI_GUIMouse::toString(JSContext* cx, uint argc, jsval* vp)
{
UNUSED2(argc);
i32 x, y, buttons;
ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
pScriptInterface->GetProperty(JS_THIS_VALUE(cx, vp), "x", x);
pScriptInterface->GetProperty(JS_THIS_VALUE(cx, vp), "y", y);
pScriptInterface->GetProperty(JS_THIS_VALUE(cx, vp), "buttons", buttons);
char buffer[256];
snprintf(buffer, 256, "%d %d %d", x, y, buttons);
JS_SET_RVAL(cx, vp, STRING_TO_JSVAL(JS_NewStringCopyZ(cx, buffer)));
return JS_TRUE;
}
std::vector<CScriptValRooted> SavedGames::GetSavedGames(ScriptInterface& scriptInterface)
{
TIMER(L"GetSavedGames");
std::vector<CScriptValRooted> games;
Status err;
VfsPaths pathnames;
err = vfs::GetPathnames(g_VFS, "saves/", L"*.0adsave", pathnames);
WARN_IF_ERR(err);
for (size_t i = 0; i < pathnames.size(); ++i)
{
OsPath realPath;
err = g_VFS->GetRealPath(pathnames[i], realPath);
if (err < 0)
{
DEBUG_WARN_ERR(err);
continue; // skip this file
}
PIArchiveReader archiveReader = CreateArchiveReader_Zip(realPath);
if (!archiveReader)
{
// Triggered by e.g. the file being open in another program
LOGWARNING(L"Failed to read saved game '%ls'", realPath.string().c_str());
continue; // skip this file
}
CScriptValRooted metadata;
CGameLoader loader(scriptInterface, &metadata, NULL);
err = archiveReader->ReadEntries(CGameLoader::ReadEntryCallback, (uintptr_t)&loader);
if (err < 0)
{
DEBUG_WARN_ERR(err);
continue; // skip this file
}
CScriptValRooted game;
scriptInterface.Eval("({})", game);
scriptInterface.SetProperty(game.get(), "id", pathnames[i].Basename());
scriptInterface.SetProperty(game.get(), "metadata", metadata);
games.push_back(game);
}
return games;
}
JS::Value CMessage::ToJSValCached(ScriptInterface& scriptInterface) const
{
if (!m_Cached)
m_Cached.reset(new JS::PersistentRootedValue(scriptInterface.GetJSRuntime(), ToJSVal(scriptInterface)));
return m_Cached->get();
}
jsval CMessage::ToJSValCached(ScriptInterface& scriptInterface) const
{
if (m_Cached.uninitialised())
m_Cached = CScriptValRooted(scriptInterface.GetContext(), ToJSVal(scriptInterface));
return m_Cached.get();
}
void
Sector::try_unexpose(GameObject* object)
{
ScriptInterface* interface = dynamic_cast<ScriptInterface*> (object);
if(interface != NULL) {
HSQUIRRELVM vm = Scripting::global_vm;
SQInteger oldtop = sq_gettop(vm);
sq_pushobject(vm, sector_table);
try {
interface->unexpose(vm, -1);
} catch(std::exception& e) {
log_warning << "Couldn't unregister object: " << e.what() << std::endl;
}
sq_settop(vm, oldtop);
}
}
static std::vector<SimulationCommand> CloneCommandsFromOtherContext(ScriptInterface& oldScript, ScriptInterface& newScript,
const std::vector<SimulationCommand>& commands)
{
JSContext* cxOld = oldScript.GetContext();
JSAutoRequest rqOld(cxOld);
std::vector<SimulationCommand> newCommands;
newCommands.reserve(commands.size());
for (const SimulationCommand& command : commands)
{
JSContext* cxNew = newScript.GetContext();
JSAutoRequest rqNew(cxNew);
JS::RootedValue tmpCommand(cxNew, newScript.CloneValueFromOtherContext(oldScript, command.data));
SimulationCommand cmd(command.player, cxNew, tmpCommand);
newCommands.emplace_back(std::move(cmd));
}
return newCommands;
}
JS::Value ScriptInterface::CloneValueFromOtherContext(ScriptInterface& otherContext, JS::HandleValue val)
{
PROFILE("CloneValueFromOtherContext");
JSAutoRequest rq(m->m_cx);
JS::RootedValue out(m->m_cx);
shared_ptr<StructuredClone> structuredClone = otherContext.WriteStructuredClone(val);
ReadStructuredClone(structuredClone, &out);
return out.get();
}
void CNetServer::UpdateGameAttributes(JS::MutableHandleValue attrs, ScriptInterface& scriptInterface)
{
// Pass the attributes as JSON, since that's the easiest safe
// cross-thread way of passing script data
std::string attrsJSON = scriptInterface.StringifyJSON(attrs, false);
CScopeLock lock(m_Worker->m_WorkerMutex);
m_Worker->m_GameAttributesQueue.push_back(attrsJSON);
}
/**
* Handle requests from the GUI for the list of players.
*
* @return A JS array containing all known players and their presences
*/
CScriptValRooted XmppClient::GUIGetPlayerList(ScriptInterface& scriptInterface)
{
std::string presence;
CScriptValRooted playerList;
scriptInterface.Eval("({})", playerList);
for(std::map<std::string, gloox::Presence::PresenceType>::const_iterator it = m_PlayerMap.begin(); it != m_PlayerMap.end(); ++it)
{
CScriptValRooted player;
GetPresenceString(it->second, presence);
scriptInterface.Eval("({})", player);
scriptInterface.SetProperty(player.get(), "name", wstring_from_utf8(it->first));
scriptInterface.SetProperty(player.get(), "presence", wstring_from_utf8(presence));
scriptInterface.SetProperty(playerList.get(), wstring_from_utf8(it->first).c_str(), player);
}
return playerList;
}
Ability::Ability(AbilityID id, const Name &name, const DescriptionText &desc, ScriptInterface &scriptIF)
:m_scriptIF(scriptIF)
{
//Verify input parameters
assert(id > 0);
assert(name.length() > 0);
assert(desc.length() > 0);
m_ID = id;
m_name.assign(name);
m_description.assign(desc);
char file[64], moduleName[64];
sprintf(file, "data/scripts/afx/0x%03x.as", id);
sprintf(moduleName, "afx:0x%03x", id);
m_scriptModuleID = scriptIF.createModuleFromFile(Name(moduleName), Filename(file));
m_scriptContextID = scriptIF.createContext();
}
/**
* Handle requests from the GUI for leaderboard data.
*
* @return A JS array containing all known leaderboard data
*/
CScriptValRooted XmppClient::GUIGetBoardList(ScriptInterface& scriptInterface)
{
CScriptValRooted boardList;
scriptInterface.Eval("([])", boardList);
for(std::vector<const glooxwrapper::Tag*>::const_iterator it = m_BoardList.begin(); it != m_BoardList.end(); ++it)
{
CScriptValRooted board;
scriptInterface.Eval("({})", board);
const char* attributes[] = { "name", "rank", "rating" };
short attributes_length = 3;
for (short i = 0; i < attributes_length; i++)
scriptInterface.SetProperty(board.get(), attributes[i], wstring_from_utf8((*it)->findAttribute(attributes[i]).to_string()));
scriptInterface.CallFunctionVoid(boardList.get(), "push", board);
}
return boardList;
}
/**
* Handle requests from the GUI for the list of all active games.
*
* @return A JS array containing all known games
*/
CScriptValRooted XmppClient::GUIGetGameList(ScriptInterface& scriptInterface)
{
CScriptValRooted gameList;
scriptInterface.Eval("([])", gameList);
for(std::vector<const glooxwrapper::Tag*>::const_iterator it = m_GameList.begin(); it != m_GameList.end(); ++it)
{
CScriptValRooted game;
scriptInterface.Eval("({})", game);
const char* stats[] = { "name", "ip", "state", "nbp", "tnbp", "players", "mapName", "niceMapName", "mapSize", "mapType", "victoryCondition" };
short stats_length = 11;
for (short i = 0; i < stats_length; i++)
scriptInterface.SetProperty(game.get(), stats[i], wstring_from_utf8((*it)->findAttribute(stats[i]).to_string()));
scriptInterface.CallFunctionVoid(gameList.get(), "push", game);
}
return gameList;
}
CScriptVal CProfileViewer::SaveToJS(ScriptInterface& scriptInterface)
{
CScriptVal root;
scriptInterface.Eval("({})", root);
std::vector<AbstractProfileTable*> tables = m->rootTables;
sort(tables.begin(), tables.end(), SortByName);
for_each(tables.begin(), tables.end(), DumpTable(scriptInterface, root));
return root;
}
JSBool JSI_GUIColor::toString(JSContext* cx, uint argc, jsval* vp)
{
UNUSED2(argc);
double r, g, b, a;
ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface;
pScriptInterface->GetProperty(JS_THIS_VALUE(cx, vp), "r", r);
pScriptInterface->GetProperty(JS_THIS_VALUE(cx, vp), "g", g);
pScriptInterface->GetProperty(JS_THIS_VALUE(cx, vp), "b", b);
pScriptInterface->GetProperty(JS_THIS_VALUE(cx, vp), "a", a);
char buffer[256];
// Convert to integers, to be compatible with the GUI's string SetSetting
snprintf(buffer, 256, "%d %d %d %d",
(int)(255.0 * r),
(int)(255.0 * g),
(int)(255.0 * b),
(int)(255.0 * a));
JS_SET_RVAL(cx, vp, STRING_TO_JSVAL(JS_NewStringCopyZ(cx, buffer)));
return JS_TRUE;
}
void ConvertCaches(ScriptInterface& scriptInterface, x86_x64::IdxCache idxCache, JS::MutableHandleValue ret)
{
JSContext* cx = scriptInterface.GetContext();
JSAutoRequest rq(cx);
scriptInterface.Eval("[]", ret);
for (size_t idxLevel = 0; idxLevel < x86_x64::Cache::maxLevels; ++idxLevel)
{
const x86_x64::Cache* pcache = x86_x64::Caches(idxCache+idxLevel);
if (pcache->type == x86_x64::Cache::kNull || pcache->numEntries == 0)
continue;
JS::RootedValue cache(cx);
scriptInterface.Eval("({})", &cache);
scriptInterface.SetProperty(cache, "type", (u32)pcache->type);
scriptInterface.SetProperty(cache, "level", (u32)pcache->level);
scriptInterface.SetProperty(cache, "associativity", (u32)pcache->associativity);
scriptInterface.SetProperty(cache, "linesize", (u32)pcache->entrySize);
scriptInterface.SetProperty(cache, "sharedby", (u32)pcache->sharedBy);
scriptInterface.SetProperty(cache, "totalsize", (u32)pcache->TotalSize());
scriptInterface.SetPropertyInt(ret, idxLevel, cache);
}
}
CStdDeserializer::CStdDeserializer(ScriptInterface& scriptInterface, std::istream& stream) :
m_ScriptInterface(scriptInterface), m_Stream(stream),
m_dummyObject(scriptInterface.GetJSRuntime())
{
JSContext* cx = m_ScriptInterface.GetContext();
JSAutoRequest rq(cx);
JS_AddExtraGCRootsTracer(m_ScriptInterface.GetJSRuntime(), CStdDeserializer::Trace, this);
// Add a dummy tag because the serializer uses the tag 0 to indicate that a value
// needs to be serialized and then tagged
m_dummyObject = JS_NewPlainObject(cx);
m_ScriptBackrefs.push_back(JS::Heap<JSObject*>(m_dummyObject));
}
void ScriptTestSetup(ScriptInterface& ifc)
{
ifc.RegisterFunction<void, std::wstring, script_TS_FAIL>("TS_FAIL");
// Load the TS_* function definitions
// (We don't use VFS because tests might not have the normal VFS paths loaded)
OsPath path = DataDir()/"tests"/"test_setup.js";
std::ifstream ifs(OsString(path).c_str());
ENSURE(ifs.good());
std::string content((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
std::wstring wcontent(content.begin(), content.end());
bool ok = ifc.LoadScript(L"test_setup.js", wcontent);
ENSURE(ok);
}
CScriptVal ConvertCaches(ScriptInterface& scriptInterface, x86_x64::IdxCache idxCache)
{
CScriptVal ret;
scriptInterface.Eval("[]", ret);
for (size_t idxLevel = 0; idxLevel < x86_x64::Cache::maxLevels; ++idxLevel)
{
const x86_x64::Cache* pcache = x86_x64::Caches(idxCache+idxLevel);
if (pcache->type == x86_x64::Cache::kNull || pcache->numEntries == 0)
continue;
CScriptVal cache;
scriptInterface.Eval("({})", cache);
scriptInterface.SetProperty(cache.get(), "type", (u32)pcache->type);
scriptInterface.SetProperty(cache.get(), "level", (u32)pcache->level);
scriptInterface.SetProperty(cache.get(), "associativity", (u32)pcache->associativity);
scriptInterface.SetProperty(cache.get(), "linesize", (u32)pcache->entrySize);
scriptInterface.SetProperty(cache.get(), "sharedby", (u32)pcache->sharedBy);
scriptInterface.SetProperty(cache.get(), "totalsize", (u32)pcache->TotalSize());
scriptInterface.SetPropertyInt(ret.get(), idxLevel, cache);
}
return ret;
}
CComponentTypeScript::CComponentTypeScript(ScriptInterface& scriptInterface, JS::HandleValue instance) :
m_ScriptInterface(scriptInterface), m_Instance(scriptInterface.GetJSRuntime(), instance)
{
// Cache the property detection for efficiency
JSContext* cx = m_ScriptInterface.GetContext();
JSAutoRequest rq(cx);
m_HasCustomSerialize = m_ScriptInterface.HasProperty(m_Instance, "Serialize");
m_HasCustomDeserialize = m_ScriptInterface.HasProperty(m_Instance, "Deserialize");
m_HasNullSerialize = false;
if (m_HasCustomSerialize)
{
JS::RootedValue val(cx);
if (m_ScriptInterface.GetProperty(m_Instance, "Serialize", &val) && val.isNull())
m_HasNullSerialize = true;
}
}
void ConvertTLBs(ScriptInterface& scriptInterface, JS::MutableHandleValue ret)
{
JSContext* cx = scriptInterface.GetContext();
JSAutoRequest rq(cx);
scriptInterface.Eval("[]", ret);
for(size_t i = 0; ; i++)
{
const x86_x64::Cache* ptlb = x86_x64::Caches(x86_x64::TLB+i);
if (!ptlb)
break;
JS::RootedValue tlb(cx);
scriptInterface.Eval("({})", &tlb);
scriptInterface.SetProperty(tlb, "type", (u32)ptlb->type);
scriptInterface.SetProperty(tlb, "level", (u32)ptlb->level);
scriptInterface.SetProperty(tlb, "associativity", (u32)ptlb->associativity);
scriptInterface.SetProperty(tlb, "pagesize", (u32)ptlb->entrySize);
scriptInterface.SetProperty(tlb, "entries", (u32)ptlb->numEntries);
scriptInterface.SetPropertyInt(ret, i, tlb);
}
}
/**
* Handle requests from the GUI for the list of players.
*
* @return A JS array containing all known players and their presences
*/
CScriptValRooted XmppClient::GUIGetPlayerList(ScriptInterface& scriptInterface)
{
CScriptValRooted playerList;
scriptInterface.Eval("([])", playerList);
// Convert the internal data structure to a Javascript object.
for (std::map<std::string, std::vector<std::string> >::const_iterator it = m_PlayerMap.begin(); it != m_PlayerMap.end(); ++it)
{
CScriptValRooted player;
scriptInterface.Eval("({})", player);
scriptInterface.SetProperty(player.get(), "name", wstring_from_utf8(it->first));
scriptInterface.SetProperty(player.get(), "presence", wstring_from_utf8(it->second[0]));
scriptInterface.SetProperty(player.get(), "rating", wstring_from_utf8(it->second[1]));
scriptInterface.SetProperty(player.get(), "role", wstring_from_utf8(it->second[2]));
scriptInterface.CallFunctionVoid(playerList.get(), "push", player);
}
return playerList;
}
CScriptVal ConvertTLBs(ScriptInterface& scriptInterface)
{
CScriptVal ret;
scriptInterface.Eval("[]", ret);
for(size_t i = 0; ; i++)
{
const x86_x64::Cache* ptlb = x86_x64::Caches(x86_x64::TLB+i);
if (!ptlb)
break;
CScriptVal tlb;
scriptInterface.Eval("({})", tlb);
scriptInterface.SetProperty(tlb.get(), "type", (u32)ptlb->type);
scriptInterface.SetProperty(tlb.get(), "level", (u32)ptlb->level);
scriptInterface.SetProperty(tlb.get(), "associativity", (u32)ptlb->associativity);
scriptInterface.SetProperty(tlb.get(), "pagesize", (u32)ptlb->entrySize);
scriptInterface.SetProperty(tlb.get(), "entries", (u32)ptlb->numEntries);
scriptInterface.SetPropertyInt(ret.get(), i, tlb);
}
return ret;
}
/**
* Send GUI message queue when queried.
*/
CScriptValRooted XmppClient::GuiPollMessage(ScriptInterface& scriptInterface)
{
if (m_GuiMessageQueue.empty())
return CScriptValRooted();
GUIMessage message = m_GuiMessageQueue.front();
CScriptValRooted messageVal;
scriptInterface.Eval("({})", messageVal);
scriptInterface.SetProperty(messageVal.get(), "type", message.type);
if (!message.from.empty())
scriptInterface.SetProperty(messageVal.get(), "from", message.from);
if (!message.text.empty())
scriptInterface.SetProperty(messageVal.get(), "text", message.text);
if (!message.level.empty())
scriptInterface.SetProperty(messageVal.get(), "level", message.level);
if (!message.message.empty())
scriptInterface.SetProperty(messageVal.get(), "message", message.message);
if (!message.data.empty())
scriptInterface.SetProperty(messageVal.get(), "data", message.data);
m_GuiMessageQueue.pop_front();
return messageVal;
}
