forked from mirrors/0ad
Ykkrosh
d7ec8c47a6
Fix EncryptPassword being called with the wrong argument order, and encrypting username instead of password. (This will break all existing lobby accounts.) Fix EncryptPassword not using all of salt_base. This was SVN commit r14123.
1003 lines
31 KiB
C++
1003 lines
31 KiB
C++
/* Copyright (C) 2013 Wildfire Games.
|
|
* This file is part of 0 A.D.
|
|
*
|
|
* 0 A.D. is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 0 A.D. is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
|
|
#include "scriptinterface/ScriptInterface.h"
|
|
|
|
#include "graphics/Camera.h"
|
|
#include "graphics/GameView.h"
|
|
#include "graphics/MapReader.h"
|
|
#include "gui/GUIManager.h"
|
|
#include "graphics/scripting/JSInterface_GameView.h"
|
|
#include "lib/timer.h"
|
|
#include "lib/utf8.h"
|
|
#include "lib/sysdep/sysdep.h"
|
|
#include "lobby/IXmppClient.h"
|
|
#include "lobby/sha.h"
|
|
#include "maths/FixedVector3D.h"
|
|
#include "network/NetClient.h"
|
|
#include "network/NetServer.h"
|
|
#include "network/NetTurnManager.h"
|
|
#include "ps/CLogger.h"
|
|
#include "ps/CConsole.h"
|
|
#include "ps/Errors.h"
|
|
#include "ps/Game.h"
|
|
#include "ps/GUID.h"
|
|
#include "ps/World.h"
|
|
#include "ps/Hotkey.h"
|
|
#include "ps/Overlay.h"
|
|
#include "ps/ProfileViewer.h"
|
|
#include "ps/Pyrogenesis.h"
|
|
#include "ps/SavedGame.h"
|
|
#include "ps/scripting/JSInterface_ConfigDB.h"
|
|
#include "ps/scripting/JSInterface_Console.h"
|
|
#include "ps/UserReport.h"
|
|
#include "ps/GameSetup/Atlas.h"
|
|
#include "ps/GameSetup/Config.h"
|
|
#include "ps/ConfigDB.h"
|
|
#include "renderer/scripting/JSInterface_Renderer.h"
|
|
#include "tools/atlas/GameInterface/GameLoop.h"
|
|
|
|
#include "simulation2/Simulation2.h"
|
|
#include "simulation2/components/ICmpAIManager.h"
|
|
#include "simulation2/components/ICmpCommandQueue.h"
|
|
#include "simulation2/components/ICmpGuiInterface.h"
|
|
#include "simulation2/components/ICmpRangeManager.h"
|
|
#include "simulation2/components/ICmpTemplateManager.h"
|
|
#include "simulation2/components/ICmpSelectable.h"
|
|
#include "simulation2/helpers/Selection.h"
|
|
|
|
#include "js/jsapi.h"
|
|
/*
|
|
* This file defines a set of functions that are available to GUI scripts, to allow
|
|
* interaction with the rest of the engine.
|
|
* Functions are exposed to scripts within the global object 'Engine', so
|
|
* scripts should call "Engine.FunctionName(...)" etc.
|
|
*/
|
|
|
|
extern void restart_mainloop_in_atlas(); // from main.cpp
|
|
|
|
namespace {
|
|
|
|
CScriptVal GetActiveGui(void* UNUSED(cbdata))
|
|
{
|
|
return OBJECT_TO_JSVAL(g_GUI->GetScriptObject());
|
|
}
|
|
|
|
void PushGuiPage(void* UNUSED(cbdata), std::wstring name, CScriptVal initData)
|
|
{
|
|
g_GUI->PushPage(name, initData);
|
|
}
|
|
|
|
void SwitchGuiPage(void* UNUSED(cbdata), std::wstring name, CScriptVal initData)
|
|
{
|
|
g_GUI->SwitchPage(name, initData);
|
|
}
|
|
|
|
void PopGuiPage(void* UNUSED(cbdata))
|
|
{
|
|
g_GUI->PopPage();
|
|
}
|
|
|
|
CScriptVal GuiInterfaceCall(void* cbdata, std::wstring name, CScriptVal data)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
if (!g_Game)
|
|
return JSVAL_VOID;
|
|
CSimulation2* sim = g_Game->GetSimulation2();
|
|
ENSURE(sim);
|
|
|
|
CmpPtr<ICmpGuiInterface> cmpGuiInterface(*sim, SYSTEM_ENTITY);
|
|
if (!cmpGuiInterface)
|
|
return JSVAL_VOID;
|
|
|
|
int player = -1;
|
|
if (g_Game)
|
|
player = g_Game->GetPlayerID();
|
|
|
|
CScriptValRooted arg (sim->GetScriptInterface().GetContext(), sim->GetScriptInterface().CloneValueFromOtherContext(guiManager->GetScriptInterface(), data.get()));
|
|
CScriptVal ret (cmpGuiInterface->ScriptCall(player, name, arg.get()));
|
|
return guiManager->GetScriptInterface().CloneValueFromOtherContext(sim->GetScriptInterface(), ret.get());
|
|
}
|
|
|
|
void PostNetworkCommand(void* cbdata, CScriptVal cmd)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
if (!g_Game)
|
|
return;
|
|
CSimulation2* sim = g_Game->GetSimulation2();
|
|
ENSURE(sim);
|
|
|
|
CmpPtr<ICmpCommandQueue> cmpCommandQueue(*sim, SYSTEM_ENTITY);
|
|
if (!cmpCommandQueue)
|
|
return;
|
|
|
|
jsval cmd2 = sim->GetScriptInterface().CloneValueFromOtherContext(guiManager->GetScriptInterface(), cmd.get());
|
|
|
|
cmpCommandQueue->PostNetworkCommand(cmd2);
|
|
}
|
|
|
|
std::vector<entity_id_t> PickEntitiesAtPoint(void* UNUSED(cbdata), int x, int y)
|
|
{
|
|
return EntitySelection::PickEntitiesAtPoint(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x, y, g_Game->GetPlayerID(), false);
|
|
}
|
|
|
|
std::vector<entity_id_t> PickFriendlyEntitiesInRect(void* UNUSED(cbdata), int x0, int y0, int x1, int y1, int player)
|
|
{
|
|
return EntitySelection::PickEntitiesInRect(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), x0, y0, x1, y1, player, false);
|
|
}
|
|
|
|
std::vector<entity_id_t> PickFriendlyEntitiesOnScreen(void* cbdata, int player)
|
|
{
|
|
return PickFriendlyEntitiesInRect(cbdata, 0, 0, g_xres, g_yres, player);
|
|
}
|
|
|
|
std::vector<entity_id_t> PickSimilarFriendlyEntities(void* UNUSED(cbdata), std::string templateName, bool includeOffScreen, bool matchRank, bool allowFoundations)
|
|
{
|
|
return EntitySelection::PickSimilarEntities(*g_Game->GetSimulation2(), *g_Game->GetView()->GetCamera(), templateName, g_Game->GetPlayerID(), includeOffScreen, matchRank, false, allowFoundations);
|
|
}
|
|
|
|
CFixedVector3D GetTerrainAtScreenPoint(void* UNUSED(cbdata), int x, int y)
|
|
{
|
|
CVector3D pos = g_Game->GetView()->GetCamera()->GetWorldCoordinates(x, y, true);
|
|
return CFixedVector3D(fixed::FromFloat(pos.X), fixed::FromFloat(pos.Y), fixed::FromFloat(pos.Z));
|
|
}
|
|
|
|
std::wstring SetCursor(void* UNUSED(cbdata), std::wstring name)
|
|
{
|
|
std::wstring old = g_CursorName;
|
|
g_CursorName = name;
|
|
return old;
|
|
}
|
|
|
|
int GetPlayerID(void* UNUSED(cbdata))
|
|
{
|
|
if (g_Game)
|
|
return g_Game->GetPlayerID();
|
|
return -1;
|
|
}
|
|
|
|
void SetPlayerID(void* UNUSED(cbdata), int id)
|
|
{
|
|
if (g_Game)
|
|
g_Game->SetPlayerID(id);
|
|
}
|
|
|
|
void StartNetworkGame(void* UNUSED(cbdata))
|
|
{
|
|
ENSURE(g_NetServer);
|
|
g_NetServer->StartGame();
|
|
}
|
|
|
|
void StartGame(void* cbdata, CScriptVal attribs, int playerID)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
ENSURE(!g_NetServer);
|
|
ENSURE(!g_NetClient);
|
|
|
|
ENSURE(!g_Game);
|
|
g_Game = new CGame();
|
|
|
|
// Convert from GUI script context to sim script context
|
|
CSimulation2* sim = g_Game->GetSimulation2();
|
|
CScriptValRooted gameAttribs (sim->GetScriptInterface().GetContext(),
|
|
sim->GetScriptInterface().CloneValueFromOtherContext(guiManager->GetScriptInterface(), attribs.get()));
|
|
|
|
g_Game->SetPlayerID(playerID);
|
|
g_Game->StartGame(gameAttribs, "");
|
|
}
|
|
|
|
CScriptVal StartSavedGame(void* cbdata, std::wstring name)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
ENSURE(!g_NetServer);
|
|
ENSURE(!g_NetClient);
|
|
|
|
ENSURE(!g_Game);
|
|
|
|
// Load the saved game data from disk
|
|
CScriptValRooted metadata;
|
|
std::string savedState;
|
|
Status err = SavedGames::Load(name, guiManager->GetScriptInterface(), metadata, savedState);
|
|
if (err < 0)
|
|
return CScriptVal();
|
|
|
|
g_Game = new CGame();
|
|
|
|
// Convert from GUI script context to sim script context
|
|
CSimulation2* sim = g_Game->GetSimulation2();
|
|
CScriptValRooted gameMetadata (sim->GetScriptInterface().GetContext(),
|
|
sim->GetScriptInterface().CloneValueFromOtherContext(guiManager->GetScriptInterface(), metadata.get()));
|
|
|
|
CScriptValRooted gameInitAttributes;
|
|
sim->GetScriptInterface().GetProperty(gameMetadata.get(), "initAttributes", gameInitAttributes);
|
|
|
|
int playerID;
|
|
sim->GetScriptInterface().GetProperty(gameMetadata.get(), "player", playerID);
|
|
|
|
// Start the game
|
|
g_Game->SetPlayerID(playerID);
|
|
g_Game->StartGame(gameInitAttributes, savedState);
|
|
|
|
return metadata.get();
|
|
}
|
|
|
|
void SaveGame(void* cbdata, std::wstring filename, std::wstring description)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
if (SavedGames::Save(filename, description, *g_Game->GetSimulation2(), guiManager, g_Game->GetPlayerID()) < 0)
|
|
LOGERROR(L"Failed to save game");
|
|
}
|
|
|
|
void SaveGamePrefix(void* cbdata, std::wstring prefix, std::wstring description)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
if (SavedGames::SavePrefix(prefix, description, *g_Game->GetSimulation2(), guiManager, g_Game->GetPlayerID()) < 0)
|
|
LOGERROR(L"Failed to save game");
|
|
}
|
|
|
|
void SetNetworkGameAttributes(void* cbdata, CScriptVal attribs)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
ENSURE(g_NetServer);
|
|
|
|
g_NetServer->UpdateGameAttributes(attribs, guiManager->GetScriptInterface());
|
|
}
|
|
|
|
void StartNetworkHost(void* cbdata, std::wstring playerName)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
ENSURE(!g_NetClient);
|
|
ENSURE(!g_NetServer);
|
|
ENSURE(!g_Game);
|
|
|
|
g_NetServer = new CNetServer();
|
|
if (!g_NetServer->SetupConnection())
|
|
{
|
|
guiManager->GetScriptInterface().ReportError("Failed to start server");
|
|
SAFE_DELETE(g_NetServer);
|
|
return;
|
|
}
|
|
|
|
g_Game = new CGame();
|
|
g_NetClient = new CNetClient(g_Game);
|
|
g_NetClient->SetUserName(playerName);
|
|
|
|
if (!g_NetClient->SetupConnection("127.0.0.1"))
|
|
{
|
|
guiManager->GetScriptInterface().ReportError("Failed to connect to server");
|
|
SAFE_DELETE(g_NetClient);
|
|
SAFE_DELETE(g_Game);
|
|
}
|
|
}
|
|
|
|
void StartNetworkJoin(void* cbdata, std::wstring playerName, std::string serverAddress)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
ENSURE(!g_NetClient);
|
|
ENSURE(!g_NetServer);
|
|
ENSURE(!g_Game);
|
|
|
|
g_Game = new CGame();
|
|
g_NetClient = new CNetClient(g_Game);
|
|
g_NetClient->SetUserName(playerName);
|
|
if (!g_NetClient->SetupConnection(serverAddress))
|
|
{
|
|
guiManager->GetScriptInterface().ReportError("Failed to connect to server");
|
|
SAFE_DELETE(g_NetClient);
|
|
SAFE_DELETE(g_Game);
|
|
}
|
|
}
|
|
|
|
void DisconnectNetworkGame(void* UNUSED(cbdata))
|
|
{
|
|
// TODO: we ought to do async reliable disconnections
|
|
|
|
SAFE_DELETE(g_NetServer);
|
|
SAFE_DELETE(g_NetClient);
|
|
SAFE_DELETE(g_Game);
|
|
}
|
|
|
|
CScriptVal PollNetworkClient(void* cbdata)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
if (!g_NetClient)
|
|
return CScriptVal();
|
|
|
|
CScriptValRooted poll = g_NetClient->GuiPoll();
|
|
|
|
// Convert from net client context to GUI script context
|
|
return guiManager->GetScriptInterface().CloneValueFromOtherContext(g_NetClient->GetScriptInterface(), poll.get());
|
|
}
|
|
|
|
void AssignNetworkPlayer(void* UNUSED(cbdata), int playerID, std::string guid)
|
|
{
|
|
ENSURE(g_NetServer);
|
|
|
|
g_NetServer->AssignPlayer(playerID, guid);
|
|
}
|
|
|
|
void SendNetworkChat(void* UNUSED(cbdata), std::wstring message)
|
|
{
|
|
ENSURE(g_NetClient);
|
|
|
|
g_NetClient->SendChatMessage(message);
|
|
}
|
|
|
|
std::vector<CScriptValRooted> GetAIs(void* cbdata)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
return ICmpAIManager::GetAIs(guiManager->GetScriptInterface());
|
|
}
|
|
|
|
std::vector<CScriptValRooted> GetSavedGames(void* cbdata)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
return SavedGames::GetSavedGames(guiManager->GetScriptInterface());
|
|
}
|
|
|
|
bool DeleteSavedGame(void* UNUSED(cbdata), std::wstring name)
|
|
{
|
|
return SavedGames::DeleteSavedGame(name);
|
|
}
|
|
|
|
void OpenURL(void* UNUSED(cbdata), std::string url)
|
|
{
|
|
sys_open_url(url);
|
|
}
|
|
|
|
std::wstring GetMatchID(void* UNUSED(cbdata))
|
|
{
|
|
return ps_generate_guid().FromUTF8();
|
|
}
|
|
|
|
void RestartInAtlas(void* UNUSED(cbdata))
|
|
{
|
|
restart_mainloop_in_atlas();
|
|
}
|
|
|
|
bool AtlasIsAvailable(void* UNUSED(cbdata))
|
|
{
|
|
return ATLAS_IsAvailable();
|
|
}
|
|
|
|
bool IsAtlasRunning(void* UNUSED(cbdata))
|
|
{
|
|
return (g_AtlasGameLoop && g_AtlasGameLoop->running);
|
|
}
|
|
|
|
CScriptVal LoadMapSettings(void* cbdata, VfsPath pathname)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
CMapSummaryReader reader;
|
|
|
|
if (reader.LoadMap(pathname) != PSRETURN_OK)
|
|
return CScriptVal();
|
|
|
|
return reader.GetMapSettings(guiManager->GetScriptInterface()).get();
|
|
}
|
|
|
|
CScriptVal GetMapSettings(void* cbdata)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
if (!g_Game)
|
|
return CScriptVal();
|
|
|
|
return guiManager->GetScriptInterface().CloneValueFromOtherContext(
|
|
g_Game->GetSimulation2()->GetScriptInterface(),
|
|
g_Game->GetSimulation2()->GetMapSettings().get());
|
|
}
|
|
|
|
/**
|
|
* Get the current X coordinate of the camera.
|
|
*/
|
|
float CameraGetX(void* UNUSED(cbdata))
|
|
{
|
|
if (g_Game && g_Game->GetView())
|
|
return g_Game->GetView()->GetCameraX();
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Get the current Z coordinate of the camera.
|
|
*/
|
|
float CameraGetZ(void* UNUSED(cbdata))
|
|
{
|
|
if (g_Game && g_Game->GetView())
|
|
return g_Game->GetView()->GetCameraZ();
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Start / stop camera following mode
|
|
* @param entityid unit id to follow. If zero, stop following mode
|
|
*/
|
|
void CameraFollow(void* UNUSED(cbdata), entity_id_t entityid)
|
|
{
|
|
if (g_Game && g_Game->GetView())
|
|
g_Game->GetView()->CameraFollow(entityid, false);
|
|
}
|
|
|
|
/**
|
|
* Start / stop first-person camera following mode
|
|
* @param entityid unit id to follow. If zero, stop following mode
|
|
*/
|
|
void CameraFollowFPS(void* UNUSED(cbdata), entity_id_t entityid)
|
|
{
|
|
if (g_Game && g_Game->GetView())
|
|
g_Game->GetView()->CameraFollow(entityid, true);
|
|
}
|
|
|
|
/// Move camera to a 2D location
|
|
void CameraMoveTo(void* UNUSED(cbdata), entity_pos_t x, entity_pos_t z)
|
|
{
|
|
// called from JS; must not fail
|
|
if(!(g_Game && g_Game->GetWorld() && g_Game->GetView() && g_Game->GetWorld()->GetTerrain()))
|
|
return;
|
|
|
|
CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
|
|
|
|
CVector3D target;
|
|
target.X = x.ToFloat();
|
|
target.Z = z.ToFloat();
|
|
target.Y = terrain->GetExactGroundLevel(target.X, target.Z);
|
|
|
|
g_Game->GetView()->MoveCameraTarget(target);
|
|
}
|
|
|
|
entity_id_t GetFollowedEntity(void* UNUSED(cbdata))
|
|
{
|
|
if (g_Game && g_Game->GetView())
|
|
return g_Game->GetView()->GetFollowedEntity();
|
|
|
|
return INVALID_ENTITY;
|
|
}
|
|
|
|
bool HotkeyIsPressed_(void* UNUSED(cbdata), std::string hotkeyName)
|
|
{
|
|
return HotkeyIsPressed(hotkeyName);
|
|
}
|
|
|
|
void DisplayErrorDialog(void* UNUSED(cbdata), std::wstring msg)
|
|
{
|
|
debug_DisplayError(msg.c_str(), DE_NO_DEBUG_INFO, NULL, NULL, NULL, 0, NULL, NULL);
|
|
}
|
|
|
|
CScriptVal GetProfilerState(void* cbdata)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
return g_ProfileViewer.SaveToJS(guiManager->GetScriptInterface());
|
|
}
|
|
|
|
|
|
bool IsUserReportEnabled(void* UNUSED(cbdata))
|
|
{
|
|
return g_UserReporter.IsReportingEnabled();
|
|
}
|
|
|
|
bool IsSplashScreenEnabled(void* UNUSED(cbdata))
|
|
{
|
|
bool splashScreenEnable = true;
|
|
CFG_GET_VAL("splashscreenenable", Bool, splashScreenEnable);
|
|
return splashScreenEnable;
|
|
}
|
|
|
|
void SetSplashScreenEnabled(void* UNUSED(cbdata), bool enabled)
|
|
{
|
|
CStr val = (enabled ? "true" : "false");
|
|
g_ConfigDB.CreateValue(CFG_USER, "splashscreenenable")->m_String = val;
|
|
g_ConfigDB.WriteFile(CFG_USER);
|
|
}
|
|
|
|
|
|
void SetUserReportEnabled(void* UNUSED(cbdata), bool enabled)
|
|
{
|
|
g_UserReporter.SetReportingEnabled(enabled);
|
|
}
|
|
|
|
std::string GetUserReportStatus(void* UNUSED(cbdata))
|
|
{
|
|
return g_UserReporter.GetStatus();
|
|
}
|
|
|
|
void SubmitUserReport(void* UNUSED(cbdata), std::string type, int version, std::wstring data)
|
|
{
|
|
g_UserReporter.SubmitReport(type.c_str(), version, utf8_from_wstring(data));
|
|
}
|
|
|
|
|
|
|
|
void SetSimRate(void* UNUSED(cbdata), float rate)
|
|
{
|
|
g_Game->SetSimRate(rate);
|
|
}
|
|
|
|
float GetSimRate(void* UNUSED(cbdata))
|
|
{
|
|
return g_Game->GetSimRate();
|
|
}
|
|
|
|
void SetTurnLength(void* UNUSED(cbdata), int length)
|
|
{
|
|
if (g_NetServer)
|
|
g_NetServer->SetTurnLength(length);
|
|
else
|
|
LOGERROR(L"Only network host can change turn length");
|
|
}
|
|
|
|
// Focus the game camera on a given position.
|
|
void SetCameraTarget(void* UNUSED(cbdata), float x, float y, float z)
|
|
{
|
|
g_Game->GetView()->ResetCameraTarget(CVector3D(x, y, z));
|
|
}
|
|
|
|
// Deliberately cause the game to crash.
|
|
// Currently implemented via access violation (read of address 0).
|
|
// Useful for testing the crashlog/stack trace code.
|
|
int Crash(void* UNUSED(cbdata))
|
|
{
|
|
debug_printf(L"Crashing at user's request.\n");
|
|
return *(volatile int*)0;
|
|
}
|
|
|
|
void DebugWarn(void* UNUSED(cbdata))
|
|
{
|
|
debug_warn(L"Warning at user's request.");
|
|
}
|
|
|
|
// Force a JS garbage collection cycle to take place immediately.
|
|
// Writes an indication of how long this took to the console.
|
|
void ForceGC(void* cbdata)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
double time = timer_Time();
|
|
JS_GC(guiManager->GetScriptInterface().GetContext());
|
|
time = timer_Time() - time;
|
|
g_Console->InsertMessage(L"Garbage collection completed in: %f", time);
|
|
}
|
|
|
|
void DumpSimState(void* UNUSED(cbdata))
|
|
{
|
|
OsPath path = psLogDir()/"sim_dump.txt";
|
|
std::ofstream file (OsString(path).c_str(), std::ofstream::out | std::ofstream::trunc);
|
|
g_Game->GetSimulation2()->DumpDebugState(file);
|
|
}
|
|
|
|
void DumpTerrainMipmap(void* UNUSED(cbdata))
|
|
{
|
|
VfsPath filename(L"screenshots/terrainmipmap.png");
|
|
g_Game->GetWorld()->GetTerrain()->GetHeightMipmap().DumpToDisk(filename);
|
|
OsPath realPath;
|
|
g_VFS->GetRealPath(filename, realPath);
|
|
LOGMESSAGERENDER(L"Terrain mipmap written to '%ls'", realPath.string().c_str());
|
|
}
|
|
|
|
void EnableTimeWarpRecording(void* UNUSED(cbdata), unsigned int numTurns)
|
|
{
|
|
g_Game->GetTurnManager()->EnableTimeWarpRecording(numTurns);
|
|
}
|
|
|
|
void RewindTimeWarp(void* UNUSED(cbdata))
|
|
{
|
|
g_Game->GetTurnManager()->RewindTimeWarp();
|
|
}
|
|
|
|
/* Begin lobby related functions */
|
|
|
|
bool HasXmppClient(void* UNUSED(cbdata))
|
|
{
|
|
return (g_XmppClient ? true : false);
|
|
}
|
|
|
|
#if CONFIG2_LOBBY
|
|
void StartXmppClient(void* cbdata, std::wstring username, std::wstring password, std::wstring room, std::wstring nick)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
ENSURE(!g_XmppClient);
|
|
|
|
g_XmppClient = IXmppClient::create(guiManager->GetScriptInterface(),
|
|
utf8_from_wstring(username), utf8_from_wstring(password),
|
|
utf8_from_wstring(room), utf8_from_wstring(nick));
|
|
g_rankedGame = true;
|
|
}
|
|
|
|
void StartRegisterXmppClient(void* cbdata, std::wstring username, std::wstring password)
|
|
{
|
|
CGUIManager* guiManager = static_cast<CGUIManager*> (cbdata);
|
|
|
|
ENSURE(!g_XmppClient);
|
|
|
|
g_XmppClient = IXmppClient::create(guiManager->GetScriptInterface(),
|
|
utf8_from_wstring(username), utf8_from_wstring(password),
|
|
"", "", true);
|
|
}
|
|
|
|
void StopXmppClient(void* UNUSED(cbdata))
|
|
{
|
|
ENSURE(g_XmppClient);
|
|
SAFE_DELETE(g_XmppClient);
|
|
g_rankedGame = false;
|
|
}
|
|
|
|
void ConnectXmppClient(void* UNUSED(cbdata))
|
|
{
|
|
ENSURE(g_XmppClient);
|
|
g_XmppClient->connect();
|
|
}
|
|
|
|
void DisconnectXmppClient(void* UNUSED(cbdata))
|
|
{
|
|
ENSURE(g_XmppClient);
|
|
g_XmppClient->disconnect();
|
|
}
|
|
|
|
void RecvXmppClient(void* UNUSED(cbdata))
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
g_XmppClient->recv();
|
|
}
|
|
|
|
void SendGetGameList(void* UNUSED(cbdata))
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
g_XmppClient->SendIqGetGameList();
|
|
}
|
|
|
|
void SendGetBoardList(void* UNUSED(cbdata))
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
g_XmppClient->SendIqGetBoardList();
|
|
}
|
|
|
|
void SendGameReport(void* UNUSED(cbdata), CScriptVal data)
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
g_XmppClient->SendIqGameReport(data);
|
|
}
|
|
|
|
void SendRegisterGame(void* UNUSED(cbdata), CScriptVal data)
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
g_XmppClient->SendIqRegisterGame(data);
|
|
}
|
|
|
|
void SendUnregisterGame(void* UNUSED(cbdata))
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
g_XmppClient->SendIqUnregisterGame();
|
|
}
|
|
|
|
void SendChangeStateGame(void* UNUSED(cbdata), std::wstring nbp, std::wstring players)
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
g_XmppClient->SendIqChangeStateGame(utf8_from_wstring(nbp), utf8_from_wstring(players));
|
|
}
|
|
|
|
CScriptVal GetPlayerList(void* UNUSED(cbdata))
|
|
{
|
|
if (!g_XmppClient)
|
|
return CScriptVal();
|
|
|
|
CScriptValRooted playerList = g_XmppClient->GUIGetPlayerList();
|
|
|
|
return playerList.get();
|
|
}
|
|
|
|
CScriptVal GetGameList(void* UNUSED(cbdata))
|
|
{
|
|
if (!g_XmppClient)
|
|
return CScriptVal();
|
|
|
|
CScriptValRooted gameList = g_XmppClient->GUIGetGameList();
|
|
|
|
return gameList.get();
|
|
}
|
|
|
|
CScriptVal GetBoardList(void* UNUSED(cbdata))
|
|
{
|
|
if (!g_XmppClient)
|
|
return CScriptVal();
|
|
|
|
CScriptValRooted boardList = g_XmppClient->GUIGetBoardList();
|
|
|
|
return boardList.get();
|
|
}
|
|
|
|
CScriptVal LobbyGuiPollMessage(void* UNUSED(cbdata))
|
|
{
|
|
if (!g_XmppClient)
|
|
return CScriptVal();
|
|
|
|
CScriptValRooted poll = g_XmppClient->GuiPollMessage();
|
|
|
|
return poll.get();
|
|
}
|
|
|
|
void LobbySendMessage(void* UNUSED(cbdata), std::wstring message)
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
|
|
g_XmppClient->SendMUCMessage(utf8_from_wstring(message));
|
|
}
|
|
|
|
void LobbySetPlayerPresence(void* UNUSED(cbdata), std::wstring presence)
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
|
|
g_XmppClient->SetPresence(utf8_from_wstring(presence));
|
|
}
|
|
|
|
void LobbySetNick(void* UNUSED(cbdata), std::wstring nick)
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
|
|
g_XmppClient->SetNick(utf8_from_wstring(nick));
|
|
}
|
|
|
|
std::wstring LobbyGetNick(void* UNUSED(cbdata))
|
|
{
|
|
if (!g_XmppClient)
|
|
return L"";
|
|
|
|
std::string nick;
|
|
g_XmppClient->GetNick(nick);
|
|
return wstring_from_utf8(nick);
|
|
}
|
|
|
|
void LobbyKick(void* UNUSED(cbdata), std::wstring nick, std::wstring reason)
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
|
|
g_XmppClient->kick(utf8_from_wstring(nick), utf8_from_wstring(reason));
|
|
}
|
|
|
|
void LobbyBan(void* UNUSED(cbdata), std::wstring nick, std::wstring reason)
|
|
{
|
|
if (!g_XmppClient)
|
|
return;
|
|
|
|
g_XmppClient->ban(utf8_from_wstring(nick), utf8_from_wstring(reason));
|
|
}
|
|
|
|
std::wstring LobbyGetPlayerPresence(void* UNUSED(cbdata), std::wstring nickname)
|
|
{
|
|
if (!g_XmppClient)
|
|
return L"";
|
|
|
|
std::string presence;
|
|
g_XmppClient->GetPresence(utf8_from_wstring(nickname), presence);
|
|
return wstring_from_utf8(presence);
|
|
}
|
|
|
|
// Non-public secure PBKDF2 hash function with salting and 1,337 iterations
|
|
static std::string EncryptPassword(const std::string& password, const std::string& username)
|
|
{
|
|
const int DIGESTSIZE = SHA_DIGEST_SIZE;
|
|
const int ITERATIONS = 1337;
|
|
|
|
static const byte salt_base[DIGESTSIZE] = {
|
|
244, 243, 249, 244, 32, 33, 34, 35, 10, 11, 12, 13, 14, 15, 16, 17,
|
|
18, 19, 20, 32, 33, 244, 224, 127, 129, 130, 140, 153, 133, 123, 234, 123 };
|
|
|
|
// initialize the salt buffer
|
|
byte salt_buffer[DIGESTSIZE] = {0};
|
|
SHA256 hash;
|
|
hash.update(salt_base, sizeof(salt_base));
|
|
hash.update(username.c_str(), username.length());
|
|
hash.finish(salt_buffer);
|
|
|
|
// PBKDF2 to create the buffer
|
|
byte encrypted[DIGESTSIZE];
|
|
pbkdf2(encrypted, (byte*)password.c_str(), password.length(), salt_buffer, DIGESTSIZE, ITERATIONS);
|
|
|
|
static const char base16[] = "0123456789ABCDEF";
|
|
char hex[2 * DIGESTSIZE];
|
|
for (int i = 0; i < DIGESTSIZE; ++i)
|
|
{
|
|
hex[i*2] = base16[encrypted[i] >> 4]; // 4 high bits
|
|
hex[i*2 + 1] = base16[encrypted[i] & 0x0F];// 4 low bits
|
|
}
|
|
return std::string(hex, sizeof(hex));
|
|
}
|
|
|
|
// Public hash interface.
|
|
std::wstring EncryptPassword(void* UNUSED(cbdata), std::wstring pass, std::wstring user)
|
|
{
|
|
return wstring_from_utf8(EncryptPassword(utf8_from_wstring(pass), utf8_from_wstring(user)));
|
|
}
|
|
|
|
bool IsRankedGame(void* UNUSED(cbdata))
|
|
{
|
|
return g_rankedGame;
|
|
}
|
|
|
|
void SetRankedGame(void* UNUSED(cbdata), bool isRanked)
|
|
{
|
|
g_rankedGame = isRanked;
|
|
}
|
|
#endif // CONFIG2_LOBBY
|
|
|
|
/* End lobby related functions */
|
|
|
|
void QuickSave(void* UNUSED(cbdata))
|
|
{
|
|
g_Game->GetTurnManager()->QuickSave();
|
|
}
|
|
|
|
void QuickLoad(void* UNUSED(cbdata))
|
|
{
|
|
g_Game->GetTurnManager()->QuickLoad();
|
|
}
|
|
|
|
void SetBoundingBoxDebugOverlay(void* UNUSED(cbdata), bool enabled)
|
|
{
|
|
ICmpSelectable::ms_EnableDebugOverlays = enabled;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void GuiScriptingInit(ScriptInterface& scriptInterface)
|
|
{
|
|
JSI_GameView::RegisterScriptFunctions(scriptInterface);
|
|
JSI_Renderer::RegisterScriptFunctions(scriptInterface);
|
|
JSI_Console::RegisterScriptFunctions(scriptInterface);
|
|
JSI_ConfigDB::RegisterScriptFunctions(scriptInterface);
|
|
|
|
// GUI manager functions:
|
|
scriptInterface.RegisterFunction<CScriptVal, &GetActiveGui>("GetActiveGui");
|
|
scriptInterface.RegisterFunction<void, std::wstring, CScriptVal, &PushGuiPage>("PushGuiPage");
|
|
scriptInterface.RegisterFunction<void, std::wstring, CScriptVal, &SwitchGuiPage>("SwitchGuiPage");
|
|
scriptInterface.RegisterFunction<void, &PopGuiPage>("PopGuiPage");
|
|
|
|
// Simulation<->GUI interface functions:
|
|
scriptInterface.RegisterFunction<CScriptVal, std::wstring, CScriptVal, &GuiInterfaceCall>("GuiInterfaceCall");
|
|
scriptInterface.RegisterFunction<void, CScriptVal, &PostNetworkCommand>("PostNetworkCommand");
|
|
|
|
// Entity picking
|
|
scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, &PickEntitiesAtPoint>("PickEntitiesAtPoint");
|
|
scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, int, int, &PickFriendlyEntitiesInRect>("PickFriendlyEntitiesInRect");
|
|
scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, &PickFriendlyEntitiesOnScreen>("PickFriendlyEntitiesOnScreen");
|
|
scriptInterface.RegisterFunction<std::vector<entity_id_t>, std::string, bool, bool, bool, &PickSimilarFriendlyEntities>("PickSimilarFriendlyEntities");
|
|
scriptInterface.RegisterFunction<CFixedVector3D, int, int, &GetTerrainAtScreenPoint>("GetTerrainAtScreenPoint");
|
|
|
|
// Network / game setup functions
|
|
scriptInterface.RegisterFunction<void, &StartNetworkGame>("StartNetworkGame");
|
|
scriptInterface.RegisterFunction<void, CScriptVal, int, &StartGame>("StartGame");
|
|
scriptInterface.RegisterFunction<void, std::wstring, &StartNetworkHost>("StartNetworkHost");
|
|
scriptInterface.RegisterFunction<void, std::wstring, std::string, &StartNetworkJoin>("StartNetworkJoin");
|
|
scriptInterface.RegisterFunction<void, &DisconnectNetworkGame>("DisconnectNetworkGame");
|
|
scriptInterface.RegisterFunction<CScriptVal, &PollNetworkClient>("PollNetworkClient");
|
|
scriptInterface.RegisterFunction<void, CScriptVal, &SetNetworkGameAttributes>("SetNetworkGameAttributes");
|
|
scriptInterface.RegisterFunction<void, int, std::string, &AssignNetworkPlayer>("AssignNetworkPlayer");
|
|
scriptInterface.RegisterFunction<void, std::wstring, &SendNetworkChat>("SendNetworkChat");
|
|
scriptInterface.RegisterFunction<std::vector<CScriptValRooted>, &GetAIs>("GetAIs");
|
|
|
|
// Saved games
|
|
scriptInterface.RegisterFunction<CScriptVal, std::wstring, &StartSavedGame>("StartSavedGame");
|
|
scriptInterface.RegisterFunction<std::vector<CScriptValRooted>, &GetSavedGames>("GetSavedGames");
|
|
scriptInterface.RegisterFunction<bool, std::wstring, &DeleteSavedGame>("DeleteSavedGame");
|
|
scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &SaveGame>("SaveGame");
|
|
scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &SaveGamePrefix>("SaveGamePrefix");
|
|
scriptInterface.RegisterFunction<void, &QuickSave>("QuickSave");
|
|
scriptInterface.RegisterFunction<void, &QuickLoad>("QuickLoad");
|
|
|
|
// Misc functions
|
|
scriptInterface.RegisterFunction<std::wstring, std::wstring, &SetCursor>("SetCursor");
|
|
scriptInterface.RegisterFunction<int, &GetPlayerID>("GetPlayerID");
|
|
scriptInterface.RegisterFunction<void, int, &SetPlayerID>("SetPlayerID");
|
|
scriptInterface.RegisterFunction<void, std::string, &OpenURL>("OpenURL");
|
|
scriptInterface.RegisterFunction<std::wstring, &GetMatchID>("GetMatchID");
|
|
scriptInterface.RegisterFunction<void, &RestartInAtlas>("RestartInAtlas");
|
|
scriptInterface.RegisterFunction<bool, &AtlasIsAvailable>("AtlasIsAvailable");
|
|
scriptInterface.RegisterFunction<bool, &IsAtlasRunning>("IsAtlasRunning");
|
|
scriptInterface.RegisterFunction<CScriptVal, VfsPath, &LoadMapSettings>("LoadMapSettings");
|
|
scriptInterface.RegisterFunction<CScriptVal, &GetMapSettings>("GetMapSettings");
|
|
scriptInterface.RegisterFunction<float, &CameraGetX>("CameraGetX");
|
|
scriptInterface.RegisterFunction<float, &CameraGetZ>("CameraGetZ");
|
|
scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollow>("CameraFollow");
|
|
scriptInterface.RegisterFunction<void, entity_id_t, &CameraFollowFPS>("CameraFollowFPS");
|
|
scriptInterface.RegisterFunction<void, entity_pos_t, entity_pos_t, &CameraMoveTo>("CameraMoveTo");
|
|
scriptInterface.RegisterFunction<entity_id_t, &GetFollowedEntity>("GetFollowedEntity");
|
|
scriptInterface.RegisterFunction<bool, std::string, &HotkeyIsPressed_>("HotkeyIsPressed");
|
|
scriptInterface.RegisterFunction<void, std::wstring, &DisplayErrorDialog>("DisplayErrorDialog");
|
|
scriptInterface.RegisterFunction<CScriptVal, &GetProfilerState>("GetProfilerState");
|
|
|
|
// User report functions
|
|
scriptInterface.RegisterFunction<bool, &IsUserReportEnabled>("IsUserReportEnabled");
|
|
scriptInterface.RegisterFunction<void, bool, &SetUserReportEnabled>("SetUserReportEnabled");
|
|
scriptInterface.RegisterFunction<std::string, &GetUserReportStatus>("GetUserReportStatus");
|
|
scriptInterface.RegisterFunction<void, std::string, int, std::wstring, &SubmitUserReport>("SubmitUserReport");
|
|
|
|
// Splash screen functions
|
|
scriptInterface.RegisterFunction<bool, &IsSplashScreenEnabled>("IsSplashScreenEnabled");
|
|
scriptInterface.RegisterFunction<void, bool, &SetSplashScreenEnabled>("SetSplashScreenEnabled");
|
|
|
|
// Development/debugging functions
|
|
scriptInterface.RegisterFunction<void, float, &SetSimRate>("SetSimRate");
|
|
scriptInterface.RegisterFunction<float, &GetSimRate>("GetSimRate");
|
|
scriptInterface.RegisterFunction<void, int, &SetTurnLength>("SetTurnLength");
|
|
scriptInterface.RegisterFunction<void, float, float, float, &SetCameraTarget>("SetCameraTarget");
|
|
scriptInterface.RegisterFunction<int, &Crash>("Crash");
|
|
scriptInterface.RegisterFunction<void, &DebugWarn>("DebugWarn");
|
|
scriptInterface.RegisterFunction<void, &ForceGC>("ForceGC");
|
|
scriptInterface.RegisterFunction<void, &DumpSimState>("DumpSimState");
|
|
scriptInterface.RegisterFunction<void, &DumpTerrainMipmap>("DumpTerrainMipmap");
|
|
scriptInterface.RegisterFunction<void, unsigned int, &EnableTimeWarpRecording>("EnableTimeWarpRecording");
|
|
scriptInterface.RegisterFunction<void, &RewindTimeWarp>("RewindTimeWarp");
|
|
scriptInterface.RegisterFunction<void, bool, &SetBoundingBoxDebugOverlay>("SetBoundingBoxDebugOverlay");
|
|
|
|
// Lobby functions
|
|
scriptInterface.RegisterFunction<bool, &HasXmppClient>("HasXmppClient");
|
|
#if CONFIG2_LOBBY // Allow the lobby to be disabled
|
|
scriptInterface.RegisterFunction<void, std::wstring, std::wstring, std::wstring, std::wstring, &StartXmppClient>("StartXmppClient");
|
|
scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &StartRegisterXmppClient>("StartRegisterXmppClient");
|
|
scriptInterface.RegisterFunction<void, &StopXmppClient>("StopXmppClient");
|
|
scriptInterface.RegisterFunction<void, &ConnectXmppClient>("ConnectXmppClient");
|
|
scriptInterface.RegisterFunction<void, &DisconnectXmppClient>("DisconnectXmppClient");
|
|
scriptInterface.RegisterFunction<void, &RecvXmppClient>("RecvXmppClient");
|
|
scriptInterface.RegisterFunction<void, &SendGetGameList>("SendGetGameList");
|
|
scriptInterface.RegisterFunction<void, &SendGetBoardList>("SendGetBoardList");
|
|
scriptInterface.RegisterFunction<void, CScriptVal, &SendRegisterGame>("SendRegisterGame");
|
|
scriptInterface.RegisterFunction<void, CScriptVal, &SendGameReport>("SendGameReport");
|
|
scriptInterface.RegisterFunction<void, &SendUnregisterGame>("SendUnregisterGame");
|
|
scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &SendChangeStateGame>("SendChangeStateGame");
|
|
scriptInterface.RegisterFunction<CScriptVal, &GetPlayerList>("GetPlayerList");
|
|
scriptInterface.RegisterFunction<CScriptVal, &GetGameList>("GetGameList");
|
|
scriptInterface.RegisterFunction<CScriptVal, &GetBoardList>("GetBoardList");
|
|
scriptInterface.RegisterFunction<CScriptVal, &LobbyGuiPollMessage>("LobbyGuiPollMessage");
|
|
scriptInterface.RegisterFunction<void, std::wstring, &LobbySendMessage>("LobbySendMessage");
|
|
scriptInterface.RegisterFunction<void, std::wstring, &LobbySetPlayerPresence>("LobbySetPlayerPresence");
|
|
scriptInterface.RegisterFunction<void, std::wstring, &LobbySetNick>("LobbySetNick");
|
|
scriptInterface.RegisterFunction<std::wstring, &LobbyGetNick>("LobbyGetNick");
|
|
scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &LobbyKick>("LobbyKick");
|
|
scriptInterface.RegisterFunction<void, std::wstring, std::wstring, &LobbyBan>("LobbyBan");
|
|
scriptInterface.RegisterFunction<std::wstring, std::wstring, &LobbyGetPlayerPresence>("LobbyGetPlayerPresence");
|
|
scriptInterface.RegisterFunction<std::wstring, std::wstring, std::wstring, &EncryptPassword>("EncryptPassword");
|
|
scriptInterface.RegisterFunction<bool, &IsRankedGame>("IsRankedGame");
|
|
scriptInterface.RegisterFunction<void, bool, &SetRankedGame>("SetRankedGame");
|
|
#endif // CONFIG2_LOBBY
|
|
}
|