Index: ps/trunk/binaries/data/mods/public/gui/common/gamedescription.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/common/gamedescription.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/gui/common/gamedescription.js (revision 19631)
@@ -1,409 +1,421 @@
/**
* Highlights the victory condition in the game-description.
*/
var g_DescriptionHighlight = "orange";
/**
* The rating assigned to lobby players who didn't complete a ranked 1v1 yet.
*/
var g_DefaultLobbyRating = 1200;
/**
* XEP-0172 doesn't restrict nicknames, but our lobby policy does.
* So use this human readable delimiter to separate buddy names in the config file.
*/
var g_BuddyListDelimiter = ",";
/**
* Returns the nickname without the lobby rating.
*/
function splitRatingFromNick(playerName)
{
let result = /^(\S+)\ \((\d+)\)$/g.exec(playerName);
if (!result)
return [playerName, g_DefaultLobbyRating];
return [result[1], +result[2]];
}
/**
* Array of playernames that the current user has marked as buddies.
*/
var g_Buddies = Engine.ConfigDB_GetValue("user", "lobby.buddies").split(g_BuddyListDelimiter);
/**
* Denotes which players are a lobby buddy of the current user.
*/
var g_BuddySymbol = '•';
/**
* Returns map description and preview image or placeholder.
*/
function getMapDescriptionAndPreview(mapType, mapName)
{
let mapData;
if (mapType == "random" && mapName == "random")
mapData = { "settings": { "Description": translate("A randomly selected map.") } };
else if (mapType == "random" && Engine.FileExists(mapName + ".json"))
mapData = Engine.ReadJSONFile(mapName + ".json");
else if (Engine.FileExists(mapName + ".xml"))
mapData = Engine.LoadMapSettings(mapName + ".xml");
return {
"description": mapData && mapData.settings && mapData.settings.Description ? translate(mapData.settings.Description) : translate("Sorry, no description available."),
"preview": mapData && mapData.settings && mapData.settings.Preview ? mapData.settings.Preview : "nopreview.png"
};
}
/**
* Sets the mappreview image correctly.
* It needs to be cropped as the engine only allows loading square textures.
*
* @param {string} guiObject
* @param {string} filename
*/
function setMapPreviewImage(guiObject, filename)
{
Engine.GetGUIObjectByName(guiObject).sprite =
"cropped:" + 400/512 + "," + 300/512 + ":" +
"session/icons/mappreview/" + filename;
}
/**
* Returns a formatted string describing the player assignments.
* Needs g_CivData to translate!
*
* @param {object} playerDataArray - As known from gamesetup and simstate.
* @param {(string[]|false)} playerStates - One of "won", "defeated", "active" for each player.
* @returns {string}
*/
function formatPlayerInfo(playerDataArray, playerStates)
{
let playerDescriptions = {};
let playerIdx = 0;
for (let playerData of playerDataArray)
{
if (playerData == null || playerData.Civ && playerData.Civ == "gaia")
continue;
++playerIdx;
let teamIdx = playerData.Team;
let isAI = playerData.AI && playerData.AI != "";
let playerState = playerStates && playerStates[playerIdx] || playerData.State;
let isActive = !playerState || playerState == "active";
let playerDescription;
if (isAI)
{
if (playerData.Civ)
{
if (isActive)
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s (%(civ)s, %(AIdifficulty)s %(AIname)s)");
else
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s (%(civ)s, %(AIdifficulty)s %(AIname)s, %(state)s)");
}
else
{
if (isActive)
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s (%(AIdifficulty)s %(AIname)s)");
else
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s (%(AIdifficulty)s %(AIname)s, %(state)s)");
}
}
else
{
if (playerData.Offline)
{
// Can only occur in the lobby for now, so no strings with civ needed
if (isActive)
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s (OFFLINE)");
else
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s (OFFLINE, %(state)s)");
}
else
{
if (playerData.Civ)
if (isActive)
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s (%(civ)s)");
else
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s (%(civ)s, %(state)s)");
else
if (isActive)
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s");
else
// Translation: Describe a player in a selected game, f.e. in the replay- or savegame menu
playerDescription = translate("%(playerName)s (%(state)s)");
}
}
// Sort player descriptions by team
if (!playerDescriptions[teamIdx])
playerDescriptions[teamIdx] = [];
playerDescriptions[teamIdx].push(sprintf(playerDescription, {
"playerName":
'[color="' +
(typeof getPlayerColor == 'function' ?
(isAI ? "white" : getPlayerColor(playerData.Name)) :
rgbToGuiColor(playerData.Color || g_Settings.PlayerDefaults[playerIdx].Color)) +
'"]' +
(g_Buddies.indexOf(splitRatingFromNick(playerData.Name)[0]) != -1 ? g_BuddySymbol + " " : "") +
escapeText(playerData.Name) +
"[/color]",
"civ":
!playerData.Civ ?
translate("Unknown Civilization") :
g_CivData && g_CivData[playerData.Civ] && g_CivData[playerData.Civ].Name ?
translate(g_CivData[playerData.Civ].Name) :
playerData.Civ,
"state":
playerState == "defeated" ?
translateWithContext("playerstate", "defeated") :
translateWithContext("playerstate", "won"),
"AIname": isAI ? translateAIName(playerData.AI) : "",
"AIdifficulty": isAI ? translateAIDifficulty(playerData.AIDiff) : ""
}));
}
let teams = Object.keys(playerDescriptions);
if (teams.indexOf("observer") > -1)
teams.splice(teams.indexOf("observer"), 1);
let teamDescription = [];
// If there are no teams, merge all playersDescriptions
if (teams.length == 1)
teamDescription.push(playerDescriptions[teams[0]].join("\n"));
// If there are teams, merge "Team N:" + playerDescriptions
else
teamDescription = teams.map(team => {
let teamCaption = team == -1 ?
translate("No Team") :
sprintf(translate("Team %(team)s"), { "team": +team + 1 });
// Translation: Describe players of one team in a selected game, f.e. in the replay- or savegame menu or lobby
return sprintf(translate("%(team)s:\n%(playerDescriptions)s"), {
"team": '[font="sans-bold-14"]' + teamCaption + "[/font]",
"playerDescriptions": playerDescriptions[team].join("\n")
});
});
if (playerDescriptions.observer)
teamDescription.push(sprintf(translate("%(team)s:\n%(playerDescriptions)s"), {
"team": '[font="sans-bold-14"]' + translatePlural("Observer", "Observers", playerDescriptions.observer.length) + "[/font]",
"playerDescriptions": playerDescriptions.observer.join("\n")
}));
return teamDescription.join("\n\n");
}
/**
* Sets an additional map label, map preview image and describes the chosen gamesettings more closely.
*
* Requires g_GameAttributes and g_VictoryConditions.
*/
function getGameDescription(extended = false)
{
let titles = [];
let victoryIdx = g_VictoryConditions.Name.indexOf(g_GameAttributes.settings.GameType || g_VictoryConditions.Default);
if (victoryIdx != -1)
{
let title = g_VictoryConditions.Title[victoryIdx];
if (g_VictoryConditions.Name[victoryIdx] == "wonder")
title = sprintf(
translatePluralWithContext(
"victory condition",
"Wonder (%(min)s minute)",
"Wonder (%(min)s minutes)",
g_GameAttributes.settings.VictoryDuration
),
{ "min": g_GameAttributes.settings.VictoryDuration }
);
let isCaptureTheRelic = g_VictoryConditions.Name[victoryIdx] == "capture_the_relic";
if (isCaptureTheRelic)
title = sprintf(
translatePluralWithContext(
"victory condition",
"Capture The Relic (%(min)s minute)",
"Capture The Relic (%(min)s minutes)",
g_GameAttributes.settings.VictoryDuration
),
{ "min": g_GameAttributes.settings.VictoryDuration }
);
titles.push({
"label": title,
"value": g_VictoryConditions.Description[victoryIdx]
});
if (isCaptureTheRelic)
titles.push({
"label": translate("Relic Count"),
"value": g_GameAttributes.settings.RelicCount
});
+
+ if (g_VictoryConditions.Name[victoryIdx] == "regicide")
+ if (g_GameAttributes.settings.RegicideGarrison)
+ titles.push({
+ "label": translate("Hero Garrison"),
+ "value": translate("Heroes can be garrisoned.")
+ });
+ else
+ titles.push({
+ "label": translate("Exposed Heroes"),
+ "value": translate("Heroes cannot be garrisoned, and they are vulnerable to raids.")
+ });
}
if (g_GameAttributes.settings.RatingEnabled &&
g_GameAttributes.settings.PlayerData.length == 2)
titles.push({
"label": translate("Rated game"),
"value": translate("When the winner of this match is determined, the lobby score will be adapted.")
});
if (g_GameAttributes.settings.LockTeams)
titles.push({
"label": translate("Locked Teams"),
"value": translate("Players can't change the initial teams.")
});
else
titles.push({
"label": translate("Diplomacy"),
"value": translate("Players can make alliances and declare war on allies.")
});
if (g_GameAttributes.settings.LastManStanding)
titles.push({
"label": translate("Last Man Standing"),
"value": translate("Only one player can win the game. If the remaining players are allies, the game continues until only one remains.")
});
else
titles.push({
"label": translate("Allied Victory"),
"value": translate("If one player wins, his or her allies win too. If one group of allies remains, they win.")
});
if (extended)
{
titles.push({
"label": translate("Ceasefire"),
"value":
g_GameAttributes.settings.Ceasefire == 0 ?
translate("disabled") :
sprintf(translatePlural(
"For the first minute, enemies will stay neutral.",
"For the first %(min)s minutes, enemies will stay neutral.",
g_GameAttributes.settings.Ceasefire),
{ "min": g_GameAttributes.settings.Ceasefire })
});
titles.push({
"label": translate("Map Name"),
"value": translate(g_GameAttributes.settings.Name)
});
titles.push({
"label": translate("Map Type"),
"value": g_MapTypes.Title[g_MapTypes.Name.indexOf(g_GameAttributes.mapType)]
});
if (g_GameAttributes.mapType == "random")
{
let mapSize = g_MapSizes.Name[g_MapSizes.Tiles.indexOf(g_GameAttributes.settings.Size)];
if (mapSize)
titles.push({
"label": translate("Map Size"),
"value": mapSize
});
}
}
titles.push({
"label": translate("Map Description"),
"value":
g_GameAttributes.map == "random" ?
translate("Randomly selects a map from the list") :
g_GameAttributes.settings.Description ?
translate(g_GameAttributes.settings.Description) :
translate("Sorry, no description available."),
});
if (extended)
{
titles.push({
"label": translate("Starting Resources"),
"value": sprintf(translate("%(startingResourcesTitle)s (%(amount)s)"), {
"startingResourcesTitle":
g_StartingResources.Title[
g_StartingResources.Resources.indexOf(
g_GameAttributes.settings.StartingResources)],
"amount": g_GameAttributes.settings.StartingResources
})
});
titles.push({
"label": translate("Population Limit"),
"value":
g_PopulationCapacities.Title[
g_PopulationCapacities.Population.indexOf(
g_GameAttributes.settings.PopulationCap)]
});
titles.push({
"label": translate("Disable Treasure"),
"value": g_GameAttributes.settings.DisableTreasure
});
titles.push({
"label": translate("Revealed Map"),
"value": g_GameAttributes.settings.RevealMap
});
titles.push({
"label": translate("Explored Map"),
"value": g_GameAttributes.settings.ExploreMap
});
titles.push({
"label": translate("Cheats"),
"value": g_GameAttributes.settings.CheatsEnabled
});
}
return titles.map(title => sprintf(translate("%(label)s %(details)s"), {
"label": "[color=\"" + g_DescriptionHighlight + "\"]" + title.label + ":" + "[/color]",
"details":
title.value === true ? translateWithContext("gamesetup option", "enabled") :
!title.value ? translateWithContext("gamesetup option", "disabled") :
title.value
})).join("\n");
}
/**
* Sets the win/defeat icon to indicate current player's state.
* @param {string} state - The current in-game state of the player.
* @param {string} imageID - The name of the XML image object to update.
*/
function setOutcomeIcon(state, imageID)
{
let image = Engine.GetGUIObjectByName(imageID);
if (state == "won")
{
image.sprite = "stretched:session/icons/victory.png";
image.tooltip = translate("Victorious");
}
else if (state == "defeated")
{
image.sprite = "stretched:session/icons/defeat.png";
image.tooltip = translate("Defeated");
}
}
Index: ps/trunk/binaries/data/mods/public/gui/gamesetup/gamesetup.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/gamesetup/gamesetup.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/gui/gamesetup/gamesetup.js (revision 19631)
@@ -1,2205 +1,2219 @@
const g_MatchSettings_SP = "config/matchsettings.json";
const g_MatchSettings_MP = "config/matchsettings.mp.json";
const g_Ceasefire = prepareForDropdown(g_Settings && g_Settings.Ceasefire);
const g_GameSpeeds = prepareForDropdown(g_Settings && g_Settings.GameSpeeds.filter(speed => !speed.ReplayOnly));
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_StartingResources = prepareForDropdown(g_Settings && g_Settings.StartingResources);
const g_VictoryConditions = prepareForDropdown(g_Settings && g_Settings.VictoryConditions);
const g_VictoryDurations = prepareForDropdown(g_Settings && g_Settings.VictoryDurations);
/**
* Highlight the "random" dropdownlist item.
*/
var g_ColorRandom = "orange";
/**
* Color for regular dropdownlist items.
*/
var g_ColorRegular = "white";
/**
* Color for "Unassigned"-placeholder item in the dropdownlist.
*/
var g_PlayerAssignmentColors = {
"player": g_ColorRegular,
"observer": "170 170 250",
"unassigned": "140 140 140",
"AI": "70 150 70"
};
/**
* Used for highlighting the sender of chat messages.
*/
var g_SenderFont = "sans-bold-13";
/**
* This yields [1, 2, ..., MaxPlayers].
*/
var g_NumPlayersList = Array(g_MaxPlayers).fill(0).map((v, i) => i + 1);
/**
* Used for generating the botnames.
*/
var g_RomanNumbers = [undefined, "I", "II", "III", "IV", "V", "VI", "VII", "VIII"];
var g_PlayerTeamList = prepareForDropdown([{
"label": translateWithContext("team", "None"),
"id": -1
}].concat(
Array(g_MaxTeams).fill(0).map((v, i) => ({
"label": i + 1,
"id": i
}))
)
);
/**
* Offer users to select playable civs only.
* Load unselectable civs as they could appear in scenario maps.
*/
var g_CivData = loadCivData();
/**
* Number of relics: [1, ..., NumCivs]
*/
var g_RelicCountList = Object.keys(g_CivData).map((civ, i) => i + 1);
var g_PlayerCivList = g_CivData && prepareForDropdown([{
"name": translateWithContext("civilization", "Random"),
"tooltip": translate("Picks one civilization at random when the game starts."),
"color": g_ColorRandom,
"code": "random"
}].concat(
Object.keys(g_CivData).filter(
civ => g_CivData[civ].SelectableInGameSetup
).map(civ => ({
"name": g_CivData[civ].Name,
"tooltip": g_CivData[civ].History,
"color": g_ColorRegular,
"code": civ
})).sort(sortNameIgnoreCase)
)
);
/**
* All selectable playercolors except gaia.
*/
var g_PlayerColorPickerList = g_Settings && g_Settings.PlayerDefaults.slice(1).map(pData => pData.Color);
/**
* Directory containing all maps of the given type.
*/
var g_MapPath = {
"random": "maps/random/",
"scenario": "maps/scenarios/",
"skirmish": "maps/skirmishes/"
};
/**
* Containing the colors to highlight the ready status of players,
* the chat ready messages and
* the tooltips and captions for the ready button
*/
var g_ReadyData = [
{
"color": g_ColorRegular,
"chat": translate("* %(username)s is not ready."),
"caption": translate("I'm ready"),
"tooltip": translate("State that you are ready to play.")
},
{
"color": "green",
"chat": translate("* %(username)s is ready!"),
"caption": translate("Stay ready"),
"tooltip": translate("Stay ready even when the game settings change.")
},
{
"color": "150 150 250",
"chat": "",
"caption": translate("I'm not ready!"),
"tooltip": translate("State that you are not ready to play.")
}
];
/**
* Processes a CNetMessage (see NetMessage.h, NetMessages.h) sent by the CNetServer.
*/
var g_NetMessageTypes = {
"netstatus": msg => handleNetStatusMessage(msg),
"netwarn": msg => addNetworkWarning(msg),
"gamesetup": msg => handleGamesetupMessage(msg),
"players": msg => handlePlayerAssignmentMessage(msg),
"ready": msg => handleReadyMessage(msg),
"start": msg => handleGamestartMessage(msg),
"kicked": msg => addChatMessage({
"type": msg.banned ? "banned" : "kicked",
"username": msg.username
}),
"chat": msg => addChatMessage({ "type": "chat", "guid": msg.guid, "text": msg.text }),
};
var g_FormatChatMessage = {
"system": (msg, user) => systemMessage(msg.text),
"settings": (msg, user) => systemMessage(translate('Game settings have been changed')),
"connect": (msg, user) => systemMessage(sprintf(translate("%(username)s has joined"), { "username": user })),
"disconnect": (msg, user) => systemMessage(sprintf(translate("%(username)s has left"), { "username": user })),
"kicked": (msg, user) => systemMessage(sprintf(translate("%(username)s has been kicked"), { "username": user })),
"banned": (msg, user) => systemMessage(sprintf(translate("%(username)s has been banned"), { "username": user })),
"chat": (msg, user) => sprintf(translate("%(username)s %(message)s"), {
"username": senderFont(sprintf(translate("<%(username)s>"), { "username": user })),
"message": escapeText(msg.text || "")
}),
"ready": (msg, user) => sprintf(g_ReadyData[msg.status].chat, { "username": user }),
"clientlist": (msg, user) => getUsernameList(),
};
var g_MapFilterList = prepareForDropdown([
{
"id": "default",
"name": translateWithContext("map filter", "Default"),
"tooltip": translateWithContext("map filter", "All maps except naval and demo maps."),
"filter": mapKeywords => mapKeywords.every(keyword => ["naval", "demo", "hidden"].indexOf(keyword) == -1),
"Default": true
},
{
"id": "naval",
"name": translate("Naval Maps"),
"tooltip": translateWithContext("map filter", "Maps where ships are needed to reach the enemy."),
"filter": mapKeywords => mapKeywords.indexOf("naval") != -1
},
{
"id": "demo",
"name": translate("Demo Maps"),
"tooltip": translateWithContext("map filter", "These maps are not playable but for demonstration purposes only."),
"filter": mapKeywords => mapKeywords.indexOf("demo") != -1
},
{
"id": "new",
"name": translate("New Maps"),
"tooltip": translateWithContext("map filter", "Maps that are brand new in this release of the game."),
"filter": mapKeywords => mapKeywords.indexOf("new") != -1
},
{
"id": "trigger",
"name": translate("Trigger Maps"),
"tooltip": translateWithContext("map filter", "Maps that come with scripted events and potentially spawn enemy units."),
"filter": mapKeywords => mapKeywords.indexOf("trigger") != -1
},
{
"id": "all",
"name": translate("All Maps"),
"tooltip": translateWithContext("map filter", "Every map of the chosen maptype."),
"filter": mapKeywords => true
},
]);
/**
* Whether this is a single- or multiplayer match.
*/
var g_IsNetworked;
/**
* Is this user in control of game settings (i.e. singleplayer or host of a multiplayergame).
*/
var g_IsController;
/**
* Whether this is a tutorial.
*/
var g_IsTutorial;
/**
* To report the game to the lobby bot.
*/
var g_ServerName;
var g_ServerPort;
/**
* States whether the GUI is currently updated in response to network messages instead of user input
* and therefore shouldn't send further messages to the network.
*/
var g_IsInGuiUpdate = false;
/**
* Whether the current player is ready to start the game.
* 0 - not ready
* 1 - ready
* 2 - stay ready
*/
var g_IsReady = 0;
/**
* Ignore duplicate ready commands on init.
*/
var g_ReadyInit = true;
/**
* If noone has changed the ready status, we have no need to spam the settings changed message.
*
* <=0 - Suppressed settings message
* 1 - Will show settings message
* 2 - Host's initial ready, suppressed settings message
*/
var g_ReadyChanged = 2;
/**
* Used to prevent calling resetReadyData when starting a game.
*/
var g_GameStarted = false;
/**
* Selectable options (player, AI, unassigned) in the player assignment dropdowns and
* their colorized, textual representation.
*/
var g_PlayerAssignmentList = {};
/**
* Remembers which clients are assigned to which player slots and whether they are ready.
* The keys are guids or "local" in Singleplayer.
*/
var g_PlayerAssignments = {};
var g_DefaultPlayerData = [];
var g_GameAttributes = { "settings": {} };
/**
* List of translated words that can be used to autocomplete titles of settings
* and their values (for example playernames).
*/
var g_Autocomplete = [];
/**
* Array of strings formatted as displayed, including playername.
*/
var g_ChatMessages = [];
/**
* Filename and translated title of all maps, given the currently selected
* maptype and filter. Sorted by title, shown in the dropdown.
*/
var g_MapSelectionList = [];
/**
* Cache containing the mapsettings. Just-in-time loading.
*/
var g_MapData = {};
/**
* Wait one tick before initializing the GUI objects and
* don't process netmessages prior to that.
*/
var g_LoadingState = 0;
/**
* Only send a lobby update if something actually changed.
*/
var g_LastGameStanza;
/**
* Remembers if the current player viewed the AI settings of some playerslot.
*/
var g_LastViewedAIPlayer = -1;
/**
* Total number of units that the engine can run with smoothly.
* It means a 4v4 with 150 population can still run nicely, but more than that might "lag".
*/
var g_PopulationCapacityRecommendation = 1200;
/**
* Order in which the GUI elements will be shown.
* All valid options are required to appear here.
* The ones under "map" are shown in the map selection panel,
* the others in the "more options" dialog.
*/
var g_OptionOrderGUI = {
"map": {
"Dropdown": [
"mapType",
"mapFilter",
"mapSelection",
"numPlayers",
"mapSize",
],
"Checkbox": [
],
},
"more": {
"Dropdown": [
"gameSpeed",
"victoryCondition",
"relicCount",
"victoryDuration",
"populationCap",
"startingResources",
"ceasefire",
],
"Checkbox": [
+ "regicideGarrison",
"exploreMap",
"revealMap",
"disableTreasures",
"disableSpies",
"lockTeams",
"lastManStanding",
"enableCheats",
"enableRating",
]
}
};
/**
* These options must be initialized first, in the given order.
*/
var g_OptionOrderInit = {
"dropdowns": [
"mapType",
"mapFilter",
"mapSelection"
],
"checkboxes": [
]
};
/**
* Contains the logic of all multiple-choice gamesettings.
*
* Logic
* ids - Array of identifier strings that indicate the selected value.
* default - Returns the index of the default value (not the value itself).
* defined - Whether a value for the setting is actually specified.
* get - The identifier of the currently selected value.
* select - Saves and processes the value of the selected index of the ids array.
*
* GUI
* title - The caption shown in the label.
* tooltip - A description shown when hovering the dropdown or a specific item.
* labels - Array of translated strings selectable for this dropdown.
* colors - Optional array of colors to tint the according dropdown items with.
* hidden - If hidden, both the label and dropdown won't be visible. (default: false)
* enabled - Only the label will be shown if the setting is disabled. (default: true)
* autocomplete - Whether to autocomplete translated values of the string. (default: false)
* If disabled, still autocompletes the translated title of the setting.
*/
var g_Dropdowns = {
"mapType": {
"title": () => translate("Map Type"),
"tooltip": (hoverIdx) => g_MapTypes.Description[hoverIdx] || translate("Select a map type."),
"labels": () => g_MapTypes.Title,
"ids": () => g_MapTypes.Name,
"default": () => g_MapTypes.Default,
"defined": () => g_GameAttributes.mapType !== undefined,
"get": () => g_GameAttributes.mapType,
"select": (idx) => {
g_MapData = {};
g_GameAttributes.mapType = g_MapTypes.Name[idx];
g_GameAttributes.mapPath = g_MapPath[g_GameAttributes.mapType];
delete g_GameAttributes.map;
if (g_GameAttributes.mapType != "scenario")
g_GameAttributes.settings = {
"PlayerData": g_DefaultPlayerData.slice(0, 4)
};
reloadMapList();
},
"autocomplete": true,
},
"mapFilter": {
"title": () => translate("Map Filter"),
"tooltip": (hoverIdx) => g_MapFilterList.tooltip[hoverIdx] || translate("Select a map filter."),
"labels": () => g_MapFilterList.name,
"ids": () => g_MapFilterList.id,
"default": () => g_MapFilterList.Default,
"defined": () => g_GameAttributes.mapFilter !== undefined,
"get": () => g_GameAttributes.mapFilter,
"select": (idx) => {
g_GameAttributes.mapFilter = g_MapFilterList.id[idx];
delete g_GameAttributes.map;
reloadMapList();
},
"autocomplete": true,
},
"mapSelection": {
"title": () => translate("Select Map"),
"tooltip": (hoverIdx) => g_MapSelectionList.description[hoverIdx] || translate("Select a map to play on."),
"labels": () => g_MapSelectionList.name,
"colors": () => g_MapSelectionList.color,
"ids": () => g_MapSelectionList.file,
"default": () => 0,
"defined": () => g_GameAttributes.map !== undefined,
"get": () => g_GameAttributes.map,
"select": (idx) => {
selectMap(g_MapSelectionList.file[idx]);
},
"autocomplete": true,
},
"mapSize": {
"title": () => translate("Map Size"),
"tooltip": (hoverIdx) => g_MapSizes.Tooltip[hoverIdx] || translate("Select map size. (Larger sizes may reduce performance.)"),
"labels": () => g_MapSizes.Name,
"ids": () => g_MapSizes.Tiles,
"default": () => g_MapSizes.Default,
"defined": () => g_GameAttributes.settings.Size !== undefined,
"get": () => g_GameAttributes.settings.Size,
"select": (idx) => {
g_GameAttributes.settings.Size = g_MapSizes.Tiles[idx];
},
"hidden": () => g_GameAttributes.mapType != "random",
"autocomplete": true,
},
"numPlayers": {
"title": () => translate("Number of Players"),
"tooltip": (hoverIdx) => translate("Select number of players."),
"labels": () => g_NumPlayersList,
"ids": () => g_NumPlayersList,
"default": () => g_MaxPlayers - 1,
"defined": () => g_GameAttributes.settings.PlayerData !== undefined,
"get": () => g_GameAttributes.settings.PlayerData.length,
"enabled": () => g_GameAttributes.mapType == "random",
"select": (idx) => {
let num = idx + 1;
let pData = g_GameAttributes.settings.PlayerData;
g_GameAttributes.settings.PlayerData =
num > pData.length ?
pData.concat(g_DefaultPlayerData.slice(pData.length, num)) :
pData.slice(0, num);
unassignInvalidPlayers(num);
sanitizePlayerData(g_GameAttributes.settings.PlayerData);
},
},
"populationCap": {
"title": () => translate("Population Cap"),
"tooltip": (hoverIdx) => {
let popCap = g_PopulationCapacities.Population[hoverIdx];
let players = g_GameAttributes.settings.PlayerData.length;
if (hoverIdx == -1 || popCap * players <= g_PopulationCapacityRecommendation)
return translate("Select population limit.");
return '[color="orange"]' +
sprintf(translate("Warning: There might be performance issues if all %(players)s players reach %(popCap)s population."), {
"players": players,
"popCap": popCap
}) + '[/color]';
},
"labels": () => g_PopulationCapacities.Title,
"ids": () => g_PopulationCapacities.Population,
"default": () => g_PopulationCapacities.Default,
"defined": () => g_GameAttributes.settings.PopulationCap !== undefined,
"get": () => g_GameAttributes.settings.PopulationCap,
"select": (idx) => {
g_GameAttributes.settings.PopulationCap = g_PopulationCapacities.Population[idx];
},
"enabled": () => g_GameAttributes.mapType != "scenario",
},
"startingResources": {
"title": () => translate("Starting Resources"),
"tooltip": (hoverIdx) => {
return hoverIdx >= 0 ?
sprintf(translate("Initial amount of each resource: %(resources)s."), {
"resources": g_StartingResources.Resources[hoverIdx]
}) :
translate("Select the game's starting resources.");
},
"labels": () => g_StartingResources.Title,
"ids": () => g_StartingResources.Resources,
"default": () => g_StartingResources.Default,
"defined": () => g_GameAttributes.settings.StartingResources !== undefined,
"get": () => g_GameAttributes.settings.StartingResources,
"select": (idx) => {
g_GameAttributes.settings.StartingResources = g_StartingResources.Resources[idx];
},
"hidden": () => g_GameAttributes.mapType == "scenario",
"autocomplete": true,
},
"ceasefire": {
"title": () => translate("Ceasefire"),
"tooltip": (hoverIdx) => translate("Set time where no attacks are possible."),
"labels": () => g_Ceasefire.Title,
"ids": () => g_Ceasefire.Duration,
"default": () => g_Ceasefire.Default,
"defined": () => g_GameAttributes.settings.Ceasefire !== undefined,
"get": () => g_GameAttributes.settings.Ceasefire,
"select": (idx) => {
g_GameAttributes.settings.Ceasefire = g_Ceasefire.Duration[idx];
},
"enabled": () => g_GameAttributes.mapType != "scenario",
},
"victoryCondition": {
"title": () => translate("Victory Condition"),
"tooltip": (hoverIdx) => g_VictoryConditions.Description[hoverIdx] || translate("Select victory condition."),
"labels": () => g_VictoryConditions.Title,
"ids": () => g_VictoryConditions.Name,
"default": () => g_VictoryConditions.Default,
"defined": () => g_GameAttributes.settings.GameType !== undefined,
"get": () => g_GameAttributes.settings.GameType,
"select": (idx) => {
g_GameAttributes.settings.GameType = g_VictoryConditions.Name[idx];
g_GameAttributes.settings.VictoryScripts = g_VictoryConditions.Scripts[idx];
},
"enabled": () => g_GameAttributes.mapType != "scenario",
"autocomplete": true,
},
"relicCount": {
"title": () => translate("Relic Count"),
"tooltip": (hoverIdx) => translate("Total number of relics spawned on the map."),
"labels": () => g_RelicCountList,
"ids": () => g_RelicCountList,
"default": () => g_RelicCountList.indexOf(5),
"defined": () => g_GameAttributes.settings.RelicCount !== undefined,
"get": () => g_GameAttributes.settings.RelicCount,
"select": (idx) => {
g_GameAttributes.settings.RelicCount = g_RelicCountList[idx];
},
"hidden": () => g_GameAttributes.settings.GameType != "capture_the_relic",
"enabled": () => g_GameAttributes.mapType != "scenario",
},
"victoryDuration": {
"title": () => translate("Victory Duration"),
"tooltip": (hoverIdx) => translate("Number of minutes until the player has won."),
"labels": () => g_VictoryDurations.Title,
"ids": () => g_VictoryDurations.Duration,
"default": () => g_VictoryDurations.Default,
"defined": () => g_GameAttributes.settings.VictoryDuration !== undefined,
"get": () => g_GameAttributes.settings.VictoryDuration,
"select": (idx) => {
g_GameAttributes.settings.VictoryDuration = g_VictoryDurations.Duration[idx];
},
"hidden": () =>
g_GameAttributes.settings.GameType != "wonder" &&
g_GameAttributes.settings.GameType != "capture_the_relic",
"enabled": () => g_GameAttributes.mapType != "scenario",
},
"gameSpeed": {
"title": () => translate("Game Speed"),
"tooltip": (hoverIdx) => translate("Select game speed."),
"labels": () => g_GameSpeeds.Title,
"ids": () => g_GameSpeeds.Speed,
"default": () => g_GameSpeeds.Default,
"defined": () => g_GameAttributes.gameSpeed !== undefined,
"get": () => g_GameAttributes.gameSpeed,
"select": (idx) => {
g_GameAttributes.gameSpeed = g_GameSpeeds.Speed[idx];
},
},
};
/**
* These dropdowns provide a setting that is repeated once for each player
* (where idx is the playerID starting from 0 for player 1).
*/
var g_PlayerDropdowns = {
"playerAssignment": {
"labels": (idx) => g_PlayerAssignmentList.Name || [],
"colors": (idx) => g_PlayerAssignmentList.Color || [],
"ids": (idx) => g_PlayerAssignmentList.Choice || [],
"default": (idx) => "ai:petra",
"defined": (idx) => idx < g_GameAttributes.settings.PlayerData.length,
"get": (idx) => {
for (let guid in g_PlayerAssignments)
if (g_PlayerAssignments[guid].player == idx + 1)
return "guid:" + guid;
for (let ai of g_Settings.AIDescriptions)
if (g_GameAttributes.settings.PlayerData[idx].AI == ai.id)
return "ai:" + ai.id;
return "unassigned";
},
"select": (selectedIdx, idx) => {
let choice = g_PlayerAssignmentList.Choice[selectedIdx];
if (choice == "unassigned" || choice.startsWith("ai:"))
{
if (g_IsNetworked)
Engine.AssignNetworkPlayer(idx+1, "");
else if (g_PlayerAssignments.local.player == idx+1)
g_PlayerAssignments.local.player = -1;
g_GameAttributes.settings.PlayerData[idx].AI = choice.startsWith("ai:") ? choice.substr(3) : "";
}
else
swapPlayers(choice.substr("guid:".length), idx);
},
"autocomplete": true,
},
"playerTeam": {
"labels": (idx) => g_PlayerTeamList.label,
"ids": (idx) => g_PlayerTeamList.id,
"default": (idx) => 0,
"defined": (idx) => g_GameAttributes.settings.PlayerData[idx].Team !== undefined,
"get": (idx) => g_GameAttributes.settings.PlayerData[idx].Team,
"select": (selectedIdx, idx) => {
g_GameAttributes.settings.PlayerData[idx].Team = selectedIdx - 1;
},
"enabled": () => g_GameAttributes.mapType != "scenario",
},
"playerCiv": {
"tooltip": (hoverIdx, idx) => g_PlayerCivList.tooltip[hoverIdx] || translate("Chose the civilization for this player"),
"labels": (idx) => g_PlayerCivList.name,
"colors": (idx) => g_PlayerCivList.color,
"ids": (idx) => g_PlayerCivList.code,
"default": (idx) => 0,
"defined": (idx) => g_GameAttributes.settings.PlayerData[idx].Civ !== undefined,
"get": (idx) => g_GameAttributes.settings.PlayerData[idx].Civ,
"select": (selectedIdx, idx) => {
g_GameAttributes.settings.PlayerData[idx].Civ = g_PlayerCivList.code[selectedIdx];
},
"enabled": () => g_GameAttributes.mapType != "scenario",
"autocomplete": true,
},
"playerColorPicker": {
"labels": (idx) => g_PlayerColorPickerList.map(color => "■"),
"colors": (idx) => g_PlayerColorPickerList.map(color => rgbToGuiColor(color)),
"ids": (idx) => g_PlayerColorPickerList.map((color, index) => index),
"default": (idx) => idx,
"defined": (idx) => g_GameAttributes.settings.PlayerData[idx].Color !== undefined,
"get": (idx) => g_GameAttributes.settings.PlayerData[idx].Color,
"select": (selectedIdx, idx) => {
let playerData = g_GameAttributes.settings.PlayerData;
// If someone else has that color, give that player the old color
let pData = playerData.find(pData => sameColor(g_PlayerColorPickerList[selectedIdx], pData.Color));
if (pData)
pData.Color = playerData[idx].Color;
playerData[idx].Color = g_PlayerColorPickerList[selectedIdx];
ensureUniquePlayerColors(playerData);
},
"enabled": () => g_GameAttributes.mapType != "scenario",
},
};
/**
* Contains the logic of all boolean gamesettings.
*/
var g_Checkboxes = {
+ "regicideGarrison": {
+ "title": () => translate("Hero Garrison"),
+ "tooltip": () => translate("Toggle whether heroes can be garrisoned."),
+ "default": () => false,
+ "defined": () => g_GameAttributes.settings.RegicideGarrison !== undefined,
+ "get": () => g_GameAttributes.settings.RegicideGarrison,
+ "set": checked => {
+ g_GameAttributes.settings.RegicideGarrison = checked;
+ },
+ "hidden": () => g_GameAttributes.settings.GameType != "regicide",
+ "enabled": () => g_GameAttributes.mapType != "scenario",
+ },
"revealMap": {
"title": () =>
// Translation: Make sure to differentiate between the revealed map and explored map options!
translate("Revealed Map"),
"tooltip":
// Translation: Make sure to differentiate between the revealed map and explored map options!
() => translate("Toggle revealed map (see everything)."),
"default": () => false,
"defined": () => g_GameAttributes.settings.RevealMap !== undefined,
"get": () => g_GameAttributes.settings.RevealMap,
"set": checked => {
g_GameAttributes.settings.RevealMap = checked;
if (checked)
g_Checkboxes.exploreMap.set(true);
},
"enabled": () => g_GameAttributes.mapType != "scenario",
},
"exploreMap": {
"title":
// Translation: Make sure to differentiate between the revealed map and explored map options!
() => translate("Explored Map"),
"tooltip":
// Translation: Make sure to differentiate between the revealed map and explored map options!
() => translate("Toggle explored map (see initial map)."),
"default": () => false,
"defined": () => g_GameAttributes.settings.ExploreMap !== undefined,
"get": () => g_GameAttributes.settings.ExploreMap,
"set": checked => {
g_GameAttributes.settings.ExploreMap = checked;
},
"enabled": () => g_GameAttributes.mapType != "scenario" && !g_GameAttributes.settings.RevealMap,
},
"disableTreasures": {
"title": () => translate("Disable Treasures"),
"tooltip": () => translate("Disable all treasures on the map."),
"default": () => false,
"defined": () => g_GameAttributes.settings.DisableTreasures !== undefined,
"get": () => g_GameAttributes.settings.DisableTreasures,
"set": checked => {
g_GameAttributes.settings.DisableTreasures = checked;
},
"enabled": () => g_GameAttributes.mapType != "scenario",
},
"disableSpies": {
"title": () => translate("Disable Spies"),
"tooltip": () => translate("Disable spies during the game."),
"default": () => false,
"defined": () => g_GameAttributes.settings.DisableSpies !== undefined,
"get": () => g_GameAttributes.settings.DisableSpies,
"set": checked => {
g_GameAttributes.settings.DisableSpies = checked;
},
"enabled": () => g_GameAttributes.mapType != "scenario",
},
"lockTeams": {
"title": () => translate("Teams Locked"),
"tooltip": () => translate("Toggle locked teams."),
"default": () => Engine.HasXmppClient(),
"defined": () => g_GameAttributes.settings.LockTeams !== undefined,
"get": () => g_GameAttributes.settings.LockTeams,
"set": checked => {
g_GameAttributes.settings.LockTeams = checked;
g_GameAttributes.settings.LastManStanding = false;
},
"enabled": () =>
g_GameAttributes.mapType != "scenario" &&
!g_GameAttributes.settings.RatingEnabled,
},
"lastManStanding": {
"title": () => translate("Last Man Standing"),
"tooltip": () => translate("Toggle whether the last remaining player or the last remaining set of allies wins."),
"default": () => false,
"defined": () => g_GameAttributes.settings.LastManStanding !== undefined,
"get": () => g_GameAttributes.settings.LastManStanding,
"set": checked => {
g_GameAttributes.settings.LastManStanding = checked;
},
"enabled": () =>
g_GameAttributes.mapType != "scenario" &&
!g_GameAttributes.settings.LockTeams,
},
"enableCheats": {
"title": () => translate("Cheats"),
"tooltip": () => translate("Toggle the usability of cheats."),
"default": () => !g_IsNetworked,
"hidden": () => !g_IsNetworked,
"defined": () => g_GameAttributes.settings.CheatsEnabled !== undefined,
"get": () => g_GameAttributes.settings.CheatsEnabled,
"set": checked => {
g_GameAttributes.settings.CheatsEnabled = !g_IsNetworked ||
checked && !g_GameAttributes.settings.RatingEnabled;
},
"enabled": () => !g_GameAttributes.settings.RatingEnabled,
},
"enableRating": {
"title": () => translate("Rated Game"),
"tooltip": () => translate("Toggle if this game will be rated for the leaderboard."),
"default": () => Engine.HasXmppClient(),
"hidden": () => !Engine.HasXmppClient(),
"defined": () => g_GameAttributes.settings.RatingEnabled !== undefined,
"get": () => !!g_GameAttributes.settings.RatingEnabled,
"set": checked => {
g_GameAttributes.settings.RatingEnabled = Engine.HasXmppClient() ? checked : undefined;
Engine.SetRankedGame(!!g_GameAttributes.settings.RatingEnabled);
if (checked)
{
g_Checkboxes.lockTeams.set(true);
g_Checkboxes.enableCheats.set(false);
}
},
},
};
/**
* For setting up arbitrary GUI objects.
*/
var g_MiscControls = {
"chatPanel": {
"hidden": () => !g_IsNetworked,
},
"chatInput": {
"tooltip": () => colorizeAutocompleteHotkey(translate("Press %(hotkey)s to autocomplete playernames or settings.")),
},
"cheatWarningText": {
"hidden": () => !g_IsNetworked || !g_GameAttributes.settings.CheatsEnabled,
},
"cancelGame": {
"tooltip": () =>
Engine.HasXmppClient() ?
translate("Return to the lobby.") :
translate("Return to the main menu."),
},
"startGame": {
"caption": () =>
g_IsController ? translate("Start game!") : g_ReadyData[g_IsReady].caption,
"tooltip": (hoverIdx) =>
!g_IsController ?
g_ReadyData[g_IsReady].tooltip :
!g_IsNetworked || Object.keys(g_PlayerAssignments).every(guid =>
g_PlayerAssignments[guid].status || g_PlayerAssignments[guid].player == -1) ?
translate("Start a new game with the current settings.") :
translate("Start a new game with the current settings (disabled until all players are ready)"),
"enabled": () => !g_IsController ||
Object.keys(g_PlayerAssignments).every(guid => g_PlayerAssignments[guid].status ||
g_PlayerAssignments[guid].player == -1 ||
guid == Engine.GetPlayerGUID() && g_IsController),
"hidden": () =>
!g_PlayerAssignments[Engine.GetPlayerGUID()] ||
g_PlayerAssignments[Engine.GetPlayerGUID()].player == -1 && !g_IsController,
},
"civResetButton": {
"hidden": () => g_GameAttributes.mapType == "scenario" || !g_IsController,
},
"teamResetButton": {
"hidden": () => g_GameAttributes.mapType == "scenario" || !g_IsController,
},
// Display these after having hidden every GUI object in the "More Options" dialog
"moreOptionsLabel": {
"hidden": () => false,
},
"hideMoreOptions": {
"hidden": () => false,
},
};
/**
* Contains options that are repeated for every player.
*/
var g_PlayerMiscControls = {
"playerBox": {
"size": (idx) => ["0", 32 * idx, "100%", 32 * (idx + 1)].join(" "),
},
"playerName": {
"caption": (idx) => {
let pData = g_GameAttributes.settings.PlayerData[idx];
let assignedGUID = Object.keys(g_PlayerAssignments).find(
guid => g_PlayerAssignments[guid].player == idx + 1);
let name = translate(pData.Name || g_DefaultPlayerData[idx].Name);
if (g_IsNetworked)
name =
'[color="' +
g_ReadyData[assignedGUID ? g_PlayerAssignments[assignedGUID].status : 2].color +
'"]' + name + '[/color]';
return name;
},
},
"playerColor": {
"sprite": (idx) => "color:" + rgbToGuiColor(g_GameAttributes.settings.PlayerData[idx].Color) + " 100",
},
"playerConfig": {
"hidden": (idx) => !g_GameAttributes.settings.PlayerData[idx].AI,
"onPress": (idx) => function() {
openAIConfig(idx);
},
},
};
/**
* Initializes some globals without touching the GUI.
*
* @param {Object} attribs - context data sent by the lobby / mainmenu
*/
function init(attribs)
{
if (!g_Settings)
{
cancelSetup();
return;
}
if (["offline", "server", "client"].indexOf(attribs.type) == -1)
{
error("Unexpected 'type' in gamesetup init: " + attribs.type);
cancelSetup();
return;
}
g_IsNetworked = attribs.type != "offline";
g_IsController = attribs.type != "client";
g_IsTutorial = attribs.tutorial && attribs.tutorial == true;
g_ServerName = attribs.serverName;
g_ServerPort = attribs.serverPort;
if (!g_IsNetworked)
g_PlayerAssignments = {
"local": {
"name": singleplayerName(),
"player": 1
}
};
// Replace empty playername when entering a singleplayermatch for the first time
if (!g_IsNetworked)
{
Engine.ConfigDB_CreateValue("user", "playername.singleplayer", singleplayerName());
Engine.ConfigDB_WriteValueToFile("user", "playername.singleplayer", singleplayerName(), "config/user.cfg");
}
initDefaults();
supplementDefaults();
setTimeout(displayGamestateNotifications, 1000);
}
function initDefaults()
{
// Remove gaia from both arrays
g_DefaultPlayerData = g_Settings.PlayerDefaults;
g_DefaultPlayerData.shift();
// Don't change the underlying defaults file, as Atlas uses that file too
for (let i in g_DefaultPlayerData)
{
g_DefaultPlayerData[i].Civ = "random";
g_DefaultPlayerData[i].Teams = -1;
}
}
/**
* Sets default values for all g_GameAttribute settings which don't have a value set.
*/
function supplementDefaults()
{
for (let dropdown in g_Dropdowns)
if (!g_Dropdowns[dropdown].defined())
g_Dropdowns[dropdown].select(g_Dropdowns[dropdown].default());
for (let checkbox in g_Checkboxes)
if (!g_Checkboxes[checkbox].defined())
g_Checkboxes[checkbox].set(g_Checkboxes[checkbox].default());
for (let dropdown in g_PlayerDropdowns)
for (let i = 0; i < g_GameAttributes.settings.PlayerData.length; ++i)
if (!isControlArrayElementHidden(i) && !g_PlayerDropdowns[dropdown].defined(i))
g_PlayerDropdowns[dropdown].select(g_PlayerDropdowns[dropdown].default(i), i);
}
/**
* Called after the first tick.
*/
function initGUIObjects()
{
for (let dropdown of g_OptionOrderInit.dropdowns)
initDropdown(dropdown);
for (let dropdown in g_Dropdowns)
if (g_OptionOrderInit.dropdowns.indexOf(dropdown) == -1)
initDropdown(dropdown);
for (let checkbox of g_OptionOrderInit.checkboxes)
initCheckbox(checkbox);
for (let checkbox in g_Checkboxes)
if (g_OptionOrderInit.checkboxes.indexOf(checkbox) == -1)
initCheckbox(checkbox);
for (let dropdown in g_PlayerDropdowns)
initPlayerDropdowns(dropdown);
resizeMoreOptionsWindow();
initSPTips();
loadPersistMatchSettings();
updateGameAttributes();
if (g_IsTutorial)
{
launchTutorial();
return;
}
Engine.GetGUIObjectByName("loadingWindow").hidden = true;
Engine.GetGUIObjectByName("setupWindow").hidden = false;
if (g_IsNetworked)
Engine.GetGUIObjectByName("chatInput").focus();
}
/**
* The main options (like map selection) and player arrays have specific names.
* Options in the "More Options" dialog use a generic name.
*/
function getGUIObjectNameFromSetting(name)
{
for (let panel in g_OptionOrderGUI)
for (let type in g_OptionOrderGUI[panel])
{
let idx = g_OptionOrderGUI[panel][type].indexOf(name);
if (idx != -1)
return [panel + "Option" + type, "[" + idx + "]"];
}
// Assume there is a GUI object with exactly that setting name
return [name, ""];
}
function initDropdown(name, idx)
{
let [guiName, guiIdx] = getGUIObjectNameFromSetting(name);
let idxName = idx === undefined ? "": "[" + idx + "]";
let data = (idx === undefined ? g_Dropdowns : g_PlayerDropdowns)[name];
let dropdown = Engine.GetGUIObjectByName(guiName + guiIdx + idxName);
dropdown.list = data.labels(idx).map((label, id) =>
data.colors && data.colors(idx) ?
'[color="' + data.colors(idx)[id] + '"]' + label + "[/color]" :
label);
dropdown.list_data = data.ids(idx);
dropdown.onSelectionChange = function() {
if (!g_IsController ||
g_IsInGuiUpdate ||
!this.list_data[this.selected] ||
data.hidden && data.hidden(idx) ||
data.enabled && !data.enabled(idx))
return;
data.select(this.selected, idx);
supplementDefaults();
updateGameAttributes();
};
if (data.tooltip)
dropdown.onHoverChange = function() {
this.tooltip = data.tooltip(this.hovered, idx);
};
}
function initPlayerDropdowns(name)
{
for (let i = 0; i < g_MaxPlayers; ++i)
initDropdown(name, i);
}
function initCheckbox(name)
{
let [guiName, guiIdx] = getGUIObjectNameFromSetting(name);
Engine.GetGUIObjectByName(guiName + guiIdx).onPress = function() {
let obj = g_Checkboxes[name];
if (!g_IsController ||
g_IsInGuiUpdate ||
obj.enabled && !obj.enabled() ||
obj.hidden && obj.hidden())
return;
obj.set(this.checked);
supplementDefaults();
updateGameAttributes();
};
}
function initSPTips()
{
if (g_IsNetworked || Engine.ConfigDB_GetValue("user", "gui.gamesetup.enabletips") !== "true")
return;
Engine.GetGUIObjectByName("spTips").hidden = false;
Engine.GetGUIObjectByName("displaySPTips").checked = true;
Engine.GetGUIObjectByName("aiTips").caption = Engine.TranslateLines(Engine.ReadFile("gui/gamesetup/ai.txt"));
}
function saveSPTipsSetting()
{
let enabled = String(Engine.GetGUIObjectByName("displaySPTips").checked);
Engine.ConfigDB_CreateValue("user", "gui.gamesetup.enabletips", enabled);
Engine.ConfigDB_WriteValueToFile("user", "gui.gamesetup.enabletips", enabled, "config/user.cfg");
}
function verticallyDistributeGUIObjects(parent, objectHeight, ignore)
{
let yPos = undefined;
let parentObject = Engine.GetGUIObjectByName(parent);
for (let child of parentObject.children)
{
if (ignore.indexOf(child.name) != -1)
continue;
let childSize = child.size;
yPos = yPos || childSize.top;
if (child.hidden)
continue;
childSize.top = yPos;
childSize.bottom = yPos + objectHeight - 2;
child.size = childSize;
yPos += objectHeight;
}
return yPos;
}
/**
* Remove empty space in case of hidden options (like cheats, rating or victory duration)
*/
function resizeMoreOptionsWindow()
{
verticallyDistributeGUIObjects("mapOptions", 32, []);
let yPos = verticallyDistributeGUIObjects("moreOptions", 32, ["moreOptionsLabel"]);
// Resize the vertically centered window containing the options
let moreOptions = Engine.GetGUIObjectByName("moreOptions");
let mSize = moreOptions.size;
mSize.bottom = mSize.top + yPos + 20;
moreOptions.size = mSize;
}
/**
* Called when the client disconnects.
* The other cases from NetClient should never occur in the gamesetup.
*/
function handleNetStatusMessage(message)
{
if (message.status != "disconnected")
{
error("Unrecognised netstatus type " + message.status);
return;
}
cancelSetup();
reportDisconnect(message.reason, true);
}
/**
* Called whenever a client clicks on ready (or not ready).
*/
function handleReadyMessage(message)
{
--g_ReadyChanged;
if (g_ReadyChanged < 1 && g_PlayerAssignments[message.guid].player != -1)
addChatMessage({
"type": "ready",
"status": message.status,
"guid": message.guid
});
g_PlayerAssignments[message.guid].status = message.status;
updateGUIObjects();
}
/**
* Called after every player is ready and the host decided to finally start the game.
*/
function handleGamestartMessage(message)
{
// Immediately inform the lobby server instead of waiting for the load to finish
if (g_IsController && Engine.HasXmppClient())
{
let clients = formatClientsForStanza();
Engine.SendChangeStateGame(clients.connectedPlayers, clients.list);
}
Engine.SwitchGuiPage("page_loading.xml", {
"attribs": g_GameAttributes,
"isNetworked" : g_IsNetworked,
"playerAssignments": g_PlayerAssignments,
"isController": g_IsController
});
}
/**
* Called whenever the host changed any setting.
*/
function handleGamesetupMessage(message)
{
if (!message.data)
return;
g_GameAttributes = message.data;
if (!!g_GameAttributes.settings.RatingEnabled)
{
g_GameAttributes.settings.CheatsEnabled = false;
g_GameAttributes.settings.LockTeams = true;
g_GameAttributes.settings.LastManStanding = false;
}
Engine.SetRankedGame(!!g_GameAttributes.settings.RatingEnabled);
resetReadyData();
updateGUIObjects();
}
/**
* Called whenever a client joins/leaves or any gamesetting is changed.
*/
function handlePlayerAssignmentMessage(message)
{
for (let guid in message.newAssignments)
if (!g_PlayerAssignments[guid])
onClientJoin(guid, message.newAssignments);
for (let guid in g_PlayerAssignments)
if (!message.newAssignments[guid])
onClientLeave(guid);
g_PlayerAssignments = message.newAssignments;
sanitizePlayerData(g_GameAttributes.settings.PlayerData);
updateGUIObjects();
sendRegisterGameStanza();
}
function onClientJoin(newGUID, newAssignments)
{
addChatMessage({
"type": "connect",
"guid": newGUID,
"username": newAssignments[newGUID].name
});
let freeSlot = g_GameAttributes.settings.PlayerData.findIndex((v,i) =>
Object.keys(g_PlayerAssignments).every(guid => g_PlayerAssignments[guid].player != i+1)
);
// Client is not and cannot become assigned as player
if (newAssignments[newGUID].player == -1 && freeSlot == -1)
return;
// Assign the joining client to the free slot
if (g_IsController && newAssignments[newGUID].player == -1)
Engine.AssignNetworkPlayer(freeSlot + 1, newGUID);
resetReadyData();
}
function onClientLeave(guid)
{
addChatMessage({
"type": "disconnect",
"guid": guid
});
if (g_PlayerAssignments[guid].player != -1)
resetReadyData();
}
/**
* Doesn't translate, so that lobby clients can do that locally
* (even if they don't have that map).
*/
function getMapDisplayName(map)
{
if (map == "random")
return map;
let mapData = loadMapData(map);
if (!mapData || !mapData.settings || !mapData.settings.Name)
return map;
return mapData.settings.Name;
}
function getMapPreview(map)
{
let mapData = loadMapData(map);
if (!mapData || !mapData.settings || !mapData.settings.Preview)
return "nopreview.png";
return mapData.settings.Preview;
}
/**
* Initialize the dropdown containing all maps for the selected maptype and mapfilter.
*/
function reloadMapList()
{
if (!g_MapPath[g_GameAttributes.mapType])
{
error("Unexpected map type: " + g_GameAttributes.mapType);
return;
}
let mapFiles = g_GameAttributes.mapType == "random" ?
getJSONFileList(g_GameAttributes.mapPath) :
getXMLFileList(g_GameAttributes.mapPath);
// Apply map filter, if any defined
let mapList = [];
// TODO: Should verify these are valid maps before adding to list
for (let mapFile of mapFiles)
{
let file = g_GameAttributes.mapPath + mapFile;
let mapData = loadMapData(file);
let filterID = g_MapFilterList.id.findIndex(id => id == g_GameAttributes.mapFilter);
let mapFilter = g_MapFilterList.filter[filterID] || undefined;
if (!mapData.settings || mapFilter && !mapFilter(mapData.settings.Keywords || []))
continue;
mapList.push({
"file": file,
"name": translate(getMapDisplayName(file)),
"color": g_ColorRegular,
"description": translate(mapData.settings.Description)
});
}
mapList = mapList.sort(sortNameIgnoreCase);
if (g_GameAttributes.mapType == "random")
mapList.unshift({
"file": "random",
"name": translateWithContext("map selection", "Random"),
"color": g_ColorRandom,
"description": "Picks one of the maps of the given maptype and filter at random."
});
g_MapSelectionList = prepareForDropdown(mapList);
initDropdown("mapSelection");
}
function loadMapData(name)
{
if (!name || !g_MapPath[g_GameAttributes.mapType])
return undefined;
if (name == "random")
return { "settings": { "Name": "", "Description": "" } };
if (!g_MapData[name])
g_MapData[name] = g_GameAttributes.mapType == "random" ?
Engine.ReadJSONFile(name + ".json") :
Engine.LoadMapSettings(name);
return g_MapData[name];
}
/**
* Sets the gameattributes the way they were the last time the user left the gamesetup.
*/
function loadPersistMatchSettings()
{
if (!g_IsController || Engine.ConfigDB_GetValue("user", "persistmatchsettings") != "true" || g_IsTutorial)
return;
let settingsFile = g_IsNetworked ? g_MatchSettings_MP : g_MatchSettings_SP;
if (!Engine.FileExists(settingsFile))
return;
let attrs = Engine.ReadJSONFile(settingsFile);
if (!attrs || !attrs.settings)
return;
g_IsInGuiUpdate = true;
let mapName = attrs.map || "";
let mapSettings = attrs.settings;
g_GameAttributes = attrs;
if (!g_IsNetworked)
mapSettings.CheatsEnabled = true;
// Replace unselectable civs with random civ
let playerData = mapSettings.PlayerData;
if (playerData && g_GameAttributes.mapType != "scenario")
for (let i in playerData)
if (!g_CivData[playerData[i].Civ] || !g_CivData[playerData[i].Civ].SelectableInGameSetup)
playerData[i].Civ = "random";
// Apply map settings
let newMapData = loadMapData(mapName);
if (newMapData && newMapData.settings)
{
for (let prop in newMapData.settings)
mapSettings[prop] = newMapData.settings[prop];
if (playerData)
mapSettings.PlayerData = playerData;
}
if (mapSettings.PlayerData)
sanitizePlayerData(mapSettings.PlayerData);
// Reload, as the maptype or mapfilter might have changed
reloadMapList();
g_GameAttributes.settings.RatingEnabled = Engine.HasXmppClient();
Engine.SetRankedGame(g_GameAttributes.settings.RatingEnabled);
supplementDefaults();
g_IsInGuiUpdate = false;
}
function savePersistMatchSettings()
{
if (g_IsTutorial)
return;
let attributes = Engine.ConfigDB_GetValue("user", "persistmatchsettings") == "true" ? g_GameAttributes : {};
Engine.WriteJSONFile(g_IsNetworked ? g_MatchSettings_MP : g_MatchSettings_SP, attributes);
}
function sanitizePlayerData(playerData)
{
// Remove gaia
if (playerData.length && !playerData[0])
playerData.shift();
playerData.forEach((pData, index) => {
// Use defaults if the map doesn't specify a value
for (let prop in g_DefaultPlayerData[index])
if (!(prop in pData))
pData[prop] = g_DefaultPlayerData[index][prop];
// Replace colors with the best matching color of PlayerDefaults
if (g_GameAttributes.mapType != "scenario")
{
let colorDistances = g_PlayerColorPickerList.map(color => colorDistance(color, pData.Color));
let smallestDistance = colorDistances.find(distance => colorDistances.every(distance2 => (distance2 >= distance)));
pData.Color = g_PlayerColorPickerList.find(color => colorDistance(color, pData.Color) == smallestDistance);
}
// If there is a player in that slot, then there can't be an AI
if (Object.keys(g_PlayerAssignments).some(guid => g_PlayerAssignments[guid].player == index + 1))
pData.AI = "";
});
ensureUniquePlayerColors(playerData);
}
function cancelSetup()
{
if (g_IsController)
savePersistMatchSettings();
Engine.DisconnectNetworkGame();
if (Engine.HasXmppClient())
{
Engine.LobbySetPlayerPresence("available");
if (g_IsController)
Engine.SendUnregisterGame();
Engine.SwitchGuiPage("page_lobby.xml");
}
else
Engine.SwitchGuiPage("page_pregame.xml");
}
/**
* Can't init the GUI before the first tick.
* Process netmessages afterwards.
*/
function onTick()
{
if (!g_Settings)
return;
// First tick happens before first render, so don't load yet
if (g_LoadingState == 0)
++g_LoadingState;
else if (g_LoadingState == 1)
{
initGUIObjects();
++g_LoadingState;
}
else if (g_LoadingState == 2)
handleNetMessages();
updateTimers();
}
/**
* Handles all pending messages sent by the net client.
*/
function handleNetMessages()
{
while (g_IsNetworked)
{
let message = Engine.PollNetworkClient();
if (!message)
break;
log("Net message: " + uneval(message));
if (g_NetMessageTypes[message.type])
g_NetMessageTypes[message.type](message);
else
error("Unrecognised net message type " + message.type);
}
}
/**
* Called when the map or the number of players changes.
*/
function unassignInvalidPlayers(maxPlayers)
{
if (g_IsNetworked)
{
// Remove invalid playerIDs from the servers playerassignments copy
for (let playerID = +maxPlayers + 1; playerID <= g_MaxPlayers; ++playerID)
Engine.AssignNetworkPlayer(playerID, "");
}
else if (g_PlayerAssignments.local.player > maxPlayers)
g_PlayerAssignments.local.player = -1;
}
function ensureUniquePlayerColors(playerData)
{
for (let i = playerData.length - 1; i >= 0; --i)
// If someone else has that color, assign an unused color
if (playerData.some((pData, j) => i != j && sameColor(playerData[i].Color, pData.Color)))
playerData[i].Color = g_PlayerColorPickerList.find(color => playerData.every(pData => !sameColor(color, pData.Color)));
}
function selectMap(name)
{
// Reset some map specific properties which are not necessarily redefined on each map
for (let prop of ["TriggerScripts", "CircularMap", "Garrison", "DisabledTemplates"])
g_GameAttributes.settings[prop] = undefined;
let mapData = loadMapData(name);
let mapSettings = mapData && mapData.settings ? deepcopy(mapData.settings) : {};
// Reset victory conditions
if (g_GameAttributes.mapType != "random")
{
let victoryIdx = g_VictoryConditions.Name.indexOf(mapSettings.GameType || "") != -1 ? g_VictoryConditions.Name.indexOf(mapSettings.GameType) : g_VictoryConditions.Default;
g_GameAttributes.settings.GameType = g_VictoryConditions.Name[victoryIdx];
g_GameAttributes.settings.VictoryScripts = g_VictoryConditions.Scripts[victoryIdx];
}
if (g_GameAttributes.mapType == "scenario")
{
delete g_GameAttributes.settings.VictoryDuration;
delete g_GameAttributes.settings.LastManStanding;
+ delete g_GameAttributes.settings.RegicideGarrison;
}
if (mapSettings.PlayerData)
sanitizePlayerData(mapSettings.PlayerData);
// Copy any new settings
g_GameAttributes.map = name;
g_GameAttributes.script = mapSettings.Script;
if (g_GameAttributes.map !== "random")
for (let prop in mapSettings)
g_GameAttributes.settings[prop] = mapSettings[prop];
unassignInvalidPlayers(g_GameAttributes.settings.PlayerData.length);
supplementDefaults();
}
function isControlArrayElementHidden(idx)
{
return idx !== undefined && idx >= g_GameAttributes.settings.PlayerData.length;
}
/**
* @param idx - Only specified for dropdown arrays.
*/
function updateGUIDropdown(name, idx = undefined)
{
let [guiName, guiIdx] = getGUIObjectNameFromSetting(name);
let idxName = idx === undefined ? "": "[" + idx + "]";
let dropdown = Engine.GetGUIObjectByName(guiName + guiIdx + idxName);
let label = Engine.GetGUIObjectByName(guiName + "Text" + guiIdx + idxName);
let frame = Engine.GetGUIObjectByName(guiName + "Frame" + guiIdx + idxName);
let title = Engine.GetGUIObjectByName(guiName + "Title" + guiIdx + idxName);
let indexHidden = isControlArrayElementHidden(idx);
let obj = (idx === undefined ? g_Dropdowns : g_PlayerDropdowns)[name];
let selected = indexHidden ? -1 : dropdown.list_data.indexOf(String(obj.get(idx)));
let enabled = !indexHidden && (!obj.enabled || obj.enabled(idx));
let hidden = indexHidden || obj.hidden && obj.hidden(idx);
dropdown.hidden = !g_IsController || !enabled || hidden;
dropdown.selected = indexHidden ? -1 : selected;
dropdown.tooltip = !indexHidden && obj.tooltip ? obj.tooltip(-1, idx) : "";
if (frame)
frame.hidden = hidden;
if (title && obj.title && !indexHidden)
title.caption = sprintf(translate("%(option)s:"), { "option": obj.title(idx) });
if (label && !indexHidden)
{
label.hidden = g_IsController && enabled || hidden;
label.caption = selected == -1 ? translateWithContext("option value", "Unknown") : dropdown.list[selected];
}
}
/**
* Not used for the player assignments, so playerCheckboxes are not implemented,
* hence no index.
*/
function updateGUICheckbox(name)
{
let obj = g_Checkboxes[name];
let checked = obj.get();
let hidden = obj.hidden && obj.hidden();
let enabled = !obj.enabled || obj.enabled();
let [guiName, guiIdx] = getGUIObjectNameFromSetting(name);
let checkbox = Engine.GetGUIObjectByName(guiName + guiIdx);
let label = Engine.GetGUIObjectByName(guiName + "Text" + guiIdx);
let frame = Engine.GetGUIObjectByName(guiName + "Frame" + guiIdx);
let title = Engine.GetGUIObjectByName(guiName + "Title" + guiIdx);
checkbox.checked = checked;
checkbox.enabled = enabled;
checkbox.hidden = hidden || !g_IsController;
checkbox.tooltip = obj.tooltip ? obj.tooltip() : "";
label.caption = checked ? translate("Yes") : translate("No");
label.hidden = hidden || g_IsController;
if (frame)
frame.hidden = hidden;
if (title && obj.title)
title.caption = sprintf(translate("%(option)s:"), { "option": obj.title() });
}
function updateGUIMiscControl(name, idx)
{
let idxName = idx === undefined ? "": "[" + idx + "]";
let obj = (idx === undefined ? g_MiscControls : g_PlayerMiscControls)[name];
let control = Engine.GetGUIObjectByName(name + idxName);
if (!control)
warn("No GUI object with name '" + name + "'");
let hide = isControlArrayElementHidden(idx);
control.hidden = hide;
if (hide)
return;
for (let property in obj)
control[property] = obj[property](idx);
}
function launchGame()
{
if (!g_IsController)
{
error("Only host can start game");
return;
}
if (!g_GameAttributes.map)
return;
savePersistMatchSettings();
// Select random map
if (g_GameAttributes.map == "random")
{
let victoryScriptsSelected = g_GameAttributes.settings.VictoryScripts;
let gameTypeSelected = g_GameAttributes.settings.GameType;
selectMap(pickRandom(g_Dropdowns.mapSelection.ids().slice(1)));
g_GameAttributes.settings.VictoryScripts = victoryScriptsSelected;
g_GameAttributes.settings.GameType = gameTypeSelected;
}
g_GameAttributes.settings.TriggerScripts = g_GameAttributes.settings.VictoryScripts.concat(g_GameAttributes.settings.TriggerScripts || []);
// Prevent reseting the readystate
g_GameStarted = true;
g_GameAttributes.settings.mapType = g_GameAttributes.mapType;
// Get a unique array of selectable cultures
let cultures = Object.keys(g_CivData).filter(civ => g_CivData[civ].SelectableInGameSetup).map(civ => g_CivData[civ].Culture);
cultures = cultures.filter((culture, index) => cultures.indexOf(culture) === index);
// Determine random civs and botnames
for (let i in g_GameAttributes.settings.PlayerData)
{
// Pick a random civ of a random culture
let chosenCiv = g_GameAttributes.settings.PlayerData[i].Civ || "random";
if (chosenCiv == "random")
{
let culture = pickRandom(cultures);
chosenCiv = pickRandom(Object.keys(g_CivData).filter(civ => g_CivData[civ].Culture == culture));
}
g_GameAttributes.settings.PlayerData[i].Civ = chosenCiv;
// Pick one of the available botnames for the chosen civ
if (g_GameAttributes.mapType === "scenario" || !g_GameAttributes.settings.PlayerData[i].AI)
continue;
let chosenName = pickRandom(g_CivData[chosenCiv].AINames);
if (!g_IsNetworked)
chosenName = translate(chosenName);
// Count how many players use the chosenName
let usedName = g_GameAttributes.settings.PlayerData.filter(pData => pData.Name && pData.Name.indexOf(chosenName) !== -1).length;
g_GameAttributes.settings.PlayerData[i].Name = !usedName ? chosenName : sprintf(translate("%(playerName)s %(romanNumber)s"), { "playerName": chosenName, "romanNumber": g_RomanNumbers[usedName+1] });
}
// Copy playernames for the purpose of replays
for (let guid in g_PlayerAssignments)
{
let player = g_PlayerAssignments[guid];
if (player.player > 0) // not observer or GAIA
g_GameAttributes.settings.PlayerData[player.player - 1].Name = player.name;
}
// Seed used for both map generation and simulation
g_GameAttributes.settings.Seed = randIntExclusive(0, Math.pow(2, 32));
g_GameAttributes.settings.AISeed = randIntExclusive(0, Math.pow(2, 32));
// Used for identifying rated game reports for the lobby
g_GameAttributes.matchID = Engine.GetMatchID();
if (g_IsNetworked)
{
Engine.SetNetworkGameAttributes(g_GameAttributes);
Engine.StartNetworkGame();
}
else
{
// Find the player ID which the user has been assigned to
let playerID = -1;
for (let i in g_GameAttributes.settings.PlayerData)
{
let assignBox = Engine.GetGUIObjectByName("playerAssignment["+i+"]");
if (assignBox.list_data[assignBox.selected] == "guid:local")
playerID = +i+1;
}
Engine.StartGame(g_GameAttributes, playerID);
Engine.SwitchGuiPage("page_loading.xml", {
"attribs": g_GameAttributes,
"isNetworked": g_IsNetworked,
"playerAssignments": g_PlayerAssignments
});
}
}
function launchTutorial()
{
g_GameAttributes.mapType = "scenario";
selectMap("maps/tutorials/starting_economy_walkthrough");
launchGame();
}
/**
* Don't set any attributes here, just show the changes in the GUI.
*
* Unless the mapsettings don't specify a property and the user didn't set it in g_GameAttributes previously.
*/
function updateGUIObjects()
{
g_IsInGuiUpdate = true;
updatePlayerAssignmentChoices();
// Hide exceeding dropdowns and checkboxes
for (let panel in g_OptionOrderGUI)
for (let child of Engine.GetGUIObjectByName(panel + "Options").children)
child.hidden = true;
// Show the relevant ones
for (let name in g_Dropdowns)
updateGUIDropdown(name);
for (let name in g_Checkboxes)
updateGUICheckbox(name);
for (let i = 0; i < g_MaxPlayers; ++i)
{
for (let name in g_PlayerDropdowns)
updateGUIDropdown(name, i);
for (let name in g_PlayerMiscControls)
updateGUIMiscControl(name, i);
}
for (let name in g_MiscControls)
updateGUIMiscControl(name);
updateGameDescription();
resizeMoreOptionsWindow();
rightAlignCancelButton();
updateAutocompleteEntries();
g_IsInGuiUpdate = false;
// Refresh AI config page
if (g_LastViewedAIPlayer != -1)
{
Engine.PopGuiPage();
openAIConfig(g_LastViewedAIPlayer);
}
}
function rightAlignCancelButton()
{
const offset = 10;
let startGame = Engine.GetGUIObjectByName("startGame");
let right = startGame.hidden ? startGame.size.right : startGame.size.left - offset;
let cancelGame = Engine.GetGUIObjectByName("cancelGame");
let cancelGameSize = cancelGame.size;
let buttonWidth = cancelGameSize.right - cancelGameSize.left;
cancelGameSize.right = right;
right -= buttonWidth;
for (let element of ["cheatWarningText", "onscreenToolTip"])
{
let elementSize = Engine.GetGUIObjectByName(element).size;
elementSize.right = right - (cancelGameSize.left - elementSize.right);
Engine.GetGUIObjectByName(element).size = elementSize;
}
cancelGameSize.left = right;
cancelGame.size = cancelGameSize;
}
function updateGameDescription()
{
setMapPreviewImage("mapPreview", getMapPreview(g_GameAttributes.map));
Engine.GetGUIObjectByName("mapInfoName").caption =
translateMapTitle(getMapDisplayName(g_GameAttributes.map));
Engine.GetGUIObjectByName("mapInfoDescription").caption = getGameDescription();
}
/**
* Broadcast the changed settings to all clients and the lobbybot.
*/
function updateGameAttributes()
{
if (g_IsInGuiUpdate || !g_IsController)
return;
if (g_IsNetworked)
{
Engine.SetNetworkGameAttributes(g_GameAttributes);
if (g_LoadingState >= 2)
sendRegisterGameStanza();
resetReadyData();
}
else
updateGUIObjects();
}
function openAIConfig(playerSlot)
{
g_LastViewedAIPlayer = playerSlot;
Engine.PushGuiPage("page_aiconfig.xml", {
"callback": "AIConfigCallback",
"isController": g_IsController,
"playerSlot": playerSlot,
"id": g_GameAttributes.settings.PlayerData[playerSlot].AI,
"difficulty": g_GameAttributes.settings.PlayerData[playerSlot].AIDiff
});
}
/**
* Called after closing the dialog.
*/
function AIConfigCallback(ai)
{
g_LastViewedAIPlayer = -1;
if (!ai.save || !g_IsController)
return;
g_GameAttributes.settings.PlayerData[ai.playerSlot].AI = ai.id;
g_GameAttributes.settings.PlayerData[ai.playerSlot].AIDiff = ai.difficulty;
updateGameAttributes();
}
function updatePlayerAssignmentChoices()
{
let playerChoices = sortGUIDsByPlayerID().map(guid => ({
"Choice": "guid:" + guid,
"Color": g_PlayerAssignments[guid].player == -1 ? g_PlayerAssignmentColors.observer : g_PlayerAssignmentColors.player,
"Name": g_PlayerAssignments[guid].name
}));
// Only display hidden AIs if the map preselects them
let aiChoices = g_Settings.AIDescriptions
.filter(ai => !ai.data.hidden || g_GameAttributes.settings.PlayerData.some(pData => pData.AI == ai.id))
.map(ai => ({
"Choice": "ai:" + ai.id,
"Name": sprintf(translate("AI: %(ai)s"), {
"ai": translate(ai.data.name)
}),
"Color": g_PlayerAssignmentColors.AI
}));
let unassignedSlot = [{
"Choice": "unassigned",
"Name": translate("Unassigned"),
"Color": g_PlayerAssignmentColors.unassigned
}];
g_PlayerAssignmentList = prepareForDropdown(playerChoices.concat(aiChoices).concat(unassignedSlot));
initPlayerDropdowns("playerAssignment");
}
function swapPlayers(guid, newSlot)
{
// Player slots are indexed from 0 as Gaia is omitted.
let newPlayerID = newSlot + 1;
let playerID = g_PlayerAssignments[guid].player;
// Attempt to swap the player or AI occupying the target slot,
// if any, into the slot this player is currently in.
if (playerID != -1)
{
for (let guid in g_PlayerAssignments)
{
// Move the player in the destination slot into the current slot.
if (g_PlayerAssignments[guid].player != newPlayerID)
continue;
if (g_IsNetworked)
Engine.AssignNetworkPlayer(playerID, guid);
else
g_PlayerAssignments[guid].player = playerID;
break;
}
// Transfer the AI from the target slot to the current slot.
g_GameAttributes.settings.PlayerData[playerID - 1].AI = g_GameAttributes.settings.PlayerData[newSlot].AI;
g_GameAttributes.settings.PlayerData[playerID - 1].AIDiff = g_GameAttributes.settings.PlayerData[newSlot].AIDiff;
// Swap civilizations if they aren't fixed
if (g_GameAttributes.mapType != "scenario")
{
[g_GameAttributes.settings.PlayerData[playerID - 1].Civ, g_GameAttributes.settings.PlayerData[newSlot].Civ] =
[g_GameAttributes.settings.PlayerData[newSlot].Civ, g_GameAttributes.settings.PlayerData[playerID - 1].Civ];
}
}
if (g_IsNetworked)
Engine.AssignNetworkPlayer(newPlayerID, guid);
else
g_PlayerAssignments[guid].player = newPlayerID;
g_GameAttributes.settings.PlayerData[newSlot].AI = "";
}
function submitChatInput()
{
let input = Engine.GetGUIObjectByName("chatInput");
let text = input.caption;
if (!text.length)
return;
input.caption = "";
if (executeNetworkCommand(text))
return;
Engine.SendNetworkChat(text);
}
function senderFont(text)
{
return '[font="' + g_SenderFont + '"]' + text + '[/font]';
}
function systemMessage(message)
{
return senderFont(sprintf(translate("== %(message)s"), { "message": message }));
}
function colorizePlayernameByGUID(guid, username = "")
{
// TODO: Maybe the host should have the moderator-prefix?
if (!username)
username = g_PlayerAssignments[guid] ? escapeText(g_PlayerAssignments[guid].name) : translate("Unknown Player");
let playerID = g_PlayerAssignments[guid] ? g_PlayerAssignments[guid].player : -1;
let color = g_ColorRegular;
if (playerID > 0)
{
color = g_GameAttributes.settings.PlayerData[playerID - 1].Color;
// Enlighten playercolor to improve readability
let [h, s, l] = rgbToHsl(color.r, color.g, color.b);
let [r, g, b] = hslToRgb(h, s, Math.max(0.6, l));
color = rgbToGuiColor({ "r": r, "g": g, "b": b });
}
return '[color="'+ color +'"]' + username + '[/color]';
}
function addChatMessage(msg)
{
if (!g_FormatChatMessage[msg.type])
return;
if (msg.type == "chat")
{
let userName = g_PlayerAssignments[Engine.GetPlayerGUID()].name;
if (userName != g_PlayerAssignments[msg.guid].name)
notifyUser(userName, msg.text);
}
let user = colorizePlayernameByGUID(msg.guid || -1, msg.username || "");
let text = g_FormatChatMessage[msg.type](msg, user);
if (!text)
return;
if (Engine.ConfigDB_GetValue("user", "chat.timestamp") == "true")
text = sprintf(translate("%(time)s %(message)s"), {
"time": sprintf(translate("\\[%(time)s]"), {
"time": Engine.FormatMillisecondsIntoDateStringLocal(new Date().getTime(), translate("HH:mm"))
}),
"message": text
});
g_ChatMessages.push(text);
Engine.GetGUIObjectByName("chatText").caption = g_ChatMessages.join("\n");
}
function showMoreOptions(show)
{
Engine.GetGUIObjectByName("moreOptionsFade").hidden = !show;
Engine.GetGUIObjectByName("moreOptions").hidden = !show;
}
function resetCivilizations()
{
for (let i in g_GameAttributes.settings.PlayerData)
g_GameAttributes.settings.PlayerData[i].Civ = "random";
updateGameAttributes();
}
function resetTeams()
{
for (let i in g_GameAttributes.settings.PlayerData)
g_GameAttributes.settings.PlayerData[i].Team = -1;
updateGameAttributes();
}
function toggleReady()
{
setReady((g_IsReady + 1) % 3, true);
}
function setReady(ready, sendMessage)
{
g_IsReady = ready;
if (sendMessage)
Engine.SendNetworkReady(g_IsReady);
updateGUIObjects();
}
function resetReadyData()
{
if (g_GameStarted)
return;
if (g_ReadyChanged < 1)
addChatMessage({ "type": "settings" });
else if (g_ReadyChanged == 2 && !g_ReadyInit)
return; // duplicate calls on init
else
g_ReadyInit = false;
g_ReadyChanged = 2;
if (!g_IsNetworked)
g_IsReady = 2;
else if (g_IsController)
{
Engine.ClearAllPlayerReady();
setReady(2, true);
}
else if (g_IsReady != 2)
setReady(0, false);
}
/**
* Send a list of playernames and distinct between players and observers.
* Don't send teams, AIs or anything else until the game was started.
* The playerData format from g_GameAttributes is kept to reuse the GUI function presenting the data.
*/
function formatClientsForStanza()
{
let connectedPlayers = 0;
let playerData = [];
for (let guid in g_PlayerAssignments)
{
let pData = { "Name": g_PlayerAssignments[guid].name };
if (g_GameAttributes.settings.PlayerData[g_PlayerAssignments[guid].player - 1])
++connectedPlayers;
else
pData.Team = "observer";
playerData.push(pData);
}
return {
"list": playerDataToStringifiedTeamList(playerData),
"connectedPlayers": connectedPlayers
};
}
/**
* Send the relevant gamesettings to the lobbybot.
*/
function sendRegisterGameStanza()
{
if (!g_IsController || !Engine.HasXmppClient())
return;
let clients = formatClientsForStanza();
let stanza = {
"name": g_ServerName,
"port": g_ServerPort,
"mapName": g_GameAttributes.map,
"niceMapName": getMapDisplayName(g_GameAttributes.map),
"mapSize": g_GameAttributes.mapType == "random" ? g_GameAttributes.settings.Size : "Default",
"mapType": g_GameAttributes.mapType,
"victoryCondition": g_VictoryConditions.Title[g_VictoryConditions.Name.indexOf(g_GameAttributes.settings.GameType)],
"nbp": clients.connectedPlayers,
"maxnbp": g_GameAttributes.settings.PlayerData.length,
"players": clients.list,
};
// Only send the stanza if the relevant settings actually changed
if (g_LastGameStanza && Object.keys(stanza).every(prop => g_LastGameStanza[prop] == stanza[prop]))
return;
g_LastGameStanza = stanza;
Engine.SendRegisterGame(stanza);
}
function updateAutocompleteEntries()
{
g_Autocomplete = [];
for (let control of [g_Dropdowns, g_Checkboxes])
for (let name in control)
g_Autocomplete = g_Autocomplete.concat(control[name].title());
for (let dropdown of [g_Dropdowns, g_PlayerDropdowns])
for (let name in dropdown)
if (dropdown[name].autocomplete)
g_Autocomplete = g_Autocomplete.concat(dropdown[name].labels());
}
Index: ps/trunk/binaries/data/mods/public/gui/session/unit_actions.js
===================================================================
--- ps/trunk/binaries/data/mods/public/gui/session/unit_actions.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/gui/session/unit_actions.js (revision 19631)
@@ -1,1478 +1,1477 @@
/**
* Which enemy entity types will be attacked on sight when patroling.
*/
var g_PatrolTargets = ["Unit"];
/**
* List of different actions units can execute,
* this is mostly used to determine which actions can be executed
*
* "execute" is meant to send the command to the engine
*
* The next functions will always return false
* in case you have to continue to seek
* (i.e. look at the next entity for getActionInfo, the next
* possible action for the actionCheck ...)
* They will return an object when the searching is finished
*
* "getActionInfo" is used to determine if the action is possible,
* and also give visual feedback to the user (tooltips, cursors, ...)
*
* "preSelectedActionCheck" is used to select actions when the gui buttons
* were used to set them, but still require a target (like the guard button)
*
* "hotkeyActionCheck" is used to check the possibility of actions when
* a hotkey is pressed
*
* "actionCheck" is used to check the possibilty of actions without specific
* command. For that, the specificness variable is used
*
* "specificness" is used to determine how specific an action is,
* The lower the number, the more specific an action is, and the bigger
* the chance of selecting that action when multiple actions are possible
*/
var unitActions =
{
"move":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "walk",
"entities": selection,
"x": target.x,
"z": target.z,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_walk",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
return { "possible": true };
},
"actionCheck": function(target, selection)
{
if (!someUnitAI(selection) || !getActionInfo("move", target).possible)
return false;
return { "type": "move" };
},
"specificness": 12,
},
"attack-move":
{
"execute": function(target, action, selection, queued)
{
let targetClasses;
if (Engine.HotkeyIsPressed("session.attackmoveUnit"))
targetClasses = { "attack": ["Unit"] };
else
targetClasses = { "attack": ["Unit", "Structure"] };
Engine.PostNetworkCommand({
"type": "attack-walk",
"entities": selection,
"x": target.x,
"z": target.z,
"targetClasses": targetClasses,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_walk",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
return { "possible": true };
},
"hotkeyActionCheck": function(target, selection)
{
if (!someUnitAI(selection) ||
!Engine.HotkeyIsPressed("session.attackmove") ||
!getActionInfo("attack-move", target).possible)
return false;
return {
"type": "attack-move",
"cursor": "action-attack-move"
};
},
"specificness": 30,
},
"capture":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "attack",
"entities": selection,
"target": action.target,
"allowCapture": true,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_attack",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (!entState.attack || !targetState.hitpoints)
return false;
return {
"possible": Engine.GuiInterfaceCall("CanAttack", {
"entity": entState.id,
"target": targetState.id,
"types": ["Capture"]
})
};
},
"actionCheck": function(target)
{
if (!getActionInfo("capture", target).possible)
return false;
return {
"type": "capture",
"cursor": "action-capture",
"target": target
};
},
"specificness": 9,
},
"attack":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "attack",
"entities": selection,
"target": action.target,
"queued": queued,
"allowCapture": false
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_attack",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (!entState.attack || !targetState.hitpoints)
return false;
return {
"possible": Engine.GuiInterfaceCall("CanAttack", {
"entity": entState.id,
"target": targetState.id,
"types": ["!Capture"]
})
};
},
"hotkeyActionCheck": function(target)
{
if (!Engine.HotkeyIsPressed("session.attack") ||
!getActionInfo("attack", target).possible)
return false;
return {
"type": "attack",
"cursor": "action-attack",
"target": target
};
},
"actionCheck": function(target)
{
if (!getActionInfo("attack", target).possible)
return false;
return {
"type": "attack",
"cursor": "action-attack",
"target": target
};
},
"specificness": 10,
},
"patrol":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "patrol",
"entities": selection,
"x": target.x,
"z": target.z,
"target": action.target,
"targetClasses": { "attack": g_PatrolTargets },
"queued": queued,
"allowCapture": false
});
Engine.GuiInterfaceCall("PlaySound", { "name": "order_patrol", "entity": selection[0] });
return true;
},
"getActionInfo": function(entState, targetState)
{
if (!entState.unitAI || !entState.unitAI.canPatrol)
return false;
return { "possible": true };
},
"hotkeyActionCheck": function(target, selection)
{
if (!someCanPatrol(selection) ||
!Engine.HotkeyIsPressed("session.patrol") ||
!getActionInfo("patrol", target).possible)
return false;
return {
"type": "patrol",
"cursor": "action-patrol",
"target": target
};
},
"preSelectedActionCheck" : function(target)
{
if (preSelectedAction != ACTION_PATROL || !getActionInfo("patrol", target).possible)
return false;
return {
"type": "patrol",
"cursor": "action-patrol",
"target": target
};
},
"specificness": 37,
},
"heal":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "heal",
"entities": selection,
"target": action.target,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_heal",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (!entState.heal ||
!hasClass(targetState, "Unit") || !targetState.needsHeal ||
!playerCheck(entState, targetState, ["Player", "Ally"]) ||
entState.id == targetState.id) // Healers can't heal themselves.
return false;
let unhealableClasses = entState.heal.unhealableClasses;
if (MatchesClassList(targetState.identity.classes, unhealableClasses))
return false;
let healableClasses = entState.heal.healableClasses;
if (!MatchesClassList(targetState.identity.classes, healableClasses))
return false;
return { "possible": true };
},
"actionCheck": function(target)
{
if (!getActionInfo("heal", target).possible)
return false;
return {
"type": "heal",
"cursor": "action-heal",
"target": target
};
},
"specificness": 7,
},
"build":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "repair",
"entities": selection,
"target": action.target,
"autocontinue": true,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_repair",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (!targetState.foundation || !entState.builder ||
!playerCheck(entState, targetState, ["Player", "Ally"]))
return false;
return { "possible": true };
},
"actionCheck": function(target)
{
if (!getActionInfo("build", target).possible)
return false;
return {
"type": "build",
"cursor": "action-build",
"target": target
};
},
"specificness": 3,
},
"repair":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "repair",
"entities": selection,
"target": action.target,
"autocontinue": true,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_repair",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (!entState.builder ||
!targetState.needsRepair && !targetState.foundation ||
!playerCheck(entState, targetState, ["Player", "Ally"]))
return false;
return { "possible": true };
},
"preSelectedActionCheck" : function(target)
{
if (preSelectedAction != ACTION_REPAIR)
return false;
if (getActionInfo("repair", target).possible)
return {
"type": "repair",
"cursor": "action-repair",
"target": target
};
return {
"type": "none",
"cursor": "action-repair-disabled",
"target": null
};
},
"hotkeyActionCheck": function(target)
{
if (!Engine.HotkeyIsPressed("session.repair") ||
!getActionInfo("repair", target).possible)
return false;
return {
"type": "build",
"cursor": "action-repair",
"target": target
};
},
"actionCheck": function(target)
{
if (!getActionInfo("repair", target).possible)
return false;
return {
"type": "build",
"cursor": "action-repair",
"target": target
};
},
"specificness": 11,
},
"gather":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "gather",
"entities": selection,
"target": action.target,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_gather",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (!targetState.resourceSupply)
return false;
let resource = findGatherType(entState, targetState.resourceSupply);
if (!resource)
return false;
return {
"possible": true,
"cursor": "action-gather-" + resource
};
},
"actionCheck": function(target)
{
let actionInfo = getActionInfo("gather", target);
if (!actionInfo.possible)
return false;
return {
"type": "gather",
"cursor": actionInfo.cursor,
"target": target
};
},
"specificness": 1,
},
"returnresource":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "returnresource",
"entities": selection,
"target": action.target,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_gather",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (!targetState.resourceDropsite)
return false;
let playerState = GetSimState().players[entState.player];
if (playerState.hasSharedDropsites && targetState.resourceDropsite.shared)
{
if (!playerCheck(entState, targetState, ["Player", "MutualAlly"]))
return false;
}
else if (!playerCheck(entState, targetState, ["Player"]))
return false;
if (!entState.resourceCarrying || !entState.resourceCarrying.length)
return false;
let carriedType = entState.resourceCarrying[0].type;
if (targetState.resourceDropsite.types.indexOf(carriedType) == -1)
return false;
return {
"possible": true,
"cursor": "action-return-" + carriedType
};
},
"actionCheck": function(target)
{
let actionInfo = getActionInfo("returnresource", target);
if (!actionInfo.possible)
return false;
return {
"type": "returnresource",
"cursor": actionInfo.cursor,
"target": target
};
},
"specificness": 2,
},
"setup-trade-route":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "setup-trade-route",
"entities": selection,
"target": action.target,
"source": null,
"route": null,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_trade",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (targetState.foundation || !entState.trader || !targetState.market ||
playerCheck(entState, targetState, ["Enemy"]) ||
!(targetState.market.land && hasClass(entState, "Organic") ||
targetState.market.naval && hasClass(entState, "Ship")))
return false;
let tradingDetails = Engine.GuiInterfaceCall("GetTradingDetails", {
"trader": entState.id,
"target": targetState.id
});
if (!tradingDetails)
return false;
let tooltip;
switch (tradingDetails.type)
{
case "is first":
tooltip = translate("Origin trade market.") + "\n";
if (tradingDetails.hasBothMarkets)
tooltip += sprintf(translate("Gain: %(gain)s"), {
"gain": getTradingTooltip(tradingDetails.gain)
});
else
tooltip += translate("Right-click on another market to set it as a destination trade market.");
break;
case "is second":
tooltip = translate("Destination trade market.") + "\n" +
sprintf(translate("Gain: %(gain)s"), {
"gain": getTradingTooltip(tradingDetails.gain)
});
break;
case "set first":
tooltip = translate("Right-click to set as origin trade market");
break;
case "set second":
if (tradingDetails.gain.traderGain == 0) // markets too close
return false;
tooltip = translate("Right-click to set as destination trade market.") + "\n" +
sprintf(translate("Gain: %(gain)s"), {
"gain": getTradingTooltip(tradingDetails.gain)
});
break;
}
return {
"possible": true,
"tooltip": tooltip
};
},
"actionCheck": function(target)
{
let actionInfo = getActionInfo("setup-trade-route", target);
if (!actionInfo.possible)
return false;
return {
"type": "setup-trade-route",
"cursor": "action-setup-trade-route",
"tooltip": actionInfo.tooltip,
"target": target
};
},
"specificness": 0,
},
"garrison":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "garrison",
"entities": selection,
"target": action.target,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_garrison",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
- if (!hasClass(entState, "Unit") ||
- !targetState.garrisonHolder ||
+ if (!entState.canGarrison || !targetState.garrisonHolder ||
!playerCheck(entState, targetState, ["Player", "MutualAlly"]))
return false;
let tooltip = sprintf(translate("Current garrison: %(garrisoned)s/%(capacity)s"), {
"garrisoned": targetState.garrisonHolder.garrisonedEntitiesCount,
"capacity": targetState.garrisonHolder.capacity
});
let extraCount = 0;
if (entState.garrisonHolder)
extraCount += entState.garrisonHolder.garrisonedEntitiesCount;
if (targetState.garrisonHolder.garrisonedEntitiesCount + extraCount >= targetState.garrisonHolder.capacity)
tooltip = "[color=\"orange\"]" + tooltip + "[/color]";
if (!MatchesClassList(entState.identity.classes, targetState.garrisonHolder.allowedClasses))
return false;
return {
"possible": true,
"tooltip": tooltip
};
},
"preSelectedActionCheck": function(target)
{
if (preSelectedAction != ACTION_GARRISON)
return false;
let actionInfo = getActionInfo("garrison", target);
if (!actionInfo.possible)
return {
"type": "none",
"cursor": "action-garrison-disabled",
"target": null
};
return {
"type": "garrison",
"cursor": "action-garrison",
"tooltip": actionInfo.tooltip,
"target": target
};
},
"hotkeyActionCheck": function(target)
{
let actionInfo = getActionInfo("garrison", target);
if (!Engine.HotkeyIsPressed("session.garrison") || !actionInfo.possible)
return false;
return {
"type": "garrison",
"cursor": "action-garrison",
"tooltip": actionInfo.tooltip,
"target": target
};
},
"specificness": 20,
},
"guard":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "guard",
"entities": selection,
"target": action.target,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_guard",
"entity": selection[0]
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (!targetState.guard ||
!playerCheck(entState, targetState, ["Player", "Ally"]) ||
!entState.unitAI || !entState.unitAI.canGuard ||
targetState.unitAI && targetState.unitAI.isGuarding)
return false;
return { "possible": true };
},
"preSelectedActionCheck" : function(target)
{
if (preSelectedAction != ACTION_GUARD)
return false;
if (getActionInfo("guard", target).possible)
return {
"type": "guard",
"cursor": "action-guard",
"target": target
};
return {
"type": "none",
"cursor": "action-guard-disabled",
"target": null
};
},
"hotkeyActionCheck": function(target)
{
if (!Engine.HotkeyIsPressed("session.guard") ||
!getActionInfo("guard", target).possible)
return false;
return {
"type": "guard",
"cursor": "action-guard",
"target": target
};
},
"specificness": 40,
},
"remove-guard":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "remove-guard",
"entities": selection,
"target": action.target,
"queued": queued
});
Engine.GuiInterfaceCall("PlaySound", {
"name": "order_guard",
"entity": selection[0]
});
return true;
},
"hotkeyActionCheck": function(target, selection)
{
if (!Engine.HotkeyIsPressed("session.guard") ||
!getActionInfo("remove-guard", target).possible ||
!someGuarding(selection))
return false;
return {
"type": "remove-guard",
"cursor": "action-remove-guard"
};
},
"specificness": 41,
},
"set-rallypoint":
{
"execute": function(target, action, selection, queued)
{
// if there is a position set in the action then use this so that when setting a
// rally point on an entity it is centered on that entity
if (action.position)
target = action.position;
Engine.PostNetworkCommand({
"type": "set-rallypoint",
"entities": selection,
"x": target.x,
"z": target.z,
"data": action.data,
"queued": queued
});
// Display rally point at the new coordinates, to avoid display lag
Engine.GuiInterfaceCall("DisplayRallyPoint", {
"entities": selection,
"x": target.x,
"z": target.z,
"queued": queued
});
return true;
},
"getActionInfo": function(entState, targetState)
{
let tooltip;
// default to walking there (or attack-walking if hotkey pressed)
let data = { "command": "walk" };
let cursor = "";
if (Engine.HotkeyIsPressed("session.attackmove"))
{
let targetClasses;
if (Engine.HotkeyIsPressed("session.attackmoveUnit"))
targetClasses = { "attack": ["Unit"] };
else
targetClasses = { "attack": ["Unit", "Structure"] };
data.command = "attack-walk";
data.targetClasses = targetClasses;
cursor = "action-attack-move";
}
if (Engine.HotkeyIsPressed("session.repair") &&
(targetState.needsRepair || targetState.foundation) &&
playerCheck(entState, targetState, ["Player", "Ally"]))
{
data.command = "repair";
data.target = targetState.id;
cursor = "action-repair";
}
else if (targetState.garrisonHolder &&
playerCheck(entState, targetState, ["Player", "MutualAlly"]))
{
data.command = "garrison";
data.target = targetState.id;
cursor = "action-garrison";
tooltip = sprintf(translate("Current garrison: %(garrisoned)s/%(capacity)s"), {
"garrisoned": targetState.garrisonHolder.garrisonedEntitiesCount,
"capacity": targetState.garrisonHolder.capacity
});
if (targetState.garrisonHolder.garrisonedEntitiesCount >=
targetState.garrisonHolder.capacity)
tooltip = "[color=\"orange\"]" + tooltip + "[/color]";
}
else if (targetState.resourceSupply)
{
let resourceType = targetState.resourceSupply.type;
if (resourceType.generic == "treasure")
cursor = "action-gather-" + resourceType.generic;
else
cursor = "action-gather-" + resourceType.specific;
data.command = "gather";
data.resourceType = resourceType;
data.resourceTemplate = targetState.template;
}
else if (entState.market && targetState.market &&
entState.id != targetState.id &&
(!entState.market.naval || targetState.market.naval) &&
!playerCheck(entState, targetState, ["Enemy"]))
{
// Find a trader (if any) that this building can produce.
let trader;
if (entState.production && entState.production.entities.length)
for (let i = 0; i < entState.production.entities.length; ++i)
if ((trader = GetTemplateData(entState.production.entities[i]).trader))
break;
let traderData = {
"firstMarket": entState.id,
"secondMarket": targetState.id,
"template": trader
};
let gain = Engine.GuiInterfaceCall("GetTradingRouteGain", traderData);
if (gain && gain.traderGain)
{
data.command = "trade";
data.target = traderData.secondMarket;
data.source = traderData.firstMarket;
cursor = "action-setup-trade-route";
tooltip = translate("Right-click to establish a default route for new traders.") + "\n" +
sprintf(
trader ?
translate("Gain: %(gain)s") :
translate("Expected gain: %(gain)s"),
{ "gain": getTradingTooltip(gain) });
}
}
else if (targetState.foundation && playerCheck(entState, targetState, ["Ally"]))
{
data.command = "build";
data.target = targetState.id;
cursor = "action-build";
}
else if (targetState.needsRepair && playerCheck(entState, targetState, ["Ally"]))
{
data.command = "repair";
data.target = targetState.id;
cursor = "action-repair";
}
else if (playerCheck(entState, targetState, ["Enemy"]))
{
data.target = targetState.id;
data.command = "attack";
cursor = "action-attack";
}
// Don't allow the rally point to be set on any of the currently selected entities (used for unset)
// except if the autorallypoint hotkey is pressed and the target can produce entities
if (!Engine.HotkeyIsPressed("session.autorallypoint") ||
!targetState.production ||
!targetState.production.entities.length)
{
for (let ent in g_Selection.selected)
if (targetState.id == +ent)
return false;
}
return {
"possible": true,
"data": data,
"position": targetState.position,
"cursor": cursor,
"tooltip": tooltip
};
},
"actionCheck": function(target, selection)
{
if (someUnitAI(selection) || !someRallyPoints(selection))
return false;
let actionInfo = getActionInfo("set-rallypoint", target);
if (!actionInfo.possible)
return false;
return {
"type": "set-rallypoint",
"cursor": actionInfo.cursor,
"data": actionInfo.data,
"tooltip": actionInfo.tooltip,
"position": actionInfo.position
};
},
"specificness": 6,
},
"unset-rallypoint":
{
"execute": function(target, action, selection, queued)
{
Engine.PostNetworkCommand({
"type": "unset-rallypoint",
"entities": selection
});
// Remove displayed rally point
Engine.GuiInterfaceCall("DisplayRallyPoint", {
"entities": []
});
return true;
},
"getActionInfo": function(entState, targetState)
{
if (entState.id != targetState.id ||
!entState.rallyPoint || !entState.rallyPoint.position)
return false;
return { "possible": true };
},
"actionCheck": function(target, selection)
{
if (someUnitAI(selection) || !someRallyPoints(selection) ||
!getActionInfo("unset-rallypoint", target).possible)
return false;
return {
"type": "unset-rallypoint",
"cursor": "action-unset-rally"
};
},
"specificness": 11,
},
"none":
{
"execute": function(target, action, selection, queued)
{
return true;
},
"specificness": 100,
},
};
/**
* Info and actions for the entity commands
* Currently displayed in the bottom of the central panel
*/
var g_EntityCommands =
{
"unload-all": {
"getInfo": function(entStates)
{
let count = 0;
for (let entState of entStates)
if (entState.garrisonHolder)
count += entState.garrisonHolder.entities.length;
if (!count)
return false;
return {
"tooltip": colorizeHotkey("%(hotkey)s" + " ", "session.unload") +
translate("Unload All."),
"icon": "garrison-out.png",
"count": count,
};
},
"execute": function()
{
unloadAll();
},
},
"delete": {
"getInfo": function(entStates)
{
return entStates.some(entState => !isUndeletable(entState)) ?
{
"tooltip":
colorizeHotkey("%(hotkey)s" + " ", "session.kill") +
translate("Destroy the selected units or buildings.") + "\n" +
colorizeHotkey(
translate("Use %(hotkey)s to avoid the confirmation dialog."),
"session.noconfirmation"
),
"icon": "kill_small.png"
} :
{
// Get all delete reasons and remove duplications
"tooltip": entStates.map(entState => isUndeletable(entState))
.filter((reason, pos, self) =>
self.indexOf(reason) == pos && reason
).join("\n"),
"icon": "kill_small_disabled.png"
};
},
"execute": function(entStates)
{
if (!entStates.length || entStates.every(entState => isUndeletable(entState)))
return;
if (Engine.HotkeyIsPressed("session.noconfirmation"))
Engine.PostNetworkCommand({
"type": "delete-entities",
"entities": entStates.map(entState => entState.id)
});
else
openDeleteDialog(entStates.map(entState => entState.id));
},
},
"stop": {
"getInfo": function(entStates)
{
if (entStates.every(entState => !entState.unitAI))
return false;
return {
"tooltip": colorizeHotkey("%(hotkey)s" + " ", "session.stop") +
translate("Abort the current order."),
"icon": "stop.png"
};
},
"execute": function(entStates)
{
if (entStates.length)
stopUnits(entStates.map(entState => entState.id));
},
},
"garrison": {
"getInfo": function(entStates)
{
if (entStates.every(entState => !entState.unitAI || entState.turretParent))
return false;
return {
"tooltip": colorizeHotkey("%(hotkey)s" + " ", "session.garrison") +
translate("Order the selected units to garrison in a building or unit."),
"icon": "garrison.png"
};
},
"execute": function()
{
inputState = INPUT_PRESELECTEDACTION;
preSelectedAction = ACTION_GARRISON;
},
},
"unload": {
"getInfo": function(entStates)
{
if (entStates.every(entState => {
if (!entState.unitAI || !entState.turretParent)
return true;
let parent = GetEntityState(entState.turretParent);
return !parent || !parent.garrisonHolder || parent.garrisonHolder.entities.indexOf(entState.id) == -1;
}))
return false;
return {
"tooltip": translate("Unload"),
"icon": "garrison-out.png"
};
},
"execute": function()
{
unloadSelection();
},
},
"repair": {
"getInfo": function(entStates)
{
if (entStates.every(entState => !entState.builder))
return false;
return {
"tooltip": colorizeHotkey("%(hotkey)s" + " ", "session.repair") +
translate("Order the selected units to repair a building or mechanical unit."),
"icon": "repair.png"
};
},
"execute": function()
{
inputState = INPUT_PRESELECTEDACTION;
preSelectedAction = ACTION_REPAIR;
},
},
"focus-rally": {
"getInfo": function(entStates)
{
if (entStates.every(entState => !entState.rallyPoint))
return false;
return {
"tooltip": colorizeHotkey("%(hotkey)s" + " ", "camera.rallypointfocus") +
translate("Focus on Rally Point."),
"icon": "focus-rally.png"
};
},
"execute": function(entStates)
{
// TODO: Would be nicer to cycle between the rallypoints of multiple entities instead of just using the first
let focusTarget;
for (let entState of entStates)
if (entState.rallyPoint && entState.rallyPoint.position)
{
focusTarget = entState.rallyPoint.position;
break;
}
if (!focusTarget)
for (let entState of entStates)
if (entState.position)
{
focusTarget = entState.position;
break;
}
if (focusTarget)
Engine.CameraMoveTo(focusTarget.x, focusTarget.z);
},
},
"back-to-work": {
"getInfo": function(entStates)
{
if (entStates.every(entState => !entState.unitAI || !entState.unitAI.hasWorkOrders))
return false;
return {
"tooltip": colorizeHotkey("%(hotkey)s" + " ", "session.backtowork") +
translate("Back to Work"),
"icon": "production.png"
};
},
"execute": function()
{
backToWork();
},
},
"add-guard": {
"getInfo": function(entStates)
{
if (entStates.every(entState =>
!entState.unitAI || !entState.unitAI.canGuard || entState.unitAI.isGuarding))
return false;
return {
"tooltip": colorizeHotkey("%(hotkey)s" + " ", "session.guard") +
translate("Order the selected units to guard a building or unit."),
"icon": "add-guard.png"
};
},
"execute": function()
{
inputState = INPUT_PRESELECTEDACTION;
preSelectedAction = ACTION_GUARD;
},
},
"remove-guard": {
"getInfo": function(entStates)
{
if (entStates.every(entState => !entState.unitAI || !entState.unitAI.isGuarding))
return false;
return {
"tooltip": translate("Remove guard"),
"icon": "remove-guard.png"
};
},
"execute": function()
{
removeGuard();
},
},
"select-trading-goods": {
"getInfo": function(entStates)
{
if (entStates.every(entState => !entState.market))
return false;
return {
"tooltip": translate("Barter & Trade"),
"icon": "economics.png"
};
},
"execute": function()
{
toggleTrade();
},
},
"patrol": {
"getInfo": function(entStates)
{
if (!entStates.some(entState => entState.unitAI && entState.unitAI.canPatrol))
return false;
return {
"tooltip": colorizeHotkey("%(hotkey)s" + " ", "session.patrol") +
translate("Patrol") + "\n" +
translate("Attack all encountered enemy units while avoiding buildings."),
"icon": "patrol.png"
};
},
"execute": function()
{
inputState = INPUT_PRESELECTEDACTION;
preSelectedAction = ACTION_PATROL;
},
},
"share-dropsite": {
"getInfo": function(entStates)
{
let sharableEntities = entStates.filter(
entState => entState.resourceDropsite && entState.resourceDropsite.sharable);
if (!sharableEntities.length)
return false;
// Returns if none of the entities belong to a player with a mutual ally
if (entStates.every(entState => !GetSimState().players[entState.player].isMutualAlly.some(
(isAlly, playerId) => isAlly && playerId != entState.player)))
return false;
return sharableEntities.some(entState => !entState.resourceDropsite.shared) ?
{
"tooltip": translate("Press to allow allies to use this dropsite"),
"icon": "locked_small.png"
} :
{
"tooltip": translate("Press to prevent allies from using this dropsite"),
"icon": "unlocked_small.png"
};
},
"execute": function(entStates)
{
let sharableEntities = entStates.filter(
entState => entState.resourceDropsite && entState.resourceDropsite.sharable);
Engine.PostNetworkCommand({
"type": "set-dropsite-sharing",
"entities": sharableEntities.map(entState => entState.id),
"shared": sharableEntities.some(entState => !entState.resourceDropsite.shared)
});
},
}
};
var g_AllyEntityCommands =
{
"unload-all": {
"getInfo": function(entState)
{
if (!entState.garrisonHolder)
return false;
let player = Engine.GetPlayerID();
let count = 0;
for (let ent in g_Selection.selected)
{
let selectedEntState = GetEntityState(+ent);
if (!selectedEntState.garrisonHolder)
continue;
for (let entity of selectedEntState.garrisonHolder.entities)
{
let state = GetEntityState(entity);
if (state.player == player)
++count;
}
}
return {
"tooltip": colorizeHotkey("%(hotkey)s" + " ", "session.unload") +
translate("Unload All."),
"icon": "garrison-out.png",
"count": count,
};
},
"execute": function(entState)
{
unloadAllByOwner();
},
},
"share-dropsite": {
"getInfo": function(entState)
{
if (Engine.GetPlayerID() == -1 ||
!GetSimState().players[Engine.GetPlayerID()].hasSharedDropsites ||
!entState.resourceDropsite || !entState.resourceDropsite.sharable)
return false;
if (entState.resourceDropsite.shared)
return {
"tooltip": translate("You are allowed to use this dropsite"),
"icon": "unlocked_small.png"
};
return {
"tooltip": translate("The use of this dropsite is prohibited"),
"icon": "locked_small.png"
};
},
"execute": function(entState)
{
// This command button is always disabled
},
}
};
function playerCheck(entState, targetState, validPlayers)
{
let playerState = GetSimState().players[entState.player];
for (let player of validPlayers)
{
if (player == "Gaia" && targetState.player == 0 ||
player == "Player" && targetState.player == entState.player ||
playerState["is"+player] && playerState["is"+player][targetState.player])
return true;
}
return false;
}
function hasClass(entState, className)
{
// note: use the functions in globalscripts/Templates.js for more versatile matching
return entState.identity && entState.identity.classes.indexOf(className) != -1;
}
/**
* Work out whether at least part of the selected entities have UnitAI.
*/
function someUnitAI(entities)
{
return entities.some(ent => {
let entState = GetEntityState(ent);
return entState && entState.unitAI;
});
}
function someRallyPoints(entities)
{
return entities.some(ent => {
let entState = GetEntityState(ent);
return entState && entState.rallyPoint;
});
}
function someGuarding(entities)
{
return entities.some(ent => {
let entState = GetEntityState(ent);
return entState && entState.unitAI && entState.unitAI.isGuarding;
});
}
function someCanPatrol(entities)
{
return entities.some(ent => {
let entState = GetEntityState(ent);
return entState && entState.unitAI && entState.unitAI.canPatrol;
});
}
/**
* Keep in sync with Commands.js.
*/
function isUndeletable(entState)
{
if (g_DevSettings.controlAll)
return false;
if (entState.resourceSupply && entState.resourceSupply.killBeforeGather)
return translate("The entity has to be killed before it can be gathered from");
if (entState.capturePoints && entState.capturePoints[entState.player] < entState.maxCapturePoints / 2)
return translate("You cannot destroy this entity as you own less than half the capture points");
if (!entState.canDelete)
return translate("This entity is undeletable");
return false;
}
Index: ps/trunk/binaries/data/mods/public/maps/scripts/CaptureTheRelic.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/scripts/CaptureTheRelic.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/maps/scripts/CaptureTheRelic.js (revision 19631)
@@ -1,192 +1,155 @@
Trigger.prototype.InitCaptureTheRelic = function()
{
let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
let catafalqueTemplates = shuffleArray(cmpTemplateManager.FindAllTemplates(false).filter(
name => name.startsWith("other/catafalque/")));
- // Attempt to spawn relics using gaia entities in neutral territory
- // If there are none, try to spawn using gaia entities in non-neutral territory
- let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
- let cmpWaterManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_WaterManager);
- let cmpTerritoryManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TerritoryManager);
-
- let potentialGaiaSpawnPoints = [];
-
- let potentialSpawnPoints = cmpRangeManager.GetEntitiesByPlayer(0).filter(entity => {
- let cmpPosition = Engine.QueryInterface(entity, IID_Position);
- if (!cmpPosition || !cmpPosition.IsInWorld())
- return false;
-
- let cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
- if (!cmpIdentity)
- return false;
-
- let templateName = cmpTemplateManager.GetCurrentTemplateName(entity);
- if (!templateName)
- return false;
-
- let template = cmpTemplateManager.GetTemplate(templateName);
- if (!template || template.UnitMotionFlying)
- return false;
-
- let pos = cmpPosition.GetPosition();
- if (pos.y <= cmpWaterManager.GetWaterLevel(pos.x, pos.z))
- return false;
-
- if (cmpTerritoryManager.GetOwner(pos.x, pos.z) == 0)
- potentialGaiaSpawnPoints.push(entity);
-
- return true;
- });
-
- if (potentialGaiaSpawnPoints.length)
- potentialSpawnPoints = potentialGaiaSpawnPoints;
-
+ let potentialSpawnPoints = TriggerHelper.GetLandSpawnPoints();
if (!potentialSpawnPoints.length)
{
error("No gaia entities found on this map that could be used as spawn points!");
return;
}
let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
let numSpawnedRelics = cmpEndGameManager.GetGameTypeSettings().relicCount;
this.playerRelicsCount = new Array(TriggerHelper.GetNumberOfPlayers()).fill(0, 1);
this.playerRelicsCount[0] = numSpawnedRelics;
for (let i = 0; i < numSpawnedRelics; ++i)
{
this.relics[i] = TriggerHelper.SpawnUnits(pickRandom(potentialSpawnPoints), catafalqueTemplates[i], 1, 0)[0];
let cmpDamageReceiver = Engine.QueryInterface(this.relics[i], IID_DamageReceiver);
cmpDamageReceiver.SetInvulnerability(true);
let cmpPositionRelic = Engine.QueryInterface(this.relics[i], IID_Position);
cmpPositionRelic.SetYRotation(randFloat(0, 2 * Math.PI));
}
};
Trigger.prototype.CheckCaptureTheRelicVictory = function(data)
{
let cmpIdentity = Engine.QueryInterface(data.entity, IID_Identity);
if (!cmpIdentity || !cmpIdentity.HasClass("Relic") || data.from == -1)
return;
--this.playerRelicsCount[data.from];
if (data.to == -1)
{
warn("Relic entity " + data.entity + " has been destroyed");
this.relics.splice(this.relics.indexOf(data.entity), 1);
}
else
++this.playerRelicsCount[data.to];
this.CheckCaptureTheRelicCountdown();
};
/**
* Check if an individual player or team has acquired all relics.
* Also check if the countdown needs to be stopped if a player/team no longer has all relics.
*/
Trigger.prototype.CheckCaptureTheRelicCountdown = function()
{
let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
for (let playerID = 1; playerID < TriggerHelper.GetNumberOfPlayers(); ++playerID)
{
let playerAndAllies = cmpEndGameManager.GetAlliedVictory() ?
QueryPlayerIDInterface(playerID).GetMutualAllies() : [playerID];
let teamRelicsOwned = 0;
for (let ally of playerAndAllies)
teamRelicsOwned += this.playerRelicsCount[ally];
if (teamRelicsOwned == this.relics.length)
{
this.StartCaptureTheRelicCountdown(playerAndAllies);
return;
}
}
this.DeleteCaptureTheRelicVictoryMessages();
};
Trigger.prototype.DeleteCaptureTheRelicVictoryMessages = function()
{
let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
cmpTimer.CancelTimer(this.relicsVictoryTimer);
let cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
cmpGuiInterface.DeleteTimeNotification(this.ownRelicsVictoryMessage);
cmpGuiInterface.DeleteTimeNotification(this.othersRelicsVictoryMessage);
};
Trigger.prototype.StartCaptureTheRelicCountdown = function(playerAndAllies)
{
let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
let cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
if (this.relicsVictoryTimer)
{
cmpTimer.CancelTimer(this.relicsVictoryTimer);
cmpGuiInterface.DeleteTimeNotification(this.ownRelicsVictoryMessage);
cmpGuiInterface.DeleteTimeNotification(this.othersRelicsVictoryMessage);
}
if (!this.relics.length)
return;
let others = [-1];
for (let playerID = 1; playerID < TriggerHelper.GetNumberOfPlayers(); ++playerID)
{
let cmpPlayer = QueryPlayerIDInterface(playerID);
if (cmpPlayer.GetState() == "won")
return;
if (playerAndAllies.indexOf(playerID) == -1)
others.push(playerID);
}
let cmpPlayer = QueryOwnerInterface(this.relics[0], IID_Player);
let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
let captureTheRelicDuration = cmpEndGameManager.GetGameTypeSettings().victoryDuration || 0;
let isTeam = playerAndAllies.length > 1;
this.ownRelicsVictoryMessage = cmpGuiInterface.AddTimeNotification({
"message": isTeam ?
markForTranslation("%(player)s's team has captured all relics and will have won in %(time)s") :
markForTranslation("%(player)s has captured all relics and will have won in %(time)s"),
"players": others,
"parameters": {
"player": cmpPlayer.GetName()
},
"translateMessage": true,
"translateParameters": []
}, captureTheRelicDuration);
this.othersRelicsVictoryMessage = cmpGuiInterface.AddTimeNotification({
"message": isTeam ?
markForTranslation("Your team has captured all relics and will have won in %(time)s") :
markForTranslation("You have captured all relics and will have won in %(time)s"),
"players": playerAndAllies,
"translateMessage": true
}, captureTheRelicDuration);
this.relicsVictoryTimer = cmpTimer.SetTimeout(SYSTEM_ENTITY, IID_EndGameManager,
"MarkPlayerAsWon", captureTheRelicDuration, playerAndAllies[0]);
};
{
let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
cmpTrigger.relics = [];
cmpTrigger.playerRelicsCount = [];
cmpTrigger.relicsVictoryTimer = undefined;
cmpTrigger.ownRelicsVictoryMessage = undefined;
cmpTrigger.othersRelicsVictoryMessage = undefined;
cmpTrigger.DoAfterDelay(0, "InitCaptureTheRelic", {});
cmpTrigger.RegisterTrigger("OnDiplomacyChanged", "CheckCaptureTheRelicCountdown", { "enabled": true });
cmpTrigger.RegisterTrigger("OnOwnershipChanged", "CheckCaptureTheRelicVictory", { "enabled": true });
cmpTrigger.RegisterTrigger("OnPlayerWon", "DeleteCaptureTheRelicVictoryMessages", { "enabled": true });
}
Index: ps/trunk/binaries/data/mods/public/maps/scripts/Regicide.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/scripts/Regicide.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/maps/scripts/Regicide.js (revision 19631)
@@ -1,114 +1,127 @@
Trigger.prototype.CheckRegicideDefeat = function(data)
{
if (data.entity == this.regicideHeroes[data.from])
TriggerHelper.DefeatPlayer(data.from);
};
Trigger.prototype.InitRegicideGame = function(msg)
{
+ let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
+ let regicideGarrison = cmpEndGameManager.GetGameTypeSettings().regicideGarrison;
+
let playersCivs = [];
for (let playerID = 1; playerID < TriggerHelper.GetNumberOfPlayers(); ++playerID)
playersCivs[playerID] = QueryPlayerIDInterface(playerID).GetCiv();
// Get all hero templates of these civs
let heroTemplates = {};
let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
for (let templateName of cmpTemplateManager.FindAllTemplates(false))
{
if (templateName.substring(0,6) != "units/")
continue;
let identity = cmpTemplateManager.GetTemplate(templateName).Identity;
let classes = GetIdentityClasses(identity);
if (classes.indexOf("Hero") == -1 ||
playersCivs.every(civ => civ != identity.Civ))
continue;
if (!heroTemplates[identity.Civ])
heroTemplates[identity.Civ] = [];
if (heroTemplates[identity.Civ].indexOf(templateName) == -1)
heroTemplates[identity.Civ].push({
- "templateName": templateName,
+ "templateName": regicideGarrison ? templateName : "ungarrisonable|" + templateName,
"classes": classes
});
}
// Sort available spawn points by preference
let spawnPreferences = ["CivilCentre", "Structure", "Ship"];
let getSpawnPreference = entity => {
let cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
if (!cmpIdentity)
return -1;
let classes = cmpIdentity.GetClassesList();
for (let i in spawnPreferences)
if (classes.indexOf(spawnPreferences[i]) != -1)
return spawnPreferences.length - i;
return 0;
};
// Attempt to spawn one hero per player
let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
for (let playerID = 1; playerID < TriggerHelper.GetNumberOfPlayers(); ++playerID)
{
let spawnPoints = cmpRangeManager.GetEntitiesByPlayer(playerID).sort((entity1, entity2) =>
getSpawnPreference(entity2) - getSpawnPreference(entity1));
+ // Spawn the hero on land as close as possible
+ if (!regicideGarrison && TriggerHelper.EntityHasClass(spawnPoints[0], "Ship"))
+ {
+ let shipPosition = Engine.QueryInterface(spawnPoints[0], IID_Position).GetPosition2D();
+ let distanceToShip = entity =>
+ Engine.QueryInterface(entity, IID_Position).GetPosition2D().distanceTo(shipPosition);
+ spawnPoints = TriggerHelper.GetLandSpawnPoints().sort((entity1, entity2) =>
+ distanceToShip(entity1) - distanceToShip(entity2));
+ }
+
this.regicideHeroes[playerID] = this.SpawnRegicideHero(playerID, heroTemplates[playersCivs[playerID]], spawnPoints);
}
};
/**
* Spawn a random hero at one of the given locations (which are checked in order).
* Garrison it if the location is a ship.
*
* @param spawnPoints - entity IDs at which to spawn
*/
Trigger.prototype.SpawnRegicideHero = function(playerID, heroTemplates, spawnPoints)
{
for (let heroTemplate of shuffleArray(heroTemplates))
for (let spawnPoint of spawnPoints)
{
let cmpPosition = Engine.QueryInterface(spawnPoint, IID_Position);
if (!cmpPosition || !cmpPosition.IsInWorld())
continue;
// Consider nomad maps where units start on a ship
let isShip = TriggerHelper.EntityHasClass(spawnPoint, "Ship");
if (isShip)
{
let cmpGarrisonHolder = Engine.QueryInterface(spawnPoint, IID_GarrisonHolder);
if (cmpGarrisonHolder.IsFull() ||
!MatchesClassList(heroTemplate.classes, cmpGarrisonHolder.GetAllowedClasses()))
continue;
}
let hero = TriggerHelper.SpawnUnits(spawnPoint, heroTemplate.templateName, 1, playerID);
if (!hero.length)
continue;
hero = hero[0];
if (isShip)
{
let cmpUnitAI = Engine.QueryInterface(hero, IID_UnitAI);
cmpUnitAI.Garrison(spawnPoint);
}
return hero;
}
error("Couldn't spawn hero for player " + playerID);
return undefined;
};
{
let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
cmpTrigger.regicideHeroes = [];
cmpTrigger.DoAfterDelay(0, "InitRegicideGame", {});
cmpTrigger.RegisterTrigger("OnOwnershipChanged", "CheckRegicideDefeat", { "enabled": true });
}
Index: ps/trunk/binaries/data/mods/public/maps/scripts/TriggerHelper.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/scripts/TriggerHelper.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/maps/scripts/TriggerHelper.js (revision 19631)
@@ -1,161 +1,203 @@
// Contains standardized functions suitable for using in trigger scripts.
// Do not use them in any other simulation script.
var TriggerHelper = {};
TriggerHelper.GetPlayerIDFromEntity = function(ent)
{
let cmpPlayer = Engine.QueryInterface(ent, IID_Player);
if (cmpPlayer)
return cmpPlayer.GetPlayerID();
return -1;
};
TriggerHelper.GetOwner = function(ent)
{
let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
if (cmpOwnership)
return cmpOwnership.GetOwner();
return -1;
};
/**
* Can be used to "force" a building/unit to spawn a group of entities.
*
* @param source Entity id of the point where they will be spawned from
* @param template Name of the template
* @param count Number of units to spawn
* @param owner Player id of the owner of the new units. By default, the owner
* of the source entity.
*/
TriggerHelper.SpawnUnits = function(source, template, count, owner)
{
let entities = [];
let cmpFootprint = Engine.QueryInterface(source, IID_Footprint);
let cmpPosition = Engine.QueryInterface(source, IID_Position);
if (!cmpPosition || !cmpPosition.IsInWorld())
{
error("tried to create entity from a source without position");
return entities;
}
if (owner == null)
owner = TriggerHelper.GetOwner(source);
for (let i = 0; i < count; ++i)
{
let ent = Engine.AddEntity(template);
let cmpEntPosition = Engine.QueryInterface(ent, IID_Position);
if (!cmpEntPosition)
{
Engine.DestroyEntity(ent);
error("tried to create entity without position");
continue;
}
let cmpEntOwnership = Engine.QueryInterface(ent, IID_Ownership);
if (cmpEntOwnership)
cmpEntOwnership.SetOwner(owner);
entities.push(ent);
let pos;
if (cmpFootprint)
pos = cmpFootprint.PickSpawnPoint(ent);
// TODO this can happen if the player build on the place
// where our trigger point is
// We should probably warn the trigger maker in some way,
// but not interrupt the game for the player
if (!pos || pos.y < 0)
pos = cmpPosition.GetPosition();
cmpEntPosition.JumpTo(pos.x, pos.z);
}
return entities;
};
/**
* Spawn units from all trigger points with this reference
* If player is defined, only spaw units from the trigger points
* that belong to that player
* @param ref Trigger point reference name to spawn units from
* @param template Template name
* @param count Number of spawned entities per Trigger point
* @param owner Owner of the spawned units. Default: the owner of the origins
* @return A list of new entities per origin like
* {originId1: [entId1, entId2], originId2: [entId3, entId4], ...}
*/
TriggerHelper.SpawnUnitsFromTriggerPoints = function(ref, template, count, owner = null)
{
let cmpTrigger = Engine.QueryInterface(SYSTEM_ENTITY, IID_Trigger);
let triggerPoints = cmpTrigger.GetTriggerPoints(ref);
let entities = {};
for (let point of triggerPoints)
entities[point] = TriggerHelper.SpawnUnits(point, template, count, owner);
return entities;
};
/**
* Returns the resource type that can be gathered from an entity
*/
TriggerHelper.GetResourceType = function(entity)
{
let cmpResourceSupply = Engine.QueryInterface(entity, IID_ResourceSupply);
if (!cmpResourceSupply)
return undefined;
return cmpResourceSupply.GetType();
};
/**
* The given player will win the game.
* If it's not a last man standing game, then allies will win too.
*/
TriggerHelper.SetPlayerWon = function(playerID)
{
let cmpEndGameManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_EndGameManager);
cmpEndGameManager.MarkPlayerAsWon(playerID);
};
/**
* Defeats a player
*/
TriggerHelper.DefeatPlayer = function(playerID)
{
let cmpPlayer = QueryPlayerIDInterface(playerID);
if (cmpPlayer)
cmpPlayer.SetState("defeated");
};
/**
* Returns the number of current players
*/
TriggerHelper.GetNumberOfPlayers = function()
{
let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
return cmpPlayerManager.GetNumPlayers();
};
/**
* A function to determine if an entity has a specific class
* @param entity ID of the entity that we want to check for classes
* @param classname The name of the class we are checking if the entity has
*/
TriggerHelper.EntityHasClass = function(entity, classname)
{
let cmpIdentity = Engine.QueryInterface(entity, IID_Identity);
if (!cmpIdentity)
return false;
let classes = cmpIdentity.GetClassesList();
return classes && classes.indexOf(classname) != -1;
};
+/**
+ * Return valid gaia-owned spawn points on land in neutral territory.
+ * If there are none, use those available in player-owned territory.
+ */
+TriggerHelper.GetLandSpawnPoints = function()
+{
+ let cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+ let cmpWaterManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_WaterManager);
+ let cmpTerritoryManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TerritoryManager);
+ let cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+
+ let neutralSpawnPoints = [];
+ let nonNeutralSpawnPoints = [];
+
+ for (let ent of cmpRangeManager.GetEntitiesByPlayer(0))
+ {
+ let cmpIdentity = Engine.QueryInterface(ent, IID_Identity);
+ let cmpPosition = Engine.QueryInterface(ent, IID_Position);
+ if (!cmpIdentity || !cmpPosition || !cmpPosition.IsInWorld())
+ continue;
+
+ let templateName = cmpTemplateManager.GetCurrentTemplateName(ent);
+ if (!templateName)
+ continue;
+
+ let template = cmpTemplateManager.GetTemplate(templateName);
+ if (!template || template.UnitMotionFlying)
+ continue;
+
+ let pos = cmpPosition.GetPosition();
+ if (pos.y <= cmpWaterManager.GetWaterLevel(pos.x, pos.z))
+ continue;
+
+ if (cmpTerritoryManager.GetOwner(pos.x, pos.z) == 0)
+ neutralSpawnPoints.push(ent);
+ else
+ nonNeutralSpawnPoints.push(ent);
+ }
+
+ return neutralSpawnPoints.length ? neutralSpawnPoints : nonNeutralSpawnPoints;
+};
+
Engine.RegisterGlobal("TriggerHelper", TriggerHelper);
Index: ps/trunk/binaries/data/mods/public/simulation/ai/common-api/entity.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/common-api/entity.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/common-api/entity.js (revision 19631)
@@ -1,973 +1,975 @@
var API3 = function(m)
{
// defines a template.
// It's completely raw data, except it's slightly cleverer now and then.
m.Template = m.Class({
_init: function(template)
{
this._template = template;
this._tpCache = new Map();
},
// helper function to return a template value, optionally adjusting for tech.
// TODO: there's no support for "_string" values here.
get: function(string)
{
let value = this._template;
if (this._entityModif && this._entityModif.has(string))
return this._entityModif.get(string);
else if (this._templateModif && this._templateModif.has(string))
return this._templateModif.get(string);
if (!this._tpCache.has(string))
{
let args = string.split("/");
for (let arg of args)
{
if (value[arg])
value = value[arg];
else
{
value = undefined;
break;
}
}
this._tpCache.set(string, value);
}
return this._tpCache.get(string);
},
genericName: function() {
return this.get("Identity/GenericName");
},
rank: function() {
return this.get("Identity/Rank");
},
classes: function() {
let template = this.get("Identity");
if (!template)
return undefined;
return GetIdentityClasses(template);
},
requiredTech: function() {
return this.get("Identity/RequiredTechnology");
},
available: function(gameState) {
let techRequired = this.requiredTech();
if (!techRequired)
return true;
return gameState.isResearched(techRequired);
},
// specifically
phase: function() {
let techRequired = this.requiredTech();
if (!techRequired)
return 0;
if (techRequired === "phase_village")
return 1;
if (techRequired === "phase_town")
return 2;
if (techRequired === "phase_city")
return 3;
return 0;
},
hasClass: function(name) {
if (!this._classes)
this._classes = this.classes();
let classes = this._classes;
return classes && classes.indexOf(name) !== -1;
},
hasClasses: function(array) {
if (!this._classes)
this._classes = this.classes();
let classes = this._classes;
if (!classes)
return false;
for (let cls of array)
if (classes.indexOf(cls) === -1)
return false;
return true;
},
civ: function() {
return this.get("Identity/Civ");
},
"cost": function(productionQueue) {
if (!this.get("Cost"))
return undefined;
let ret = {};
for (let type in this.get("Cost/Resources"))
ret[type] = +this.get("Cost/Resources/" + type);
return ret;
},
"costSum": function(productionQueue) {
let cost = this.cost(productionQueue);
if (!cost)
return undefined;
let ret = 0;
for (let type in cost)
ret += cost[type];
return ret;
},
"techCostMultiplier": function(type) {
return +(this.get("ProductionQueue/TechCostMultiplier/"+type) || 1);
},
/**
* Returns the radius of a circle surrounding this entity's
* obstruction shape, or undefined if no obstruction.
*/
obstructionRadius: function() {
if (!this.get("Obstruction"))
return undefined;
if (this.get("Obstruction/Static"))
{
let w = +this.get("Obstruction/Static/@width");
let h = +this.get("Obstruction/Static/@depth");
return Math.sqrt(w*w + h*h) / 2;
}
if (this.get("Obstruction/Unit"))
return +this.get("Obstruction/Unit/@radius");
return 0; // this should never happen
},
/**
* Returns the radius of a circle surrounding this entity's
* footprint.
*/
footprintRadius: function() {
if (!this.get("Footprint"))
return undefined;
if (this.get("Footprint/Square"))
{
let w = +this.get("Footprint/Square/@width");
let h = +this.get("Footprint/Square/@depth");
return Math.sqrt(w*w + h*h) / 2;
}
if (this.get("Footprint/Circle"))
return +this.get("Footprint/Circle/@radius");
return 0; // this should never happen
},
maxHitpoints: function()
{
return +(this.get("Health/Max") || 0);
},
isHealable: function()
{
if (this.get("Health") !== undefined)
return this.get("Health/Unhealable") !== "true";
return false;
},
isRepairable: function()
{
return this.get("Repairable") !== undefined;
},
getPopulationBonus: function() {
return +this.get("Cost/PopulationBonus");
},
armourStrengths: function() {
if (!this.get("Armour"))
return undefined;
return {
hack: +this.get("Armour/Hack"),
pierce: +this.get("Armour/Pierce"),
crush: +this.get("Armour/Crush")
};
},
attackTypes: function() {
if (!this.get("Attack"))
return undefined;
let ret = [];
for (let type in this.get("Attack"))
ret.push(type);
return ret;
},
attackRange: function(type) {
if (!this.get("Attack/" + type +""))
return undefined;
return {
max: +this.get("Attack/" + type +"/MaxRange"),
min: +(this.get("Attack/" + type +"/MinRange") || 0)
};
},
attackStrengths: function(type) {
if (!this.get("Attack/" + type +""))
return undefined;
return {
hack: +(this.get("Attack/" + type + "/Hack") || 0),
pierce: +(this.get("Attack/" + type + "/Pierce") || 0),
crush: +(this.get("Attack/" + type + "/Crush") || 0)
};
},
captureStrength: function() {
if (!this.get("Attack/Capture"))
return undefined;
return +this.get("Attack/Capture/Value") || 0;
},
attackTimes: function(type) {
if (!this.get("Attack/" + type +""))
return undefined;
return {
prepare: +(this.get("Attack/" + type + "/PrepareTime") || 0),
repeat: +(this.get("Attack/" + type + "/RepeatTime") || 1000)
};
},
// returns the classes this templates counters:
// Return type is [ [-neededClasses- , multiplier], … ].
getCounteredClasses: function() {
if (!this.get("Attack"))
return undefined;
let Classes = [];
for (let type in this.get("Attack"))
{
let bonuses = this.get("Attack/" + type + "/Bonuses");
if (!bonuses)
continue;
for (let b in bonuses)
{
let bonusClasses = this.get("Attack/" + type + "/Bonuses/" + b + "/Classes");
if (bonusClasses)
Classes.push([bonusClasses.split(" "), +this.get("Attack/" + type +"/Bonuses" + b +"/Multiplier")]);
}
}
return Classes;
},
// returns true if the entity counters those classes.
// TODO: refine using the multiplier
countersClasses: function(classes) {
if (!this.get("Attack"))
return false;
let mcounter = [];
for (let type in this.get("Attack"))
{
let bonuses = this.get("Attack/" + type + "/Bonuses");
if (!bonuses)
continue;
for (let b in bonuses)
{
let bonusClasses = this.get("Attack/" + type + "/Bonuses/" + b + "/Classes");
if (bonusClasses)
mcounter.concat(bonusClasses.split(" "));
}
}
for (let i in classes)
{
if (mcounter.indexOf(classes[i]) !== -1)
return true;
}
return false;
},
// returns, if it exists, the multiplier from each attack against a given class
getMultiplierAgainst: function(type, againstClass) {
if (!this.get("Attack/" + type +""))
return undefined;
if (this.get("Attack/" + type + "/Bonuses"))
{
for (let b in this.get("Attack/" + type + "/Bonuses"))
{
let bonusClasses = this.get("Attack/" + type + "/Bonuses/" + b + "/Classes");
if (!bonusClasses)
continue;
for (let bcl of bonusesClasses.split(" "))
if (bcl === againstClass)
return +this.get("Attack/" + type + "/Bonuses/" + b + "/Multiplier");
}
}
return 1;
},
"buildableEntities": function() {
let templates = this.get("Builder/Entities/_string");
if (!templates)
return [];
let civ = this.civ();
return templates.replace(/\{civ\}/g, civ).split(/\s+/);
},
"trainableEntities": function(civ) {
let templates = this.get("ProductionQueue/Entities/_string");
if (!templates)
return undefined;
if (civ)
templates = templates.replace(/\{civ\}/g, civ);
return templates.split(/\s+/);
},
"researchableTechs": function(civ) {
if (this.civ() !== civ) // techs can only be researched in structures from the player civ TODO no more true
return undefined;
let templates = this.get("ProductionQueue/Technologies/_string");
if (!templates)
return undefined;
return templates.split(/\s+/);
},
resourceSupplyType: function() {
if (!this.get("ResourceSupply"))
return undefined;
let [type, subtype] = this.get("ResourceSupply/Type").split('.');
return { "generic": type, "specific": subtype };
},
// will return either "food", "wood", "stone", "metal" and not treasure.
getResourceType: function() {
if (!this.get("ResourceSupply"))
return undefined;
let [type, subtype] = this.get("ResourceSupply/Type").split('.');
if (type == "treasure")
return subtype;
return type;
},
resourceSupplyMax: function() {
return +this.get("ResourceSupply/Amount");
},
maxGatherers: function() {
return +(this.get("ResourceSupply/MaxGatherers") || 0);
},
resourceGatherRates: function() {
if (!this.get("ResourceGatherer"))
return undefined;
let ret = {};
let baseSpeed = +this.get("ResourceGatherer/BaseSpeed");
for (let r in this.get("ResourceGatherer/Rates"))
ret[r] = +this.get("ResourceGatherer/Rates/" + r) * baseSpeed;
return ret;
},
resourceDropsiteTypes: function() {
if (!this.get("ResourceDropsite"))
return undefined;
let types = this.get("ResourceDropsite/Types");
return types ? types.split(/\s+/) : [];
},
garrisonableClasses: function() {
return this.get("GarrisonHolder/List/_string");
},
garrisonMax: function() {
return this.get("GarrisonHolder/Max");
},
garrisonEjectHealth: function() {
return +this.get("GarrisonHolder/EjectHealth");
},
getDefaultArrow: function() {
return +this.get("BuildingAI/DefaultArrowCount");
},
getArrowMultiplier: function() {
return +this.get("BuildingAI/GarrisonArrowMultiplier");
},
getGarrisonArrowClasses: function() {
if (!this.get("BuildingAI"))
return undefined;
return this.get("BuildingAI/GarrisonArrowClasses").split(/\s+/);
},
buffHeal: function() {
return +this.get("GarrisonHolder/BuffHeal");
},
promotion: function() {
return this.get("Promotion/Entity");
},
/**
* Returns whether this is an animal that is too difficult to hunt.
* (Any non domestic currently.)
*/
isHuntable: function() {
if(!this.get("ResourceSupply/KillBeforeGather"))
return false;
// special case: rabbits too difficult to hunt for such a small food amount
let specificName = this.get("Identity/SpecificName");
if (specificName && specificName === "Rabbit")
return false;
// do not hunt retaliating animals (animals without UnitAI are dead animals)
let behaviour = this.get("UnitAI/NaturalBehaviour");
return !this.get("UnitAI") ||
!(behaviour === "violent" || behaviour === "aggressive" || behaviour === "defensive");
},
walkSpeed: function() {
return +this.get("UnitMotion/WalkSpeed");
},
trainingCategory: function() {
return this.get("TrainingRestrictions/Category");
},
buildCategory: function() {
return this.get("BuildRestrictions/Category");
},
"buildTime": function(productionQueue) {
let time = +this.get("Cost/BuildTime");
if (productionQueue)
time *= productionQueue.techCostMultiplier("time");
return time;
},
buildDistance: function() {
return this.get("BuildRestrictions/Distance");
},
buildPlacementType: function() {
return this.get("BuildRestrictions/PlacementType");
},
buildTerritories: function() {
if (!this.get("BuildRestrictions") || !this.get("BuildRestrictions/Territory"))
return undefined;
return this.get("BuildRestrictions/Territory").split(/\s+/);
},
hasBuildTerritory: function(territory) {
let territories = this.buildTerritories();
return territories && territories.indexOf(territory) !== -1;
},
hasTerritoryInfluence: function() {
return this.get("TerritoryInfluence") !== undefined;
},
hasDefensiveFire: function() {
if (!this.get("Attack/Ranged"))
return false;
return this.getDefaultArrow() || this.getArrowMultiplier();
},
territoryInfluenceRadius: function() {
if (this.get("TerritoryInfluence") !== undefined)
return +this.get("TerritoryInfluence/Radius");
return -1;
},
territoryInfluenceWeight: function() {
if (this.get("TerritoryInfluence") !== undefined)
return +this.get("TerritoryInfluence/Weight");
return -1;
},
territoryDecayRate: function() {
return +(this.get("TerritoryDecay/DecayRate") || 0);
},
defaultRegenRate: function() {
return +(this.get("Capturable/RegenRate") || 0);
},
garrisonRegenRate: function() {
return +(this.get("Capturable/GarrisonRegenRate") || 0);
},
visionRange: function() {
return +this.get("Vision/Range");
},
gainMultiplier: function() {
return +this.get("Trader/GainMultiplier");
}
});
// defines an entity, with a super Template.
// also redefines several of the template functions where the only change is applying aura and tech modifications.
m.Entity = m.Class({
_super: m.Template,
_init: function(sharedAI, entity)
{
this._super.call(this, sharedAI.GetTemplate(entity.template));
this._templateName = entity.template;
this._entity = entity;
this._ai = sharedAI;
// save a reference to the template tech modifications
if (!sharedAI._templatesModifications[entity.owner][this._templateName])
sharedAI._templatesModifications[entity.owner][this._templateName] = new Map();
this._templateModif = sharedAI._templatesModifications[entity.owner][this._templateName];
// save a reference to the entity tech/aura modifications
if (!sharedAI._entitiesModifications.has(entity.id))
sharedAI._entitiesModifications.set(entity.id, new Map());
this._entityModif = sharedAI._entitiesModifications.get(entity.id);
},
toString: function() {
return "[Entity " + this.id() + " " + this.templateName() + "]";
},
id: function() {
return this._entity.id;
},
templateName: function() {
return this._templateName;
},
/**
* Returns extra data that the AI scripts have associated with this entity,
* for arbitrary local annotations.
* (This data should not be shared with any other AI scripts.)
*/
getMetadata: function(player, key) {
return this._ai.getMetadata(player, this, key);
},
/**
* Sets extra data to be associated with this entity.
*/
setMetadata: function(player, key, value) {
this._ai.setMetadata(player, this, key, value);
},
deleteAllMetadata: function(player) {
delete this._ai._entityMetadata[player][this.id()];
},
deleteMetadata: function(player, key) {
this._ai.deleteMetadata(player, this, key);
},
position: function() { return this._entity.position; },
angle: function() { return this._entity.angle; },
isIdle: function() {
if (typeof this._entity.idle === "undefined")
return undefined;
return this._entity.idle;
},
"getStance": function() { return this._entity.stance !== undefined ? this._entity.stance : undefined; },
unitAIState: function() { return this._entity.unitAIState !== undefined ? this._entity.unitAIState : undefined; },
unitAIOrderData: function() { return this._entity.unitAIOrderData !== undefined ? this._entity.unitAIOrderData : undefined; },
hitpoints: function() { return this._entity.hitpoints !== undefined ? this._entity.hitpoints : undefined; },
isHurt: function() { return this.hitpoints() < this.maxHitpoints(); },
healthLevel: function() { return this.hitpoints() / this.maxHitpoints(); },
needsHeal: function() { return this.isHurt() && this.isHealable(); },
needsRepair: function() { return this.isHurt() && this.isRepairable(); },
decaying: function() { return this._entity.decaying !== undefined ? this._entity.decaying : undefined; },
capturePoints: function() {return this._entity.capturePoints !== undefined ? this._entity.capturePoints : undefined; },
"isSharedDropsite": function() { return this._entity.sharedDropsite === true; },
/**
* Returns the current training queue state, of the form
* [ { "id": 0, "template": "...", "count": 1, "progress": 0.5, "metadata": ... }, ... ]
*/
trainingQueue: function() {
let queue = this._entity.trainingQueue;
return queue;
},
trainingQueueTime: function() {
let queue = this._entity.trainingQueue;
if (!queue)
return undefined;
let time = 0;
for (let item of queue)
time += item.timeRemaining;
return time/1000;
},
foundationProgress: function() {
if (this._entity.foundationProgress === undefined)
return undefined;
return this._entity.foundationProgress;
},
getBuilders: function() {
if (this._entity.foundationProgress === undefined)
return undefined;
if (this._entity.foundationBuilders === undefined)
return [];
return this._entity.foundationBuilders;
},
getBuildersNb: function() {
if (this._entity.foundationProgress === undefined)
return undefined;
if (this._entity.foundationBuilders === undefined)
return 0;
return this._entity.foundationBuilders.length;
},
owner: function() {
return this._entity.owner;
},
isOwn: function(player) {
if (typeof this._entity.owner === "undefined")
return false;
return this._entity.owner === player;
},
resourceSupplyAmount: function() {
if (this._entity.resourceSupplyAmount === undefined)
return undefined;
return this._entity.resourceSupplyAmount;
},
resourceSupplyNumGatherers: function()
{
if (this._entity.resourceSupplyNumGatherers !== undefined)
return this._entity.resourceSupplyNumGatherers;
return undefined;
},
isFull: function()
{
if (this._entity.resourceSupplyNumGatherers !== undefined)
return this.maxGatherers() === this._entity.resourceSupplyNumGatherers;
return undefined;
},
resourceCarrying: function() {
if (this._entity.resourceCarrying === undefined)
return undefined;
return this._entity.resourceCarrying;
},
currentGatherRate: function() {
// returns the gather rate for the current target if applicable.
if (!this.get("ResourceGatherer"))
return undefined;
if (this.unitAIOrderData().length &&
(this.unitAIState().split(".")[1] === "GATHER" || this.unitAIState().split(".")[1] === "RETURNRESOURCE"))
{
let res;
// this is an abuse of "_ai" but it works.
if (this.unitAIState().split(".")[1] === "GATHER" && this.unitAIOrderData()[0].target !== undefined)
res = this._ai._entities.get(this.unitAIOrderData()[0].target);
else if (this.unitAIOrderData()[1] !== undefined && this.unitAIOrderData()[1].target !== undefined)
res = this._ai._entities.get(this.unitAIOrderData()[1].target);
if (!res)
return 0;
let type = res.resourceSupplyType();
if (!type)
return 0;
if (type.generic === "treasure")
return 1000;
let tstring = type.generic + "." + type.specific;
let rate = +this.get("ResourceGatherer/BaseSpeed");
rate *= +this.get("ResourceGatherer/Rates/" +tstring);
if (rate)
return rate;
return 0;
}
return undefined;
},
isBuilder: function() { return this.get("Builder") !== undefined; },
isGatherer: function() { return this.get("ResourceGatherer") !== undefined; },
canGather: function(type) {
let gatherRates = this.get("ResourceGatherer/Rates");
if (!gatherRates)
return false;
for (let r in gatherRates)
if (r.split('.')[0] === type)
return true;
return false;
},
isGarrisonHolder: function() { return this.get("GarrisonHolder") !== undefined; },
garrisoned: function() { return this._entity.garrisoned; },
canGarrisonInside: function() { return this._entity.garrisoned.length < this.garrisonMax(); },
/**
* returns true if the entity can attack (including capture) the given class.
*/
"canAttackClass": function(aClass)
{
if (!this.get("Attack"))
return false;
for (let type in this.get("Attack"))
{
if (type === "Slaughter")
continue;
let restrictedClasses = this.get("Attack/" + type + "/RestrictedClasses/_string");
if (!restrictedClasses || !MatchesClassList([aClass], restrictedClasses))
return true;
}
return false;
},
/**
* returns true if the entity can capture the given target entity
* if no target is given, returns true if the entity has the Capture attack
*/
"canCapture": function(target)
{
if (!this.get("Attack/Capture"))
return false;
if (!target)
return true;
let restrictedClasses = this.get("Attack/Capture/RestrictedClasses/_string");
return !restrictedClasses || !MatchesClassList(target.classes(), restrictedClasses);
},
"isCapturable": function() { return this.get("Capturable") !== undefined; },
"canGuard": function() { return this.get("UnitAI/CanGuard") === "true"; },
+ "canGarrison": function() { return this.get("Garrisonable") !== "false"; },
+
move: function(x, z, queued = false) {
Engine.PostCommand(PlayerID,{"type": "walk", "entities": [this.id()], "x": x, "z": z, "queued": queued });
return this;
},
moveToRange: function(x, z, min, max, queued = false) {
Engine.PostCommand(PlayerID,{"type": "walk-to-range", "entities": [this.id()], "x": x, "z": z, "min": min, "max": max, "queued": queued });
return this;
},
attackMove: function(x, z, targetClasses, queued = false) {
Engine.PostCommand(PlayerID,{"type": "attack-walk", "entities": [this.id()], "x": x, "z": z, "targetClasses": targetClasses, "queued": queued });
return this;
},
// violent, aggressive, defensive, passive, standground
setStance: function(stance, queued = false) {
if (this.getStance() === undefined)
return undefined;
Engine.PostCommand(PlayerID,{"type": "stance", "entities": [this.id()], "name" : stance, "queued": queued });
return this;
},
stopMoving: function() {
Engine.PostCommand(PlayerID,{"type": "stop", "entities": [this.id()], "queued": false});
},
unload: function(id) {
if (!this.get("GarrisonHolder"))
return undefined;
Engine.PostCommand(PlayerID,{"type": "unload", "garrisonHolder": this.id(), "entities": [id]});
return this;
},
// Unloads all owned units, don't unload allies
unloadAll: function() {
if (!this.get("GarrisonHolder"))
return undefined;
Engine.PostCommand(PlayerID,{"type": "unload-all-by-owner", "garrisonHolders": [this.id()]});
return this;
},
garrison: function(target, queued = false) {
Engine.PostCommand(PlayerID,{"type": "garrison", "entities": [this.id()], "target": target.id(),"queued": queued});
return this;
},
attack: function(unitId, allowCapture = true, queued = false) {
Engine.PostCommand(PlayerID,{"type": "attack", "entities": [this.id()], "target": unitId, "allowCapture": allowCapture, "queued": queued});
return this;
},
// moveApart from a point in the opposite direction with a distance dist
moveApart: function(point, dist) {
if (this.position() !== undefined) {
let direction = [this.position()[0] - point[0], this.position()[1] - point[1]];
let norm = m.VectorDistance(point, this.position());
if (norm === 0)
direction = [1, 0];
else
{
direction[0] /= norm;
direction[1] /= norm;
}
Engine.PostCommand(PlayerID,{"type": "walk", "entities": [this.id()], "x": this.position()[0] + direction[0]*dist, "z": this.position()[1] + direction[1]*dist, "queued": false});
}
return this;
},
// Flees from a unit in the opposite direction.
flee: function(unitToFleeFrom) {
if (this.position() !== undefined && unitToFleeFrom.position() !== undefined) {
let FleeDirection = [this.position()[0] - unitToFleeFrom.position()[0],
this.position()[1] - unitToFleeFrom.position()[1]];
let dist = m.VectorDistance(unitToFleeFrom.position(), this.position() );
FleeDirection[0] = 40 * FleeDirection[0]/dist;
FleeDirection[1] = 40 * FleeDirection[1]/dist;
Engine.PostCommand(PlayerID,{"type": "walk", "entities": [this.id()], "x": this.position()[0] + FleeDirection[0], "z": this.position()[1] + FleeDirection[1], "queued": false});
}
return this;
},
gather: function(target, queued = false) {
Engine.PostCommand(PlayerID,{"type": "gather", "entities": [this.id()], "target": target.id(), "queued": queued});
return this;
},
repair: function(target, autocontinue = false, queued = false) {
Engine.PostCommand(PlayerID,{"type": "repair", "entities": [this.id()], "target": target.id(), "autocontinue": autocontinue, "queued": queued});
return this;
},
returnResources: function(target, queued = false) {
Engine.PostCommand(PlayerID,{"type": "returnresource", "entities": [this.id()], "target": target.id(), "queued": queued});
return this;
},
destroy: function() {
Engine.PostCommand(PlayerID,{"type": "delete-entities", "entities": [this.id()] });
return this;
},
barter: function(buyType, sellType, amount) {
Engine.PostCommand(PlayerID,{"type": "barter", "sell" : sellType, "buy" : buyType, "amount" : amount });
return this;
},
tradeRoute: function(target, source) {
Engine.PostCommand(PlayerID,{"type": "setup-trade-route", "entities": [this.id()], "target": target.id(), "source": source.id(), "route": undefined, "queued": false });
return this;
},
setRallyPoint: function(target, command) {
let data = {"command": command, "target": target.id()};
Engine.PostCommand(PlayerID, {"type": "set-rallypoint", "entities": [this.id()], "x": target.position()[0], "z": target.position()[1], "data": data});
return this;
},
unsetRallyPoint: function() {
Engine.PostCommand(PlayerID, {"type": "unset-rallypoint", "entities": [this.id()]});
return this;
},
train: function(civ, type, count, metadata, promotedTypes)
{
let trainable = this.trainableEntities(civ);
if (!trainable)
{
error("Called train("+type+", "+count+") on non-training entity "+this);
return this;
}
if (trainable.indexOf(type) === -1)
{
error("Called train("+type+", "+count+") on entity "+this+" which can't train that");
return this;
}
Engine.PostCommand(PlayerID,{
"type": "train",
"entities": [this.id()],
"template": type,
"count": count,
"metadata": metadata,
"promoted": promotedTypes
});
return this;
},
construct: function(template, x, z, angle, metadata) {
// TODO: verify this unit can construct this, just for internal
// sanity-checking and error reporting
Engine.PostCommand(PlayerID,{
"type": "construct",
"entities": [this.id()],
"template": template,
"x": x,
"z": z,
"angle": angle,
"autorepair": false,
"autocontinue": false,
"queued": false,
"metadata" : metadata // can be undefined
});
return this;
},
research: function(template) {
Engine.PostCommand(PlayerID,{ "type": "research", "entity": this.id(), "template": template });
return this;
},
stopProduction: function(id) {
Engine.PostCommand(PlayerID,{ "type": "stop-production", "entity": this.id(), "id": id });
return this;
},
stopAllProduction: function(percentToStopAt) {
let queue = this._entity.trainingQueue;
if (!queue)
return true; // no queue, so technically we stopped all production.
for (let item of queue)
if (item.progress < percentToStopAt)
Engine.PostCommand(PlayerID,{ "type": "stop-production", "entity": this.id(), "id": item.id });
return this;
},
"guard": function(target, queued = false) {
Engine.PostCommand(PlayerID, { "type": "guard", "entities": [this.id()], "target": target.id(), "queued": queued });
return this;
},
"removeGuard": function() {
Engine.PostCommand(PlayerID, { "type": "remove-guard", "entities": [this.id()] });
return this;
}
});
return m;
}(API3);
Index: ps/trunk/binaries/data/mods/public/simulation/ai/common-api/shared.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/common-api/shared.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/common-api/shared.js (revision 19631)
@@ -1,470 +1,484 @@
var API3 = function(m)
{
/** Shared script handling templates and basic terrain analysis */
m.SharedScript = function(settings)
{
if (!settings)
return;
this._players = settings.players;
this._templates = settings.templates;
this._derivedTemplates = {};
this._techTemplates = settings.techTemplates;
this._entityMetadata = {};
for (let i in this._players)
this._entityMetadata[this._players[i]] = {};
// array of entity collections
this._entityCollections = new Map();
this._entitiesModifications = new Map(); // entities modifications
this._templatesModifications = {}; // template modifications
// each name is a reference to the actual one.
this._entityCollectionsName = new Map();
this._entityCollectionsByDynProp = {};
this._entityCollectionsUID = 0;
};
/** Return a simple object (using no classes etc) that will be serialized into saved games */
m.SharedScript.prototype.Serialize = function()
{
return {
"players": this._players,
"techTemplates": this._techTemplates,
"templatesModifications": this._templatesModifications,
"entitiesModifications": this._entitiesModifications,
"metadata": this._entityMetadata
};
};
/**
* Called after the constructor when loading a saved game, with 'data' being
* whatever Serialize() returned
*/
m.SharedScript.prototype.Deserialize = function(data)
{
this._players = data.players;
this._techTemplates = data.techTemplates;
this._templatesModifications = data.templatesModifications;
this._entitiesModifications = data.entitiesModifications;
this._entityMetadata = data.metadata;
this._derivedTemplates = {};
this.isDeserialized = true;
};
/**
* Components that will be disabled in foundation entity templates.
* (This is a bit yucky and fragile since it's the inverse of
* CCmpTemplateManager::CopyFoundationSubset and only includes components
* that our Template class currently uses.)
*/
m.g_FoundationForbiddenComponents = {
"ProductionQueue": 1,
"ResourceSupply": 1,
"ResourceDropsite": 1,
"GarrisonHolder": 1,
"Capturable": 1
};
/**
* Components that will be disabled in resource entity templates.
* Roughly the inverse of CCmpTemplateManager::CopyResourceSubset.
*/
m.g_ResourceForbiddenComponents = {
"Cost": 1,
"Decay": 1,
"Health": 1,
"UnitAI": 1,
"UnitMotion": 1,
"Vision": 1
};
m.SharedScript.prototype.GetTemplate = function(name)
{
if (this._templates[name])
return this._templates[name];
if (this._derivedTemplates[name])
return this._derivedTemplates[name];
// If this is a foundation template, construct it automatically
if (name.indexOf("foundation|") !== -1)
{
let base = this.GetTemplate(name.substr(11));
let foundation = {};
for (let key in base)
if (!m.g_FoundationForbiddenComponents[key])
foundation[key] = base[key];
this._derivedTemplates[name] = foundation;
return foundation;
}
else if (name.indexOf("resource|") !== -1)
{
let base = this.GetTemplate(name.substr(9));
let resource = {};
for (let key in base)
if (!m.g_ResourceForbiddenComponents[key])
resource[key] = base[key];
this._derivedTemplates[name] = resource;
return resource;
}
+ else if (name.indexOf("ungarrisonable|") !== -1)
+ {
+ let base = this.GetTemplate(name.substr(15));
+
+ let ent = {};
+ for (let key in base)
+ if (key !== "Garrisonable")
+ ent[key] = base[key];
+ else
+ ent[key] = "false";
+
+ this._derivedTemplates[name] = ent;
+ return ent;
+ }
error("Tried to retrieve invalid template '"+name+"'");
return null;
};
/**
* Initialize the shared component.
* We need to know the initial state of the game for this, as we will use it.
* This is called right at the end of the map generation.
*/
m.SharedScript.prototype.init = function(state, deserialization)
{
if (!deserialization)
{
this._entitiesModifications = new Map();
for (let i = 0; i < state.players.length; ++i)
this._templatesModifications[i] = {};
}
this.ApplyTemplatesDelta(state);
this.passabilityClasses = state.passabilityClasses;
this.players = this._players;
this.playersData = state.players;
this.timeElapsed = state.timeElapsed;
this.circularMap = state.circularMap;
this.mapSize = state.mapSize;
this.gameType = state.gameType;
this.alliedVictory = state.alliedVictory;
this.ceasefireActive = state.ceasefireActive;
this.passabilityMap = state.passabilityMap;
if (this.mapSize % this.passabilityMap.width !== 0)
error("AI shared component inconsistent sizes: map=" + this.mapSize + " while passability=" + this.passabilityMap.width);
this.passabilityMap.cellSize = this.mapSize / this.passabilityMap.width;
this.territoryMap = state.territoryMap;
if (this.mapSize % this.territoryMap.width !== 0)
error("AI shared component inconsistent sizes: map=" + this.mapSize + " while territory=" + this.territoryMap.width);
this.territoryMap.cellSize = this.mapSize / this.territoryMap.width;
/*
let landPassMap = new Uint8Array(this.passabilityMap.data.length);
let waterPassMap = new Uint8Array(this.passabilityMap.data.length);
let obstructionMaskLand = this.passabilityClasses["default-terrain-only"];
let obstructionMaskWater = this.passabilityClasses["ship-terrain-only"];
for (let i = 0; i < this.passabilityMap.data.length; ++i)
{
landPassMap[i] = (this.passabilityMap.data[i] & obstructionMaskLand) ? 0 : 255;
waterPassMap[i] = (this.passabilityMap.data[i] & obstructionMaskWater) ? 0 : 255;
}
Engine.DumpImage("LandPassMap.png", landPassMap, this.passabilityMap.width, this.passabilityMap.height, 255);
Engine.DumpImage("WaterPassMap.png", waterPassMap, this.passabilityMap.width, this.passabilityMap.height, 255);
*/
this._entities = new Map();
if (state.entities)
for (let id in state.entities)
this._entities.set(+id, new m.Entity(this, state.entities[id]));
// entity collection updated on create/destroy event.
this.entities = new m.EntityCollection(this, this._entities);
// create the terrain analyzer
this.terrainAnalyzer = new m.TerrainAnalysis();
this.terrainAnalyzer.init(this, state);
this.accessibility = new m.Accessibility();
this.accessibility.init(state, this.terrainAnalyzer);
// Setup resources
this.resourceInfo = state.resources;
m.Resources.prototype.types = state.resources.codes;
// Resource types: ignore = not used for resource maps
// abundant = abundant resource with small amount each
// sparse = sparse resource, but huge amount each
// The following maps are defined in TerrainAnalysis.js and are used for some building placement (cc, dropsites)
// They are updated by checking for create and destroy events for all resources
this.normalizationFactor = { "abundant": 50, "sparse": 90 };
this.influenceRadius = { "abundant": 36, "sparse": 48 };
this.ccInfluenceRadius = { "abundant": 60, "sparse": 120 };
this.resourceMaps = {}; // Contains maps showing the density of resources
this.ccResourceMaps = {}; // Contains maps showing the density of resources, optimized for CC placement.
this.createResourceMaps();
this.gameState = {};
for (let i in this._players)
{
this.gameState[this._players[i]] = new m.GameState();
this.gameState[this._players[i]].init(this,state, this._players[i]);
}
};
/**
* General update of the shared script, before each AI's update
* applies entity deltas, and each gamestate.
*/
m.SharedScript.prototype.onUpdate = function(state)
{
if (this.isDeserialized)
{
this.init(state, true);
this.isDeserialized = false;
}
// deals with updating based on create and destroy messages.
this.ApplyEntitiesDelta(state);
this.ApplyTemplatesDelta(state);
Engine.ProfileStart("onUpdate");
// those are dynamic and need to be reset as the "state" object moves in memory.
this.events = state.events;
this.passabilityClasses = state.passabilityClasses;
this.playersData = state.players;
this.timeElapsed = state.timeElapsed;
this.barterPrices = state.barterPrices;
this.ceasefireActive = state.ceasefireActive;
this.passabilityMap = state.passabilityMap;
this.passabilityMap.cellSize = this.mapSize / this.passabilityMap.width;
this.territoryMap = state.territoryMap;
this.territoryMap.cellSize = this.mapSize / this.territoryMap.width;
for (let i in this.gameState)
this.gameState[i].update(this);
// TODO: merge this with "ApplyEntitiesDelta" since after all they do the same.
this.updateResourceMaps(this.events);
Engine.ProfileStop();
};
m.SharedScript.prototype.ApplyEntitiesDelta = function(state)
{
Engine.ProfileStart("Shared ApplyEntitiesDelta");
let foundationFinished = {};
// by order of updating:
// we "Destroy" last because we want to be able to switch Metadata first.
let CreateEvents = state.events.Create;
for (let i = 0; i < CreateEvents.length; ++i)
{
let evt = CreateEvents[i];
if (!state.entities[evt.entity])
continue; // Sometimes there are things like foundations which get destroyed too fast
let entity = new m.Entity(this, state.entities[evt.entity]);
this._entities.set(evt.entity, entity);
this.entities.addEnt(entity);
// Update all the entity collections since the create operation affects static properties as well as dynamic
for (let entCol of this._entityCollections.values())
entCol.updateEnt(entity);
}
for (let evt of state.events.EntityRenamed)
{ // Switch the metadata: TODO entityCollections are updated only because of the owner change. Should be done properly
for (let p in this._players)
{
this._entityMetadata[this._players[p]][evt.newentity] = this._entityMetadata[this._players[p]][evt.entity];
this._entityMetadata[this._players[p]][evt.entity] = {};
}
}
for (let evt of state.events.TrainingFinished)
{ // Apply metadata stored in training queues
for (let entId of evt.entities)
for (let key in evt.metadata)
this.setMetadata(evt.owner, this._entities.get(entId), key, evt.metadata[key]);
}
for (let evt of state.events.ConstructionFinished)
{ // we'll move metadata.
if (!this._entities.has(evt.entity))
continue;
let ent = this._entities.get(evt.entity);
let newEnt = this._entities.get(evt.newentity);
if (this._entityMetadata[ent.owner()] && this._entityMetadata[ent.owner()][evt.entity] !== undefined)
for (let key in this._entityMetadata[ent.owner()][evt.entity])
this.setMetadata(ent.owner(), newEnt, key, this._entityMetadata[ent.owner()][evt.entity][key]);
foundationFinished[evt.entity] = true;
}
for (let evt of state.events.AIMetadata)
{
if (!this._entities.has(evt.id))
continue; // might happen in some rare cases of foundations getting destroyed, perhaps.
// Apply metadata (here for buildings for example)
for (let key in evt.metadata)
this.setMetadata(evt.owner, this._entities.get(evt.id), key, evt.metadata[key]);
}
let DestroyEvents = state.events.Destroy;
for (let i = 0; i < DestroyEvents.length; ++i)
{
let evt = DestroyEvents[i];
// A small warning: javascript "delete" does not actually delete, it only removes the reference in this object.
// the "deleted" object remains in memory, and any older reference to it will still reference it as if it were not "deleted".
// Worse, they might prevent it from being garbage collected, thus making it stay alive and consuming ram needlessly.
// So take care, and if you encounter a weird bug with deletion not appearing to work correctly, this is probably why.
if (!this._entities.has(evt.entity))
continue;// probably should remove the event.
if (foundationFinished[evt.entity])
evt.SuccessfulFoundation = true;
// The entity was destroyed but its data may still be useful, so
// remember the entity and this AI's metadata concerning it
evt.metadata = {};
evt.entityObj = this._entities.get(evt.entity);
for (let j in this._players)
evt.metadata[this._players[j]] = this._entityMetadata[this._players[j]][evt.entity];
let entity = this._entities.get(evt.entity);
for (let entCol of this._entityCollections.values())
entCol.removeEnt(entity);
this.entities.removeEnt(entity);
this._entities.delete(evt.entity);
this._entitiesModifications.delete(evt.entity);
for (let j in this._players)
delete this._entityMetadata[this._players[j]][evt.entity];
}
for (let id in state.entities)
{
let changes = state.entities[id];
let entity = this._entities.get(+id);
for (let prop in changes)
{
entity._entity[prop] = changes[prop];
this.updateEntityCollections(prop, entity);
}
}
// apply per-entity aura-related changes.
// this supersedes tech-related changes.
for (let id in state.changedEntityTemplateInfo)
{
if (!this._entities.has(+id))
continue; // dead, presumably.
let changes = state.changedEntityTemplateInfo[id];
if (!this._entitiesModifications.has(+id))
this._entitiesModifications.set(+id, new Map());
let modif = this._entitiesModifications.get(+id);
for (let change of changes)
modif.set(change.variable, change.value);
}
Engine.ProfileStop();
};
m.SharedScript.prototype.ApplyTemplatesDelta = function(state)
{
Engine.ProfileStart("Shared ApplyTemplatesDelta");
for (let player in state.changedTemplateInfo)
{
let playerDiff = state.changedTemplateInfo[player];
for (let template in playerDiff)
{
let changes = playerDiff[template];
if (!this._templatesModifications[player][template])
this._templatesModifications[player][template] = new Map();
let modif = this._templatesModifications[player][template];
for (let change of changes)
modif.set(change.variable, change.value);
}
}
Engine.ProfileStop();
};
m.SharedScript.prototype.registerUpdatingEntityCollection = function(entCollection)
{
entCollection.setUID(this._entityCollectionsUID);
this._entityCollections.set(this._entityCollectionsUID, entCollection);
for (let prop of entCollection.dynamicProperties())
{
if (!this._entityCollectionsByDynProp[prop])
this._entityCollectionsByDynProp[prop] = new Map();
this._entityCollectionsByDynProp[prop].set(this._entityCollectionsUID, entCollection);
}
this._entityCollectionsUID++;
};
m.SharedScript.prototype.removeUpdatingEntityCollection = function(entCollection)
{
let uid = entCollection.getUID();
if (this._entityCollections.has(uid))
this._entityCollections.delete(uid);
for (let prop of entCollection.dynamicProperties())
if (this._entityCollectionsByDynProp[prop].has(uid))
this._entityCollectionsByDynProp[prop].delete(uid);
};
m.SharedScript.prototype.updateEntityCollections = function(property, ent)
{
if (this._entityCollectionsByDynProp[property] === undefined)
return;
for (let entCol of this._entityCollectionsByDynProp[property].values())
entCol.updateEnt(ent);
};
m.SharedScript.prototype.setMetadata = function(player, ent, key, value)
{
let metadata = this._entityMetadata[player][ent.id()];
if (!metadata)
metadata = this._entityMetadata[player][ent.id()] = {};
metadata[key] = value;
this.updateEntityCollections('metadata', ent);
this.updateEntityCollections('metadata.' + key, ent);
};
m.SharedScript.prototype.getMetadata = function(player, ent, key)
{
let metadata = this._entityMetadata[player][ent.id()];
if (!metadata || !(key in metadata))
return undefined;
return metadata[key];
};
m.SharedScript.prototype.deleteMetadata = function(player, ent, key)
{
let metadata = this._entityMetadata[player][ent.id()];
if (!metadata || !(key in metadata))
return true;
metadata[key] = undefined;
delete metadata[key];
this.updateEntityCollections('metadata', ent);
this.updateEntityCollections('metadata.' + key, ent);
return true;
};
m.copyPrototype = function(descendant, parent)
{
let sConstructor = parent.toString();
let aMatch = sConstructor.match( /\s*function (.*)\(/ );
if ( aMatch != null )
descendant.prototype[aMatch[1]] = parent;
for (let p in parent.prototype)
descendant.prototype[p] = parent.prototype[p];
};
return m;
}(API3);
Index: ps/trunk/binaries/data/mods/public/simulation/ai/petra/garrisonManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/petra/garrisonManager.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/petra/garrisonManager.js (revision 19631)
@@ -1,347 +1,347 @@
var PETRA = function(m)
{
/**
* Manage the garrisonHolders
* When a unit is ordered to garrison, it must be done through this.garrison() function so that
* an object in this.holders is created. This object contains an array with the entities
* in the process of being garrisoned. To have all garrisoned units, we must add those in holder.garrisoned().
* Futhermore garrison units have a metadata garrisonType describing its reason (protection, transport, ...)
*/
m.GarrisonManager = function(Config)
{
this.Config = Config;
this.holders = new Map();
this.decayingStructures = new Map();
};
m.GarrisonManager.prototype.update = function(gameState, events)
{
// First check for possible upgrade of a structure
for (let evt of events.EntityRenamed)
{
for (let id of this.holders.keys())
{
if (id !== evt.entity)
continue;
let data = this.holders.get(id);
this.holders.delete(id);
this.holders.set(evt.newentity, data);
}
for (let id of this.decayingStructures.keys())
{
if (id !== evt.entity)
continue;
this.decayingStructures.delete(id);
if (this.decayingStructures.has(evt.newentity))
continue;
let ent = gameState.getEntityById(evt.newentity);
if (!ent || !ent.territoryDecayRate() || !ent.garrisonRegenRate())
continue;
let gmin = Math.ceil((ent.territoryDecayRate() - ent.defaultRegenRate()) / ent.garrisonRegenRate());
this.decayingStructures.set(evt.newentity, gmin);
}
}
for (let [id, data] of this.holders.entries())
{
let list = data.list;
let holder = gameState.getEntityById(id);
if (!holder || !gameState.isPlayerAlly(holder.owner()))
{
// this holder was certainly destroyed or captured. Let's remove it
for (let entId of list)
{
let ent = gameState.getEntityById(entId);
if (ent && ent.getMetadata(PlayerID, "garrisonHolder") == id)
{
this.leaveGarrison(ent);
ent.stopMoving();
}
}
this.holders.delete(id);
continue;
}
// Update the list of garrisoned units
for (let j = 0; j < list.length; ++j)
{
for (let evt of events.EntityRenamed)
if (evt.entity === list[j])
list[j] = evt.newentity;
let ent = gameState.getEntityById(list[j]);
if (!ent) // unit must have been killed while garrisoning
list.splice(j--, 1);
else if (holder.garrisoned().indexOf(list[j]) !== -1) // unit is garrisoned
{
this.leaveGarrison(ent);
list.splice(j--, 1);
}
else
{
if (ent.unitAIOrderData().some(order => order.target && order.target == id))
continue;
if (ent.getMetadata(PlayerID, "garrisonHolder") == id)
{
// The garrison order must have failed
this.leaveGarrison(ent);
list.splice(j--, 1);
}
else
{
if (gameState.ai.Config.debug > 0)
{
API3.warn("Petra garrison error: unit " + ent.id() + " (" + ent.genericName() +
") is expected to garrison in " + id + " (" + holder.genericName() +
"), but has no such garrison order " + uneval(ent.unitAIOrderData()));
m.dumpEntity(ent);
}
list.splice(j--, 1);
}
}
}
if (!holder.position()) // could happen with siege unit inside a ship
continue;
if (gameState.ai.elapsedTime - holder.getMetadata(PlayerID, "holderTimeUpdate") > 3)
{
let range = holder.attackRange("Ranged") ? holder.attackRange("Ranged").max : 80;
let around = { "defenseStructure": false, "meleeSiege": false, "rangeSiege": false, "unit": false };
for (let ent of gameState.getEnemyEntities().values())
{
if (!ent.position())
continue;
if (ent.owner() === 0 && (!ent.unitAIState() || ent.unitAIState().split(".")[1] !== "COMBAT"))
continue;
let dist = API3.SquareVectorDistance(ent.position(), holder.position());
if (dist > range*range)
continue;
if (ent.hasClass("Structure"))
{
if (ent.attackRange("Ranged")) // TODO units on wall are not taken into account
around.defenseStructure = true;
}
else if (m.isSiegeUnit(ent))
{
if (ent.attackTypes().indexOf("Melee") !== -1)
around.meleeSiege = true;
else
around.rangeSiege = true;
}
else
{
around.unit = true;
break;
}
}
// Keep defenseManager.garrisonUnitsInside in sync to avoid garrisoning-ungarrisoning some units
data.allowMelee = around.defenseStructure || around.unit;
for (let entId of holder.garrisoned())
{
let ent = gameState.getEntityById(entId);
if (ent.owner() === PlayerID && !this.keepGarrisoned(ent, holder, around))
holder.unload(entId);
}
for (let j = 0; j < list.length; ++j)
{
let ent = gameState.getEntityById(list[j]);
if (this.keepGarrisoned(ent, holder, around))
continue;
if (ent.getMetadata(PlayerID, "garrisonHolder") == id)
{
this.leaveGarrison(ent);
ent.stopMoving();
}
list.splice(j--, 1);
}
if (this.numberOfGarrisonedUnits(holder) === 0)
this.holders.delete(id);
else
holder.setMetadata(PlayerID, "holderTimeUpdate", gameState.ai.elapsedTime);
}
}
// Warning new garrison orders (as in the following lines) should be done after having updated the holders
// (or TODO we should add a test that the garrison order is from a previous turn when updating)
for (let [id, gmin] of this.decayingStructures.entries())
{
let ent = gameState.getEntityById(id);
if (!ent || ent.owner() !== PlayerID)
this.decayingStructures.delete(id);
else if (this.numberOfGarrisonedUnits(ent) < gmin)
gameState.ai.HQ.defenseManager.garrisonUnitsInside(gameState, ent, {"min": gmin, "type": "decay"});
}
};
/** TODO should add the units garrisoned inside garrisoned units */
m.GarrisonManager.prototype.numberOfGarrisonedUnits = function(holder)
{
if (!this.holders.has(holder.id()))
return holder.garrisoned().length;
return holder.garrisoned().length + this.holders.get(holder.id()).list.length;
};
m.GarrisonManager.prototype.allowMelee = function(holder)
{
if (!this.holders.has(holder.id()))
return undefined;
return this.holders.get(holder.id()).allowMelee;
};
/** This is just a pre-garrison state, while the entity walk to the garrison holder */
m.GarrisonManager.prototype.garrison = function(gameState, ent, holder, type)
{
- if (this.numberOfGarrisonedUnits(holder) >= holder.garrisonMax())
+ if (this.numberOfGarrisonedUnits(holder) >= holder.garrisonMax() || !ent.canGarrison())
return;
this.registerHolder(gameState, holder);
this.holders.get(holder.id()).list.push(ent.id());
if (gameState.ai.Config.debug > 2)
{
warn("garrison unit " + ent.genericName() + " in " + holder.genericName() + " with type " + type);
warn(" we try to garrison a unit with plan " + ent.getMetadata(PlayerID, "plan") + " and role " + ent.getMetadata(PlayerID, "role") +
" and subrole " + ent.getMetadata(PlayerID, "subrole") + " and transport " + ent.getMetadata(PlayerID, "transport"));
}
if (ent.getMetadata(PlayerID, "plan") !== undefined)
ent.setMetadata(PlayerID, "plan", -2);
else
ent.setMetadata(PlayerID, "plan", -3);
ent.setMetadata(PlayerID, "subrole", "garrisoning");
ent.setMetadata(PlayerID, "garrisonHolder", holder.id());
ent.setMetadata(PlayerID, "garrisonType", type);
ent.garrison(holder);
};
/**
This is the end of the pre-garrison state, either because the entity is really garrisoned
or because it has changed its order (i.e. because the garrisonHolder was destroyed)
This function is for internal use inside garrisonManager. From outside, you should also update
the holder and then using cancelGarrison should be the preferred solution
*/
m.GarrisonManager.prototype.leaveGarrison = function(ent)
{
ent.setMetadata(PlayerID, "subrole", undefined);
if (ent.getMetadata(PlayerID, "plan") === -2)
ent.setMetadata(PlayerID, "plan", -1);
else
ent.setMetadata(PlayerID, "plan", undefined);
ent.setMetadata(PlayerID, "garrisonHolder", undefined);
};
/** Cancel a pre-garrison state */
m.GarrisonManager.prototype.cancelGarrison = function(ent)
{
ent.stopMoving();
this.leaveGarrison(ent);
let holderId = ent.getMetadata(PlayerID, "garrisonHolder");
if (!holderId || !this.holders.has(holderId))
return;
let list = this.holders.get(holderId).list;
let index = list.indexOf(ent.id());
if (index !== -1)
list.splice(index, 1);
};
m.GarrisonManager.prototype.keepGarrisoned = function(ent, holder, around)
{
switch (ent.getMetadata(PlayerID, "garrisonType"))
{
case 'force': // force the ungarrisoning
return false;
case 'trade': // trader garrisoned in ship
return true;
case 'protection': // hurt unit for healing or infantry for defense
if (holder.buffHeal() && ent.isHealable() && ent.healthLevel() < this.Config.garrisonHealthLevel.high)
return true;
if (MatchesClassList(ent.classes(), holder.getGarrisonArrowClasses()))
{
if (around.unit || around.defenseStructure)
return true;
if (around.meleeSiege || around.rangeSiege)
return ent.attackTypes().indexOf("Melee") === -1 || ent.healthLevel() < this.Config.garrisonHealthLevel.low;
return false;
}
if (ent.attackTypes() && ent.attackTypes().indexOf("Melee") !== -1)
return false;
if (around.unit)
return ent.hasClass("Support") || m.isSiegeUnit(ent); // only ranged siege here and below as melee siege already released above
if (m.isSiegeUnit(ent))
return around.meleeSiege;
return holder.buffHeal() && ent.needsHeal();
case 'decay':
return this.decayingStructures.has(holder.id());
case 'emergency': // f.e. hero in regicide mode
if (holder.buffHeal() && ent.isHealable() && ent.healthLevel() < this.Config.garrisonHealthLevel.high)
return true;
if (around.unit || around.defenseStructure || around.meleeSiege ||
around.rangeSiege && ent.healthLevel() < this.Config.garrisonHealthLevel.high)
return true;
return holder.buffHeal() && ent.needsHeal();
default:
if (ent.getMetadata(PlayerID, "onBoard") === "onBoard") // transport is not (yet ?) managed by garrisonManager
return true;
API3.warn("unknown type in garrisonManager " + ent.getMetadata(PlayerID, "garrisonType") +
" for " + ent.genericName() + " id " + ent.id() +
" inside " + holder.genericName() + " id " + holder.id());
ent.setMetadata(PlayerID, "garrisonType", "protection");
return true;
}
};
/** Add this holder in the list managed by the garrisonManager */
m.GarrisonManager.prototype.registerHolder = function(gameState, holder)
{
if (this.holders.has(holder.id())) // already registered
return;
this.holders.set(holder.id(), { "list": [], "allowMelee": true });
holder.setMetadata(PlayerID, "holderTimeUpdate", gameState.ai.elapsedTime);
};
/**
* Garrison units in decaying structures to stop their decay
* do it only for structures useful for defense, except if we are expanding (justCaptured=true)
* in which case we also do it for structures useful for unit trainings (TODO only Barracks are done)
*/
m.GarrisonManager.prototype.addDecayingStructure = function(gameState, entId, justCaptured)
{
if (this.decayingStructures.has(entId))
return true;
let ent = gameState.getEntityById(entId);
if (!ent || (!(ent.hasClass("Barracks") && justCaptured) && !ent.hasDefensiveFire()))
return false;
if (!ent.territoryDecayRate() || !ent.garrisonRegenRate())
return false;
let gmin = Math.ceil((ent.territoryDecayRate() - ent.defaultRegenRate()) / ent.garrisonRegenRate());
this.decayingStructures.set(entId, gmin);
return true;
};
m.GarrisonManager.prototype.removeDecayingStructure = function(entId)
{
if (!this.decayingStructures.has(entId))
return;
this.decayingStructures.delete(entId);
};
m.GarrisonManager.prototype.Serialize = function()
{
return { "holders": this.holders, "decayingStructures": this.decayingStructures };
};
m.GarrisonManager.prototype.Deserialize = function(data)
{
for (let key in data)
this[key] = data[key];
};
return m;
}(PETRA);
Index: ps/trunk/binaries/data/mods/public/simulation/ai/petra/navalManager.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/ai/petra/navalManager.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/simulation/ai/petra/navalManager.js (revision 19631)
@@ -1,794 +1,797 @@
var PETRA = function(m)
{
/**
* Naval Manager
* Will deal with anything ships.
* -Basically trade over water (with fleets and goals commissioned by the economy manager)
* -Defense over water (commissioned by the defense manager)
* -Transport of units over water (a few units).
* -Scouting, ultimately.
* Also deals with handling docks, making sure we have access and stuffs like that.
*/
m.NavalManager = function(Config)
{
this.Config = Config;
// ship subCollections. Also exist for land zones, idem, not caring.
this.seaShips = [];
this.seaTransportShips = [];
this.seaWarShips = [];
this.seaFishShips = [];
// wanted NB per zone.
this.wantedTransportShips = [];
this.wantedWarShips = [];
this.wantedFishShips = [];
// needed NB per zone.
this.neededTransportShips = [];
this.neededWarShips = [];
this.transportPlans = [];
// shore-line regions where we can load and unload units
this.landingZones = {};
};
/** More initialisation for stuff that needs the gameState */
m.NavalManager.prototype.init = function(gameState, deserializing)
{
// finished docks
this.docks = gameState.getOwnStructures().filter(API3.Filters.and(API3.Filters.byClassesOr(["Dock", "Shipyard"]),
API3.Filters.not(API3.Filters.isFoundation())));
this.docks.registerUpdates();
this.ships = gameState.getOwnUnits().filter(API3.Filters.and(API3.Filters.byClass("Ship"), API3.Filters.not(API3.Filters.byMetadata(PlayerID, "role", "trader"))));
// note: those two can overlap (some transport ships are warships too and vice-versa).
this.transportShips = this.ships.filter(API3.Filters.and(API3.Filters.byCanGarrison(), API3.Filters.not(API3.Filters.byClass("FishingBoat"))));
this.warShips = this.ships.filter(API3.Filters.byClass("Warship"));
this.fishShips = this.ships.filter(API3.Filters.byClass("FishingBoat"));
this.ships.registerUpdates();
this.transportShips.registerUpdates();
this.warShips.registerUpdates();
this.fishShips.registerUpdates();
let availableFishes = {};
for (let fish of gameState.getFishableSupplies().values())
{
let sea = this.getFishSea(gameState, fish);
if (sea && availableFishes[sea])
availableFishes[sea] += fish.resourceSupplyAmount();
else if (sea)
availableFishes[sea] = fish.resourceSupplyAmount();
}
for (let i = 0; i < gameState.ai.accessibility.regionSize.length; ++i)
{
if (!gameState.ai.HQ.navalRegions[i])
{
// push dummies
this.seaShips.push(undefined);
this.seaTransportShips.push(undefined);
this.seaWarShips.push(undefined);
this.seaFishShips.push(undefined);
this.wantedTransportShips.push(0);
this.wantedWarShips.push(0);
this.wantedFishShips.push(0);
this.neededTransportShips.push(0);
this.neededWarShips.push(0);
}
else
{
let collec = this.ships.filter(API3.Filters.byMetadata(PlayerID, "sea", i));
collec.registerUpdates();
this.seaShips.push(collec);
collec = this.transportShips.filter(API3.Filters.byMetadata(PlayerID, "sea", i));
collec.registerUpdates();
this.seaTransportShips.push(collec);
collec = this.warShips.filter(API3.Filters.byMetadata(PlayerID, "sea", i));
collec.registerUpdates();
this.seaWarShips.push(collec);
collec = this.fishShips.filter(API3.Filters.byMetadata(PlayerID, "sea", i));
collec.registerUpdates();
this.seaFishShips.push(collec);
this.wantedTransportShips.push(0);
this.wantedWarShips.push(0);
if (availableFishes[i] && availableFishes[i] > 1000)
this.wantedFishShips.push(this.Config.Economy.targetNumFishers);
else
this.wantedFishShips.push(0);
this.neededTransportShips.push(0);
this.neededWarShips.push(0);
}
}
// load units and buildings from the config files
let civ = gameState.getPlayerCiv();
if (civ in this.Config.buildings.naval)
this.bNaval = this.Config.buildings.naval[civ];
else
this.bNaval = this.Config.buildings.naval['default'];
for (let i in this.bNaval)
this.bNaval[i] = gameState.applyCiv(this.bNaval[i]);
if (deserializing)
return;
// determination of the possible landing zones
let width = gameState.getMap().width;
let length = width * gameState.getMap().height;
for (let i = 0; i < length; ++i)
{
let land = gameState.ai.accessibility.landPassMap[i];
if (land < 2)
continue;
let naval = gameState.ai.accessibility.navalPassMap[i];
if (naval < 2)
continue;
if (!this.landingZones[land])
this.landingZones[land] = {};
if (!this.landingZones[land][naval])
this.landingZones[land][naval] = new Set();
this.landingZones[land][naval].add(i);
}
// and keep only thoses with enough room around when possible
for (let land in this.landingZones)
{
for (let sea in this.landingZones[land])
{
let landing = this.landingZones[land][sea];
let nbaround = {};
let nbcut = 0;
for (let i of landing)
{
let nb = 0;
if (landing.has(i-1))
nb++;
if (landing.has(i+1))
nb++;
if (landing.has(i+width))
nb++;
if (landing.has(i-width))
nb++;
nbaround[i] = nb;
nbcut = Math.max(nb, nbcut);
}
nbcut = Math.min(2, nbcut);
for (let i of landing)
{
if (nbaround[i] < nbcut)
landing.delete(i);
}
}
}
// Assign our initial docks and ships
for (let ship of this.ships.values())
this.setShipIndex(gameState, ship);
for (let dock of this.docks.values())
this.setAccessIndices(gameState, dock);
};
m.NavalManager.prototype.updateFishingBoats = function(sea, num)
{
if (this.wantedFishShips[sea])
this.wantedFishShips[sea] = num;
};
m.NavalManager.prototype.resetFishingBoats = function(gameState, sea)
{
if (sea !== undefined)
this.wantedFishShips[sea] = 0;
else
this.wantedFishShips.fill(0);
};
m.NavalManager.prototype.setAccessIndices = function(gameState, ent)
{
m.getLandAccess(gameState, ent);
m.getSeaAccess(gameState, ent);
};
m.NavalManager.prototype.setShipIndex = function(gameState, ship)
{
let sea = gameState.ai.accessibility.getAccessValue(ship.position(), true);
ship.setMetadata(PlayerID, "sea", sea);
};
/** Get the sea, cache it if not yet done and check if in opensea */
m.NavalManager.prototype.getFishSea = function(gameState, fish)
{
let sea = fish.getMetadata(PlayerID, "sea");
if (sea)
return sea;
const ntry = 4;
const around = [ [-0.7,0.7], [0,1], [0.7,0.7], [1,0], [0.7,-0.7], [0,-1], [-0.7,-0.7], [-1,0] ];
let pos = gameState.ai.accessibility.gamePosToMapPos(fish.position());
let width = gameState.ai.accessibility.width;
let k = pos[0] + pos[1]*width;
sea = gameState.ai.accessibility.navalPassMap[k];
fish.setMetadata(PlayerID, "sea", sea);
let radius = 120 / gameState.ai.accessibility.cellSize / ntry;
if (around.every(a =>
{
for (let t = 0; t < ntry; ++t)
{
let i = pos[0] + Math.round(a[0]*radius*(ntry-t));
let j = pos[1] + Math.round(a[1]*radius*(ntry-t));
if (i < 0 || i >= width || j < 0 || j >= width)
continue;
if (gameState.ai.accessibility.landPassMap[i + j*width] === 1)
{
let navalPass = gameState.ai.accessibility.navalPassMap[i + j*width];
if (navalPass === sea)
return true;
else if (navalPass === 1) // we could be outside the map
continue;
}
return false;
}
return true;
}))
fish.setMetadata(PlayerID, "opensea", true);
return sea;
};
/** check if we can safely fish at the fish position */
m.NavalManager.prototype.canFishSafely = function(gameState, fish)
{
if (fish.getMetadata(PlayerID, "opensea"))
return true;
const ntry = 4;
const around = [ [-0.7,0.7], [0,1], [0.7,0.7], [1,0], [0.7,-0.7], [0,-1], [-0.7,-0.7], [-1,0] ];
let territoryMap = gameState.ai.HQ.territoryMap;
let width = territoryMap.width;
let radius = 140 / territoryMap.cellSize / ntry;
let pos = territoryMap.gamePosToMapPos(fish.position());
return around.every(a =>
{
for (let t = 0; t < ntry; ++t)
{
let i = pos[0] + Math.round(a[0]*radius*t);
let j = pos[1] + Math.round(a[1]*radius*t);
if (i < 0 || i >= width || j < 0 || j >= width)
break;
let owner = territoryMap.getOwnerIndex(i + j*width);
if (owner !== 0 && gameState.isPlayerEnemy(owner))
return false;
}
return true;
});
};
/** get the list of seas (or lands) around this region not connected by a dock */
m.NavalManager.prototype.getUnconnectedSeas = function(gameState, region)
{
let seas = gameState.ai.accessibility.regionLinks[region].slice();
let docks = gameState.getOwnStructures().filter(API3.Filters.byClass("Dock"));
docks.forEach(function (dock) {
if (dock.getMetadata(PlayerID, "access") !== region)
return;
let i = seas.indexOf(dock.getMetadata(PlayerID, "sea"));
if (i !== -1)
seas.splice(i--,1);
});
return seas;
};
m.NavalManager.prototype.checkEvents = function(gameState, queues, events)
{
for (let evt of events.ConstructionFinished)
{
if (!evt || !evt.newentity)
continue;
let entity = gameState.getEntityById(evt.newentity);
if (entity && entity.hasClass("Dock") && entity.isOwn(PlayerID))
this.setAccessIndices(gameState, entity);
}
for (let evt of events.TrainingFinished)
{
if (!evt || !evt.entities)
continue;
for (let entId of evt.entities)
{
let entity = gameState.getEntityById(entId);
if (!entity || !entity.hasClass("Ship") || !entity.isOwn(PlayerID))
continue;
this.setShipIndex(gameState, entity);
}
}
for (let evt of events.Destroy)
{
if (!evt.entityObj || evt.entityObj.owner() !== PlayerID || !evt.metadata || !evt.metadata[PlayerID])
continue;
if (!evt.entityObj.hasClass("Ship") || !evt.metadata[PlayerID].transporter)
continue;
let plan = this.getPlan(evt.metadata[PlayerID].transporter);
if (!plan)
continue;
let shipId = evt.entityObj.id();
if (this.Config.debug > 1)
API3.warn("one ship " + shipId + " from plan " + plan.ID + " destroyed during " + plan.state);
if (plan.state === "boarding")
{
// just reset the units onBoard metadata and wait for a new ship to be assigned to this plan
plan.units.forEach(function (ent) {
if ((ent.getMetadata(PlayerID, "onBoard") === "onBoard" && ent.position()) ||
ent.getMetadata(PlayerID, "onBoard") === shipId)
ent.setMetadata(PlayerID, "onBoard", undefined);
});
plan.needTransportShips = !plan.transportShips.hasEntities();
}
else if (plan.state === "sailing")
{
let endIndex = plan.endIndex;
let self = this;
plan.units.forEach(function (ent) {
if (!ent.position()) // unit from another ship of this plan ... do nothing
return;
let access = gameState.ai.accessibility.getAccessValue(ent.position());
let endPos = ent.getMetadata(PlayerID, "endPos");
ent.setMetadata(PlayerID, "transport", undefined);
ent.setMetadata(PlayerID, "onBoard", undefined);
ent.setMetadata(PlayerID, "endPos", undefined);
// nothing else to do if access = endIndex as already at destination
// otherwise, we should require another transport
// TODO if attacking and no more ships available, remove the units from the attack
// to avoid delaying it too much
if (access !== endIndex)
self.requireTransport(gameState, ent, access, endIndex, endPos);
});
}
}
for (let evt of events.OwnershipChanged) // capture events
{
if (evt.to === PlayerID)
{
let ent = gameState.getEntityById(evt.entity);
if (ent && ent.hasClass("Dock"))
this.setAccessIndices(gameState, ent);
}
}
};
m.NavalManager.prototype.getPlan = function(ID)
{
for (let plan of this.transportPlans)
if (plan.ID === ID)
return plan;
return undefined;
};
m.NavalManager.prototype.addPlan = function(plan)
{
this.transportPlans.push(plan);
};
/**
* complete already existing plan or create a new one for this requirement
* (many units can then call this separately and end up in the same plan)
* TODO check garrison classes
*/
m.NavalManager.prototype.requireTransport = function(gameState, entity, startIndex, endIndex, endPos)
{
+ if (!entity.canGarrison())
+ return false;
+
if (entity.getMetadata(PlayerID, "transport") !== undefined)
{
if (this.Config.debug > 0)
API3.warn("Petra naval manager error: unit " + entity.id() + " has already required a transport");
return false;
}
for (let plan of this.transportPlans)
{
if (plan.startIndex !== startIndex || plan.endIndex !== endIndex)
continue;
if (plan.state !== "boarding")
continue;
plan.addUnit(entity, endPos);
return true;
}
let plan = new m.TransportPlan(gameState, [entity], startIndex, endIndex, endPos);
if (plan.failed)
{
if (this.Config.debug > 1)
API3.warn(">>>> transport plan aborted <<<<");
return false;
}
plan.init(gameState);
this.transportPlans.push(plan);
return true;
};
/** split a transport plan in two, moving all entities not yet affected to a ship in the new plan */
m.NavalManager.prototype.splitTransport = function(gameState, plan)
{
if (this.Config.debug > 1)
API3.warn(">>>> split of transport plan started <<<<");
let newplan = new m.TransportPlan(gameState, [], plan.startIndex, plan.endIndex, plan.endPos);
if (newplan.failed)
{
if (this.Config.debug > 1)
API3.warn(">>>> split of transport plan aborted <<<<");
return false;
}
newplan.init(gameState);
let nbUnits = 0;
plan.units.forEach(function (ent) {
if (ent.getMetadata(PlayerID, "onBoard"))
return;
++nbUnits;
newplan.addUnit(ent, ent.getMetadata(PlayerID, "endPos"));
});
if (this.Config.debug > 1)
API3.warn(">>>> previous plan left with units " + plan.units.length);
if (nbUnits)
this.transportPlans.push(newplan);
return nbUnits !== 0;
};
/**
* create a transport from a garrisoned ship to a land location
* needed at start game when starting with a garrisoned ship
*/
m.NavalManager.prototype.createTransportIfNeeded = function(gameState, fromPos, toPos, toAccess)
{
let fromAccess = gameState.ai.accessibility.getAccessValue(fromPos);
if (fromAccess !== 1)
return;
if (toAccess < 2)
return;
for (let ship of this.ships.values())
{
if (!ship.isGarrisonHolder() || !ship.garrisoned().length)
continue;
if (ship.getMetadata(PlayerID, "transporter") !== undefined)
continue;
let units = [];
for (let entId of ship.garrisoned())
units.push(gameState.getEntityById(entId));
// TODO check that the garrisoned units have not another purpose
let plan = new m.TransportPlan(gameState, units, fromAccess, toAccess, toPos, ship);
if (plan.failed)
continue;
plan.init(gameState);
this.transportPlans.push(plan);
}
};
// set minimal number of needed ships when a new event (new base or new attack plan)
m.NavalManager.prototype.setMinimalTransportShips = function(gameState, sea, number)
{
if (!sea)
return;
if (this.wantedTransportShips[sea] < number )
this.wantedTransportShips[sea] = number;
};
// bumps up the number of ships we want if we need more.
m.NavalManager.prototype.checkLevels = function(gameState, queues)
{
if (queues.ships.hasQueuedUnits())
return;
for (let sea = 0; sea < this.neededTransportShips.length; sea++)
this.neededTransportShips[sea] = 0;
for (let plan of this.transportPlans)
{
if (!plan.needTransportShips || plan.units.length < 2)
continue;
let sea = plan.sea;
if (gameState.countOwnQueuedEntitiesWithMetadata("sea", sea) > 0 ||
this.seaTransportShips[sea].length < this.wantedTransportShips[sea])
continue;
++this.neededTransportShips[sea];
if (this.wantedTransportShips[sea] === 0 || this.seaTransportShips[sea].length < plan.transportShips.length + 2)
{
++this.wantedTransportShips[sea];
return;
}
}
for (let sea = 0; sea < this.neededTransportShips.length; sea++)
if (this.neededTransportShips[sea] > 2)
++this.wantedTransportShips[sea];
};
m.NavalManager.prototype.maintainFleet = function(gameState, queues)
{
if (queues.ships.hasQueuedUnits())
return;
if (!gameState.getOwnEntitiesByClass("Dock", true).filter(API3.Filters.isBuilt()).hasEntities() &&
!gameState.getOwnEntitiesByClass("Shipyard", true).filter(API3.Filters.isBuilt()).hasEntities())
return;
// check if we have enough transport ships per region.
for (let sea = 0; sea < this.seaShips.length; ++sea)
{
if (this.seaShips[sea] === undefined)
continue;
if (gameState.countOwnQueuedEntitiesWithMetadata("sea", sea) > 0)
continue;
if (this.seaTransportShips[sea].length < this.wantedTransportShips[sea])
{
let template = this.getBestShip(gameState, sea, "transport");
if (template)
{
queues.ships.addPlan(new m.TrainingPlan(gameState, template, { "sea": sea }, 1, 1));
continue;
}
}
if (this.seaFishShips[sea].length < this.wantedFishShips[sea])
{
let template = this.getBestShip(gameState, sea, "fishing");
if (template)
{
queues.ships.addPlan(new m.TrainingPlan(gameState, template, { "base": 0, "role": "worker", "sea": sea }, 1, 1));
continue;
}
}
}
};
/** assigns free ships to plans that need some */
m.NavalManager.prototype.assignShipsToPlans = function(gameState)
{
for (let plan of this.transportPlans)
if (plan.needTransportShips)
plan.assignShip(gameState);
};
/** let blocking ships move apart from active ships (waiting for a better pathfinder) */
m.NavalManager.prototype.moveApart = function(gameState)
{
let self = this;
this.ships.forEach(function(ship) {
if (ship.hasClass("FishingBoat")) // small ships should not be a problem
return;
let sea = ship.getMetadata(PlayerID, "sea");
if (ship.getMetadata(PlayerID, "transporter") === undefined)
{
if (ship.isIdle()) // do not stay idle near a dock to not disturb other ships
{
gameState.getAllyStructures().filter(API3.Filters.byClass("Dock")).forEach(function(dock) {
if (dock.getMetadata(PlayerID, "sea") !== sea)
return;
if (API3.SquareVectorDistance(ship.position(), dock.position()) > 2500)
return;
ship.moveApart(dock.position(), 50);
});
}
return;
}
// if transporter ship not idle, move away other ships which could block it
self.seaShips[sea].forEach(function(blockingShip) {
if (blockingShip === ship || !blockingShip.isIdle())
return;
if (API3.SquareVectorDistance(ship.position(), blockingShip.position()) > 900)
return;
if (blockingShip.getMetadata(PlayerID, "transporter") === undefined)
blockingShip.moveApart(ship.position(), 12);
else
blockingShip.moveApart(ship.position(), 6);
});
});
gameState.ai.HQ.tradeManager.traders.filter(API3.Filters.byClass("Ship")).forEach(function(ship) {
if (ship.getMetadata(PlayerID, "route") === undefined)
return;
let sea = ship.getMetadata(PlayerID, "sea");
self.seaShips[sea].forEach(function(blockingShip) {
if (blockingShip === ship || !blockingShip.isIdle())
return;
if (API3.SquareVectorDistance(ship.position(), blockingShip.position()) > 900)
return;
if (blockingShip.getMetadata(PlayerID, "transporter") === undefined)
blockingShip.moveApart(ship.position(), 12);
else
blockingShip.moveApart(ship.position(), 6);
});
});
};
m.NavalManager.prototype.buildNavalStructures = function(gameState, queues)
{
if (!gameState.ai.HQ.navalMap || !gameState.ai.HQ.baseManagers[1])
return;
if (gameState.getPopulation() > this.Config.Economy.popForDock)
{
if (queues.dock.countQueuedUnitsWithClass("NavalMarket") === 0 &&
!gameState.getOwnStructures().filter(API3.Filters.and(API3.Filters.byClass("NavalMarket"), API3.Filters.isFoundation())).hasEntities() &&
gameState.ai.HQ.canBuild(gameState, "structures/{civ}_dock"))
{
let dockStarted = false;
for (let base of gameState.ai.HQ.baseManagers)
{
if (dockStarted)
break;
if (!base.anchor || base.constructing)
continue;
let remaining = this.getUnconnectedSeas(gameState, base.accessIndex);
for (let sea of remaining)
{
if (!gameState.ai.HQ.navalRegions[sea])
continue;
let wantedLand = {};
wantedLand[base.accessIndex] = true;
queues.dock.addPlan(new m.ConstructionPlan(gameState, "structures/{civ}_dock", { "land": wantedLand, "sea": sea }));
dockStarted = true;
break;
}
}
}
}
if (gameState.currentPhase() < 2 || gameState.getPopulation() < this.Config.Economy.popForTown + 15 ||
queues.militaryBuilding.hasQueuedUnits() || this.bNaval.length === 0)
return;
let docks = gameState.getOwnStructures().filter(API3.Filters.byClass("Dock"));
if (!docks.hasEntities())
return;
let nNaval = 0;
for (let naval of this.bNaval)
nNaval += gameState.countEntitiesAndQueuedByType(naval, true);
if (nNaval === 0 || (nNaval < this.bNaval.length && gameState.getPopulation() > 120))
{
for (let naval of this.bNaval)
{
if (gameState.countEntitiesAndQueuedByType(naval, true) < 1 && gameState.ai.HQ.canBuild(gameState, naval))
{
let wantedLand = {};
for (let base of gameState.ai.HQ.baseManagers)
if (base.anchor)
wantedLand[base.accessIndex] = true;
let sea = docks.toEntityArray()[0].getMetadata(PlayerID, "sea");
queues.militaryBuilding.addPlan(new m.ConstructionPlan(gameState, naval, { "land": wantedLand, "sea": sea }));
break;
}
}
}
};
/** goal can be either attack (choose ship with best arrowCount) or transport (choose ship with best capacity) */
m.NavalManager.prototype.getBestShip = function(gameState, sea, goal)
{
let civ = gameState.getPlayerCiv();
let trainableShips = [];
gameState.getOwnTrainingFacilities().filter(API3.Filters.byMetadata(PlayerID, "sea", sea)).forEach(function(ent) {
let trainables = ent.trainableEntities(civ);
for (let trainable of trainables)
{
if (gameState.isTemplateDisabled(trainable))
continue;
let template = gameState.getTemplate(trainable);
if (template && template.hasClass("Ship") && trainableShips.indexOf(trainable) === -1)
trainableShips.push(trainable);
}
});
let best = 0;
let bestShip;
let limits = gameState.getEntityLimits();
let current = gameState.getEntityCounts();
for (let trainable of trainableShips)
{
let template = gameState.getTemplate(trainable);
if (!template.available(gameState))
continue;
let category = template.trainingCategory();
if (category && limits[category] && current[category] >= limits[category])
continue;
let arrows = +(template.getDefaultArrow() || 0);
if (goal === "attack") // choose the maximum default arrows
{
if (best > arrows)
continue;
best = arrows;
}
else if (goal === "transport") // choose the maximum capacity, with a bonus if arrows or if siege transport
{
let capacity = +(template.garrisonMax() || 0);
if (capacity < 2)
continue;
capacity += 10*arrows;
if (MatchesClassList(template.garrisonableClasses(), "Siege"))
capacity += 50;
if (best > capacity)
continue;
best = capacity;
}
else if (goal === "fishing")
if (!template.hasClass("FishingBoat"))
continue;
bestShip = trainable;
}
return bestShip;
};
m.NavalManager.prototype.update = function(gameState, queues, events)
{
Engine.ProfileStart("Naval Manager update");
this.checkEvents(gameState, queues, events);
// close previous transport plans if finished
for (let i = 0; i < this.transportPlans.length; ++i)
{
let remaining = this.transportPlans[i].update(gameState);
if (remaining)
continue;
if (this.Config.debug > 1)
API3.warn("no more units on transport plan " + this.transportPlans[i].ID);
this.transportPlans[i].releaseAll();
this.transportPlans.splice(i--, 1);
}
// assign free ships to plans which need them
this.assignShipsToPlans(gameState);
// and require for more ships/structures if needed
if (gameState.ai.playedTurn % 3 === 0)
{
this.checkLevels(gameState, queues);
this.maintainFleet(gameState, queues);
this.buildNavalStructures(gameState, queues);
}
// let inactive ships move apart from active ones (waiting for a better pathfinder)
this.moveApart(gameState);
Engine.ProfileStop();
};
m.NavalManager.prototype.Serialize = function()
{
let properties = {
"wantedTransportShips": this.wantedTransportShips,
"wantedWarShips": this.wantedWarShips,
"wantedFishShips": this.wantedFishShips,
"neededTransportShips": this.neededTransportShips,
"neededWarShips": this.neededWarShips,
"landingZones": this.landingZones
};
let transports = {};
for (let plan in this.transportPlans)
transports[plan] = this.transportPlans[plan].Serialize();
return { "properties": properties, "transports": transports };
};
m.NavalManager.prototype.Deserialize = function(gameState, data)
{
for (let key in data.properties)
this[key] = data.properties[key];
this.transportPlans = [];
for (let i in data.transports)
{
let dataPlan = data.transports[i];
let plan = new m.TransportPlan(gameState, [], dataPlan.startIndex, dataPlan.endIndex, dataPlan.endPos);
plan.Deserialize(dataPlan);
plan.init(gameState);
this.transportPlans.push(plan);
}
};
return m;
}(PETRA);
Index: ps/trunk/binaries/data/mods/public/simulation/components/GarrisonHolder.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/GarrisonHolder.js (revision 19630)
+++ ps/trunk/binaries/data/mods/public/simulation/components/GarrisonHolder.js (revision 19631)
@@ -1,754 +1,754 @@
function GarrisonHolder() {}
GarrisonHolder.prototype.Schema =
"" +
"" +
"" +
"" +
"" +
"tokens" +
"" +
"" +
"" +
"" +
"