Index: ps/trunk/binaries/data/mods/mod/gui/modmod/modmod.js
===================================================================
--- ps/trunk/binaries/data/mods/mod/gui/modmod/modmod.js (revision 27191)
+++ ps/trunk/binaries/data/mods/mod/gui/modmod/modmod.js (revision 27192)
@@ -1,490 +1,489 @@
/**
* @file This GUI page displays all available mods and allows the player to enabled and launch a set of compatible mods.
*/
/**
* A mod is defined by a mod.json file, for example
* {
* "name": "0ad",
* "version": "0.0.27",
* "label": "0 A.D. - Empires Ascendant",
* "url": "https://wildfiregames.com/",
* "description": "A free, open-source, historical RTS game.",
* "dependencies": []
* }
*
* Or:
* {
* "name": "mod2",
* "label": "Mod 2",
* "version": "1.1",
* "description": "",
* "dependencies": ["0ad<=0.0.27", "rote"]
* }
*
* A mod is identified by the directory name.
* A mod must define the "name", "version", "label", "description" and "dependencies" property.
* The "url" property is optional.
*
* The property "name" can consist alphanumeric characters, underscore and dash.
* The name is used for version comparison of mod dependencies.
* The property "version" may only contain numbers and up to two periods.
* The property "label" is a human-readable name of the mod.
* The property "description" is a human-readable summary of the features of the mod.
* The property "url" is reference to a website about the mod.
* The property "dependencies" is an array of strings. Each string is either a modname or a mod version comparison.
* A mod version comparison is a modname, followed by an operator (=, <, >, <= or >=), followed by a mod version.
* This allows mods to express upwards and downwards compatibility.
*/
/**
* Mod definitions loaded from the files, including invalid mods.
*/
var g_Mods = {};
/**
* Folder names of all mods that are or can be launched.
*/
var g_ModsEnabled = [];
var g_ModsDisabled = [];
var g_ModsEnabledFiltered = [];
var g_ModsDisabledFiltered = [];
/**
* Cache mod compatibility recomputed when some mod is enbaled/disabled.
*/
var g_ModsCompatibility = [];
/**
* Name of the mods installed by the ModInstaller.
*/
var g_InstalledMods;
var g_HasIncompatibleMods;
var g_FakeMod = {
"name": translate("This mod does not exist"),
"version": "",
"label": "",
"url": "",
"description": "",
"dependencies": []
};
var g_ColorNoModSelected = "255 255 100";
var g_ColorDependenciesMet = "100 255 100";
var g_ColorDependenciesNotMet = "255 100 100";
function init(data, hotloadData)
{
g_InstalledMods = data && data.installedMods || hotloadData && hotloadData.installedMods || [];
g_HasIncompatibleMods = Engine.HasIncompatibleMods();
initMods();
initGUIButtons(data);
if (g_HasIncompatibleMods)
Engine.PushGuiPage("page_incompatible_mods.xml", {});
}
function initMods()
{
loadMods();
loadEnabledMods();
recomputeCompatibility();
validateMods();
initGUIFilters();
}
function getHotloadData()
{
return { "installedMods": g_InstalledMods };
}
function loadMods()
{
g_Mods = Engine.GetAvailableMods();
deepfreeze(g_Mods);
}
/**
* Return fake mod for mods which do not exist
*/
function getMod(folder)
{
return !!g_Mods[folder] ? g_Mods[folder] : g_FakeMod;
}
function loadEnabledMods()
{
if (g_HasIncompatibleMods)
g_ModsEnabled = Engine.GetEnabledMods().concat(Engine.GetIncompatibleMods())
.filter(folder => folder != "mod");
else
g_ModsEnabled = Engine.GetEnabledMods().filter(folder => !!g_Mods[folder]);
g_ModsDisabled = Object.keys(g_Mods).filter(folder => g_ModsEnabled.indexOf(folder) == -1);
g_ModsEnabledFiltered = g_ModsEnabled;
g_ModsDisabledFiltered = g_ModsDisabled;
}
function validateMods()
{
for (let folder in g_Mods)
validateMod(folder, g_Mods[folder], true);
}
function initGUIFilters()
{
Engine.GetGUIObjectByName("negateFilter").checked = false;
Engine.GetGUIObjectByName("modCompatibleFilter").checked = true;
displayModLists();
}
function initGUIButtons(data)
{
// Either get back to the previous page or quit if there is no previous page
let hasPreviousPage = !data || data.cancelbutton || false;
Engine.GetGUIObjectByName("cancelButton").hidden = !hasPreviousPage;
Engine.GetGUIObjectByName("quitButton").hidden = hasPreviousPage;
// Turn 'save' off, it will be enabled on any change.
Engine.GetGUIObjectByName("saveConfigurationButton").enabled = false;
Engine.GetGUIObjectByName("toggleModButton").caption = translateWithContext("mod activation", "Enable");
}
function saveMods()
{
sortEnabledMods();
- Engine.ConfigDB_CreateValue("user", "mod.enabledmods", ["mod"].concat(g_ModsEnabled).join(" "));
- Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", "mod.enabledmods", ["mod"].concat(g_ModsEnabled).join(" "));
Engine.GetGUIObjectByName("saveConfigurationButton").enabled = false;
}
function startMods()
{
saveMods();
if (!Engine.SetModsAndRestartEngine(["mod"].concat(g_ModsEnabled)))
Engine.GetGUIObjectByName("message").caption = coloredText(translate('Dependencies not met'), g_ColorDependenciesNotMet);
}
function displayModLists()
{
g_ModsEnabledFiltered = displayModList("modsEnabledList", g_ModsEnabled, true);
g_ModsDisabledFiltered = displayModList("modsDisabledList", g_ModsDisabled, false);
}
function displayModList(listObjectName, folders, enabled)
{
let listObject = Engine.GetGUIObjectByName(listObjectName);
if (listObjectName == "modsDisabledList")
{
let sortFolder = folder => String(getMod(folder)[listObject.selected_column] || folder);
folders.sort((folder1, folder2) =>
listObject.selected_column_order *
sortFolder(folder1).localeCompare(sortFolder(folder2)));
}
folders = folders.filter(filterMod);
if (!enabled && Engine.GetGUIObjectByName("modCompatibleFilter").checked)
folders = folders.filter(folder => g_ModsCompatibility[folder]);
let selected = listObject.selected !== -1 ? listObject.list_name[listObject.selected] : null;
listObject.list_name = folders.map(folder => colorMod(folder, getMod(folder).name || "", enabled));
listObject.list_folder = folders.map(folder => colorMod(folder, folder, enabled));
listObject.list_label = folders.map(folder => colorMod(folder, getMod(folder).label || "", enabled));
listObject.list_url = folders.map(folder => colorMod(folder, getMod(folder).url || "", enabled));
listObject.list_version = folders.map(folder => colorMod(folder, getMod(folder).version || "", enabled));
listObject.list_dependencies = folders.map(folder => colorMod(folder, getMod(folder)?.dependencies.join(" ") || "", enabled));
listObject.list = folders;
listObject.selected = selected ? listObject.list_name.indexOf(selected) : -1;
return folders;
}
function getModColor(folder, enabled)
{
if (!g_ModsCompatibility[folder])
return enabled ? g_ColorDependenciesNotMet : "gray";
if (g_InstalledMods.indexOf(getMod(folder).name) != -1)
return "green";
return false;
}
function colorMod(folder, text, enabled)
{
let color = getModColor(folder, enabled);
return color ? coloredText(text, color) : text;
}
function reloadDisabledMods()
{
g_ModsDisabled = Object.keys(g_Mods).filter(folder => g_ModsEnabled.indexOf(folder) == -1);
}
function enableMod()
{
let modsDisabledList = Engine.GetGUIObjectByName("modsDisabledList");
let pos = modsDisabledList.selected;
if (pos == -1 || !g_ModsCompatibility[g_ModsDisabledFiltered[pos]])
return;
g_ModsEnabled.push(g_ModsDisabledFiltered.splice(pos, 1)[0]);
reloadDisabledMods();
recomputeCompatibility();
Engine.GetGUIObjectByName("saveConfigurationButton").enabled = true;
if (pos >= g_ModsDisabledFiltered.length)
--pos;
displayModLists();
Engine.GetGUIObjectByName("message").caption = "";
modsDisabledList.selected = pos;
}
function disableMod()
{
let modsEnabledList = Engine.GetGUIObjectByName("modsEnabledList");
let pos = modsEnabledList.selected;
if (pos == -1)
return;
// Find true position of disabled mod and remove it
let disabledMod = g_ModsEnabledFiltered[pos];
for (let i = 0; i < g_ModsEnabled.length; ++i)
if (g_ModsEnabled[i] == disabledMod)
{
g_ModsEnabled.splice(i, 1);
break;
}
if (!!g_Mods[disabledMod])
g_ModsDisabled.push(disabledMod);
// Remove mods that required the removed mod and cascade
// Sort them, so we know which ones can depend on the removed mod
// TODO: Find position where the removed mod would have fit (for now assume idx 0)
sortEnabledMods();
for (let i = 0; i < g_ModsEnabled.length; ++i)
if (!areDependenciesMet(g_ModsEnabled[i], true))
{
g_ModsDisabled.push(g_ModsEnabled.splice(i, 1)[0]);
--i;
}
Engine.GetGUIObjectByName("saveConfigurationButton").enabled = true;
recomputeCompatibility(true);
displayModLists();
Engine.GetGUIObjectByName("message").caption = "";
modsEnabledList.selected = Math.min(pos, g_ModsEnabledFiltered.length - 1);
}
function filterMod(folder)
{
let mod = getMod(folder);
let negateFilter = Engine.GetGUIObjectByName("negateFilter").checked;
let searchText = Engine.GetGUIObjectByName("modGenericFilter").caption;
if (searchText &&
folder.indexOf(searchText) == -1 &&
(mod.name || "").indexOf(searchText) == -1 &&
(mod.label || "").indexOf(searchText) == -1 &&
(mod.url || "").indexOf(searchText) == -1 &&
(mod.version || "").indexOf(searchText) == -1 &&
(mod.description || "").indexOf(searchText) == -1 &&
(mod.dependencies || "").indexOf(searchText) == -1)
return negateFilter;
return !negateFilter;
}
function closePage()
{
Engine.SwitchGuiPage("page_pregame.xml", {});
}
/**
* Moves an item in the list up or down.
*/
function moveCurrItem(objectName, up)
{
// Prevent moving while filters are applied
// because we would need to map filtered positions
// to not filtered positions so changes will persist.
if (Engine.GetGUIObjectByName("modGenericFilter").caption)
return;
let obj = Engine.GetGUIObjectByName(objectName);
let idx = obj.selected;
if (idx == -1)
return;
let num = obj.list.length;
let idx2 = idx + (up ? -1 : 1);
if (idx2 < 0 || idx2 >= num)
return;
let tmp = g_ModsEnabled[idx];
g_ModsEnabled[idx] = g_ModsEnabled[idx2];
g_ModsEnabled[idx2] = tmp;
g_ModsEnabledFiltered = displayModList("modsEnabledList", g_ModsEnabled, true);
obj.selected = idx2;
}
function areDependenciesMet(folder, disabledAction = false)
{
// If we disabled mod it will not change satus of incompatible mods
if (disabledAction && !g_ModsCompatibility[folder])
return g_ModsCompatibility[folder];
if (!g_Mods[folder])
return false;
for (let dependency of getMod(folder).dependencies)
{
if (!isDependencyMet(dependency))
return false;
}
return true;
}
function recomputeCompatibility(disabledAction = false)
{
for (let mod in g_Mods)
g_ModsCompatibility[mod] = areDependenciesMet(mod, disabledAction);
}
/**
* @param dependency is a mod name or a mod version comparison.
*/
function isDependencyMet(dependency)
{
let operator = dependency.match(g_RegExpComparisonOperator);
let [name, version] = operator ? dependency.split(operator[0]) : [dependency, undefined];
return g_ModsEnabled.some(folder =>
getMod(folder).name == name &&
(!operator || versionSatisfied(getMod(folder).version, operator[0], version)));
}
/**
* Compares the given versions using the given operator.
* '-' or '_' is ignored. Only numbers are supported.
* @note "5.3" < "5.3.0"
*/
function versionSatisfied(version1, operator, version2)
{
let versionList1 = version1.split(/[-_]/)[0].split(/\./g);
let versionList2 = version2.split(/[-_]/)[0].split(/\./g);
let eq = operator.indexOf("=") != -1;
let lt = operator.indexOf("<") != -1;
let gt = operator.indexOf(">") != -1;
for (let i = 0; i < Math.min(versionList1.length, versionList2.length); ++i)
{
let diff = +versionList1[i] - +versionList2[i];
if (gt && diff > 0 || lt && diff < 0)
return true;
if (gt && diff < 0 || lt && diff > 0 || eq && diff)
return false;
}
// common prefix matches
let ldiff = versionList1.length - versionList2.length;
if (!ldiff)
return eq;
// NB: 2.3 != 2.3.0
if (ldiff < 0)
return lt;
return gt;
}
function sortEnabledMods()
{
let dependencies = {};
for (let folder of g_ModsEnabled)
dependencies[folder] = getMod(folder).dependencies.map(d => d.split(g_RegExpComparisonOperator)[0]);
g_ModsEnabled.sort((folder1, folder2) =>
dependencies[folder1].indexOf(getMod(folder2).name) != -1 ? 1 :
dependencies[folder2].indexOf(getMod(folder1).name) != -1 ? -1 : 0);
g_ModsEnabledFiltered = displayModList("modsEnabledList", g_ModsEnabled, true);
}
function selectedMod(listObjectName)
{
let listObject = Engine.GetGUIObjectByName(listObjectName);
let isPickedDisabledList = listObjectName == "modsDisabledList";
let otherListObject = Engine.GetGUIObjectByName(isPickedDisabledList ?
"modsEnabledList" : "modsDisabledList");
let toggleModButton = Engine.GetGUIObjectByName("toggleModButton");
let isModSelected = listObject.selected != -1;
if (isModSelected)
{
otherListObject.selected = -1;
toggleModButton.onPress = isPickedDisabledList ? enableMod : disableMod;
}
const isFiltering = Engine.GetGUIObjectByName("modGenericFilter").caption;
Engine.GetGUIObjectByName("visitWebButton").enabled = isModSelected && !!getSelectedModUrl();
toggleModButton.caption = isPickedDisabledList ?
translateWithContext("mod activation", "Enable") :
translateWithContext("mod activation", "Disable");
toggleModButton.enabled = isPickedDisabledList ? isModSelected && g_ModsCompatibility[listObject.list[listObject.selected]] || false : isModSelected;
Engine.GetGUIObjectByName("enabledModUp").enabled = isModSelected && listObjectName == "modsEnabledList" && !isFiltering;
Engine.GetGUIObjectByName("enabledModDown").enabled = isModSelected && listObjectName == "modsEnabledList" && !isFiltering;
Engine.GetGUIObjectByName("globalModDescription").caption =
listObject.list[listObject.selected] ?
getMod(listObject.list[listObject.selected]).description :
'[color="' + g_ColorNoModSelected + '"]' + translate("No mod has been selected.") + '[/color]';
if (!g_ModsEnabled.length)
Engine.GetGUIObjectByName("message").caption = coloredText(translate('Enable at least 0ad mod'), g_ColorDependenciesNotMet);
if (!Engine.GetGUIObjectByName("startButton").hidden)
Engine.GetGUIObjectByName("startButton").enabled = g_ModsEnabled.length > 0;
}
/**
* @returns {string} The url of the currently selected mod.
*/
function getSelectedModUrl()
{
let modsEnabledList = Engine.GetGUIObjectByName("modsEnabledList");
let modsDisabledList = Engine.GetGUIObjectByName("modsDisabledList");
let list = modsEnabledList.selected == -1 ? modsDisabledList : modsEnabledList;
let folder = list.list[list.selected];
return folder && getMod(folder) && getMod(folder).url || undefined;
}
function visitModWebsite()
{
let url = getSelectedModUrl();
if (!url)
return;
if (!url.startsWith("http://") && !url.startsWith("https://"))
url = "http://" + url;
openURL(url);
}
Index: ps/trunk/binaries/data/mods/public/gui/common/campaigns/CampaignRun.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/common/campaigns/CampaignRun.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/common/campaigns/CampaignRun.js (revision 27192)
@@ -1,153 +1,152 @@
// Cached run for CampaignRun.getCurrentRun()
// TODO: Move this to a static member once linters accept it.
var g_CurrentCampaignRun;
/**
* A campaign "Run" saves metadata on a campaign progession.
* It is equivalent to a saved game for a game.
* It is named a "run" in an attempt to disambiguate with saved games from campaign runs,
* campaign templates, and the actual concept of a campaign at large.
*
* The intent is that this file should be lightweight to load/save.
*/
class CampaignRun
{
static getCurrentRunFilename()
{
return Engine.ConfigDB_GetValue("user", "currentcampaign");
}
static hasCurrentRun()
{
return !!CampaignRun.getCurrentRunFilename();
}
static getCurrentRun()
{
let current = CampaignRun.getCurrentRunFilename();
if (g_CurrentCampaignRun && g_CurrentCampaignRun.ID == current)
return g_CurrentCampaignRun.run;
let run = new CampaignRun(current).load();
g_CurrentCampaignRun = {
"run": run,
"ID": current
};
return run;
}
static clearCurrentRun()
{
- Engine.ConfigDB_RemoveValue("user", "currentcampaign");
- Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+ Engine.ConfigDB_RemoveValueAndSave("user", "currentcampaign");
}
constructor(name = "")
{
this.filename = name;
// Metadata on the run, such as its description.
this.meta = {};
// 'User' data
this.data = {};
// ID of the campaign templates.
this.template = null;
}
setData(data)
{
if (!data)
{
warn("Invalid campaign scenario end data. Nothing will be saved.");
return this;
}
this.data = data;
this.save();
return this;
}
setTemplate(template)
{
this.template = template;
this.save();
return this;
}
setMeta(description)
{
this.meta.userDescription = description;
this.save();
return this;
}
setCurrent()
{
Engine.ConfigDB_CreateValue("user", "currentcampaign", this.filename);
Engine.ConfigDB_WriteValueToFile("user", "currentcampaign", this.filename, "config/user.cfg");
g_CurrentCampaignRun = {
"ID": this.filename,
"run": this
};
return this;
}
isCurrent()
{
return this.filename === CampaignRun.getCurrentRunFilename();
}
getMenuPath()
{
return "campaigns/" + this.template.interface + "/page.xml";
}
getEndGamePath()
{
return "campaigns/" + this.template.interface + "/endgame/page.xml";
}
/**
* Return a readable name for this campaign.
* @param full - if true, include both user description and template name. Otherwise, skip one if they're identical.
*/
getLabel(full)
{
if (!full && this.meta.userDescription === translateWithContext("Campaign Template", this.template.Name))
return this.meta.userDescription;
return sprintf(translate("%(userDesc)s - %(templateName)s"), {
"userDesc": this.meta.userDescription,
"templateName": translateWithContext("Campaign Template", this.template.Name)
});
}
load()
{
if (!Engine.FileExists("saves/campaigns/" + this.filename + ".0adcampaign"))
throw new Error("Campaign file does not exist");
let data = Engine.ReadJSONFile("saves/campaigns/" + this.filename + ".0adcampaign");
this.data = data.data;
this.meta = data.meta;
this.template = CampaignTemplate.getTemplate(data.template_identifier);
if (!this.template)
throw new Error("Campaign template " + data.template_identifier + " does not exist (perhaps it comes from a mod?)");
return this;
}
save()
{
let data = {
"data": this.data,
"meta": this.meta,
"template_identifier": this.template.identifier
};
Engine.WriteJSONFile("saves/campaigns/" + this.filename + ".0adcampaign", data);
return this;
}
destroy()
{
Engine.DeleteCampaignSave("saves/campaigns/" + this.filename + ".0adcampaign");
if (CampaignRun.getCurrentRunFilename() === this.filename)
CampaignRun.clearCurrentRun();
}
}
Index: ps/trunk/binaries/data/mods/public/gui/gamesetup/Controllers/PlayerAssignmentsController.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/gamesetup/Controllers/PlayerAssignmentsController.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/gamesetup/Controllers/PlayerAssignmentsController.js (revision 27192)
@@ -1,233 +1,233 @@
/**
* This class provides a property independent interface to g_PlayerAssignment events and actions.
*/
class PlayerAssignmentsController
{
constructor(setupWindow, netMessages)
{
this.clientJoinHandlers = new Set();
this.clientLeaveHandlers = new Set();
this.playerAssignmentsChangeHandlers = new Set();
if (!g_IsNetworked)
{
let name = singleplayerName();
// Replace empty player name when entering a single-player match for the first time.
- Engine.ConfigDB_CreateAndWriteValueToFile("user", this.ConfigNameSingleplayer, name, "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", this.ConfigNameSingleplayer, name);
// By default, assign the player to the first slot.
g_PlayerAssignments = {
"local": {
"name": name,
"player": 1
}
};
}
// Keep a list of last assigned slot for each player, so we can try to re-assign them
// if they disconnect/rejoin.
this.lastAssigned = {};
g_GameSettings.playerCount.watch(() => this.unassignInvalidPlayers(), ["nbPlayers"]);
setupWindow.registerLoadHandler(this.onLoad.bind(this));
setupWindow.registerGetHotloadDataHandler(this.onGetHotloadData.bind(this));
netMessages.registerNetMessageHandler("players", this.onPlayerAssignmentMessage.bind(this));
this.registerClientJoinHandler(this.onClientJoin.bind(this));
}
registerPlayerAssignmentsChangeHandler(handler)
{
this.playerAssignmentsChangeHandlers.add(handler);
}
unregisterPlayerAssignmentsChangeHandler(handler)
{
this.playerAssignmentsChangeHandlers.delete(handler);
}
registerClientJoinHandler(handler)
{
this.clientJoinHandlers.add(handler);
}
unregisterClientJoinHandler(handler)
{
this.clientJoinHandlers.delete(handler);
}
registerClientLeaveHandler(handler)
{
this.clientLeaveHandlers.add(handler);
}
unregisterClientLeaveHandler(handler)
{
this.clientLeaveHandlers.delete(handler);
}
onLoad(initData, hotloadData)
{
if (hotloadData)
{
g_PlayerAssignments = hotloadData.playerAssignments;
this.updatePlayerAssignments();
}
else if (!g_IsNetworked)
{
// Simulate a net message for the local player to keep a common path.
this.onPlayerAssignmentMessage({
"newAssignments": g_PlayerAssignments
});
}
}
onGetHotloadData(object)
{
object.playerAssignments = g_PlayerAssignments;
}
/**
* On client join, try to assign them to a free slot.
* (This is called before g_PlayerAssignments is updated).
*/
onClientJoin(newGUID, newAssignments)
{
if (!g_IsController || newAssignments[newGUID].player != -1)
return;
// Assign the client (or only buddies if prefered) to a free slot
if (newGUID != Engine.GetPlayerGUID())
{
const assignOption = Engine.ConfigDB_GetValue("user", this.ConfigAssignPlayers);
if (assignOption == "disabled" ||
assignOption == "buddies" && g_Buddies.indexOf(splitRatingFromNick(newAssignments[newGUID].name).nick) == -1)
return;
}
// Find a player slot that no other player is assigned to.
const possibleSlots = [...Array(g_GameSettings.playerCount.nbPlayers).keys()].map(i => i + 1);
let slot;
const newName = newAssignments[newGUID].name;
// First check if we know them and try to give them their old assignment back.
if (this.lastAssigned[newName] > 0 && this.lastAssigned[newName] <= g_GameSettings.playerCount.nbPlayers)
{
let free = true;
for (const guid in newAssignments)
if (newAssignments[guid].player === this.lastAssigned[newName])
{
free = false;
break;
}
if (free)
slot = this.lastAssigned[newName];
}
if (!slot)
slot = possibleSlots.find(i => {
for (const guid in newAssignments)
if (newAssignments[guid].player == i)
return false;
return true;
});
if (slot === undefined)
return;
this.assignClient(newGUID, slot);
}
/**
* To be called when g_PlayerAssignments is modified.
*/
updatePlayerAssignments()
{
Engine.ProfileStart("updatePlayerAssignments");
for (const guid in g_PlayerAssignments)
this.lastAssigned[g_PlayerAssignments[guid].name] = g_PlayerAssignments[guid].player;
for (const handler of this.playerAssignmentsChangeHandlers)
handler();
Engine.ProfileStop();
}
/**
* Called whenever a client joins or leaves or any game setting is changed.
*/
onPlayerAssignmentMessage(message)
{
let newAssignments = message.newAssignments;
for (let guid in newAssignments)
if (!g_PlayerAssignments[guid])
for (let handler of this.clientJoinHandlers)
handler(guid, message.newAssignments);
for (let guid in g_PlayerAssignments)
if (!newAssignments[guid])
for (let handler of this.clientLeaveHandlers)
handler(guid);
g_PlayerAssignments = newAssignments;
this.updatePlayerAssignments();
}
assignClient(guid, playerIndex)
{
if (g_IsNetworked)
Engine.AssignNetworkPlayer(playerIndex, guid);
else
{
g_PlayerAssignments[guid].player = playerIndex;
this.updatePlayerAssignments();
}
}
/**
* If both clients are assigned players, this will swap their assignments.
*/
assignPlayer(guidToAssign, playerIndex)
{
if (g_PlayerAssignments[guidToAssign].player != -1)
{
for (let guid in g_PlayerAssignments)
if (g_PlayerAssignments[guid].player == playerIndex + 1)
{
this.assignClient(guid, g_PlayerAssignments[guidToAssign].player);
break;
}
}
this.assignClient(guidToAssign, playerIndex + 1);
}
unassignClient(playerID)
{
if (g_IsNetworked)
Engine.AssignNetworkPlayer(playerID, "");
else if (g_PlayerAssignments.local.player == playerID)
{
g_PlayerAssignments.local.player = -1;
this.updatePlayerAssignments();
}
}
unassignInvalidPlayers()
{
if (g_IsNetworked)
{
for (let guid in g_PlayerAssignments)
if (g_PlayerAssignments[guid].player > g_GameSettings.playerCount.nbPlayers)
Engine.AssignNetworkPlayer(g_PlayerAssignments[guid].player, "");
}
else if (g_PlayerAssignments.local.player > g_GameSettings.playerCount.nbPlayers)
{
g_PlayerAssignments.local.player = -1;
this.updatePlayerAssignments();
}
}
}
PlayerAssignmentsController.prototype.ConfigNameSingleplayer =
"playername.singleplayer";
PlayerAssignmentsController.prototype.ConfigAssignPlayers =
"gui.gamesetup.assignplayers";
Index: ps/trunk/binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/TipsPanel.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/TipsPanel.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/TipsPanel.js (revision 27192)
@@ -1,45 +1,45 @@
/**
* The TipsPanel shows some hints to newcomers.
* It is only shown in Singleplayer mode since the chat is shown instead in multiplayer mode.
*/
class TipsPanel
{
constructor(gameSettingsPanel)
{
let available = !g_IsNetworked && Engine.ConfigDB_GetValue("user", this.Config) == "true";
this.spTips = Engine.GetGUIObjectByName("spTips");
this.spTips.hidden = !available;
if (!available)
return;
this.displaySPTips = Engine.GetGUIObjectByName("displaySPTips");
this.displaySPTips.onPress = this.onPress.bind(this);
Engine.GetGUIObjectByName("aiTips").caption =
Engine.TranslateLines(Engine.ReadFile(this.File));
gameSettingsPanel.registerGameSettingsPanelResizeHandler(this.onGameSettingsPanelResize.bind(this));
}
onPress()
{
- Engine.ConfigDB_CreateAndWriteValueToFile(
+ Engine.ConfigDB_CreateAndSaveValue(
"user",
this.Config,
- String(this.displaySPTips.checked),
- "config/user.cfg");
+ String(this.displaySPTips.checked)
+ );
}
onGameSettingsPanelResize(settingsPanel)
{
this.spTips.hidden =
this.spTips.getComputedSize().right > settingsPanel.getComputedSize().left;
}
}
TipsPanel.prototype.File =
"gui/gamesetup/Pages/GameSetupPage/Panels/Tips.txt";
TipsPanel.prototype.Config =
"gui.gamesetup.enabletips";
Index: ps/trunk/binaries/data/mods/public/gui/gamesetup_mp/gamesetup_mp.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/gamesetup_mp/gamesetup_mp.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/gamesetup_mp/gamesetup_mp.js (revision 27192)
@@ -1,472 +1,472 @@
/**
* Whether we are attempting to join or host a game.
*/
var g_IsConnecting = false;
/**
* "server" or "client"
*/
var g_GameType;
/**
* Server title shown in the lobby gamelist.
*/
var g_ServerName = "";
/**
* Identifier if server is using password.
*/
var g_ServerHasPassword = false;
var g_ServerId;
var g_IsRejoining = false;
var g_PlayerAssignments; // used when rejoining
var g_UserRating;
function init(attribs)
{
g_UserRating = attribs.rating;
switch (attribs.multiplayerGameType)
{
case "join":
{
if (!Engine.HasXmppClient())
{
switchSetupPage("pageJoin");
break;
}
if (attribs.hasPassword)
{
g_ServerName = attribs.name;
g_ServerId = attribs.hostJID;
switchSetupPage("pagePassword");
}
else if (startJoinFromLobby(attribs.name, attribs.hostJID, ""))
switchSetupPage("pageConnecting");
break;
}
case "host":
{
let hasXmppClient = Engine.HasXmppClient();
Engine.GetGUIObjectByName("hostSTUNWrapper").hidden = !hasXmppClient;
Engine.GetGUIObjectByName("hostPasswordWrapper").hidden = !hasXmppClient;
if (hasXmppClient)
{
Engine.GetGUIObjectByName("hostPlayerName").caption = attribs.name;
Engine.GetGUIObjectByName("hostServerName").caption =
sprintf(translate("%(name)s's game"), { "name": attribs.name });
Engine.GetGUIObjectByName("useSTUN").checked = Engine.ConfigDB_GetValue("user", "lobby.stun.enabled") == "true";
}
switchSetupPage("pageHost");
break;
}
default:
error("Unrecognised multiplayer game type: " + attribs.multiplayerGameType);
break;
}
}
function cancelSetup()
{
if (g_IsConnecting)
Engine.DisconnectNetworkGame();
if (Engine.HasXmppClient())
Engine.LobbySetPlayerPresence("available");
// Keep the page open if an attempt to join/host by ip failed
if (!g_IsConnecting || (Engine.HasXmppClient() && g_GameType == "client"))
{
Engine.PopGuiPage();
return;
}
g_IsConnecting = false;
Engine.GetGUIObjectByName("hostFeedback").caption = "";
if (g_GameType == "client")
switchSetupPage("pageJoin");
else if (g_GameType == "server")
switchSetupPage("pageHost");
else
error("cancelSetup: Unrecognised multiplayer game type: " + g_GameType);
}
function confirmPassword()
{
if (Engine.GetGUIObjectByName("pagePassword").hidden)
return;
if (startJoinFromLobby(g_ServerName, g_ServerId, Engine.GetGUIObjectByName("clientPassword").caption))
switchSetupPage("pageConnecting");
}
function confirmSetup()
{
if (!Engine.GetGUIObjectByName("pageJoin").hidden)
{
let joinPlayerName = Engine.GetGUIObjectByName("joinPlayerName").caption;
let joinServer = Engine.GetGUIObjectByName("joinServer").caption;
let joinPort = Engine.GetGUIObjectByName("joinPort").caption;
if (startJoin(joinPlayerName, joinServer, getValidPort(joinPort)))
switchSetupPage("pageConnecting");
}
else if (!Engine.GetGUIObjectByName("pageHost").hidden)
{
let hostServerName = Engine.GetGUIObjectByName("hostServerName").caption;
if (!hostServerName)
{
Engine.GetGUIObjectByName("hostFeedback").caption = translate("Please enter a valid server name.");
return;
}
let hostPort = Engine.GetGUIObjectByName("hostPort").caption;
if (getValidPort(hostPort) != +hostPort)
{
Engine.GetGUIObjectByName("hostFeedback").caption = sprintf(
translate("Server port number must be between %(min)s and %(max)s."), {
"min": g_ValidPorts.min,
"max": g_ValidPorts.max
});
return;
}
let hostPlayerName = Engine.GetGUIObjectByName("hostPlayerName").caption;
let hostPassword = Engine.GetGUIObjectByName("hostPassword").caption;
if (startHost(hostPlayerName, hostServerName, getValidPort(hostPort), hostPassword))
switchSetupPage("pageConnecting");
}
}
function startConnectionStatus(type)
{
g_GameType = type;
g_IsConnecting = true;
g_IsRejoining = false;
Engine.GetGUIObjectByName("connectionStatus").caption = translate("Connecting to server...");
}
function onTick()
{
if (!g_IsConnecting)
return;
pollAndHandleNetworkClient();
}
function getConnectionFailReason(reason)
{
switch (reason)
{
case "not_server": return translate("Server is not running.");
case "invalid_password": return translate("Password is invalid.");
case "banned": return translate("You have been banned.");
case "local_ip_failed": return translate("Failed to get local IP of the server (it was assumed to be on the same network).");
default:
warn("Unknown connection failure reason: " + reason);
return sprintf(translate("\\[Invalid value %(reason)s]"), { "reason": reason });
}
}
function reportConnectionFail(reason)
{
messageBox(
400, 200,
(translate("Failed to connect to the server.")
) + "\n\n" + getConnectionFailReason(reason),
translate("Connection failed")
);
}
function pollAndHandleNetworkClient()
{
while (true)
{
var message = Engine.PollNetworkClient();
if (!message)
break;
log(sprintf(translate("Net message: %(message)s"), { "message": uneval(message) }));
// If we're rejoining an active game, we don't want to actually display
// the game setup screen, so perform similar processing to gamesetup.js
// in this screen
if (g_IsRejoining)
{
switch (message.type)
{
case "serverdata":
switch (message.status)
{
case "failed":
cancelSetup();
reportConnectionFail(message.reason, false);
return;
default:
error("Unrecognised netstatus type: " + message.status);
break;
}
break;
case "netstatus":
switch (message.status)
{
case "disconnected":
cancelSetup();
reportDisconnect(message.reason, false);
return;
default:
error("Unrecognised netstatus type: " + message.status);
break;
}
break;
case "players":
g_PlayerAssignments = message.newAssignments;
break;
case "start":
Engine.SwitchGuiPage("page_loading.xml", {
"attribs": message.initAttributes,
"isRejoining": g_IsRejoining,
"playerAssignments": g_PlayerAssignments
});
// Process further pending netmessages in the session page
return;
case "chat":
break;
case "netwarn":
break;
default:
error("Unrecognised net message type: " + message.type);
}
}
else
// Not rejoining - just trying to connect to server.
{
switch (message.type)
{
case "serverdata":
switch (message.status)
{
case "failed":
cancelSetup();
reportConnectionFail(message.reason, false);
return;
default:
error("Unrecognised netstatus type: " + message.status);
break;
}
break;
case "netstatus":
switch (message.status)
{
case "connected":
Engine.GetGUIObjectByName("connectionStatus").caption = translate("Registering with server...");
break;
case "authenticated":
if (message.rejoining)
{
Engine.GetGUIObjectByName("connectionStatus").caption = translate("Game has already started, rejoining...");
g_IsRejoining = true;
return; // we'll process the game setup messages in the next tick
}
Engine.SwitchGuiPage("page_gamesetup.xml", {
"serverName": g_ServerName,
"hasPassword": g_ServerHasPassword
});
return; // don't process any more messages - leave them for the game GUI loop
case "disconnected":
cancelSetup();
reportDisconnect(message.reason, false);
return;
default:
error("Unrecognised netstatus type: " + message.status);
break;
}
break;
case "netwarn":
break;
default:
error("Unrecognised net message type: " + message.type);
break;
}
}
}
}
function switchSetupPage(newPage)
{
let multiplayerPages = Engine.GetGUIObjectByName("multiplayerPages");
for (let page of multiplayerPages.children)
if (page.name.startsWith("page"))
page.hidden = true;
if (newPage == "pageJoin" || newPage == "pageHost")
{
let pageSize = multiplayerPages.size;
let halfHeight = newPage == "pageJoin" ? 145 : Engine.HasXmppClient() ? 140 : 125;
pageSize.top = -halfHeight;
pageSize.bottom = halfHeight;
multiplayerPages.size = pageSize;
}
else if (newPage == "pagePassword")
{
let pageSize = multiplayerPages.size;
let halfHeight = 60;
pageSize.top = -halfHeight;
pageSize.bottom = halfHeight;
multiplayerPages.size = pageSize;
}
Engine.GetGUIObjectByName(newPage).hidden = false;
Engine.GetGUIObjectByName("hostPlayerNameWrapper").hidden = Engine.HasXmppClient();
Engine.GetGUIObjectByName("hostServerNameWrapper").hidden = !Engine.HasXmppClient();
Engine.GetGUIObjectByName("continueButton").hidden = newPage == "pageConnecting" || newPage == "pagePassword";
}
function startHost(playername, servername, port, password)
{
startConnectionStatus("server");
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "playername.multiplayer", playername, "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", "playername.multiplayer", playername);
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "multiplayerhosting.port", port, "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", "multiplayerhosting.port", port);
let hostFeedback = Engine.GetGUIObjectByName("hostFeedback");
// Disallow identically named games in the multiplayer lobby
if (Engine.HasXmppClient() &&
Engine.GetGameList().some(game => game.name == servername))
{
cancelSetup();
hostFeedback.caption = translate("Game name already in use.");
return false;
}
let useSTUN = Engine.HasXmppClient() && Engine.GetGUIObjectByName("useSTUN").checked;
try
{
Engine.StartNetworkHost(playername + (g_UserRating ? " (" + g_UserRating + ")" : ""), port, useSTUN, password, true);
}
catch (e)
{
cancelSetup();
messageBox(
400, 200,
sprintf(translate("Cannot host game: %(message)s."), { "message": e.message }),
translate("Error")
);
return false;
}
g_ServerName = servername;
g_ServerHasPassword = !!password;
if (Engine.HasXmppClient())
Engine.LobbySetPlayerPresence("playing");
return true;
}
/**
* Connect via direct IP (used by the 'simple' MP screen)
*/
function startJoin(playername, ip, port)
{
try
{
Engine.StartNetworkJoin(playername, ip, port, true);
}
catch (e)
{
cancelSetup();
messageBox(
400, 200,
sprintf(translate("Cannot join game: %(message)s."), { "message": e.message }),
translate("Error")
);
return false;
}
startConnectionStatus("client");
// Future-proofing: there could be an XMPP client even if we join a game directly.
if (Engine.HasXmppClient())
Engine.LobbySetPlayerPresence("playing");
// Only save the player name and host address if they're valid.
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "playername.multiplayer", playername, "config/user.cfg");
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "multiplayerserver", ip, "config/user.cfg");
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "multiplayerjoining.port", port, "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", "playername.multiplayer", playername);
+ Engine.ConfigDB_CreateAndSaveValue("user", "multiplayerserver", ip);
+ Engine.ConfigDB_CreateAndSaveValue("user", "multiplayerjoining.port", port);
return true;
}
/**
* Connect via the lobby.
*/
function startJoinFromLobby(playername, hostJID, password)
{
if (!Engine.HasXmppClient())
{
cancelSetup();
messageBox(
400, 200,
sprintf("You cannot join a lobby game without logging in to the lobby."),
translate("Error")
);
return false;
}
try
{
Engine.StartNetworkJoinLobby(playername + (g_UserRating ? " (" + g_UserRating + ")" : ""), hostJID, password);
}
catch (e)
{
cancelSetup();
messageBox(
400, 200,
sprintf(translate("Cannot join game: %(message)s."), { "message": e.message }),
translate("Error")
);
return false;
}
startConnectionStatus("client");
Engine.LobbySetPlayerPresence("playing");
return true;
}
function getDefaultGameName()
{
return sprintf(translate("%(playername)s's game"), {
"playername": multiplayerName()
});
}
function getDefaultPassword()
{
return "";
}
Index: ps/trunk/binaries/data/mods/public/gui/gamesetup_mp/gamesetup_mp.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/gamesetup_mp/gamesetup_mp.xml (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/gamesetup_mp/gamesetup_mp.xml (revision 27192)
@@ -1,168 +1,168 @@
Index: ps/trunk/binaries/data/mods/public/gui/hotkeys/HotkeyPicker.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/hotkeys/HotkeyPicker.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/hotkeys/HotkeyPicker.js (revision 27192)
@@ -1,123 +1,122 @@
/**
* Handle the interface to pick a hotkey combination.
* The player must keep a key combination for 2s in the input field for it to be registered.
*/
class HotkeyPicker
{
constructor(metadata, onClose, name, combinations)
{
this.metadata = metadata;
this.name = name;
this.combinations = combinations;
this.window = Engine.GetGUIObjectByName("hotkeyPicker");
this.window.hidden = false;
this.enteringInput = -1;
if (this.metadata.hotkeys[name])
{
Engine.GetGUIObjectByName("hotkeyPickerTitle").caption = translateWithContext("hotkey metadata", this.metadata.hotkeys[name].name);
Engine.GetGUIObjectByName("hotkeyPickerDescHotkey").caption = translateWithContext("hotkey metadata", this.metadata.hotkeys[name].desc);
}
else
{
Engine.GetGUIObjectByName("hotkeyPickerTitle").caption = this.name;
Engine.GetGUIObjectByName("hotkeyPickerDescHotkey").hidden = true;
}
this.setupCombinations();
this.render();
Engine.GetGUIObjectByName("hotkeyPickerReset").onPress = () => {
// This is a bit "using a bazooka to kill a fly"
- Engine.ConfigDB_RemoveValue("user", "hotkey." + this.name);
- Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+ Engine.ConfigDB_RemoveValueAndSave("user", "hotkey." + this.name);
Engine.ReloadHotkeys();
let data = Engine.GetHotkeyMap();
this.combinations = data[this.name];
this.setupCombinations();
this.render();
};
Engine.GetGUIObjectByName("hotkeyPickerCancel").onPress = () => {
onClose(this, false);
};
Engine.GetGUIObjectByName("hotkeyPickerSave").onPress = () => {
onClose(this, true);
};
}
setupCombinations()
{
for (let i = 0; i < 4; ++i)
{
let s = Engine.GetGUIObjectByName("combination[" + i + "]").size;
s.top = +i * 60 + 120;
s.bottom = +i * 60 + 150;
Engine.GetGUIObjectByName("combination[" + i + "]").size = s;
Engine.GetGUIObjectByName("combNb[" + i + "]").caption = sprintf(translate("#%i"), i);
if (i == this.combinations.length)
this.combinations.push([]);
let input = Engine.GetGUIObjectByName("combMapping[" + i + "]");
let picker = Engine.GetGUIObjectByName("picker[" + i + "]");
Engine.GetGUIObjectByName("combMappingBtn[" + i + "]").onPress = () => {
this.enteringInput = i;
picker.focus();
this.render();
};
picker.onKeyChange = keys => {
input.caption = (keys.length ?
formatHotkeyCombination(keys) + translate(" (hold to register)") :
translate("Enter new Hotkey, hold to register."));
};
Engine.GetGUIObjectByName("deleteComb[" + i + "]").onPress = (j => () => {
this.combinations[j] = [];
this.render();
})(i);
picker.onCombination = (j => keys => {
this.combinations[j] = keys;
this.enteringInput = -1;
picker.blur();
this.render();
})(i);
}
}
close()
{
this.window.hidden = true;
for (let i = 0; i < 4; ++i)
Engine.GetGUIObjectByName("picker[" + i + "]").blur();
}
render()
{
for (let i = 0; i < 4; ++i)
{
let input = Engine.GetGUIObjectByName("combMapping[" + i + "]");
if (i == this.enteringInput)
input.caption = translate("Enter new Hotkey, hold to register.");
else
input.caption = formatHotkeyCombination(this.combinations[i]) || translateWithContext("Unassigned hotkey", "(unused)");
Engine.GetGUIObjectByName("conflicts[" + i + "]").caption = "";
Engine.GetGUIObjectByName("deleteComb[" + i + "]").hidden = !this.combinations[i].length;
let conflicts = (Engine.GetConflicts(this.combinations[i]) || [])
.filter(name => name != this.name).map(translate);
if (conflicts.length)
Engine.GetGUIObjectByName("conflicts[" + i + "]").caption =
coloredText(translate("May conflict with: "), "255 153 0") + conflicts.join(", ");
}
// Gray out buttons when entering an input so it's obvious clicking on them will do nothing.
Engine.GetGUIObjectByName("hotkeyPickerReset").enabled = this.enteringInput == -1;
Engine.GetGUIObjectByName("hotkeyPickerCancel").enabled = this.enteringInput == -1;
Engine.GetGUIObjectByName("hotkeyPickerSave").enabled = this.enteringInput == -1;
}
}
Index: ps/trunk/binaries/data/mods/public/gui/hotkeys/HotkeysPage.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/hotkeys/HotkeysPage.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/hotkeys/HotkeysPage.js (revision 27192)
@@ -1,198 +1,198 @@
class HotkeysPage
{
constructor(metadata)
{
this.metadata = metadata;
Engine.GetGUIObjectByName("hotkeyList").onMouseLeftDoubleClickItem = () => {
let idx = Engine.GetGUIObjectByName("hotkeyList").selected;
let picker = new HotkeyPicker(
this.metadata,
this.onHotkeyPicked.bind(this),
Engine.GetGUIObjectByName("hotkeyList").list_data[idx],
clone(this.hotkeys[Engine.GetGUIObjectByName("hotkeyList").list_data[idx]])
);
};
Engine.GetGUIObjectByName("hotkeyList").onHoverChange = () => this.onHotkeyHover();
Engine.GetGUIObjectByName("hotkeyFilter").onSelectionChange = () => this.setupHotkeyList();
Engine.GetGUIObjectByName("hotkeyFilter").onHoverChange = () => this.onFilterHover();
Engine.GetGUIObjectByName("hotkeyTextFilter").onTextEdit = () => this.setupHotkeyList();
this.saveButton = Engine.GetGUIObjectByName("hotkeySave");
this.saveButton.enabled = false;
Engine.GetGUIObjectByName("hotkeyClose").onPress = () => Engine.PopGuiPage();
Engine.GetGUIObjectByName("hotkeyReset").onPress = () => this.resetUserHotkeys();
this.saveButton.onPress = () => {
this.saveUserHotkeys();
this.saveButton.enabled = false;
};
this.setupHotkeyData();
this.setupFilters();
this.setupHotkeyList();
}
setupHotkeyData()
{
let hotkeydata = Engine.GetHotkeyMap();
this.hotkeys = hotkeydata;
let categories = clone(this.metadata.categories);
for (let name in categories)
categories[name].hotkeys = [];
// Add hotkeys defined in the metadata but not in the C++ map.
for (let hotkeyName in this.metadata.hotkeys)
if (!this.hotkeys[hotkeyName])
this.hotkeys[hotkeyName] = [];
for (let hotkeyName in this.hotkeys)
{
if (this.metadata.hotkeys[hotkeyName])
for (let cat of this.metadata.hotkeys[hotkeyName].categories)
categories[cat].hotkeys.push(hotkeyName);
else
categories[this.metadata.DEFAULT_CATEGORY].hotkeys.push(hotkeyName);
}
for (let cat in categories)
categories[cat].hotkeys.sort((a, b) => {
if (!this.metadata.hotkeys[a] || !this.metadata.hotkeys[b])
return !this.metadata.hotkeys[a] ? 1 : -1;
return this.metadata.hotkeys[a].order - this.metadata.hotkeys[b].order;
});
for (let cat in categories)
if (categories[cat].hotkeys.length === 0)
delete categories[cat];
this.categories = categories;
}
setupFilters()
{
let dropdown = Engine.GetGUIObjectByName("hotkeyFilter");
let names = [];
for (let cat in this.categories)
names.push(translateWithContext("hotkey metadata", this.categories[cat].name));
dropdown.list = [translate("All Hotkeys")].concat(names);
dropdown.list_data = [-1].concat(Object.keys(this.categories));
dropdown.selected = 0;
}
setupHotkeyList()
{
let hotkeyList = Engine.GetGUIObjectByName("hotkeyList");
hotkeyList.selected = -1;
let textFilter = Engine.GetGUIObjectByName("hotkeyTextFilter").caption.toLowerCase();
let hotkeys;
let dropdown = Engine.GetGUIObjectByName("hotkeyFilter");
if (dropdown.selected && dropdown.selected !== 0)
hotkeys = this.categories[dropdown.list_data[dropdown.selected]].hotkeys;
else
hotkeys = Object.values(this.categories).map(x => x.hotkeys).flat();
hotkeys = hotkeys.filter(x => {
return x.indexOf(textFilter) !== -1 ||
translateWithContext("hotkey metadata", this.metadata.hotkeys[x]?.name || x).toLowerCase().indexOf(textFilter) !== -1;
});
hotkeyList.list_name = hotkeys.map(x => translateWithContext("hotkey metadata", this.metadata.hotkeys[x]?.name || x));
hotkeyList.list_mapping = hotkeys.map(x => formatHotkeyCombinations(this.hotkeys[x]));
hotkeyList.list = hotkeys.map(() => 0);
hotkeyList.list_data = hotkeys.map(x => x);
}
onFilterHover()
{
let dropdown = Engine.GetGUIObjectByName("hotkeyFilter");
if (dropdown.hovered === -1)
dropdown.tooltip = "";
else if (dropdown.hovered === 0)
dropdown.tooltip = translate("All available hotkeys.");
else
dropdown.tooltip = translateWithContext("hotkey metadata", this.categories[dropdown.list_data[dropdown.hovered]].desc);
}
onHotkeyHover()
{
let hotkeyList = Engine.GetGUIObjectByName("hotkeyList");
if (hotkeyList.hovered === -1)
hotkeyList.tooltip = "";
else
{
let hotkey = hotkeyList.list_data[hotkeyList.hovered];
hotkeyList.tooltip = this.metadata.hotkeys[hotkey]?.desc ?
translateWithContext("hotkey metadata", this.metadata.hotkeys[hotkey]?.desc) :
translate(this.UnavailableTooltipString);
}
}
onHotkeyPicked(picker, success)
{
picker.close();
if (!success)
return;
// Remove empty combinations which the picker added.
picker.combinations = picker.combinations.filter(x => x.length);
this.hotkeys[picker.name] = picker.combinations;
// Have to find the correct line.
let panel = Engine.GetGUIObjectByName("hotkeyList");
for (let cat in this.categories)
{
let idx = this.categories[cat].hotkeys.findIndex(([name, _]) => name == picker.name);
if (idx === -1)
continue;
this.categories[cat].hotkeys[idx][1] = picker.combinations;
}
this.saveButton.enabled = true;
this.setupHotkeyList();
}
resetUserHotkeys()
{
messageBox(
400, 200,
translate("Reset all hotkeys to default values?\nWARNING: this cannot be reversed."),
translate("Confirmation"),
[translate("No"), translate("Yes")],
[
() => {},
() => {
for (let cat in this.categories)
this.categories[cat].hotkeys.forEach(([name, _]) => {
Engine.ConfigDB_RemoveValue("user", "hotkey." + name);
});
- Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+ Engine.ConfigDB_SaveChanges("user");
Engine.ReloadHotkeys();
this.saveButton.enabled = false;
this.setupHotkeyData();
this.setupHotkeyList();
}
]);
}
saveUserHotkeys()
{
for (let hotkey in this.hotkeys)
Engine.ConfigDB_RemoveValue("user", "hotkey." + hotkey);
Engine.ReloadHotkeys();
let defaultData = Engine.GetHotkeyMap();
for (let hotkey in this.hotkeys)
{
let keymap = formatHotkeyCombinations(this.hotkeys[hotkey], false);
if (keymap.join("") !== formatHotkeyCombinations(defaultData[hotkey], false).join(""))
Engine.ConfigDB_CreateValues("user", "hotkey." + hotkey, keymap);
}
- Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+ Engine.ConfigDB_SaveChanges("user");
Engine.ReloadHotkeys();
}
}
function init()
{
let hotkeyPage = new HotkeysPage(new HotkeyMetadata());
}
HotkeysPage.prototype.UnavailableTooltipString = markForTranslation("No tooltip available.");
Index: ps/trunk/binaries/data/mods/public/gui/lobby/LobbyPage/Buttons/BuddyButton.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/lobby/LobbyPage/Buttons/BuddyButton.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/lobby/LobbyPage/Buttons/BuddyButton.js (revision 27192)
@@ -1,70 +1,70 @@
/**
* This class manages the button that enables the player to add or remove buddies.
*/
class BuddyButton
{
constructor(xmppMessages)
{
this.buddyChangedHandlers = new Set();
this.playerName = undefined;
this.toggleBuddyButton = Engine.GetGUIObjectByName("toggleBuddyButton");
this.toggleBuddyButton.onPress = this.onPress.bind(this);
let rebuild = this.rebuild.bind(this);
xmppMessages.registerXmppMessageHandler("system", "connected", rebuild);
xmppMessages.registerXmppMessageHandler("system", "disconnected", rebuild);
this.rebuild();
}
registerBuddyChangeHandler(handler)
{
this.buddyChangedHandlers.add(handler);
}
onPlayerSelectionChange(playerName)
{
this.playerName = playerName;
this.rebuild();
}
rebuild()
{
this.toggleBuddyButton.caption =
g_Buddies.indexOf(this.playerName) != -1 ?
this.UnmarkString :
this.MarkString;
this.toggleBuddyButton.enabled = Engine.IsXmppClientConnected() && !!this.playerName && this.playerName != g_Nickname;
}
/**
* Toggle the buddy state of the selected player.
*/
onPress()
{
if (!this.playerName || this.playerName == g_Nickname || this.playerName.indexOf(g_BuddyListDelimiter) != -1)
return;
let index = g_Buddies.indexOf(this.playerName);
if (index != -1)
g_Buddies.splice(index, 1);
else
g_Buddies.push(this.playerName);
- Engine.ConfigDB_CreateAndWriteValueToFile(
+ Engine.ConfigDB_CreateAndSaveValue(
"user",
"lobby.buddies",
- g_Buddies.filter(nick => nick).join(g_BuddyListDelimiter) || g_BuddyListDelimiter,
- "config/user.cfg");
+ g_Buddies.filter(nick => nick).join(g_BuddyListDelimiter) || g_BuddyListDelimiter
+ );
this.rebuild();
for (let handler of this.buddyChangedHandlers)
handler();
}
}
BuddyButton.prototype.MarkString = translate("Mark as Buddy");
BuddyButton.prototype.UnmarkString = translate("Unmark as Buddy");
Index: ps/trunk/binaries/data/mods/public/gui/options/options.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/options/options.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/options/options.js (revision 27192)
@@ -1,463 +1,461 @@
/**
* Translated JSON file contents.
*/
var g_Options;
/**
* Names of config keys that have changed, value returned when closing the page.
*/
var g_ChangedKeys;
/**
* Vertical size of a tab button.
*/
var g_TabButtonHeight = 30;
/**
* Vertical space between two tab buttons.
*/
var g_TabButtonDist = 5;
/**
* Vertical distance between the top of the page and the first option.
*/
var g_OptionControlOffset = 5;
/**
* Vertical size of each option control.
*/
var g_OptionControlHeight = 26;
/**
* Vertical distance between two consecutive options.
*/
var g_OptionControlDist = 2;
/**
* Horizontal indentation to distinguish options that depend on another option.
*/
var g_DependentLabelIndentation = 25;
/**
* Color used to indicate that the string entered by the player isn't a sane color.
*/
var g_InsaneColor = "255 0 255";
/**
* Defines the parsing of config strings and GUI control interaction for the different option types.
*
* @property configToValue - parses a string from the user config to a value of the declared type.
* @property valueToGui - sets the GUI control to display the given value.
* @property guiToValue - returns the value of the GUI control.
* @property guiSetter - event name that should be considered a value change of the GUI control.
* @property initGUI - sets properties of the GUI control that are independent of the current value.
* @property sanitizeValue - Displays a visual clue if the entered value is invalid and returns a sane value.
* @property tooltip - appends a custom tooltip to the given option description depending on the current value.
*/
var g_OptionType = {
"boolean":
{
"configToValue": config => config == "true",
"valueToGui": (value, control) => {
control.checked = value;
},
"guiToValue": control => control.checked,
"guiSetter": "onPress"
},
"string":
{
"configToValue": value => value,
"valueToGui": (value, control) => {
control.caption = value;
},
"guiToValue": control => control.caption,
"guiSetter": "onTextEdit"
},
"color":
{
"configToValue": value => value,
"valueToGui": (value, control) => {
control.caption = value;
},
"initGUI": (option, control) => {
control.children[2].onPress = () => {
colorMixer(
control.caption,
(color) => {
if (color != control.caption)
{
control.caption = color;
control.onTextEdit();
}
}
);
};
},
"guiToValue": control => control.caption,
"guiSetter": "onTextEdit",
"sanitizeValue": (value, control, option) => {
let color = guiToRgbColor(value);
let sanitized = rgbToGuiColor(color);
if (control)
{
control.sprite = sanitized == value ? "ModernDarkBoxWhite" : "ModernDarkBoxWhiteInvalid";
control.children[1].sprite = sanitized == value ? "color:" + value : "color:" + g_InsaneColor;
}
return sanitized;
},
"tooltip": (value, option) =>
sprintf(translate("Default: %(value)s"), {
"value": Engine.ConfigDB_GetValue("default", option.config)
})
},
"number":
{
"configToValue": value => value,
"valueToGui": (value, control) => {
control.caption = value;
},
"guiToValue": control => control.caption,
"guiSetter": "onTextEdit",
"sanitizeValue": (value, control, option) => {
let sanitized =
Math.min(option.max !== undefined ? option.max : +Infinity,
Math.max(option.min !== undefined ? option.min : -Infinity,
isNaN(+value) ? 0 : value));
if (control)
control.sprite = sanitized == value ? "ModernDarkBoxWhite" : "ModernDarkBoxWhiteInvalid";
return sanitized;
},
"tooltip": (value, option) =>
sprintf(
option.min !== undefined && option.max !== undefined ?
translateWithContext("option number", "Min: %(min)s, Max: %(max)s") :
option.min !== undefined && option.max === undefined ?
translateWithContext("option number", "Min: %(min)s") :
option.min === undefined && option.max !== undefined ?
translateWithContext("option number", "Max: %(max)s") :
"",
{
"min": option.min,
"max": option.max
})
},
"dropdown":
{
"configToValue": value => value,
"valueToGui": (value, control) => {
control.selected = control.list_data.indexOf(value);
},
"guiToValue": control => control.list_data[control.selected],
"guiSetter": "onSelectionChange",
"initGUI": (option, control) => {
control.list = option.list.map(e => e.label);
control.list_data = option.list.map(e => e.value);
control.onHoverChange = () => {
let item = option.list[control.hovered];
control.tooltip = item && item.tooltip || option.tooltip;
};
}
},
"dropdownNumber":
{
"configToValue": value => +value,
"valueToGui": (value, control) => {
control.selected = control.list_data.indexOf("" + value);
},
"guiToValue": control => +control.list_data[control.selected],
"guiSetter": "onSelectionChange",
"initGUI": (option, control) => {
control.list = option.list.map(e => e.label);
control.list_data = option.list.map(e => e.value);
control.onHoverChange = () => {
const item = option.list[control.hovered];
control.tooltip = item && item.tooltip || option.tooltip;
};
},
"timeout": (option, oldValue, hasChanges, newValue) => {
if (!option.timeout)
return;
timedConfirmation(
500, 200,
translate("Changes will be reverted in %(time)s seconds. Do you want to keep changes?"),
"time",
option.timeout,
translate("Warning"),
[translate("No"), translate("Yes")],
[() => {this.revertChange(option, +oldValue, hasChanges);}, null]
);
}
},
"slider":
{
"configToValue": value => +value,
"valueToGui": (value, control) => {
control.value = +value;
},
"guiToValue": control => control.value,
"guiSetter": "onValueChange",
"initGUI": (option, control) => {
control.max_value = option.max;
control.min_value = option.min;
},
"tooltip": (value, option) =>
sprintf(translateWithContext("slider number", "Value: %(val)s (min: %(min)s, max: %(max)s)"), {
"val": value.toFixed(2),
"min": option.min.toFixed(2),
"max": option.max.toFixed(2)
})
}
};
function init(data, hotloadData)
{
g_ChangedKeys = hotloadData ? hotloadData.changedKeys : new Set();
g_TabCategorySelected = hotloadData ? hotloadData.tabCategorySelected : 0;
g_Options = Engine.ReadJSONFile("gui/options/options.json");
translateObjectKeys(g_Options, ["label", "tooltip"]);
deepfreeze(g_Options);
placeTabButtons(
g_Options,
false,
g_TabButtonHeight,
g_TabButtonDist,
selectPanel,
displayOptions);
}
function getHotloadData()
{
return {
"tabCategorySelected": g_TabCategorySelected,
"changedKeys": g_ChangedKeys
};
}
/**
* Sets up labels and controls of all options of the currently selected category.
*/
function displayOptions()
{
// Hide all controls
for (let body of Engine.GetGUIObjectByName("option_controls").children)
{
body.hidden = true;
for (let control of body.children)
control.hidden = true;
}
// Initialize label and control of each option for this category
for (let i = 0; i < g_Options[g_TabCategorySelected].options.length; ++i)
{
// Position vertically
let body = Engine.GetGUIObjectByName("option_control[" + i + "]");
let bodySize = body.size;
bodySize.top = g_OptionControlOffset + i * (g_OptionControlHeight + g_OptionControlDist);
bodySize.bottom = bodySize.top + g_OptionControlHeight;
body.size = bodySize;
body.hidden = false;
// Load option data
let option = g_Options[g_TabCategorySelected].options[i];
let optionType = g_OptionType[option.type];
let value = optionType.configToValue(Engine.ConfigDB_GetValue("user", option.config));
// Setup control
let control = Engine.GetGUIObjectByName("option_control_" + option.type + "[" + i + "]");
control.tooltip = option.tooltip + (optionType.tooltip ? "\n" + optionType.tooltip(value, option) : "");
control.hidden = false;
if (optionType.initGUI)
optionType.initGUI(option, control);
control[optionType.guiSetter] = function() {};
optionType.valueToGui(value, control);
if (optionType.sanitizeValue)
optionType.sanitizeValue(value, control, option);
control[optionType.guiSetter] = function() {
let value = optionType.guiToValue(control);
if (optionType.sanitizeValue)
optionType.sanitizeValue(value, control, option);
const oldValue = optionType.configToValue(Engine.ConfigDB_GetValue("user", option.config));
control.tooltip = option.tooltip + (optionType.tooltip ? "\n" + optionType.tooltip(value, option) : "");
const hasChanges = Engine.ConfigDB_HasChanges("user");
Engine.ConfigDB_CreateValue("user", option.config, String(value));
- Engine.ConfigDB_SetChanges("user", true);
g_ChangedKeys.add(option.config);
fireConfigChangeHandlers(new Set([option.config]));
if (option.timeout)
optionType.timeout(option, oldValue, hasChanges, value);
if (option.function)
Engine[option.function](value);
enableButtons();
};
// Setup label
let label = Engine.GetGUIObjectByName("option_label[" + i + "]");
label.caption = option.label;
label.tooltip = option.tooltip;
label.hidden = false;
let labelSize = label.size;
labelSize.left = option.dependencies ? g_DependentLabelIndentation : 0;
labelSize.rright = control.size.rleft;
label.size = labelSize;
}
enableButtons();
}
/**
* Enable exactly the buttons whose dependencies are met.
*/
function enableButtons()
{
g_Options[g_TabCategorySelected].options.forEach((option, i) => {
const isDependencyMet = dependency => {
if (typeof dependency === "string")
return Engine.ConfigDB_GetValue("user", dependency) == "true";
else if (typeof dependency === "object")
{
const availableOps = {
"==": (config, value) => config == value,
"!=": (config, value) => config != value
};
const op = availableOps[dependency.op] || availableOps["=="];
return op(Engine.ConfigDB_GetValue("user", dependency.config), dependency.value);
}
error("Unsupported dependency: " + uneval(dependency));
return false;
};
const enabled = !option.dependencies || option.dependencies.every(isDependencyMet);
Engine.GetGUIObjectByName("option_label[" + i + "]").enabled = enabled;
Engine.GetGUIObjectByName("option_control_" + option.type + "[" + i + "]").enabled = enabled;
});
const hasChanges = Engine.ConfigDB_HasChanges("user");
Engine.GetGUIObjectByName("revertChanges").enabled = hasChanges;
Engine.GetGUIObjectByName("saveChanges").enabled = hasChanges;
}
function setDefaults()
{
messageBox(
500, 200,
translate("Resetting the options will erase your saved settings. Do you want to continue?"),
translate("Warning"),
[translate("No"), translate("Yes")],
[null, reallySetDefaults]
);
}
function reallySetDefaults()
{
for (let category in g_Options)
for (let option of g_Options[category].options)
{
Engine.ConfigDB_RemoveValue("user", option.config);
g_ChangedKeys.add(option.config);
}
- Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+ Engine.ConfigDB_SaveChanges("user");
revertChanges();
}
function revertChange(option, oldValue, hadChanges)
{
+ Engine.ConfigDB_CreateValue("user", option.config, String(oldValue));
+
if (!hadChanges)
Engine.ConfigDB_SetChanges("user", false);
- Engine.ConfigDB_CreateValue("user", option.config, String(oldValue));
if (option.function)
Engine[option.function](oldValue);
displayOptions();
}
function revertChanges()
{
Engine.ConfigDB_Reload("user");
- Engine.ConfigDB_SetChanges("user", false);
for (let category in g_Options)
for (let option of g_Options[category].options)
if (option.function)
Engine[option.function](
g_OptionType[option.type].configToValue(
Engine.ConfigDB_GetValue("user", option.config)));
displayOptions();
}
function saveChanges()
{
for (let category in g_Options)
for (let i = 0; i < g_Options[category].options.length; ++i)
{
let option = g_Options[category].options[i];
let optionType = g_OptionType[option.type];
if (!optionType.sanitizeValue)
continue;
let value = optionType.configToValue(Engine.ConfigDB_GetValue("user", option.config));
if (value == optionType.sanitizeValue(value, undefined, option))
continue;
selectPanel(category);
messageBox(
500, 200,
translate("Some setting values are invalid! Are you sure you want to save them?"),
translate("Warning"),
[translate("No"), translate("Yes")],
[null, reallySaveChanges]
);
return;
}
reallySaveChanges();
}
function reallySaveChanges()
{
- Engine.ConfigDB_WriteFile("user", "config/user.cfg");
- Engine.ConfigDB_SetChanges("user", false);
+ Engine.ConfigDB_SaveChanges("user");
enableButtons();
}
/**
* Close GUI page and inform the parent GUI page which options changed.
**/
function closePage()
{
if (Engine.ConfigDB_HasChanges("user"))
messageBox(
500, 200,
translate("You have unsaved changes, do you want to close this window?"),
translate("Warning"),
[translate("No"), translate("Yes")],
[null, closePageWithoutConfirmation]);
else
closePageWithoutConfirmation();
}
function closePageWithoutConfirmation()
{
Engine.PopGuiPage(g_ChangedKeys);
}
Index: ps/trunk/binaries/data/mods/public/gui/prelobby/common/credentials/credentials.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/prelobby/common/credentials/credentials.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/prelobby/common/credentials/credentials.js (revision 27192)
@@ -1,91 +1,90 @@
function checkUsername(register)
{
let username = Engine.GetGUIObjectByName("username").caption;
if (!username)
return translate("Please enter your username");
if (register && (!username.match(/^[a-z0-9._-]*$/i) || username.length > 20))
return translate("Invalid username");
return "";
}
function checkPassword(register)
{
let password = Engine.GetGUIObjectByName("password").caption;
if (!password)
return register ?
translateWithContext("register", "Please enter your password") :
translateWithContext("login", "Please enter your password");
if (register && password.length < 8)
return translate("Please choose a longer password");
return "";
}
function checkPasswordConfirmation()
{
let password1 = Engine.GetGUIObjectByName("password").caption;
if (!password1)
return translate("Please enter your password again");
let password2 = Engine.GetGUIObjectByName("passwordRepeat").caption;
if (password1 != password2)
return translate("Passwords do not match");
return "";
}
function initRememberPassword()
{
Engine.GetGUIObjectByName("rememberPassword").checked =
Engine.ConfigDB_GetValue("user", "lobby.rememberpassword") == "true";
}
function toggleRememberPassword()
{
let checkbox = Engine.GetGUIObjectByName("rememberPassword");
let enabled = Engine.ConfigDB_GetValue("user", "lobby.rememberpassword") == "true";
if (!checkbox.checked && enabled && Engine.ConfigDB_GetValue("user", "lobby.password"))
messageBox(
360, 160,
translate("Are you sure you want to delete the password after connecting?"),
translate("Confirmation"),
[translate("No"), translate("Yes")],
[
() => { checkbox.checked = true; },
- () => { Engine.ConfigDB_CreateAndWriteValueToFile("user", "lobby.rememberpassword", String(!enabled), "config/user.cfg"); }
+ () => { Engine.ConfigDB_CreateAndSaveValue("user", "lobby.rememberpassword", String(!enabled)); }
]);
else
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "lobby.rememberpassword", String(!enabled), "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", "lobby.rememberpassword", String(!enabled));
}
function getEncryptedPassword()
{
let typedUnencryptedPassword = Engine.GetGUIObjectByName("password").caption;
let storedEncryptedPassword = Engine.ConfigDB_GetValue("user", "lobby.password");
if (typedUnencryptedPassword == storedEncryptedPassword.substr(0, 10))
return storedEncryptedPassword;
return Engine.EncryptPassword(
typedUnencryptedPassword,
Engine.GetGUIObjectByName("username").caption);
}
function saveCredentials()
{
let username = Engine.GetGUIObjectByName("username").caption;
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "playername.multiplayer", username, "config/user.cfg");
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "lobby.login", username, "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", "playername.multiplayer", username);
+ Engine.ConfigDB_CreateAndSaveValue("user", "lobby.login", username);
if (Engine.ConfigDB_GetValue("user", "lobby.rememberpassword") == "true")
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "lobby.password", getEncryptedPassword(), "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", "lobby.password", getEncryptedPassword());
else
{
- Engine.ConfigDB_RemoveValue("user", "lobby.password");
- Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+ Engine.ConfigDB_RemoveValueAndSave("user", "lobby.password");
}
}
Index: ps/trunk/binaries/data/mods/public/gui/session/AutoFormation.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/AutoFormation.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/session/AutoFormation.js (revision 27192)
@@ -1,70 +1,67 @@
/**
* Handles the logic related to the 'default formation' feature.
* When given a walking order, units that aren't in formation will be put
* in the default formation, to improve pathfinding and reactivity.
* However, when given other tasks (such as e.g. gather), they will be removed
* from any formation they are in, as those orders don't work very well with formations.
*
* Set the default formation to the null formation to disable this entirely.
*
* TODO: it would be nice to let players choose default formations for different orders,
* but that would be neater if orders where defined somewhere unique,
* instead of mostly in unit_actions.js
*/
class AutoFormation
{
constructor()
{
this.defaultFormation = Engine.ConfigDB_GetValue("user", "gui.session.defaultformation");
if (!this.defaultFormation)
this.setDefault(NULL_FORMATION);
this.lastDefault = this.defaultFormation === NULL_FORMATION ?
"special/formations/box" : this.defaultFormation;
Engine.SetGlobalHotkey("session.toggledefaultformation", "Press", () => {
if (this.defaultFormation === NULL_FORMATION)
this.setDefault(this.lastDefault);
else
this.setDefault(NULL_FORMATION);
});
}
/**
* Set the default formation to @param formation.
* TODO: would be good to validate, particularly since some formations aren't
* usable with any arbitrary unit type, we may want to warn then.
*/
setDefault(formation)
{
this.defaultFormation = formation;
if (formation !== NULL_FORMATION)
this.lastDefault = this.defaultFormation;
- Engine.ConfigDB_CreateValue("user", "gui.session.defaultformation", this.defaultFormation);
- // TODO: It's extremely terrible that we have to explicitly flush the config...
- Engine.ConfigDB_SetChanges("user", true);
- Engine.ConfigDB_WriteFile("user", "config/user.cfg");
+ Engine.ConfigDB_ConfigDB_CreateAndSaveValue("user", "gui.session.defaultformation", this.defaultFormation);
return true;
}
isDefault(formation)
{
return formation == this.defaultFormation;
}
/**
* @return the default formation, or "undefined" if the null formation was chosen,
* otherwise units in formation would disband on any order, which isn't desirable.
*/
getDefault()
{
return this.defaultFormation == NULL_FORMATION ? undefined : this.defaultFormation;
}
/**
* @return the null formation, or "undefined", depending on "walkOnly" preference.
*/
getNull()
{
let walkOnly = Engine.ConfigDB_GetValue("user", "gui.session.formationwalkonly") === "true";
return walkOnly ? NULL_FORMATION : undefined;
}
}
Index: ps/trunk/binaries/data/mods/public/gui/session/RangeOverlayManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/RangeOverlayManager.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/session/RangeOverlayManager.js (revision 27192)
@@ -1,80 +1,79 @@
/**
* This class informs:
* - the GuiInterface of which components of entities are to display range overlays and
* - the RangeOverlayManager entity component which entities are to display range overlays.
*/
class RangeOverlayManager
{
constructor(selection)
{
this.selection = selection;
for (let type of this.Types)
{
this.setEnabled(type, this.isEnabled(type));
Engine.SetGlobalHotkey(type.hotkey, "Press", this.toggle.bind(this, type));
}
registerConfigChangeHandler(this.onConfigChange.bind(this));
}
onConfigChange(changes)
{
for (let type of this.Types)
if (changes.has(type.config))
this.setEnabled(type, this.isEnabled(type));
}
isEnabled(type)
{
return Engine.ConfigDB_GetValue("user", type.config) == "true";
}
setEnabled(type, enabled)
{
Engine.GuiInterfaceCall("EnableVisualRangeOverlayType", {
"type": type.component,
"enabled": enabled
});
let selected = this.selection.toList();
for (let ent in this.selection.highlighted)
selected.push(this.selection.highlighted[ent]);
Engine.GuiInterfaceCall("SetRangeOverlays", {
"entities": selected,
"enabled": enabled
});
}
toggle(type)
{
let enabled = !this.isEnabled(type);
- Engine.ConfigDB_CreateAndWriteValueToFile(
+ Engine.ConfigDB_CreateAndSaveValue(
"user",
type.config,
- String(enabled),
- "config/user.cfg");
+ String(enabled));
this.setEnabled(type, enabled);
}
}
RangeOverlayManager.prototype.Types = [
{
"component": "Attack",
"config": "gui.session.attackrange",
"hotkey": "session.toggleattackrange"
},
{
"component": "Auras",
"config": "gui.session.aurasrange",
"hotkey": "session.toggleaurasrange"
},
{
"component": "Heal",
"config": "gui.session.healrange",
"hotkey": "session.togglehealrange"
}
];
Index: ps/trunk/binaries/data/mods/public/gui/session/chat/ChatWindow.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/chat/ChatWindow.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/session/chat/ChatWindow.js (revision 27192)
@@ -1,95 +1,95 @@
/**
* This class is concerned with opening, closing the chat page, and
* resizing it depending on whether the chat history is shown.
*/
class ChatWindow
{
constructor()
{
this.chatInput = Engine.GetGUIObjectByName("chatInput");
this.closeChat = Engine.GetGUIObjectByName("closeChat");
this.extendedChat = Engine.GetGUIObjectByName("extendedChat");
this.chatHistoryText = Engine.GetGUIObjectByName("chatHistoryText");
this.chatHistoryPage = Engine.GetGUIObjectByName("chatHistoryPage");
this.chatDialogPanel = Engine.GetGUIObjectByName("chatDialogPanel");
this.chatDialogPanelSmallSize = Engine.GetGUIObjectByName("chatDialogPanelSmall").size;
this.chatDialogPanelLargeSize = Engine.GetGUIObjectByName("chatDialogPanelLarge").size;
// Adjust the width so that the chat history is in the golden ratio
this.aspectRatio = (1 + Math.sqrt(5)) / 2;
this.initPage();
}
initPage()
{
this.closeChat.onPress = this.closePage.bind(this);
this.extendedChat.onPress = () => {
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "chat.session.extended", String(this.isExtended()), "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", "chat.session.extended", String(this.isExtended()));
this.resizeChatWindow();
this.chatInput.focus();
};
this.extendedChat.checked = Engine.ConfigDB_GetValue("user", "chat.session.extended") == "true";
this.chatDialogPanel.onWindowResized = this.resizeChatWindow.bind(this);
this.resizeChatWindow();
}
/**
* Called if the addressee or history filter selection changed.
*/
onSelectionChange()
{
if (this.isOpen())
this.chatInput.focus();
}
isOpen()
{
return !this.chatDialogPanel.hidden;
}
isExtended()
{
return this.extendedChat.checked;
}
openPage(command)
{
this.chatInput.focus();
this.chatDialogPanel.hidden = false;
}
closePage()
{
this.chatInput.caption = "";
this.chatInput.blur();
this.chatDialogPanel.hidden = true;
}
resizeChatWindow()
{
// Hide/show the panel
this.chatHistoryPage.hidden = !this.isExtended();
// Resize the window
if (this.isExtended())
{
this.chatDialogPanel.size = this.chatDialogPanelLargeSize;
let chatHistoryTextSize = this.chatHistoryText.getComputedSize();
let width = this.aspectRatio * (chatHistoryTextSize.bottom - chatHistoryTextSize.top);
let size = this.chatDialogPanel.size;
size.left = -width / 2 - this.chatHistoryText.size.left;
size.right = width / 2 + this.chatHistoryText.size.left;
this.chatDialogPanel.size = size;
}
else
this.chatDialogPanel.size = this.chatDialogPanelSmallSize;
}
}
Index: ps/trunk/binaries/data/mods/public/gui/session/session.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/session.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/session/session.js (revision 27192)
@@ -1,881 +1,881 @@
const g_IsReplay = Engine.IsVisualReplay();
const g_CivData = loadCivData(false, true);
const g_MapSizes = prepareForDropdown(g_Settings && g_Settings.MapSizes);
const g_MapTypes = prepareForDropdown(g_Settings && g_Settings.MapTypes);
const g_PopulationCapacities = prepareForDropdown(g_Settings && g_Settings.PopulationCapacities);
const g_WorldPopulationCapacities = prepareForDropdown(g_Settings && g_Settings.WorldPopulationCapacities);
const g_StartingResources = prepareForDropdown(g_Settings && g_Settings.StartingResources);
const g_VictoryConditions = g_Settings && g_Settings.VictoryConditions;
var g_Ambient;
var g_AutoFormation;
var g_Chat;
var g_Cheats;
var g_DeveloperOverlay;
var g_DiplomacyColors;
var g_DiplomacyDialog;
var g_GameSpeedControl;
var g_Menu;
var g_MiniMapPanel;
var g_NetworkStatusOverlay;
var g_NetworkDelayOverlay;
var g_ObjectivesDialog;
var g_OutOfSyncNetwork;
var g_OutOfSyncReplay;
var g_PanelEntityManager;
var g_PauseControl;
var g_PauseOverlay;
var g_PlayerViewControl;
var g_QuitConfirmationDefeat;
var g_QuitConfirmationReplay;
var g_RangeOverlayManager;
var g_ResearchProgress;
var g_TimeNotificationOverlay;
var g_TopPanel;
var g_TradeDialog;
/**
* Map, player and match settings set in game setup.
*/
const g_InitAttributes = deepfreeze(Engine.GuiInterfaceCall("GetInitAttributes"));
/**
* True if this is a multiplayer game.
*/
const g_IsNetworked = Engine.HasNetClient();
/**
* Is this user in control of game settings (i.e. is a network server, or offline player).
*/
var g_IsController = !g_IsNetworked || Engine.IsNetController();
/**
* Whether we have finished the synchronization and
* can start showing simulation related message boxes.
*/
var g_IsNetworkedActive = false;
/**
* True if the connection to the server has been lost.
*/
var g_Disconnected = false;
/**
* True if the current user has observer capabilities.
*/
var g_IsObserver = false;
/**
* True if the current user has rejoined (or joined the game after it started).
*/
var g_HasRejoined = false;
/**
* The playerID selected in the change perspective tool.
*/
var g_ViewedPlayer = Engine.GetPlayerID();
/**
* True if the camera should focus on attacks and player commands
* and select the affected units.
*/
var g_FollowPlayer = false;
/**
* Cache the basic player data (name, civ, color).
*/
var g_Players = [];
/**
* Last time when onTick was called().
* Used for animating the main menu.
*/
var g_LastTickTime = Date.now();
/**
* Recalculate which units have their status bars shown with this frequency in milliseconds.
*/
var g_StatusBarUpdate = 200;
/**
* For restoring selection, order and filters when returning to the replay menu
*/
var g_ReplaySelectionData;
/**
* Remembers which clients are assigned to which player slots.
* The keys are GUIDs or "local" in single-player.
*/
var g_PlayerAssignments;
/**
* Whether the entire UI should be hidden (useful for promotional screenshots).
* Can be toggled with a hotkey.
*/
var g_ShowGUI = true;
/**
* Whether status bars should be shown for all of the player's units.
*/
var g_ShowAllStatusBars = false;
/**
* Cache of simulation state and template data (apart from TechnologyData, updated on every simulation update).
*/
var g_SimState;
var g_EntityStates = {};
var g_TemplateData = {};
var g_TechnologyData = {};
var g_ResourceData = new Resources();
/**
* These handlers are called each time a new turn was simulated.
* Use this as sparely as possible.
*/
var g_SimulationUpdateHandlers = new Set();
/**
* These handlers are called after the player states have been initialized.
*/
var g_PlayersInitHandlers = new Set();
/**
* These handlers are called when a player has been defeated or won the game.
*/
var g_PlayerFinishedHandlers = new Set();
/**
* These events are fired whenever the player added or removed entities from the selection.
*/
var g_EntitySelectionChangeHandlers = new Set();
/**
* These events are fired when the user has performed a hotkey assignment change.
* Currently only fired on init, but to be fired from any hotkey editor dialog.
*/
var g_HotkeyChangeHandlers = new Set();
/**
* List of additional entities to highlight.
*/
var g_ShowGuarding = false;
var g_ShowGuarded = false;
var g_AdditionalHighlight = [];
/**
* Order in which the panel entities are shown.
*/
var g_PanelEntityOrder = ["Hero", "Relic"];
/**
* Unit classes to be checked for the idle-worker-hotkey.
*/
var g_WorkerTypes = ["FemaleCitizen", "Trader", "FishingBoat", "Citizen"];
/**
* Unit classes to be checked for the military-only-selection modifier and for the idle-warrior-hotkey.
*/
var g_MilitaryTypes = ["Melee", "Ranged"];
function GetSimState()
{
if (!g_SimState)
g_SimState = deepfreeze(Engine.GuiInterfaceCall("GetSimulationState"));
return g_SimState;
}
function GetMultipleEntityStates(ents)
{
if (!ents.length)
return null;
let entityStates = Engine.GuiInterfaceCall("GetMultipleEntityStates", ents);
for (let item of entityStates)
g_EntityStates[item.entId] = item.state && deepfreeze(item.state);
return entityStates;
}
function GetEntityState(entId)
{
if (!g_EntityStates[entId])
{
let entityState = Engine.GuiInterfaceCall("GetEntityState", entId);
g_EntityStates[entId] = entityState && deepfreeze(entityState);
}
return g_EntityStates[entId];
}
/**
* Returns template data calling GetTemplateData defined in GuiInterface.js
* and deepfreezing returned object.
* @param {string} templateName - Data of this template will be returned.
* @param {number|undefined} player - Modifications of this player will be applied to the template.
* If undefined, id of player calling this method will be used.
*/
function GetTemplateData(templateName, player)
{
if (!(templateName in g_TemplateData))
{
let template = Engine.GuiInterfaceCall("GetTemplateData", { "templateName": templateName, "player": player });
translateObjectKeys(template, ["specific", "generic", "tooltip"]);
g_TemplateData[templateName] = deepfreeze(template);
}
return g_TemplateData[templateName];
}
function GetTechnologyData(technologyName, civ)
{
if (!g_TechnologyData[civ])
g_TechnologyData[civ] = {};
if (!(technologyName in g_TechnologyData[civ]))
{
const tech = TechnologyTemplates.Get(technologyName);
if (!tech)
return;
let template = GetTechnologyDataHelper(tech, civ, g_ResourceData);
translateObjectKeys(template, ["specific", "generic", "description", "tooltip", "requirementsTooltip"]);
g_TechnologyData[civ][technologyName] = deepfreeze(template);
}
return g_TechnologyData[civ][technologyName];
}
function init(initData, hotloadData)
{
if (!g_Settings)
{
Engine.EndGame();
Engine.SwitchGuiPage("page_pregame.xml");
return;
}
// Fallback used by atlas
g_PlayerAssignments = initData ? initData.playerAssignments : { "local": { "player": 1 } };
// Fallback used by atlas and autostart games
if (g_PlayerAssignments.local && !g_PlayerAssignments.local.name)
g_PlayerAssignments.local.name = singleplayerName();
if (initData)
{
g_ReplaySelectionData = initData.replaySelectionData;
g_HasRejoined = initData.isRejoining;
if (initData.savedGUIData)
restoreSavedGameData(initData.savedGUIData);
}
if (g_InitAttributes.campaignData)
g_CampaignSession = new CampaignSession(g_InitAttributes.campaignData);
let mapCache = new MapCache();
g_Cheats = new Cheats();
g_DiplomacyColors = new DiplomacyColors();
g_PlayerViewControl = new PlayerViewControl();
g_PlayerViewControl.registerViewedPlayerChangeHandler(g_DiplomacyColors.updateDisplayedPlayerColors.bind(g_DiplomacyColors));
g_DiplomacyColors.registerDiplomacyColorsChangeHandler(g_PlayerViewControl.rebuild.bind(g_PlayerViewControl));
g_DiplomacyColors.registerDiplomacyColorsChangeHandler(updateGUIObjects);
g_PauseControl = new PauseControl();
g_PlayerViewControl.registerPreViewedPlayerChangeHandler(removeStatusBarDisplay);
g_PlayerViewControl.registerViewedPlayerChangeHandler(resetTemplates);
g_Ambient = new Ambient();
g_AutoFormation = new AutoFormation();
g_Chat = new Chat(g_PlayerViewControl, g_Cheats);
g_DeveloperOverlay = new DeveloperOverlay(g_PlayerViewControl, g_Selection);
g_DiplomacyDialog = new DiplomacyDialog(g_PlayerViewControl, g_DiplomacyColors);
g_GameSpeedControl = new GameSpeedControl(g_PlayerViewControl);
g_Menu = new Menu(g_PauseControl, g_PlayerViewControl, g_Chat);
g_MiniMapPanel = new MiniMapPanel(g_PlayerViewControl, g_DiplomacyColors, g_WorkerTypes);
g_NetworkStatusOverlay = new NetworkStatusOverlay();
g_NetworkDelayOverlay = new NetworkDelayOverlay();
g_ObjectivesDialog = new ObjectivesDialog(g_PlayerViewControl, mapCache);
g_OutOfSyncNetwork = new OutOfSyncNetwork();
g_OutOfSyncReplay = new OutOfSyncReplay();
g_PanelEntityManager = new PanelEntityManager(g_PlayerViewControl, g_Selection, g_PanelEntityOrder);
g_PauseOverlay = new PauseOverlay(g_PauseControl);
g_QuitConfirmationDefeat = new QuitConfirmationDefeat();
g_QuitConfirmationReplay = new QuitConfirmationReplay();
g_RangeOverlayManager = new RangeOverlayManager(g_Selection);
g_ResearchProgress = new ResearchProgress(g_PlayerViewControl, g_Selection);
g_TradeDialog = new TradeDialog(g_PlayerViewControl);
g_TopPanel = new TopPanel(g_PlayerViewControl, g_DiplomacyDialog, g_TradeDialog, g_ObjectivesDialog, g_GameSpeedControl);
g_TimeNotificationOverlay = new TimeNotificationOverlay(g_PlayerViewControl);
initBatchTrain();
initDisplayedNames();
initSelectionPanels();
LoadModificationTemplates();
updatePlayerData();
initializeMusic(); // before changing the perspective
Engine.SetBoundingBoxDebugOverlay(false);
for (let handler of g_PlayersInitHandlers)
handler();
for (let handler of g_HotkeyChangeHandlers)
handler();
if (hotloadData)
{
g_Selection.selected = hotloadData.selection;
g_PlayerAssignments = hotloadData.playerAssignments;
g_Players = hotloadData.player;
}
// TODO: use event instead
onSimulationUpdate();
setTimeout(displayGamestateNotifications, 1000);
}
function registerPlayersInitHandler(handler)
{
g_PlayersInitHandlers.add(handler);
}
function registerPlayersFinishedHandler(handler)
{
g_PlayerFinishedHandlers.add(handler);
}
function registerSimulationUpdateHandler(handler)
{
g_SimulationUpdateHandlers.add(handler);
}
function unregisterSimulationUpdateHandler(handler)
{
g_SimulationUpdateHandlers.delete(handler);
}
function registerEntitySelectionChangeHandler(handler)
{
g_EntitySelectionChangeHandlers.add(handler);
}
function unregisterEntitySelectionChangeHandler(handler)
{
g_EntitySelectionChangeHandlers.delete(handler);
}
function registerHotkeyChangeHandler(handler)
{
g_HotkeyChangeHandlers.add(handler);
}
function updatePlayerData()
{
let simState = GetSimState();
if (!simState)
return;
let playerData = [];
for (let i = 0; i < simState.players.length; ++i)
{
let playerState = simState.players[i];
playerData.push({
"name": playerState.name,
"civ": playerState.civ,
"color": {
"r": playerState.color.r * 255,
"g": playerState.color.g * 255,
"b": playerState.color.b * 255,
"a": playerState.color.a * 255
},
"team": playerState.team,
"teamsLocked": playerState.teamsLocked,
"cheatsEnabled": playerState.cheatsEnabled,
"state": playerState.state,
"isAlly": playerState.isAlly,
"isMutualAlly": playerState.isMutualAlly,
"isNeutral": playerState.isNeutral,
"isEnemy": playerState.isEnemy,
"guid": undefined, // network guid for players controlled by hosts
"offline": g_Players[i] && !!g_Players[i].offline
});
}
for (let guid in g_PlayerAssignments)
{
let playerID = g_PlayerAssignments[guid].player;
if (!playerData[playerID])
continue;
playerData[playerID].guid = guid;
playerData[playerID].name = g_PlayerAssignments[guid].name;
}
g_Players = playerData;
}
/**
* @param {number} ent - The entity to get its ID for.
* @return {number} - The entity ID of the entity or of its garrisonHolder.
*/
function getEntityOrHolder(ent)
{
let entState = GetEntityState(ent);
if (entState && !entState.position && entState.garrisonable && entState.garrisonable.holder != INVALID_ENTITY)
return getEntityOrHolder(entState.garrisonable.holder);
return ent;
}
function initializeMusic()
{
initMusic();
if (g_ViewedPlayer != -1 && g_CivData[g_Players[g_ViewedPlayer].civ].Music)
global.music.storeTracks(g_CivData[g_Players[g_ViewedPlayer].civ].Music);
global.music.setState(global.music.states.PEACE);
}
function resetTemplates()
{
// Update GUI and clear player-dependent cache
g_TemplateData = {};
Engine.GuiInterfaceCall("ResetTemplateModified");
// TODO: do this more selectively
onSimulationUpdate();
}
/**
* Returns true if the player with that ID is in observermode.
*/
function isPlayerObserver(playerID)
{
let playerStates = GetSimState().players;
return !playerStates[playerID] || playerStates[playerID].state != "active";
}
/**
* Returns true if the current user can issue commands for that player.
*/
function controlsPlayer(playerID)
{
let playerStates = GetSimState().players;
return !!playerStates[Engine.GetPlayerID()] &&
playerStates[Engine.GetPlayerID()].controlsAll ||
Engine.GetPlayerID() == playerID &&
!!playerStates[playerID] &&
playerStates[playerID].state != "defeated";
}
/**
* Called when one or more players have won or were defeated.
*
* @param {array} - IDs of the players who have won or were defeated.
* @param {Object} - a plural string stating the victory reason.
* @param {boolean} - whether these players have won or lost.
*/
function playersFinished(players, victoryString, won)
{
addChatMessage({
"type": "playerstate",
"message": victoryString,
"players": players
});
updatePlayerData();
// TODO: The other calls in this function should move too
for (let handler of g_PlayerFinishedHandlers)
handler(players, won);
if (players.indexOf(Engine.GetPlayerID()) == -1 || Engine.IsAtlasRunning())
return;
global.music.setState(
won ?
global.music.states.VICTORY :
global.music.states.DEFEAT
);
}
function resumeGame()
{
g_PauseControl.implicitResume();
}
function closeOpenDialogs()
{
g_Menu.close();
g_Chat.closePage();
g_DiplomacyDialog.close();
g_ObjectivesDialog.close();
g_TradeDialog.close();
}
function endGame(showSummary)
{
// Before ending the game
let replayDirectory = Engine.GetCurrentReplayDirectory();
let simData = Engine.GuiInterfaceCall("GetReplayMetadata");
let playerID = Engine.GetPlayerID();
Engine.EndGame();
// After the replay file was closed in EndGame
// Done here to keep EndGame small
if (!g_IsReplay)
Engine.AddReplayToCache(replayDirectory);
if (g_IsController && Engine.HasXmppClient())
Engine.SendUnregisterGame();
let summaryData = {
"sim": simData,
"gui": {
"dialog": false,
"assignedPlayer": playerID,
"disconnected": g_Disconnected,
"isReplay": g_IsReplay,
"replayDirectory": !g_HasRejoined && replayDirectory,
"replaySelectionData": g_ReplaySelectionData
}
};
if (g_InitAttributes.campaignData)
{
let menu = g_CampaignSession.getMenu();
if (g_InitAttributes.campaignData.skipSummary)
{
Engine.SwitchGuiPage(menu);
return;
}
summaryData.campaignData = { "filename": g_InitAttributes.campaignData.run };
summaryData.nextPage = menu;
}
if (showSummary)
Engine.SwitchGuiPage("page_summary.xml", summaryData);
else if (g_InitAttributes.campaignData)
Engine.SwitchGuiPage(summaryData.nextPage, summaryData.campaignData);
else if (Engine.HasXmppClient())
Engine.SwitchGuiPage("page_lobby.xml", { "dialog": false });
else if (g_IsReplay)
Engine.SwitchGuiPage("page_replaymenu.xml");
else
Engine.SwitchGuiPage("page_pregame.xml");
}
// Return some data that we'll use when hotloading this file after changes
function getHotloadData()
{
return {
"selection": g_Selection.selected,
"playerAssignments": g_PlayerAssignments,
"player": g_Players,
};
}
function getSavedGameData()
{
return {
"groups": g_Groups.groups
};
}
function restoreSavedGameData(data)
{
// Restore camera if any
if (data.camera)
Engine.SetCameraData(data.camera.PosX, data.camera.PosY, data.camera.PosZ,
data.camera.RotX, data.camera.RotY, data.camera.Zoom);
// Clear selection when loading a game
g_Selection.reset();
// Restore control groups
for (let groupNumber in data.groups)
{
g_Groups.groups[groupNumber].groups = data.groups[groupNumber].groups;
g_Groups.groups[groupNumber].ents = data.groups[groupNumber].ents;
}
updateGroups();
}
/**
* Called every frame.
*/
function onTick()
{
if (!g_Settings)
return;
let now = Date.now();
let tickLength = now - g_LastTickTime;
g_LastTickTime = now;
handleNetMessages();
updateCursorAndTooltip();
if (g_Selection.dirty)
{
g_Selection.dirty = false;
// When selection changed, get the entityStates of new entities
GetMultipleEntityStates(g_Selection.filter(entId => !g_EntityStates[entId]));
for (let handler of g_EntitySelectionChangeHandlers)
handler();
updateGUIObjects();
// Display rally points for selected structures.
if (Engine.GetPlayerID() != -1)
Engine.GuiInterfaceCall("DisplayRallyPoint", { "entities": g_Selection.toList() });
}
else if (g_ShowAllStatusBars && now % g_StatusBarUpdate <= tickLength)
recalculateStatusBarDisplay();
updateTimers();
Engine.GuiInterfaceCall("ClearRenamedEntities");
let isPlayingCinemaPath = GetSimState().cinemaPlaying && !g_Disconnected;
if (isPlayingCinemaPath)
updateCinemaOverlay();
}
function onSimulationUpdate()
{
// Templates change depending on technologies and auras, so they have to be reloaded after such a change.
// g_TechnologyData data never changes, so it shouldn't be deleted.
g_EntityStates = {};
if (Engine.GuiInterfaceCall("IsTemplateModified"))
{
g_TemplateData = {};
Engine.GuiInterfaceCall("ResetTemplateModified");
}
g_SimState = undefined;
// Some changes may require re-rendering the selection.
if (Engine.GuiInterfaceCall("IsSelectionDirty"))
{
g_Selection.onChange();
Engine.GuiInterfaceCall("ResetSelectionDirty");
}
if (!GetSimState())
return;
GetMultipleEntityStates(g_Selection.toList());
for (let handler of g_SimulationUpdateHandlers)
handler();
// TODO: Move to handlers
updateCinemaPath();
handleNotifications();
updateGUIObjects();
}
function toggleGUI()
{
g_ShowGUI = !g_ShowGUI;
updateCinemaPath();
}
function updateCinemaPath()
{
let isPlayingCinemaPath = GetSimState().cinemaPlaying && !g_Disconnected;
Engine.GetGUIObjectByName("session").hidden = !g_ShowGUI || isPlayingCinemaPath;
Engine.GetGUIObjectByName("cinemaOverlay").hidden = !isPlayingCinemaPath;
Engine.ConfigDB_CreateValue("user", "silhouettes", !isPlayingCinemaPath && Engine.ConfigDB_GetValue("user", "silhouettes") == "true" ? "true" : "false");
}
function updateCinemaOverlay()
{
let cinemaOverlay = Engine.GetGUIObjectByName("cinemaOverlay");
let width = cinemaOverlay.getComputedSize().right;
let height = cinemaOverlay.getComputedSize().bottom;
let barHeight = (height - width / 2.39) / 2;
if (barHeight < 0)
barHeight = 0;
let cinemaBarTop = Engine.GetGUIObjectByName("cinemaBarTop");
let cinemaBarTopSize = cinemaBarTop.size;
cinemaBarTopSize.bottom = barHeight;
cinemaBarTop.size = cinemaBarTopSize;
let cinemaBarBottom = Engine.GetGUIObjectByName("cinemaBarBottom");
let cinemaBarBottomSize = cinemaBarBottom.size;
cinemaBarBottomSize.top = -barHeight;
cinemaBarBottom.size = cinemaBarBottomSize;
}
// TODO: Use event subscription onSimulationUpdate, onEntitySelectionChange, onPlayerViewChange, ... instead
function updateGUIObjects()
{
g_Selection.update();
if (g_ShowAllStatusBars)
recalculateStatusBarDisplay();
if (g_ShowGuarding || g_ShowGuarded)
updateAdditionalHighlight();
updateGroups();
updateSelectionDetails();
updateBuildingPlacementPreview();
if (!g_IsObserver)
{
// Update music state on basis of battle state.
let battleState = Engine.GuiInterfaceCall("GetBattleState", g_ViewedPlayer);
if (battleState)
global.music.setState(global.music.states[battleState]);
}
}
function updateGroups()
{
g_Groups.update();
// Determine the sum of the costs of a given template
let getCostSum = (ent) => {
let cost = GetTemplateData(GetEntityState(ent).template).cost;
return cost ? Object.keys(cost).map(key => cost[key]).reduce((sum, cur) => sum + cur) : 0;
};
for (let i in Engine.GetGUIObjectByName("unitGroupPanel").children)
{
Engine.GetGUIObjectByName("unitGroupLabel[" + i + "]").caption = +i + 1;
let button = Engine.GetGUIObjectByName("unitGroupButton[" + i + "]");
button.hidden = g_Groups.groups[i].getTotalCount() == 0;
button.onPress = (function(i) { return function() { performGroup((Engine.HotkeyIsPressed("selection.add") ? "add" : "select"), i); }; })(i);
button.onDoublePress = (function(i) { return function() { performGroup("snap", i); }; })(i);
button.onPressRight = (function(i) { return function() { performGroup("breakUp", i); }; })(i);
// Choose the icon of the most common template (or the most costly if it's not unique)
if (g_Groups.groups[i].getTotalCount() > 0)
{
let icon = GetTemplateData(GetEntityState(g_Groups.groups[i].getEntsGrouped().reduce((pre, cur) => {
if (pre.ents.length == cur.ents.length)
return getCostSum(pre.ents[0]) > getCostSum(cur.ents[0]) ? pre : cur;
return pre.ents.length > cur.ents.length ? pre : cur;
}).ents[0]).template).icon;
Engine.GetGUIObjectByName("unitGroupIcon[" + i + "]").sprite =
icon ? ("stretched:session/portraits/" + icon) : "groupsIcon";
}
setPanelObjectPosition(button, i, 1);
}
}
/**
* Toggles the display of status bars for all of the player's entities.
*
* @param {boolean} remove - Whether to hide all previously shown status bars.
*/
function recalculateStatusBarDisplay(remove = false)
{
let entities;
if (g_ShowAllStatusBars && !remove)
entities = g_ViewedPlayer == -1 ?
Engine.PickNonGaiaEntitiesOnScreen() :
Engine.PickPlayerEntitiesOnScreen(g_ViewedPlayer);
else
{
let selected = g_Selection.toList();
for (const ent of g_Selection.highlighted)
selected.push(ent);
// Remove selected entities from the 'all entities' array,
// to avoid disabling their status bars.
entities = Engine.GuiInterfaceCall(
g_ViewedPlayer == -1 ? "GetNonGaiaEntities" : "GetPlayerEntities", {
"viewedPlayer": g_ViewedPlayer
}).filter(idx => selected.indexOf(idx) == -1);
}
Engine.GuiInterfaceCall("SetStatusBars", {
"entities": entities,
"enabled": g_ShowAllStatusBars && !remove,
"showRank": Engine.ConfigDB_GetValue("user", "gui.session.rankabovestatusbar") == "true",
"showExperience": Engine.ConfigDB_GetValue("user", "gui.session.experiencestatusbar") == "true"
});
}
function removeStatusBarDisplay()
{
if (g_ShowAllStatusBars)
recalculateStatusBarDisplay(true);
}
/**
* Updates the primary/secondary names in the simulation and GUI.
*/
function updateDisplayedNames()
{
g_SpecificNamesPrimary = Engine.ConfigDB_GetValue("user", "gui.session.howtoshownames") == 0 || Engine.ConfigDB_GetValue("user", "gui.session.howtoshownames") == 2;
g_ShowSecondaryNames = Engine.ConfigDB_GetValue("user", "gui.session.howtoshownames") == 0 || Engine.ConfigDB_GetValue("user", "gui.session.howtoshownames") == 1;
}
/**
* Inverts the given configuration boolean and returns the current state.
* For example "silhouettes".
*/
function toggleConfigBool(configName)
{
let enabled = Engine.ConfigDB_GetValue("user", configName) != "true";
- Engine.ConfigDB_CreateAndWriteValueToFile("user", configName, String(enabled), "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", configName, String(enabled));
return enabled;
}
// Update the additional list of entities to be highlighted.
function updateAdditionalHighlight()
{
let entsAdd = []; // list of entities units to be highlighted
let entsRemove = [];
let highlighted = g_Selection.toList();
for (const ent of g_Selection.highlighted)
highlighted.push(ent);
if (g_ShowGuarding)
// flag the guarding entities to add in this additional highlight
for (const sel of g_Selection.toList())
{
const state = GetEntityState(sel);
if (!state.guard || !state.guard.entities.length)
continue;
for (let ent of state.guard.entities)
if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1)
entsAdd.push(ent);
}
if (g_ShowGuarded)
// flag the guarded entities to add in this additional highlight
for (const sel of g_Selection.toList())
{
const state = GetEntityState(sel);
if (!state.unitAI || !state.unitAI.isGuarding)
continue;
let ent = state.unitAI.isGuarding;
if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1)
entsAdd.push(ent);
}
// flag the entities to remove (from the previously added) from this additional highlight
for (let ent of g_AdditionalHighlight)
if (highlighted.indexOf(ent) == -1 && entsAdd.indexOf(ent) == -1 && entsRemove.indexOf(ent) == -1)
entsRemove.push(ent);
_setHighlight(entsAdd, g_HighlightedAlpha, true);
_setHighlight(entsRemove, 0, false);
g_AdditionalHighlight = entsAdd;
}
Index: ps/trunk/binaries/data/mods/public/gui/session/top_panel/CounterManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/top_panel/CounterManager.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/session/top_panel/CounterManager.js (revision 27192)
@@ -1,133 +1,132 @@
/**
* This class manages the counters in the top panel.
* For allies who researched team vision and observers,
* it displays the resources in a tooltip in a player chosen order.
*/
class CounterManager
{
constructor(playerViewControl)
{
this.allyPlayerStates = {};
this.counters = [];
this.resourceCounts = Engine.GetGUIObjectByName("resourceCounts");
// TODO: filter resources depending on JSON file
for (let resCode of g_ResourceData.GetCodes())
this.addCounter(resCode, CounterResource);
this.addCounter("population", CounterPopulation);
this.init();
registerSimulationUpdateHandler(this.rebuild.bind(this));
playerViewControl.registerViewedPlayerChangeHandler(this.rebuild.bind(this));
}
addCounter(resCode, type)
{
let panelCount = this.resourceCounts.children.length;
if (this.counters.length + 1 > panelCount)
throw "There are " + (this.counters.length + 1) + " resource counters to display, but only " + panelCount + " panel items!";
let id = "[" + this.counters.length + "]";
this.counters.push(
new type(
resCode,
Engine.GetGUIObjectByName("resource" + id),
Engine.GetGUIObjectByName("resource" + id + "_icon"),
Engine.GetGUIObjectByName("resource" + id + "_count"),
Engine.GetGUIObjectByName("resource" + id + "_stats")));
}
init()
{
horizontallySpaceObjects("resourceCounts", this.counters.length);
hideRemaining("resourceCounts", this.counters.length);
for (let counter of this.counters)
{
counter.icon.sprite = "stretched:session/icons/resources/" + counter.resCode + ".png";
counter.panel.onPress = this.onPress.bind(this);
}
}
onPress()
{
- Engine.ConfigDB_CreateAndWriteValueToFile(
+ Engine.ConfigDB_CreateAndSaveValue(
"user",
"gui.session.respoptooltipsort",
- String((+Engine.ConfigDB_GetValue("user", "gui.session.respoptooltipsort") + 2) % 3 - 1),
- "config/user.cfg");
+ String((+Engine.ConfigDB_GetValue("user", "gui.session.respoptooltipsort") + 2) % 3 - 1));
this.rebuild();
}
rebuild()
{
let hidden = g_ViewedPlayer <= 0;
this.resourceCounts.hidden = hidden;
if (hidden)
return;
let viewedPlayerState = g_SimState.players[g_ViewedPlayer];
this.allyPlayerStates = {};
for (let player in g_SimState.players)
if (player != 0 &&
player != g_ViewedPlayer &&
g_Players[player].state != "defeated" &&
(g_IsObserver ||
viewedPlayerState.hasSharedLos &&
g_Players[player].isMutualAlly[g_ViewedPlayer]))
this.allyPlayerStates[player] = g_SimState.players[player];
this.selectedOrder = +Engine.ConfigDB_GetValue("user", "gui.session.respoptooltipsort");
this.orderTooltip = this.getOrderTooltip();
for (let counter of this.counters)
{
let hidden = g_ViewedPlayer <= 0;
counter.panel.hidden = hidden;
if (!hidden)
counter.rebuild(viewedPlayerState, this.getAllyStatTooltip.bind(this));
}
}
getOrderTooltip()
{
if (!Object.keys(this.allyPlayerStates).length)
return "";
return "\n" + sprintf(translate("%(order)s: %(hotkey)s to change order."), {
"hotkey": setStringTags("\\[Click]", g_HotkeyTags),
"order":
this.selectedOrder == 0 ?
translate("Unordered") :
this.selectedOrder == 1 ?
translate("Descending") :
translate("Ascending")
})
}
getAllyStatTooltip(getTooltipData)
{
let tooltipData = [];
for (let playerID in this.allyPlayerStates)
{
let playername = colorizePlayernameHelper("■", playerID) + " " + g_Players[playerID].name;
tooltipData.push(getTooltipData(this.allyPlayerStates[playerID], playername));
}
if (this.selectedOrder)
tooltipData.sort((a, b) => this.selectedOrder * (b.orderValue - a.orderValue));
return this.orderTooltip +
tooltipData.reduce((result, data) =>
result + "\n" + sprintf(translate(this.AllyStatTooltip), data), "");
}
}
CounterManager.ResourceTitleTags = { "font": "sans-bold-16" };
CounterManager.prototype.AllyStatTooltip = markForTranslation("%(playername)s: %(statValue)s");
Index: ps/trunk/binaries/data/mods/public/gui/splashscreen/splashscreen.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/splashscreen/splashscreen.js (revision 27191)
+++ ps/trunk/binaries/data/mods/public/gui/splashscreen/splashscreen.js (revision 27192)
@@ -1,14 +1,14 @@
var g_SplashScreenFile = "gui/splashscreen/splashscreen.txt";
function init(data)
{
Engine.GetGUIObjectByName("mainText").caption = Engine.TranslateLines(Engine.ReadFile(g_SplashScreenFile));
Engine.GetGUIObjectByName("displaySplashScreen").checked = Engine.ConfigDB_GetValue("user", "gui.splashscreen.enable") === "true";
}
function closePage()
{
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "gui.splashscreen.enable", String(Engine.GetGUIObjectByName("displaySplashScreen").checked), "config/user.cfg");
- Engine.ConfigDB_CreateAndWriteValueToFile("user", "gui.splashscreen.version", Engine.GetFileMTime(g_SplashScreenFile), "config/user.cfg");
+ Engine.ConfigDB_CreateAndSaveValue("user", "gui.splashscreen.enable", String(Engine.GetGUIObjectByName("displaySplashScreen").checked));
+ Engine.ConfigDB_CreateAndSaveValue("user", "gui.splashscreen.version", Engine.GetFileMTime(g_SplashScreenFile));
Engine.PopGuiPage();
}
Index: ps/trunk/source/ps/ConfigDB.cpp
===================================================================
--- ps/trunk/source/ps/ConfigDB.cpp (revision 27191)
+++ ps/trunk/source/ps/ConfigDB.cpp (revision 27192)
@@ -1,538 +1,539 @@
-/* Copyright (C) 2021 Wildfire Games.
+/* Copyright (C) 2022 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 .
*/
#include "precompiled.h"
#include "ConfigDB.h"
#include "lib/allocators/shared_ptr.h"
#include "lib/file/vfs/vfs_path.h"
#include "ps/CLogger.h"
#include "ps/CStr.h"
#include "ps/Filesystem.h"
#include
#include
#include
namespace
{
void TriggerAllHooks(const std::multimap>& hooks, const CStr& name)
{
std::for_each(hooks.lower_bound(name), hooks.upper_bound(name), [](const std::pair>& hook) { hook.second(); });
}
// These entries will not be printed to logfiles, so that logfiles can be shared without leaking personal or sensitive data
const std::unordered_set g_UnloggedEntries = {
"lobby.password",
"lobby.buddies",
"userreport.id" // authentication token for GDPR personal data requests
};
#define CHECK_NS(rval)\
do {\
if (ns < 0 || ns >= CFG_LAST)\
{\
debug_warn(L"CConfigDB: Invalid ns value");\
return rval;\
}\
} while (false)
template void Get(const CStr& value, T& ret)
{
std::stringstream ss(value);
ss >> ret;
}
template<> void Get<>(const CStr& value, bool& ret)
{
ret = value == "true";
}
template<> void Get<>(const CStr& value, std::string& ret)
{
ret = value;
}
std::string EscapeString(const CStr& str)
{
std::string ret;
for (size_t i = 0; i < str.length(); ++i)
{
if (str[i] == '\\')
ret += "\\\\";
else if (str[i] == '"')
ret += "\\\"";
else
ret += str[i];
}
return ret;
}
} // anonymous namespace
typedef std::map TConfigMap;
#define GETVAL(type)\
void CConfigDB::GetValue(EConfigNamespace ns, const CStr& name, type& value)\
{\
CHECK_NS(;);\
std::lock_guard s(m_Mutex);\
TConfigMap::iterator it = m_Map[CFG_COMMAND].find(name);\
if (it != m_Map[CFG_COMMAND].end())\
{\
if (!it->second.empty())\
Get(it->second[0], value);\
return;\
}\
for (int search_ns = ns; search_ns >= 0; --search_ns)\
{\
it = m_Map[search_ns].find(name);\
if (it != m_Map[search_ns].end())\
{\
if (!it->second.empty())\
Get(it->second[0], value);\
return;\
}\
}\
}
GETVAL(bool)
GETVAL(int)
GETVAL(u32)
GETVAL(float)
GETVAL(double)
GETVAL(std::string)
#undef GETVAL
std::unique_ptr g_ConfigDBPtr;
void CConfigDB::Initialise()
{
g_ConfigDBPtr = std::make_unique();
}
void CConfigDB::Shutdown()
{
g_ConfigDBPtr.reset();
}
bool CConfigDB::IsInitialised()
{
return !!g_ConfigDBPtr;
}
CConfigDB* CConfigDB::Instance()
{
return g_ConfigDBPtr.get();
}
CConfigDB::CConfigDB()
{
m_HasChanges.fill(false);
}
CConfigDB::~CConfigDB()
{
}
bool CConfigDB::HasChanges(EConfigNamespace ns) const
{
CHECK_NS(false);
std::lock_guard s(m_Mutex);
return m_HasChanges[ns];
}
void CConfigDB::SetChanges(EConfigNamespace ns, bool value)
{
CHECK_NS(;);
std::lock_guard s(m_Mutex);
m_HasChanges[ns] = value;
}
void CConfigDB::GetValues(EConfigNamespace ns, const CStr& name, CConfigValueSet& values) const
{
CHECK_NS(;);
std::lock_guard s(m_Mutex);
TConfigMap::const_iterator it = m_Map[CFG_COMMAND].find(name);
if (it != m_Map[CFG_COMMAND].end())
{
values = it->second;
return;
}
for (int search_ns = ns; search_ns >= 0; --search_ns)
{
it = m_Map[search_ns].find(name);
if (it != m_Map[search_ns].end())
{
values = it->second;
return;
}
}
}
EConfigNamespace CConfigDB::GetValueNamespace(EConfigNamespace ns, const CStr& name) const
{
CHECK_NS(CFG_LAST);
std::lock_guard s(m_Mutex);
TConfigMap::const_iterator it = m_Map[CFG_COMMAND].find(name);
if (it != m_Map[CFG_COMMAND].end())
return CFG_COMMAND;
for (int search_ns = ns; search_ns >= 0; --search_ns)
{
it = m_Map[search_ns].find(name);
if (it != m_Map[search_ns].end())
return (EConfigNamespace)search_ns;
}
return CFG_LAST;
}
std::map CConfigDB::GetValuesWithPrefix(EConfigNamespace ns, const CStr& prefix) const
{
std::lock_guard s(m_Mutex);
std::map ret;
CHECK_NS(ret);
// Loop upwards so that values in later namespaces can override
// values in earlier namespaces
for (int search_ns = 0; search_ns <= ns; ++search_ns)
for (const std::pair& p : m_Map[search_ns])
if (boost::algorithm::starts_with(p.first, prefix))
ret[p.first] = p.second;
for (const std::pair& p : m_Map[CFG_COMMAND])
if (boost::algorithm::starts_with(p.first, prefix))
ret[p.first] = p.second;
return ret;
}
void CConfigDB::SetValueString(EConfigNamespace ns, const CStr& name, const CStr& value)
{
CHECK_NS(;);
std::lock_guard s(m_Mutex);
TConfigMap::iterator it = m_Map[ns].find(name);
if (it == m_Map[ns].end())
it = m_Map[ns].insert(m_Map[ns].begin(), make_pair(name, CConfigValueSet(1)));
if (!it->second.empty())
it->second[0] = value;
else
it->second.emplace_back(value);
TriggerAllHooks(m_Hooks, name);
}
void CConfigDB::SetValueBool(EConfigNamespace ns, const CStr& name, const bool value)
{
CStr valueString = value ? "true" : "false";
SetValueString(ns, name, valueString);
}
void CConfigDB::SetValueList(EConfigNamespace ns, const CStr& name, std::vector values)
{
CHECK_NS(;);
std::lock_guard s(m_Mutex);
TConfigMap::iterator it = m_Map[ns].find(name);
if (it == m_Map[ns].end())
it = m_Map[ns].insert(m_Map[ns].begin(), make_pair(name, CConfigValueSet(1)));
it->second = values;
}
-void CConfigDB::RemoveValue(EConfigNamespace ns, const CStr& name)
+bool CConfigDB::RemoveValue(EConfigNamespace ns, const CStr& name)
{
- CHECK_NS(;);
+ CHECK_NS(false);
std::lock_guard s(m_Mutex);
TConfigMap::iterator it = m_Map[ns].find(name);
if (it == m_Map[ns].end())
- return;
+ return false;
m_Map[ns].erase(it);
TriggerAllHooks(m_Hooks, name);
+ return true;
}
void CConfigDB::SetConfigFile(EConfigNamespace ns, const VfsPath& path)
{
CHECK_NS(;);
std::lock_guard s(m_Mutex);
m_ConfigFile[ns] = path;
}
bool CConfigDB::Reload(EConfigNamespace ns)
{
CHECK_NS(false);
std::lock_guard s(m_Mutex);
std::shared_ptr buffer;
size_t buflen;
{
// Handle missing files quietly
if (g_VFS->GetFileInfo(m_ConfigFile[ns], NULL) < 0)
{
LOGMESSAGE("Cannot find config file \"%s\" - ignoring", m_ConfigFile[ns].string8());
return false;
}
LOGMESSAGE("Loading config file \"%s\"", m_ConfigFile[ns].string8());
Status ret = g_VFS->LoadFile(m_ConfigFile[ns], buffer, buflen);
if (ret != INFO::OK)
{
LOGERROR("CConfigDB::Reload(): vfs_load for \"%s\" failed: return was %lld", m_ConfigFile[ns].string8(), (long long)ret);
return false;
}
}
TConfigMap newMap;
char *filebuf = (char*)buffer.get();
char *filebufend = filebuf+buflen;
bool quoted = false;
CStr header;
CStr name;
CStr value;
int line = 1;
std::vector values;
for (char* pos = filebuf; pos < filebufend; ++pos)
{
switch (*pos)
{
case '\n':
case ';':
break; // We finished parsing this line
case ' ':
case '\r':
case '\t':
continue; // ignore
case '[':
header.clear();
for (++pos; pos < filebufend && *pos != '\n' && *pos != ']'; ++pos)
header.push_back(*pos);
if (pos == filebufend || *pos == '\n')
{
LOGERROR("Config header with missing close tag encountered on line %d in '%s'", line, m_ConfigFile[ns].string8());
header.clear();
++line;
continue;
}
LOGMESSAGE("Found config header '%s'", header.c_str());
header.push_back('.');
while (++pos < filebufend && *pos != '\n' && *pos != ';')
if (*pos != ' ' && *pos != '\r')
{
LOGERROR("Config settings on the same line as a header on line %d in '%s'", line, m_ConfigFile[ns].string8());
break;
}
while (pos < filebufend && *pos != '\n')
++pos;
++line;
continue;
case '=':
// Parse parameters (comma separated, possibly quoted)
for (++pos; pos < filebufend && *pos != '\n' && *pos != ';'; ++pos)
{
switch (*pos)
{
case '"':
quoted = true;
// parse until not quoted anymore
for (++pos; pos < filebufend && *pos != '\n' && *pos != '"'; ++pos)
{
if (*pos == '\\' && ++pos == filebufend)
{
LOGERROR("Escape character at end of input (line %d in '%s')", line, m_ConfigFile[ns].string8());
break;
}
value.push_back(*pos);
}
if (pos < filebufend && *pos == '"')
quoted = false;
else
--pos; // We should terminate the outer loop too
break;
case ' ':
case '\r':
case '\t':
break; // ignore
case ',':
if (!value.empty())
values.push_back(value);
value.clear();
break;
default:
value.push_back(*pos);
break;
}
}
if (quoted) // We ignore the invalid parameter
LOGERROR("Unmatched quote while parsing config file '%s' on line %d", m_ConfigFile[ns].string8(), line);
else if (!value.empty())
values.push_back(value);
value.clear();
quoted = false;
break; // We are either at the end of the line, or we still have a comment to parse
default:
name.push_back(*pos);
continue;
}
// Consume the rest of the line
while (pos < filebufend && *pos != '\n')
++pos;
// Store the setting
if (!name.empty())
{
CStr key(header + name);
newMap[key] = values;
if (g_UnloggedEntries.find(key) != g_UnloggedEntries.end())
LOGMESSAGE("Loaded config string \"%s\"", key);
else if (values.empty())
LOGMESSAGE("Loaded config string \"%s\" = (empty)", key);
else
{
std::string vals;
for (size_t i = 0; i + 1 < newMap[key].size(); ++i)
vals += "\"" + EscapeString(newMap[key][i]) + "\", ";
vals += "\"" + EscapeString(newMap[key][values.size()-1]) + "\"";
LOGMESSAGE("Loaded config string \"%s\" = %s", key, vals);
}
}
name.clear();
values.clear();
++line;
}
if (!name.empty())
LOGERROR("Config file does not have a new line after the last config setting '%s'", name);
m_Map[ns].swap(newMap);
m_HasChanges[ns] = false;
return true;
}
bool CConfigDB::WriteFile(EConfigNamespace ns) const
{
CHECK_NS(false);
std::lock_guard s(m_Mutex);
return WriteFile(ns, m_ConfigFile[ns]);
}
bool CConfigDB::WriteFile(EConfigNamespace ns, const VfsPath& path) const
{
CHECK_NS(false);
std::lock_guard s(m_Mutex);
std::shared_ptr buf;
AllocateAligned(buf, 1*MiB, maxSectorSize);
char* pos = (char*)buf.get();
for (const std::pair& p : m_Map[ns])
{
size_t i;
pos += sprintf(pos, "%s = ", p.first.c_str());
for (i = 0; i + 1 < p.second.size(); ++i)
pos += sprintf(pos, "\"%s\", ", EscapeString(p.second[i]).c_str());
if (!p.second.empty())
pos += sprintf(pos, "\"%s\"\n", EscapeString(p.second[i]).c_str());
else
pos += sprintf(pos, "\"\"\n");
}
const size_t len = pos - (char*)buf.get();
Status ret = g_VFS->CreateFile(path, buf, len);
if (ret < 0)
{
LOGERROR("CConfigDB::WriteFile(): CreateFile \"%s\" failed (error: %d)", path.string8(), (int)ret);
return false;
}
return true;
}
bool CConfigDB::WriteValueToFile(EConfigNamespace ns, const CStr& name, const CStr& value)
{
CHECK_NS(false);
std::lock_guard s(m_Mutex);
return WriteValueToFile(ns, name, value, m_ConfigFile[ns]);
}
bool CConfigDB::WriteValueToFile(EConfigNamespace ns, const CStr& name, const CStr& value, const VfsPath& path)
{
CHECK_NS(false);
std::lock_guard s(m_Mutex);
TConfigMap newMap;
m_Map[ns].swap(newMap);
Reload(ns);
SetValueString(ns, name, value);
bool ret = WriteFile(ns, path);
m_Map[ns].swap(newMap);
return ret;
}
CConfigDBHook CConfigDB::RegisterHookAndCall(const CStr& name, std::function hook)
{
hook();
std::lock_guard s(m_Mutex);
return CConfigDBHook(*this, m_Hooks.emplace(name, hook));
}
void CConfigDB::UnregisterHook(CConfigDBHook&& hook)
{
if (hook.m_Ptr != m_Hooks.end())
{
std::lock_guard s(m_Mutex);
m_Hooks.erase(hook.m_Ptr);
hook.m_Ptr = m_Hooks.end();
}
}
void CConfigDB::UnregisterHook(std::unique_ptr hook)
{
UnregisterHook(std::move(*hook.get()));
}
#undef CHECK_NS
Index: ps/trunk/source/ps/ConfigDB.h
===================================================================
--- ps/trunk/source/ps/ConfigDB.h (revision 27191)
+++ ps/trunk/source/ps/ConfigDB.h (revision 27192)
@@ -1,244 +1,244 @@
-/* Copyright (C) 2021 Wildfire Games.
+/* Copyright (C) 2022 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 .
*/
/*
CConfigDB - Load, access and store configuration variables
TDD : http://www.wildfiregames.com/forum/index.php?showtopic=1125
OVERVIEW:
JavaScript: Check this documentation: http://trac.wildfiregames.com/wiki/Exposed_ConfigDB_Functions
*/
#ifndef INCLUDED_CONFIGDB
#define INCLUDED_CONFIGDB
#include "lib/file/vfs/vfs_path.h"
#include "ps/CStr.h"
#include
#include